|
|
@@ -0,0 +1,1062 @@
|
|
|
+#!/usr/bin/env python
|
|
|
+# Copyright (c) 2018 Linaro Limited
|
|
|
+#
|
|
|
+# This library is free software; you can redistribute it and/or
|
|
|
+# modify it under the terms of the GNU Lesser General Public
|
|
|
+# License as published by the Free Software Foundation; either
|
|
|
+# version 2 of the License, or (at your option) any later version.
|
|
|
+#
|
|
|
+# This library is distributed in the hope that it will be useful,
|
|
|
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
|
+# Lesser General Public License for more details.
|
|
|
+#
|
|
|
+# You should have received a copy of the GNU Lesser General Public
|
|
|
+# License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
|
+#
|
|
|
+
|
|
|
+#
|
|
|
+# Generate a decoding tree from a specification file.
|
|
|
+#
|
|
|
+# The tree is built from instruction "patterns". A pattern may represent
|
|
|
+# a single architectural instruction or a group of same, depending on what
|
|
|
+# is convenient for further processing.
|
|
|
+#
|
|
|
+# Each pattern has "fixedbits" & "fixedmask", the combination of which
|
|
|
+# describes the condition under which the pattern is matched:
|
|
|
+#
|
|
|
+# (insn & fixedmask) == fixedbits
|
|
|
+#
|
|
|
+# Each pattern may have "fields", which are extracted from the insn and
|
|
|
+# passed along to the translator. Examples of such are registers,
|
|
|
+# immediates, and sub-opcodes.
|
|
|
+#
|
|
|
+# In support of patterns, one may declare fields, argument sets, and
|
|
|
+# formats, each of which may be re-used to simplify further definitions.
|
|
|
+#
|
|
|
+# *** Field syntax:
|
|
|
+#
|
|
|
+# field_def := '%' identifier ( unnamed_field )+ ( !function=identifier )?
|
|
|
+# unnamed_field := number ':' ( 's' ) number
|
|
|
+#
|
|
|
+# For unnamed_field, the first number is the least-significant bit position of
|
|
|
+# the field and the second number is the length of the field. If the 's' is
|
|
|
+# present, the field is considered signed. If multiple unnamed_fields are
|
|
|
+# present, they are concatenated. In this way one can define disjoint fields.
|
|
|
+#
|
|
|
+# If !function is specified, the concatenated result is passed through the
|
|
|
+# named function, taking and returning an integral value.
|
|
|
+#
|
|
|
+# FIXME: the fields of the structure into which this result will be stored
|
|
|
+# is restricted to "int". Which means that we cannot expand 64-bit items.
|
|
|
+#
|
|
|
+# Field examples:
|
|
|
+#
|
|
|
+# %disp 0:s16 -- sextract(i, 0, 16)
|
|
|
+# %imm9 16:6 10:3 -- extract(i, 16, 6) << 3 | extract(i, 10, 3)
|
|
|
+# %disp12 0:s1 1:1 2:10 -- sextract(i, 0, 1) << 11
|
|
|
+# | extract(i, 1, 1) << 10
|
|
|
+# | extract(i, 2, 10)
|
|
|
+# %shimm8 5:s8 13:1 !function=expand_shimm8
|
|
|
+# -- expand_shimm8(sextract(i, 5, 8) << 1
|
|
|
+# | extract(i, 13, 1))
|
|
|
+#
|
|
|
+# *** Argument set syntax:
|
|
|
+#
|
|
|
+# args_def := '&' identifier ( args_elt )+
|
|
|
+# args_elt := identifier
|
|
|
+#
|
|
|
+# Each args_elt defines an argument within the argument set.
|
|
|
+# Each argument set will be rendered as a C structure "arg_$name"
|
|
|
+# with each of the fields being one of the member arguments.
|
|
|
+#
|
|
|
+# Argument set examples:
|
|
|
+#
|
|
|
+# ®3 ra rb rc
|
|
|
+# &loadstore reg base offset
|
|
|
+#
|
|
|
+# *** Format syntax:
|
|
|
+#
|
|
|
+# fmt_def := '@' identifier ( fmt_elt )+
|
|
|
+# fmt_elt := fixedbit_elt | field_elt | field_ref | args_ref
|
|
|
+# fixedbit_elt := [01.-]+
|
|
|
+# field_elt := identifier ':' 's'? number
|
|
|
+# field_ref := '%' identifier | identifier '=' '%' identifier
|
|
|
+# args_ref := '&' identifier
|
|
|
+#
|
|
|
+# Defining a format is a handy way to avoid replicating groups of fields
|
|
|
+# across many instruction patterns.
|
|
|
+#
|
|
|
+# A fixedbit_elt describes a contiguous sequence of bits that must
|
|
|
+# be 1, 0, [.-] for don't care. The difference between '.' and '-'
|
|
|
+# is that '.' means that the bit will be covered with a field or a
|
|
|
+# final [01] from the pattern, and '-' means that the bit is really
|
|
|
+# ignored by the cpu and will not be specified.
|
|
|
+#
|
|
|
+# A field_elt describes a simple field only given a width; the position of
|
|
|
+# the field is implied by its position with respect to other fixedbit_elt
|
|
|
+# and field_elt.
|
|
|
+#
|
|
|
+# If any fixedbit_elt or field_elt appear then all bits must be defined.
|
|
|
+# Padding with a fixedbit_elt of all '.' is an easy way to accomplish that.
|
|
|
+#
|
|
|
+# A field_ref incorporates a field by reference. This is the only way to
|
|
|
+# add a complex field to a format. A field may be renamed in the process
|
|
|
+# via assignment to another identifier. This is intended to allow the
|
|
|
+# same argument set be used with disjoint named fields.
|
|
|
+#
|
|
|
+# A single args_ref may specify an argument set to use for the format.
|
|
|
+# The set of fields in the format must be a subset of the arguments in
|
|
|
+# the argument set. If an argument set is not specified, one will be
|
|
|
+# inferred from the set of fields.
|
|
|
+#
|
|
|
+# It is recommended, but not required, that all field_ref and args_ref
|
|
|
+# appear at the end of the line, not interleaving with fixedbit_elf or
|
|
|
+# field_elt.
|
|
|
+#
|
|
|
+# Format examples:
|
|
|
+#
|
|
|
+# @opr ...... ra:5 rb:5 ... 0 ....... rc:5
|
|
|
+# @opi ...... ra:5 lit:8 1 ....... rc:5
|
|
|
+#
|
|
|
+# *** Pattern syntax:
|
|
|
+#
|
|
|
+# pat_def := identifier ( pat_elt )+
|
|
|
+# pat_elt := fixedbit_elt | field_elt | field_ref
|
|
|
+# | args_ref | fmt_ref | const_elt
|
|
|
+# fmt_ref := '@' identifier
|
|
|
+# const_elt := identifier '=' number
|
|
|
+#
|
|
|
+# The fixedbit_elt and field_elt specifiers are unchanged from formats.
|
|
|
+# A pattern that does not specify a named format will have one inferred
|
|
|
+# from a referenced argument set (if present) and the set of fields.
|
|
|
+#
|
|
|
+# A const_elt allows a argument to be set to a constant value. This may
|
|
|
+# come in handy when fields overlap between patterns and one has to
|
|
|
+# include the values in the fixedbit_elt instead.
|
|
|
+#
|
|
|
+# The decoder will call a translator function for each pattern matched.
|
|
|
+#
|
|
|
+# Pattern examples:
|
|
|
+#
|
|
|
+# addl_r 010000 ..... ..... .... 0000000 ..... @opr
|
|
|
+# addl_i 010000 ..... ..... .... 0000000 ..... @opi
|
|
|
+#
|
|
|
+# which will, in part, invoke
|
|
|
+#
|
|
|
+# trans_addl_r(ctx, &arg_opr, insn)
|
|
|
+# and
|
|
|
+# trans_addl_i(ctx, &arg_opi, insn)
|
|
|
+#
|
|
|
+
|
|
|
+import io
|
|
|
+import os
|
|
|
+import re
|
|
|
+import sys
|
|
|
+import getopt
|
|
|
+import pdb
|
|
|
+
|
|
|
+insnwidth = 32
|
|
|
+insnmask = 0xffffffff
|
|
|
+fields = {}
|
|
|
+arguments = {}
|
|
|
+formats = {}
|
|
|
+patterns = []
|
|
|
+
|
|
|
+translate_prefix = 'trans'
|
|
|
+translate_scope = 'static '
|
|
|
+input_file = ''
|
|
|
+output_file = None
|
|
|
+output_fd = None
|
|
|
+insntype = 'uint32_t'
|
|
|
+
|
|
|
+re_ident = '[a-zA-Z][a-zA-Z0-9_]*'
|
|
|
+
|
|
|
+
|
|
|
+def error(lineno, *args):
|
|
|
+ """Print an error message from file:line and args and exit."""
|
|
|
+ global output_file
|
|
|
+ global output_fd
|
|
|
+
|
|
|
+ if lineno:
|
|
|
+ r = '{0}:{1}: error:'.format(input_file, lineno)
|
|
|
+ elif input_file:
|
|
|
+ r = '{0}: error:'.format(input_file)
|
|
|
+ else:
|
|
|
+ r = 'error:'
|
|
|
+ for a in args:
|
|
|
+ r += ' ' + str(a)
|
|
|
+ r += '\n'
|
|
|
+ sys.stderr.write(r)
|
|
|
+ if output_file and output_fd:
|
|
|
+ output_fd.close()
|
|
|
+ os.remove(output_file)
|
|
|
+ exit(1)
|
|
|
+
|
|
|
+
|
|
|
+def output(*args):
|
|
|
+ global output_fd
|
|
|
+ for a in args:
|
|
|
+ output_fd.write(a)
|
|
|
+
|
|
|
+
|
|
|
+if sys.version_info >= (3, 0):
|
|
|
+ re_fullmatch = re.fullmatch
|
|
|
+else:
|
|
|
+ def re_fullmatch(pat, str):
|
|
|
+ return re.match('^' + pat + '$', str)
|
|
|
+
|
|
|
+
|
|
|
+def output_autogen():
|
|
|
+ output('/* This file is autogenerated by scripts/decodetree.py. */\n\n')
|
|
|
+
|
|
|
+
|
|
|
+def str_indent(c):
|
|
|
+ """Return a string with C spaces"""
|
|
|
+ return ' ' * c
|
|
|
+
|
|
|
+
|
|
|
+def str_fields(fields):
|
|
|
+ """Return a string uniquely identifing FIELDS"""
|
|
|
+ r = ''
|
|
|
+ for n in sorted(fields.keys()):
|
|
|
+ r += '_' + n
|
|
|
+ return r[1:]
|
|
|
+
|
|
|
+
|
|
|
+def str_match_bits(bits, mask):
|
|
|
+ """Return a string pretty-printing BITS/MASK"""
|
|
|
+ global insnwidth
|
|
|
+
|
|
|
+ i = 1 << (insnwidth - 1)
|
|
|
+ space = 0x01010100
|
|
|
+ r = ''
|
|
|
+ while i != 0:
|
|
|
+ if i & mask:
|
|
|
+ if i & bits:
|
|
|
+ r += '1'
|
|
|
+ else:
|
|
|
+ r += '0'
|
|
|
+ else:
|
|
|
+ r += '.'
|
|
|
+ if i & space:
|
|
|
+ r += ' '
|
|
|
+ i >>= 1
|
|
|
+ return r
|
|
|
+
|
|
|
+
|
|
|
+def is_pow2(x):
|
|
|
+ """Return true iff X is equal to a power of 2."""
|
|
|
+ return (x & (x - 1)) == 0
|
|
|
+
|
|
|
+
|
|
|
+def ctz(x):
|
|
|
+ """Return the number of times 2 factors into X."""
|
|
|
+ r = 0
|
|
|
+ while ((x >> r) & 1) == 0:
|
|
|
+ r += 1
|
|
|
+ return r
|
|
|
+
|
|
|
+
|
|
|
+def is_contiguous(bits):
|
|
|
+ shift = ctz(bits)
|
|
|
+ if is_pow2((bits >> shift) + 1):
|
|
|
+ return shift
|
|
|
+ else:
|
|
|
+ return -1
|
|
|
+
|
|
|
+
|
|
|
+def eq_fields_for_args(flds_a, flds_b):
|
|
|
+ if len(flds_a) != len(flds_b):
|
|
|
+ return False
|
|
|
+ for k, a in flds_a.items():
|
|
|
+ if k not in flds_b:
|
|
|
+ return False
|
|
|
+ return True
|
|
|
+
|
|
|
+
|
|
|
+def eq_fields_for_fmts(flds_a, flds_b):
|
|
|
+ if len(flds_a) != len(flds_b):
|
|
|
+ return False
|
|
|
+ for k, a in flds_a.items():
|
|
|
+ if k not in flds_b:
|
|
|
+ return False
|
|
|
+ b = flds_b[k]
|
|
|
+ if a.__class__ != b.__class__ or a != b:
|
|
|
+ return False
|
|
|
+ return True
|
|
|
+
|
|
|
+
|
|
|
+class Field:
|
|
|
+ """Class representing a simple instruction field"""
|
|
|
+ def __init__(self, sign, pos, len):
|
|
|
+ self.sign = sign
|
|
|
+ self.pos = pos
|
|
|
+ self.len = len
|
|
|
+ self.mask = ((1 << len) - 1) << pos
|
|
|
+
|
|
|
+ def __str__(self):
|
|
|
+ if self.sign:
|
|
|
+ s = 's'
|
|
|
+ else:
|
|
|
+ s = ''
|
|
|
+ return str(pos) + ':' + s + str(len)
|
|
|
+
|
|
|
+ def str_extract(self):
|
|
|
+ if self.sign:
|
|
|
+ extr = 'sextract32'
|
|
|
+ else:
|
|
|
+ extr = 'extract32'
|
|
|
+ return '{0}(insn, {1}, {2})'.format(extr, self.pos, self.len)
|
|
|
+
|
|
|
+ def __eq__(self, other):
|
|
|
+ return self.sign == other.sign and self.sign == other.sign
|
|
|
+
|
|
|
+ def __ne__(self, other):
|
|
|
+ return not self.__eq__(other)
|
|
|
+# end Field
|
|
|
+
|
|
|
+
|
|
|
+class MultiField:
|
|
|
+ """Class representing a compound instruction field"""
|
|
|
+ def __init__(self, subs, mask):
|
|
|
+ self.subs = subs
|
|
|
+ self.sign = subs[0].sign
|
|
|
+ self.mask = mask
|
|
|
+
|
|
|
+ def __str__(self):
|
|
|
+ return str(self.subs)
|
|
|
+
|
|
|
+ def str_extract(self):
|
|
|
+ ret = '0'
|
|
|
+ pos = 0
|
|
|
+ for f in reversed(self.subs):
|
|
|
+ if pos == 0:
|
|
|
+ ret = f.str_extract()
|
|
|
+ else:
|
|
|
+ ret = 'deposit32({0}, {1}, {2}, {3})' \
|
|
|
+ .format(ret, pos, 32 - pos, f.str_extract())
|
|
|
+ pos += f.len
|
|
|
+ return ret
|
|
|
+
|
|
|
+ def __ne__(self, other):
|
|
|
+ if len(self.subs) != len(other.subs):
|
|
|
+ return True
|
|
|
+ for a, b in zip(self.subs, other.subs):
|
|
|
+ if a.__class__ != b.__class__ or a != b:
|
|
|
+ return True
|
|
|
+ return False
|
|
|
+
|
|
|
+ def __eq__(self, other):
|
|
|
+ return not self.__ne__(other)
|
|
|
+# end MultiField
|
|
|
+
|
|
|
+
|
|
|
+class ConstField:
|
|
|
+ """Class representing an argument field with constant value"""
|
|
|
+ def __init__(self, value):
|
|
|
+ self.value = value
|
|
|
+ self.mask = 0
|
|
|
+ self.sign = value < 0
|
|
|
+
|
|
|
+ def __str__(self):
|
|
|
+ return str(self.value)
|
|
|
+
|
|
|
+ def str_extract(self):
|
|
|
+ return str(self.value)
|
|
|
+
|
|
|
+ def __cmp__(self, other):
|
|
|
+ return self.value - other.value
|
|
|
+# end ConstField
|
|
|
+
|
|
|
+
|
|
|
+class FunctionField:
|
|
|
+ """Class representing a field passed through an expander"""
|
|
|
+ def __init__(self, func, base):
|
|
|
+ self.mask = base.mask
|
|
|
+ self.sign = base.sign
|
|
|
+ self.base = base
|
|
|
+ self.func = func
|
|
|
+
|
|
|
+ def __str__(self):
|
|
|
+ return self.func + '(' + str(self.base) + ')'
|
|
|
+
|
|
|
+ def str_extract(self):
|
|
|
+ return self.func + '(' + self.base.str_extract() + ')'
|
|
|
+
|
|
|
+ def __eq__(self, other):
|
|
|
+ return self.func == other.func and self.base == other.base
|
|
|
+
|
|
|
+ def __ne__(self, other):
|
|
|
+ return not self.__eq__(other)
|
|
|
+# end FunctionField
|
|
|
+
|
|
|
+
|
|
|
+class Arguments:
|
|
|
+ """Class representing the extracted fields of a format"""
|
|
|
+ def __init__(self, nm, flds):
|
|
|
+ self.name = nm
|
|
|
+ self.fields = sorted(flds)
|
|
|
+
|
|
|
+ def __str__(self):
|
|
|
+ return self.name + ' ' + str(self.fields)
|
|
|
+
|
|
|
+ def struct_name(self):
|
|
|
+ return 'arg_' + self.name
|
|
|
+
|
|
|
+ def output_def(self):
|
|
|
+ output('typedef struct {\n')
|
|
|
+ for n in self.fields:
|
|
|
+ output(' int ', n, ';\n')
|
|
|
+ output('} ', self.struct_name(), ';\n\n')
|
|
|
+# end Arguments
|
|
|
+
|
|
|
+
|
|
|
+class General:
|
|
|
+ """Common code between instruction formats and instruction patterns"""
|
|
|
+ def __init__(self, name, lineno, base, fixb, fixm, udfm, fldm, flds):
|
|
|
+ self.name = name
|
|
|
+ self.lineno = lineno
|
|
|
+ self.base = base
|
|
|
+ self.fixedbits = fixb
|
|
|
+ self.fixedmask = fixm
|
|
|
+ self.undefmask = udfm
|
|
|
+ self.fieldmask = fldm
|
|
|
+ self.fields = flds
|
|
|
+
|
|
|
+ def __str__(self):
|
|
|
+ r = self.name
|
|
|
+ if self.base:
|
|
|
+ r = r + ' ' + self.base.name
|
|
|
+ else:
|
|
|
+ r = r + ' ' + str(self.fields)
|
|
|
+ r = r + ' ' + str_match_bits(self.fixedbits, self.fixedmask)
|
|
|
+ return r
|
|
|
+
|
|
|
+ def str1(self, i):
|
|
|
+ return str_indent(i) + self.__str__()
|
|
|
+# end General
|
|
|
+
|
|
|
+
|
|
|
+class Format(General):
|
|
|
+ """Class representing an instruction format"""
|
|
|
+
|
|
|
+ def extract_name(self):
|
|
|
+ return 'extract_' + self.name
|
|
|
+
|
|
|
+ def output_extract(self):
|
|
|
+ output('static void ', self.extract_name(), '(',
|
|
|
+ self.base.struct_name(), ' *a, ', insntype, ' insn)\n{\n')
|
|
|
+ for n, f in self.fields.items():
|
|
|
+ output(' a->', n, ' = ', f.str_extract(), ';\n')
|
|
|
+ output('}\n\n')
|
|
|
+# end Format
|
|
|
+
|
|
|
+
|
|
|
+class Pattern(General):
|
|
|
+ """Class representing an instruction pattern"""
|
|
|
+
|
|
|
+ def output_decl(self):
|
|
|
+ global translate_scope
|
|
|
+ global translate_prefix
|
|
|
+ output('typedef ', self.base.base.struct_name(),
|
|
|
+ ' arg_', self.name, ';\n')
|
|
|
+ output(translate_scope, 'void ', translate_prefix, '_', self.name,
|
|
|
+ '(DisasContext *ctx, arg_', self.name,
|
|
|
+ ' *a, ', insntype, ' insn);\n')
|
|
|
+
|
|
|
+ def output_code(self, i, extracted, outerbits, outermask):
|
|
|
+ global translate_prefix
|
|
|
+ ind = str_indent(i)
|
|
|
+ arg = self.base.base.name
|
|
|
+ output(ind, '/* line ', str(self.lineno), ' */\n')
|
|
|
+ if not extracted:
|
|
|
+ output(ind, self.base.extract_name(), '(&u.f_', arg, ', insn);\n')
|
|
|
+ for n, f in self.fields.items():
|
|
|
+ output(ind, 'u.f_', arg, '.', n, ' = ', f.str_extract(), ';\n')
|
|
|
+ output(ind, translate_prefix, '_', self.name,
|
|
|
+ '(ctx, &u.f_', arg, ', insn);\n')
|
|
|
+ output(ind, 'return true;\n')
|
|
|
+# end Pattern
|
|
|
+
|
|
|
+
|
|
|
+def parse_field(lineno, name, toks):
|
|
|
+ """Parse one instruction field from TOKS at LINENO"""
|
|
|
+ global fields
|
|
|
+ global re_ident
|
|
|
+ global insnwidth
|
|
|
+
|
|
|
+ # A "simple" field will have only one entry;
|
|
|
+ # a "multifield" will have several.
|
|
|
+ subs = []
|
|
|
+ width = 0
|
|
|
+ func = None
|
|
|
+ for t in toks:
|
|
|
+ if re_fullmatch('!function=' + re_ident, t):
|
|
|
+ if func:
|
|
|
+ error(lineno, 'duplicate function')
|
|
|
+ func = t.split('=')
|
|
|
+ func = func[1]
|
|
|
+ continue
|
|
|
+
|
|
|
+ if re_fullmatch('[0-9]+:s[0-9]+', t):
|
|
|
+ # Signed field extract
|
|
|
+ subtoks = t.split(':s')
|
|
|
+ sign = True
|
|
|
+ elif re_fullmatch('[0-9]+:[0-9]+', t):
|
|
|
+ # Unsigned field extract
|
|
|
+ subtoks = t.split(':')
|
|
|
+ sign = False
|
|
|
+ else:
|
|
|
+ error(lineno, 'invalid field token "{0}"'.format(t))
|
|
|
+ po = int(subtoks[0])
|
|
|
+ le = int(subtoks[1])
|
|
|
+ if po + le > insnwidth:
|
|
|
+ error(lineno, 'field {0} too large'.format(t))
|
|
|
+ f = Field(sign, po, le)
|
|
|
+ subs.append(f)
|
|
|
+ width += le
|
|
|
+
|
|
|
+ if width > insnwidth:
|
|
|
+ error(lineno, 'field too large')
|
|
|
+ if len(subs) == 1:
|
|
|
+ f = subs[0]
|
|
|
+ else:
|
|
|
+ mask = 0
|
|
|
+ for s in subs:
|
|
|
+ if mask & s.mask:
|
|
|
+ error(lineno, 'field components overlap')
|
|
|
+ mask |= s.mask
|
|
|
+ f = MultiField(subs, mask)
|
|
|
+ if func:
|
|
|
+ f = FunctionField(func, f)
|
|
|
+
|
|
|
+ if name in fields:
|
|
|
+ error(lineno, 'duplicate field', name)
|
|
|
+ fields[name] = f
|
|
|
+# end parse_field
|
|
|
+
|
|
|
+
|
|
|
+def parse_arguments(lineno, name, toks):
|
|
|
+ """Parse one argument set from TOKS at LINENO"""
|
|
|
+ global arguments
|
|
|
+ global re_ident
|
|
|
+
|
|
|
+ flds = []
|
|
|
+ for t in toks:
|
|
|
+ if not re_fullmatch(re_ident, t):
|
|
|
+ error(lineno, 'invalid argument set token "{0}"'.format(t))
|
|
|
+ if t in flds:
|
|
|
+ error(lineno, 'duplicate argument "{0}"'.format(t))
|
|
|
+ flds.append(t)
|
|
|
+
|
|
|
+ if name in arguments:
|
|
|
+ error(lineno, 'duplicate argument set', name)
|
|
|
+ arguments[name] = Arguments(name, flds)
|
|
|
+# end parse_arguments
|
|
|
+
|
|
|
+
|
|
|
+def lookup_field(lineno, name):
|
|
|
+ global fields
|
|
|
+ if name in fields:
|
|
|
+ return fields[name]
|
|
|
+ error(lineno, 'undefined field', name)
|
|
|
+
|
|
|
+
|
|
|
+def add_field(lineno, flds, new_name, f):
|
|
|
+ if new_name in flds:
|
|
|
+ error(lineno, 'duplicate field', new_name)
|
|
|
+ flds[new_name] = f
|
|
|
+ return flds
|
|
|
+
|
|
|
+
|
|
|
+def add_field_byname(lineno, flds, new_name, old_name):
|
|
|
+ return add_field(lineno, flds, new_name, lookup_field(lineno, old_name))
|
|
|
+
|
|
|
+
|
|
|
+def infer_argument_set(flds):
|
|
|
+ global arguments
|
|
|
+
|
|
|
+ for arg in arguments.values():
|
|
|
+ if eq_fields_for_args(flds, arg.fields):
|
|
|
+ return arg
|
|
|
+
|
|
|
+ name = str(len(arguments))
|
|
|
+ arg = Arguments(name, flds.keys())
|
|
|
+ arguments[name] = arg
|
|
|
+ return arg
|
|
|
+
|
|
|
+
|
|
|
+def infer_format(arg, fieldmask, flds):
|
|
|
+ global arguments
|
|
|
+ global formats
|
|
|
+
|
|
|
+ const_flds = {}
|
|
|
+ var_flds = {}
|
|
|
+ for n, c in flds.items():
|
|
|
+ if c is ConstField:
|
|
|
+ const_flds[n] = c
|
|
|
+ else:
|
|
|
+ var_flds[n] = c
|
|
|
+
|
|
|
+ # Look for an existing format with the same argument set and fields
|
|
|
+ for fmt in formats.values():
|
|
|
+ if arg and fmt.base != arg:
|
|
|
+ continue
|
|
|
+ if fieldmask != fmt.fieldmask:
|
|
|
+ continue
|
|
|
+ if not eq_fields_for_fmts(flds, fmt.fields):
|
|
|
+ continue
|
|
|
+ return (fmt, const_flds)
|
|
|
+
|
|
|
+ name = 'Fmt_' + str(len(formats))
|
|
|
+ if not arg:
|
|
|
+ arg = infer_argument_set(flds)
|
|
|
+
|
|
|
+ fmt = Format(name, 0, arg, 0, 0, 0, fieldmask, var_flds)
|
|
|
+ formats[name] = fmt
|
|
|
+
|
|
|
+ return (fmt, const_flds)
|
|
|
+# end infer_format
|
|
|
+
|
|
|
+
|
|
|
+def parse_generic(lineno, is_format, name, toks):
|
|
|
+ """Parse one instruction format from TOKS at LINENO"""
|
|
|
+ global fields
|
|
|
+ global arguments
|
|
|
+ global formats
|
|
|
+ global patterns
|
|
|
+ global re_ident
|
|
|
+ global insnwidth
|
|
|
+ global insnmask
|
|
|
+
|
|
|
+ fixedmask = 0
|
|
|
+ fixedbits = 0
|
|
|
+ undefmask = 0
|
|
|
+ width = 0
|
|
|
+ flds = {}
|
|
|
+ arg = None
|
|
|
+ fmt = None
|
|
|
+ for t in toks:
|
|
|
+ # '&Foo' gives a format an explcit argument set.
|
|
|
+ if t[0] == '&':
|
|
|
+ tt = t[1:]
|
|
|
+ if arg:
|
|
|
+ error(lineno, 'multiple argument sets')
|
|
|
+ if tt in arguments:
|
|
|
+ arg = arguments[tt]
|
|
|
+ else:
|
|
|
+ error(lineno, 'undefined argument set', t)
|
|
|
+ continue
|
|
|
+
|
|
|
+ # '@Foo' gives a pattern an explicit format.
|
|
|
+ if t[0] == '@':
|
|
|
+ tt = t[1:]
|
|
|
+ if fmt:
|
|
|
+ error(lineno, 'multiple formats')
|
|
|
+ if tt in formats:
|
|
|
+ fmt = formats[tt]
|
|
|
+ else:
|
|
|
+ error(lineno, 'undefined format', t)
|
|
|
+ continue
|
|
|
+
|
|
|
+ # '%Foo' imports a field.
|
|
|
+ if t[0] == '%':
|
|
|
+ tt = t[1:]
|
|
|
+ flds = add_field_byname(lineno, flds, tt, tt)
|
|
|
+ continue
|
|
|
+
|
|
|
+ # 'Foo=%Bar' imports a field with a different name.
|
|
|
+ if re_fullmatch(re_ident + '=%' + re_ident, t):
|
|
|
+ (fname, iname) = t.split('=%')
|
|
|
+ flds = add_field_byname(lineno, flds, fname, iname)
|
|
|
+ continue
|
|
|
+
|
|
|
+ # 'Foo=number' sets an argument field to a constant value
|
|
|
+ if re_fullmatch(re_ident + '=[0-9]+', t):
|
|
|
+ (fname, value) = t.split('=')
|
|
|
+ value = int(value)
|
|
|
+ flds = add_field(lineno, flds, fname, ConstField(value))
|
|
|
+ continue
|
|
|
+
|
|
|
+ # Pattern of 0s, 1s, dots and dashes indicate required zeros,
|
|
|
+ # required ones, or dont-cares.
|
|
|
+ if re_fullmatch('[01.-]+', t):
|
|
|
+ shift = len(t)
|
|
|
+ fms = t.replace('0', '1')
|
|
|
+ fms = fms.replace('.', '0')
|
|
|
+ fms = fms.replace('-', '0')
|
|
|
+ fbs = t.replace('.', '0')
|
|
|
+ fbs = fbs.replace('-', '0')
|
|
|
+ ubm = t.replace('1', '0')
|
|
|
+ ubm = ubm.replace('.', '0')
|
|
|
+ ubm = ubm.replace('-', '1')
|
|
|
+ fms = int(fms, 2)
|
|
|
+ fbs = int(fbs, 2)
|
|
|
+ ubm = int(ubm, 2)
|
|
|
+ fixedbits = (fixedbits << shift) | fbs
|
|
|
+ fixedmask = (fixedmask << shift) | fms
|
|
|
+ undefmask = (undefmask << shift) | ubm
|
|
|
+ # Otherwise, fieldname:fieldwidth
|
|
|
+ elif re_fullmatch(re_ident + ':s?[0-9]+', t):
|
|
|
+ (fname, flen) = t.split(':')
|
|
|
+ sign = False
|
|
|
+ if flen[0] == 's':
|
|
|
+ sign = True
|
|
|
+ flen = flen[1:]
|
|
|
+ shift = int(flen, 10)
|
|
|
+ f = Field(sign, insnwidth - width - shift, shift)
|
|
|
+ flds = add_field(lineno, flds, fname, f)
|
|
|
+ fixedbits <<= shift
|
|
|
+ fixedmask <<= shift
|
|
|
+ undefmask <<= shift
|
|
|
+ else:
|
|
|
+ error(lineno, 'invalid token "{0}"'.format(t))
|
|
|
+ width += shift
|
|
|
+
|
|
|
+ # We should have filled in all of the bits of the instruction.
|
|
|
+ if not (is_format and width == 0) and width != insnwidth:
|
|
|
+ error(lineno, 'definition has {0} bits'.format(width))
|
|
|
+
|
|
|
+ # Do not check for fields overlaping fields; one valid usage
|
|
|
+ # is to be able to duplicate fields via import.
|
|
|
+ fieldmask = 0
|
|
|
+ for f in flds.values():
|
|
|
+ fieldmask |= f.mask
|
|
|
+
|
|
|
+ # Fix up what we've parsed to match either a format or a pattern.
|
|
|
+ if is_format:
|
|
|
+ # Formats cannot reference formats.
|
|
|
+ if fmt:
|
|
|
+ error(lineno, 'format referencing format')
|
|
|
+ # If an argument set is given, then there should be no fields
|
|
|
+ # without a place to store it.
|
|
|
+ if arg:
|
|
|
+ for f in flds.keys():
|
|
|
+ if f not in arg.fields:
|
|
|
+ error(lineno, 'field {0} not in argument set {1}'
|
|
|
+ .format(f, arg.name))
|
|
|
+ else:
|
|
|
+ arg = infer_argument_set(flds)
|
|
|
+ if name in formats:
|
|
|
+ error(lineno, 'duplicate format name', name)
|
|
|
+ fmt = Format(name, lineno, arg, fixedbits, fixedmask,
|
|
|
+ undefmask, fieldmask, flds)
|
|
|
+ formats[name] = fmt
|
|
|
+ else:
|
|
|
+ # Patterns can reference a format ...
|
|
|
+ if fmt:
|
|
|
+ # ... but not an argument simultaneously
|
|
|
+ if arg:
|
|
|
+ error(lineno, 'pattern specifies both format and argument set')
|
|
|
+ if fixedmask & fmt.fixedmask:
|
|
|
+ error(lineno, 'pattern fixed bits overlap format fixed bits')
|
|
|
+ fieldmask |= fmt.fieldmask
|
|
|
+ fixedbits |= fmt.fixedbits
|
|
|
+ fixedmask |= fmt.fixedmask
|
|
|
+ undefmask |= fmt.undefmask
|
|
|
+ else:
|
|
|
+ (fmt, flds) = infer_format(arg, fieldmask, flds)
|
|
|
+ arg = fmt.base
|
|
|
+ for f in flds.keys():
|
|
|
+ if f not in arg.fields:
|
|
|
+ error(lineno, 'field {0} not in argument set {1}'
|
|
|
+ .format(f, arg.name))
|
|
|
+ if f in fmt.fields.keys():
|
|
|
+ error(lineno, 'field {0} set by format and pattern'.format(f))
|
|
|
+ for f in arg.fields:
|
|
|
+ if f not in flds.keys() and f not in fmt.fields.keys():
|
|
|
+ error(lineno, 'field {0} not initialized'.format(f))
|
|
|
+ pat = Pattern(name, lineno, fmt, fixedbits, fixedmask,
|
|
|
+ undefmask, fieldmask, flds)
|
|
|
+ patterns.append(pat)
|
|
|
+
|
|
|
+ # Validate the masks that we have assembled.
|
|
|
+ if fieldmask & fixedmask:
|
|
|
+ error(lineno, 'fieldmask overlaps fixedmask (0x{0:08x} & 0x{1:08x})'
|
|
|
+ .format(fieldmask, fixedmask))
|
|
|
+ if fieldmask & undefmask:
|
|
|
+ error(lineno, 'fieldmask overlaps undefmask (0x{0:08x} & 0x{1:08x})'
|
|
|
+ .format(fieldmask, undefmask))
|
|
|
+ if fixedmask & undefmask:
|
|
|
+ error(lineno, 'fixedmask overlaps undefmask (0x{0:08x} & 0x{1:08x})'
|
|
|
+ .format(fixedmask, undefmask))
|
|
|
+ if not is_format:
|
|
|
+ allbits = fieldmask | fixedmask | undefmask
|
|
|
+ if allbits != insnmask:
|
|
|
+ error(lineno, 'bits left unspecified (0x{0:08x})'
|
|
|
+ .format(allbits ^ insnmask))
|
|
|
+# end parse_general
|
|
|
+
|
|
|
+
|
|
|
+def parse_file(f):
|
|
|
+ """Parse all of the patterns within a file"""
|
|
|
+
|
|
|
+ # Read all of the lines of the file. Concatenate lines
|
|
|
+ # ending in backslash; discard empty lines and comments.
|
|
|
+ toks = []
|
|
|
+ lineno = 0
|
|
|
+ for line in f:
|
|
|
+ lineno += 1
|
|
|
+
|
|
|
+ # Discard comments
|
|
|
+ end = line.find('#')
|
|
|
+ if end >= 0:
|
|
|
+ line = line[:end]
|
|
|
+
|
|
|
+ t = line.split()
|
|
|
+ if len(toks) != 0:
|
|
|
+ # Next line after continuation
|
|
|
+ toks.extend(t)
|
|
|
+ elif len(t) == 0:
|
|
|
+ # Empty line
|
|
|
+ continue
|
|
|
+ else:
|
|
|
+ toks = t
|
|
|
+
|
|
|
+ # Continuation?
|
|
|
+ if toks[-1] == '\\':
|
|
|
+ toks.pop()
|
|
|
+ continue
|
|
|
+
|
|
|
+ if len(toks) < 2:
|
|
|
+ error(lineno, 'short line')
|
|
|
+
|
|
|
+ name = toks[0]
|
|
|
+ del toks[0]
|
|
|
+
|
|
|
+ # Determine the type of object needing to be parsed.
|
|
|
+ if name[0] == '%':
|
|
|
+ parse_field(lineno, name[1:], toks)
|
|
|
+ elif name[0] == '&':
|
|
|
+ parse_arguments(lineno, name[1:], toks)
|
|
|
+ elif name[0] == '@':
|
|
|
+ parse_generic(lineno, True, name[1:], toks)
|
|
|
+ else:
|
|
|
+ parse_generic(lineno, False, name, toks)
|
|
|
+ toks = []
|
|
|
+# end parse_file
|
|
|
+
|
|
|
+
|
|
|
+class Tree:
|
|
|
+ """Class representing a node in a decode tree"""
|
|
|
+
|
|
|
+ def __init__(self, fm, tm):
|
|
|
+ self.fixedmask = fm
|
|
|
+ self.thismask = tm
|
|
|
+ self.subs = []
|
|
|
+ self.base = None
|
|
|
+
|
|
|
+ def str1(self, i):
|
|
|
+ ind = str_indent(i)
|
|
|
+ r = '{0}{1:08x}'.format(ind, self.fixedmask)
|
|
|
+ if self.format:
|
|
|
+ r += ' ' + self.format.name
|
|
|
+ r += ' [\n'
|
|
|
+ for (b, s) in self.subs:
|
|
|
+ r += '{0} {1:08x}:\n'.format(ind, b)
|
|
|
+ r += s.str1(i + 4) + '\n'
|
|
|
+ r += ind + ']'
|
|
|
+ return r
|
|
|
+
|
|
|
+ def __str__(self):
|
|
|
+ return self.str1(0)
|
|
|
+
|
|
|
+ def output_code(self, i, extracted, outerbits, outermask):
|
|
|
+ ind = str_indent(i)
|
|
|
+
|
|
|
+ # If we identified all nodes below have the same format,
|
|
|
+ # extract the fields now.
|
|
|
+ if not extracted and self.base:
|
|
|
+ output(ind, self.base.extract_name(),
|
|
|
+ '(&u.f_', self.base.base.name, ', insn);\n')
|
|
|
+ extracted = True
|
|
|
+
|
|
|
+ # Attempt to aid the compiler in producing compact switch statements.
|
|
|
+ # If the bits in the mask are contiguous, extract them.
|
|
|
+ sh = is_contiguous(self.thismask)
|
|
|
+ if sh > 0:
|
|
|
+ # Propagate SH down into the local functions.
|
|
|
+ def str_switch(b, sh=sh):
|
|
|
+ return '(insn >> {0}) & 0x{1:x}'.format(sh, b >> sh)
|
|
|
+
|
|
|
+ def str_case(b, sh=sh):
|
|
|
+ return '0x{0:x}'.format(b >> sh)
|
|
|
+ else:
|
|
|
+ def str_switch(b):
|
|
|
+ return 'insn & 0x{0:08x}'.format(b)
|
|
|
+
|
|
|
+ def str_case(b):
|
|
|
+ return '0x{0:08x}'.format(b)
|
|
|
+
|
|
|
+ output(ind, 'switch (', str_switch(self.thismask), ') {\n')
|
|
|
+ for b, s in sorted(self.subs):
|
|
|
+ assert (self.thismask & ~s.fixedmask) == 0
|
|
|
+ innermask = outermask | self.thismask
|
|
|
+ innerbits = outerbits | b
|
|
|
+ output(ind, 'case ', str_case(b), ':\n')
|
|
|
+ output(ind, ' /* ',
|
|
|
+ str_match_bits(innerbits, innermask), ' */\n')
|
|
|
+ s.output_code(i + 4, extracted, innerbits, innermask)
|
|
|
+ output(ind, '}\n')
|
|
|
+ output(ind, 'return false;\n')
|
|
|
+# end Tree
|
|
|
+
|
|
|
+
|
|
|
+def build_tree(pats, outerbits, outermask):
|
|
|
+ # Find the intersection of all remaining fixedmask.
|
|
|
+ innermask = ~outermask
|
|
|
+ for i in pats:
|
|
|
+ innermask &= i.fixedmask
|
|
|
+
|
|
|
+ if innermask == 0:
|
|
|
+ pnames = []
|
|
|
+ for p in pats:
|
|
|
+ pnames.append(p.name + ':' + str(p.lineno))
|
|
|
+ error(pats[0].lineno, 'overlapping patterns:', pnames)
|
|
|
+
|
|
|
+ fullmask = outermask | innermask
|
|
|
+
|
|
|
+ # Sort each element of pats into the bin selected by the mask.
|
|
|
+ bins = {}
|
|
|
+ for i in pats:
|
|
|
+ fb = i.fixedbits & innermask
|
|
|
+ if fb in bins:
|
|
|
+ bins[fb].append(i)
|
|
|
+ else:
|
|
|
+ bins[fb] = [i]
|
|
|
+
|
|
|
+ # We must recurse if any bin has more than one element or if
|
|
|
+ # the single element in the bin has not been fully matched.
|
|
|
+ t = Tree(fullmask, innermask)
|
|
|
+
|
|
|
+ for b, l in bins.items():
|
|
|
+ s = l[0]
|
|
|
+ if len(l) > 1 or s.fixedmask & ~fullmask != 0:
|
|
|
+ s = build_tree(l, b | outerbits, fullmask)
|
|
|
+ t.subs.append((b, s))
|
|
|
+
|
|
|
+ return t
|
|
|
+# end build_tree
|
|
|
+
|
|
|
+
|
|
|
+def prop_format(tree):
|
|
|
+ """Propagate Format objects into the decode tree"""
|
|
|
+
|
|
|
+ # Depth first search.
|
|
|
+ for (b, s) in tree.subs:
|
|
|
+ if isinstance(s, Tree):
|
|
|
+ prop_format(s)
|
|
|
+
|
|
|
+ # If all entries in SUBS have the same format, then
|
|
|
+ # propagate that into the tree.
|
|
|
+ f = None
|
|
|
+ for (b, s) in tree.subs:
|
|
|
+ if f is None:
|
|
|
+ f = s.base
|
|
|
+ if f is None:
|
|
|
+ return
|
|
|
+ if f is not s.base:
|
|
|
+ return
|
|
|
+ tree.base = f
|
|
|
+# end prop_format
|
|
|
+
|
|
|
+
|
|
|
+def main():
|
|
|
+ global arguments
|
|
|
+ global formats
|
|
|
+ global patterns
|
|
|
+ global translate_scope
|
|
|
+ global translate_prefix
|
|
|
+ global output_fd
|
|
|
+ global output_file
|
|
|
+ global input_file
|
|
|
+ global insnwidth
|
|
|
+ global insntype
|
|
|
+
|
|
|
+ decode_function = 'decode'
|
|
|
+ decode_scope = 'static '
|
|
|
+
|
|
|
+ long_opts = ['decode=', 'translate=', 'output=', 'insnwidth=']
|
|
|
+ try:
|
|
|
+ (opts, args) = getopt.getopt(sys.argv[1:], 'o:w:', long_opts)
|
|
|
+ except getopt.GetoptError as err:
|
|
|
+ error(0, err)
|
|
|
+ for o, a in opts:
|
|
|
+ if o in ('-o', '--output'):
|
|
|
+ output_file = a
|
|
|
+ elif o == '--decode':
|
|
|
+ decode_function = a
|
|
|
+ decode_scope = ''
|
|
|
+ elif o == '--translate':
|
|
|
+ translate_prefix = a
|
|
|
+ translate_scope = ''
|
|
|
+ elif o in ('-w', '--insnwidth'):
|
|
|
+ insnwidth = int(a)
|
|
|
+ if insnwidth == 16:
|
|
|
+ insntype = 'uint16_t'
|
|
|
+ insnmask = 0xffff
|
|
|
+ elif insnwidth != 32:
|
|
|
+ error(0, 'cannot handle insns of width', insnwidth)
|
|
|
+ else:
|
|
|
+ assert False, 'unhandled option'
|
|
|
+
|
|
|
+ if len(args) < 1:
|
|
|
+ error(0, 'missing input file')
|
|
|
+ input_file = args[0]
|
|
|
+ f = open(input_file, 'r')
|
|
|
+ parse_file(f)
|
|
|
+ f.close()
|
|
|
+
|
|
|
+ t = build_tree(patterns, 0, 0)
|
|
|
+ prop_format(t)
|
|
|
+
|
|
|
+ if output_file:
|
|
|
+ output_fd = open(output_file, 'w')
|
|
|
+ else:
|
|
|
+ output_fd = sys.stdout
|
|
|
+
|
|
|
+ output_autogen()
|
|
|
+ for n in sorted(arguments.keys()):
|
|
|
+ f = arguments[n]
|
|
|
+ f.output_def()
|
|
|
+
|
|
|
+ # A single translate function can be invoked for different patterns.
|
|
|
+ # Make sure that the argument sets are the same, and declare the
|
|
|
+ # function only once.
|
|
|
+ out_pats = {}
|
|
|
+ for i in patterns:
|
|
|
+ if i.name in out_pats:
|
|
|
+ p = out_pats[i.name]
|
|
|
+ if i.base.base != p.base.base:
|
|
|
+ error(0, i.name, ' has conflicting argument sets')
|
|
|
+ else:
|
|
|
+ i.output_decl()
|
|
|
+ out_pats[i.name] = i
|
|
|
+ output('\n')
|
|
|
+
|
|
|
+ for n in sorted(formats.keys()):
|
|
|
+ f = formats[n]
|
|
|
+ f.output_extract()
|
|
|
+
|
|
|
+ output(decode_scope, 'bool ', decode_function,
|
|
|
+ '(DisasContext *ctx, ', insntype, ' insn)\n{\n')
|
|
|
+
|
|
|
+ i4 = str_indent(4)
|
|
|
+ output(i4, 'union {\n')
|
|
|
+ for n in sorted(arguments.keys()):
|
|
|
+ f = arguments[n]
|
|
|
+ output(i4, i4, f.struct_name(), ' f_', f.name, ';\n')
|
|
|
+ output(i4, '} u;\n\n')
|
|
|
+
|
|
|
+ t.output_code(4, False, 0, 0)
|
|
|
+
|
|
|
+ output('}\n')
|
|
|
+
|
|
|
+ if output_file:
|
|
|
+ output_fd.close()
|
|
|
+# end main
|
|
|
+
|
|
|
+
|
|
|
+if __name__ == '__main__':
|
|
|
+ main()
|
Peter Maydell