target/hexagon/dectree.py - third_party/qemu - Git at Google

 #!/usr/bin/env python3

 ##
 ##  Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
 ##
 ##  This program is free software; you can redistribute it and/or modify
 ##  it under the terms of the GNU General Public License as published by
 ##  the Free Software Foundation; either version 2 of the License, or
 ##  (at your option) any later version.
 ##
 ##  This program 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 General Public License for more details.
 ##
 ##  You should have received a copy of the GNU General Public License
 ##  along with this program; if not, see <http://www.gnu.org/licenses/>.
 ##

 import io
 import re

 import sys
 import iset

 encs = {
     tag: "".join(reversed(iset.iset[tag]["enc"].replace(" ", "")))
     for tag in iset.tags
     if iset.iset[tag]["enc"] != "MISSING ENCODING"
 }

 enc_classes = set([iset.iset[tag]["enc_class"] for tag in encs.keys()])
 subinsn_enc_classes = set(
     [enc_class for enc_class in enc_classes if enc_class.startswith("SUBINSN_")]
 )
 ext_enc_classes = set(
     [
         enc_class
         for enc_class in enc_classes
         if enc_class not in ("NORMAL", "16BIT") and not enc_class.startswith("SUBINSN_")
     ]
 )

 try:
     subinsn_groupings = iset.subinsn_groupings
 except AttributeError:
     subinsn_groupings = {}

 for tag, subinsn_grouping in subinsn_groupings.items():
     encs[tag] = "".join(reversed(subinsn_grouping["enc"].replace(" ", "")))

 dectree_normal = {"leaves": set()}
 dectree_16bit = {"leaves": set()}
 dectree_subinsn_groupings = {"leaves": set()}
 dectree_subinsns = {name: {"leaves": set()} for name in subinsn_enc_classes}
 dectree_extensions = {name: {"leaves": set()} for name in ext_enc_classes}

 for tag in encs.keys():
     if tag in subinsn_groupings:
         dectree_subinsn_groupings["leaves"].add(tag)
         continue
     enc_class = iset.iset[tag]["enc_class"]
     if enc_class.startswith("SUBINSN_"):
         if len(encs[tag]) != 32:
             encs[tag] = encs[tag] + "0" * (32 - len(encs[tag]))
         dectree_subinsns[enc_class]["leaves"].add(tag)
     elif enc_class == "16BIT":
         if len(encs[tag]) != 16:
             raise Exception(
                 'Tag "{}" has enc_class "{}" and not an encoding '
                 + "width of 16 bits!".format(tag, enc_class)
             )
         dectree_16bit["leaves"].add(tag)
     else:
         if len(encs[tag]) != 32:
             raise Exception(
                 'Tag "{}" has enc_class "{}" and not an encoding '
                 + "width of 32 bits!".format(tag, enc_class)
             )
         if enc_class == "NORMAL":
             dectree_normal["leaves"].add(tag)
         else:
             dectree_extensions[enc_class]["leaves"].add(tag)

 faketags = set()
 for tag, enc in iset.enc_ext_spaces.items():
     faketags.add(tag)
     encs[tag] = "".join(reversed(enc.replace(" ", "")))
     dectree_normal["leaves"].add(tag)

 faketags |= set(subinsn_groupings.keys())


 def every_bit_counts(bitset):
     for i in range(1, len(next(iter(bitset)))):
         if len(set([bits[:i] + bits[i + 1 :] for bits in bitset])) == len(bitset):
             return False
     return True


 def auto_separate(node):
     tags = node["leaves"]
     if len(tags) <= 1:
         return
     enc_width = len(encs[next(iter(tags))])
     opcode_bit_for_all = [
         all([encs[tag][i] in "01" for tag in tags]) for i in range(enc_width)
     ]
     opcode_bit_is_0_for_all = [
         opcode_bit_for_all[i] and all([encs[tag][i] == "0" for tag in tags])
         for i in range(enc_width)
     ]
     opcode_bit_is_1_for_all = [
         opcode_bit_for_all[i] and all([encs[tag][i] == "1" for tag in tags])
         for i in range(enc_width)
     ]
     differentiator_opcode_bit = [
         opcode_bit_for_all[i]
         and not (opcode_bit_is_0_for_all[i] or opcode_bit_is_1_for_all[i])
         for i in range(enc_width)
     ]
     best_width = 0
     for width in range(4, 0, -1):
         for lsb in range(enc_width - width, -1, -1):
             bitset = set([encs[tag][lsb : lsb + width] for tag in tags])
             if all(differentiator_opcode_bit[lsb : lsb + width]) and (
                 len(bitset) == len(tags) or every_bit_counts(bitset)
             ):
                 best_width = width
                 best_lsb = lsb
                 caught_all_tags = len(bitset) == len(tags)
                 break
         if best_width != 0:
             break
     if best_width == 0:
         raise Exception(
             "Could not find a way to differentiate the encodings "
             + "of the following tags:\n{}".format("\n".join(tags))
         )
     if caught_all_tags:
         for width in range(1, best_width):
             for lsb in range(enc_width - width, -1, -1):
                 bitset = set([encs[tag][lsb : lsb + width] for tag in tags])
                 if all(differentiator_opcode_bit[lsb : lsb + width]) and len(
                     bitset
                 ) == len(tags):
                     best_width = width
                     best_lsb = lsb
                     break
             else:
                 continue
             break
     node["separator_lsb"] = best_lsb
     node["separator_width"] = best_width
     node["children"] = []
     for value in range(2**best_width):
         child = {}
         bits = "".join(reversed("{:0{}b}".format(value, best_width)))
         child["leaves"] = set(
             [tag for tag in tags if encs[tag][best_lsb : best_lsb + best_width] == bits]
         )
         node["children"].append(child)
     for child in node["children"]:
         auto_separate(child)


 auto_separate(dectree_normal)
 auto_separate(dectree_16bit)
 if subinsn_groupings:
     auto_separate(dectree_subinsn_groupings)
 for dectree_subinsn in dectree_subinsns.values():
     auto_separate(dectree_subinsn)
 for dectree_ext in dectree_extensions.values():
     auto_separate(dectree_ext)

 for tag in faketags:
     del encs[tag]


 def table_name(parents, node):
     path = parents + [node]
     root = path[0]
     tag = next(iter(node["leaves"]))
     if tag in subinsn_groupings:
         enc_width = len(subinsn_groupings[tag]["enc"].replace(" ", ""))
     else:
         tag = next(iter(node["leaves"] - faketags))
         enc_width = len(encs[tag])
     determining_bits = ["_"] * enc_width
     for parent, child in zip(path[:-1], path[1:]):
         lsb = parent["separator_lsb"]
         width = parent["separator_width"]
         value = parent["children"].index(child)
         determining_bits[lsb : lsb + width] = list(
             reversed("{:0{}b}".format(value, width))
         )
     if tag in subinsn_groupings:
         name = "DECODE_ROOT_EE"
     else:
         enc_class = iset.iset[tag]["enc_class"]
         if enc_class in ext_enc_classes:
             name = "DECODE_EXT_{}".format(enc_class)
         elif enc_class in subinsn_enc_classes:
             name = "DECODE_SUBINSN_{}".format(enc_class)
         else:
             name = "DECODE_ROOT_{}".format(enc_width)
     if node != root:
         name += "_" + "".join(reversed(determining_bits))
     return name


 def print_node(f, node, parents):
     if len(node["leaves"]) <= 1:
         return
     name = table_name(parents, node)
     lsb = node["separator_lsb"]
     width = node["separator_width"]
     print(
         "DECODE_NEW_TABLE({},{},DECODE_SEPARATOR_BITS({},{}))".format(
             name, 2**width, lsb, width
         ),
         file=f,
     )
     for child in node["children"]:
         if len(child["leaves"]) == 0:
             print("INVALID()", file=f)
         elif len(child["leaves"]) == 1:
             (tag,) = child["leaves"]
             if tag in subinsn_groupings:
                 class_a = subinsn_groupings[tag]["class_a"]
                 class_b = subinsn_groupings[tag]["class_b"]
                 enc = subinsn_groupings[tag]["enc"].replace(" ", "")
                 if "RESERVED" in tag:
                     print("INVALID()", file=f)
                 else:
                     print(
                         'SUBINSNS({},{},{},"{}")'.format(tag, class_a, class_b, enc),
                         file=f,
                     )
             elif tag in iset.enc_ext_spaces:
                 enc = iset.enc_ext_spaces[tag].replace(" ", "")
                 print('EXTSPACE({},"{}")'.format(tag, enc), file=f)
             else:
                 enc = "".join(reversed(encs[tag]))
                 print('TERMINAL({},"{}")'.format(tag, enc), file=f)
         else:
             print("TABLE_LINK({})".format(table_name(parents + [node], child)), file=f)
     print(
         "DECODE_END_TABLE({},{},DECODE_SEPARATOR_BITS({},{}))".format(
             name, 2**width, lsb, width
         ),
         file=f,
     )
     print(file=f)
     parents.append(node)
     for child in node["children"]:
         print_node(f, child, parents)
     parents.pop()


 def print_tree(f, tree):
     print_node(f, tree, [])


 def print_match_info(f):
     for tag in sorted(encs.keys(), key=iset.tags.index):
         enc = "".join(reversed(encs[tag]))
         mask = int(re.sub(r"[^1]", r"0", enc.replace("0", "1")), 2)
         match = int(re.sub(r"[^01]", r"0", enc), 2)
         suffix = ""
         print(
             "DECODE{}_MATCH_INFO({},0x{:x}U,0x{:x}U)".format(suffix, tag, mask, match),
             file=f,
         )


 regre = re.compile(r"((?<!DUP)[MNORCPQXSGVZA])([stuvwxyzdefg]+)([.]?[LlHh]?)(\d+S?)")
 immre = re.compile(r"[#]([rRsSuUm])(\d+)(?:[:](\d+))?")


 def ordered_unique(l):
     return sorted(set(l), key=l.index)


 implicit_registers = {"SP": 29, "FP": 30, "LR": 31}

 num_registers = {"R": 32, "V": 32}


 def print_op_info(f):
     for tag in sorted(encs.keys(), key=iset.tags.index):
         enc = encs[tag]
         print(file=f)
         print("DECODE_OPINFO({},".format(tag), file=f)
         regs = ordered_unique(regre.findall(iset.iset[tag]["syntax"]))
         imms = ordered_unique(immre.findall(iset.iset[tag]["syntax"]))
         regno = 0
         for reg in regs:
             reg_type = reg[0]
             reg_letter = reg[1][0]
             reg_num_choices = int(reg[3].rstrip("S"))
             reg_mapping = reg[0] + "".join(["_" for letter in reg[1]]) + reg[3]
             reg_enc_fields = re.findall(reg_letter + "+", enc)
             if len(reg_enc_fields) == 0:
                 raise Exception('Tag "{}" missing register field!'.format(tag))
             if len(reg_enc_fields) > 1:
                 raise Exception('Tag "{}" has split register field!'.format(tag))
             reg_enc_field = reg_enc_fields[0]
             if 2 ** len(reg_enc_field) != reg_num_choices:
                 raise Exception(
                     'Tag "{}" has incorrect register field width!'.format(tag)
                 )
             print(
                 "        DECODE_REG({},{},{})".format(
                     regno, len(reg_enc_field), enc.index(reg_enc_field)
                 ),
                 file=f,
             )
             if reg_type in num_registers and reg_num_choices != num_registers[reg_type]:
                 print(
                     "        DECODE_MAPPED_REG({},{})".format(regno, reg_mapping),
                     file=f,
                 )
             regno += 1

         def implicit_register_key(reg):
             return implicit_registers[reg]

         for reg in sorted(
             set(
                 [
                     r
                     for r in (
                         iset.iset[tag]["rregs"].split(",")
                         + iset.iset[tag]["wregs"].split(",")
                     )
                     if r in implicit_registers
                 ]
             ),
             key=implicit_register_key,
         ):
             print(
                 "        DECODE_IMPL_REG({},{})".format(regno, implicit_registers[reg]),
                 file=f,
             )
             regno += 1
         if imms and imms[0][0].isupper():
             imms = reversed(imms)
         for imm in imms:
             if imm[0].isupper():
                 immno = 1
             else:
                 immno = 0
             imm_type = imm[0]
             imm_width = int(imm[1])
             imm_shift = imm[2]
             if imm_shift:
                 imm_shift = int(imm_shift)
             else:
                 imm_shift = 0
             if imm_type.islower():
                 imm_letter = "i"
             else:
                 imm_letter = "I"
             remainder = imm_width
             for m in reversed(list(re.finditer(imm_letter + "+", enc))):
                 remainder -= m.end() - m.start()
                 print(
                     "        DECODE_IMM({},{},{},{})".format(
                         immno, m.end() - m.start(), m.start(), remainder
                     ),
                     file=f,
                 )
             if remainder != 0:
                 if imm[2]:
                     imm[2] = ":" + imm[2]
                 raise Exception(
                     'Tag "{}" has an incorrect number of '
                     + 'encoding bits for immediate "{}"'.format(tag, "".join(imm))
                 )
             if imm_type.lower() in "sr":
                 print("        DECODE_IMM_SXT({},{})".format(immno, imm_width), file=f)
             if imm_type.lower() == "n":
                 print("        DECODE_IMM_NEG({},{})".format(immno, imm_width), file=f)
             if imm_shift:
                 print(
                     "        DECODE_IMM_SHIFT({},{})".format(immno, imm_shift), file=f
                 )
         print(")", file=f)


 if __name__ == "__main__":
     with open(sys.argv[1], "w") as f:
         print_tree(f, dectree_normal)
         print_tree(f, dectree_16bit)
         if subinsn_groupings:
             print_tree(f, dectree_subinsn_groupings)
         for name, dectree_subinsn in sorted(dectree_subinsns.items()):
             print_tree(f, dectree_subinsn)
         for name, dectree_ext in sorted(dectree_extensions.items()):
             print_tree(f, dectree_ext)
         print_match_info(f)
         print_op_info(f)
	#!/usr/bin/env python3

	##
	## Copyright(c) 2019-2023 Qualcomm Innovation Center, Inc. All Rights Reserved.
	##
	## This program is free software; you can redistribute it and/or modify
	## it under the terms of the GNU General Public License as published by
	## the Free Software Foundation; either version 2 of the License, or
	## (at your option) any later version.
	##
	## This program 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 General Public License for more details.
	##
	## You should have received a copy of the GNU General Public License
	## along with this program; if not, see <http://www.gnu.org/licenses/>.
	##

	import io
	import re

	import sys
	import iset

	encs = {
	tag: "".join(reversed(iset.iset[tag]["enc"].replace(" ", "")))
	for tag in iset.tags
	if iset.iset[tag]["enc"] != "MISSING ENCODING"
	}

	enc_classes = set([iset.iset[tag]["enc_class"] for tag in encs.keys()])
	subinsn_enc_classes = set(
	[enc_class for enc_class in enc_classes if enc_class.startswith("SUBINSN_")]
	)
	ext_enc_classes = set(
	[
	enc_class
	for enc_class in enc_classes
	if enc_class not in ("NORMAL", "16BIT") and not enc_class.startswith("SUBINSN_")
	]
	)

	try:
	subinsn_groupings = iset.subinsn_groupings
	except AttributeError:
	subinsn_groupings = {}

	for tag, subinsn_grouping in subinsn_groupings.items():
	encs[tag] = "".join(reversed(subinsn_grouping["enc"].replace(" ", "")))

	dectree_normal = {"leaves": set()}
	dectree_16bit = {"leaves": set()}
	dectree_subinsn_groupings = {"leaves": set()}
	dectree_subinsns = {name: {"leaves": set()} for name in subinsn_enc_classes}
	dectree_extensions = {name: {"leaves": set()} for name in ext_enc_classes}

	for tag in encs.keys():
	if tag in subinsn_groupings:
	dectree_subinsn_groupings["leaves"].add(tag)
	continue
	enc_class = iset.iset[tag]["enc_class"]
	if enc_class.startswith("SUBINSN_"):
	if len(encs[tag]) != 32:
	encs[tag] = encs[tag] + "0" * (32 - len(encs[tag]))
	dectree_subinsns[enc_class]["leaves"].add(tag)
	elif enc_class == "16BIT":
	if len(encs[tag]) != 16:
	raise Exception(
	'Tag "{}" has enc_class "{}" and not an encoding '
	+ "width of 16 bits!".format(tag, enc_class)
	)
	dectree_16bit["leaves"].add(tag)
	else:
	if len(encs[tag]) != 32:
	raise Exception(
	'Tag "{}" has enc_class "{}" and not an encoding '
	+ "width of 32 bits!".format(tag, enc_class)
	)
	if enc_class == "NORMAL":
	dectree_normal["leaves"].add(tag)
	else:
	dectree_extensions[enc_class]["leaves"].add(tag)

	faketags = set()
	for tag, enc in iset.enc_ext_spaces.items():
	faketags.add(tag)
	encs[tag] = "".join(reversed(enc.replace(" ", "")))
	dectree_normal["leaves"].add(tag)

	faketags \|= set(subinsn_groupings.keys())


	def every_bit_counts(bitset):
	for i in range(1, len(next(iter(bitset)))):
	if len(set([bits[:i] + bits[i + 1 :] for bits in bitset])) == len(bitset):
	return False
	return True


	def auto_separate(node):
	tags = node["leaves"]
	if len(tags) <= 1:
	return
	enc_width = len(encs[next(iter(tags))])
	opcode_bit_for_all = [
	all([encs[tag][i] in "01" for tag in tags]) for i in range(enc_width)
	]
	opcode_bit_is_0_for_all = [
	opcode_bit_for_all[i] and all([encs[tag][i] == "0" for tag in tags])
	for i in range(enc_width)
	]
	opcode_bit_is_1_for_all = [
	opcode_bit_for_all[i] and all([encs[tag][i] == "1" for tag in tags])
	for i in range(enc_width)
	]
	differentiator_opcode_bit = [
	opcode_bit_for_all[i]
	and not (opcode_bit_is_0_for_all[i] or opcode_bit_is_1_for_all[i])
	for i in range(enc_width)
	]
	best_width = 0
	for width in range(4, 0, -1):
	for lsb in range(enc_width - width, -1, -1):
	bitset = set([encs[tag][lsb : lsb + width] for tag in tags])
	if all(differentiator_opcode_bit[lsb : lsb + width]) and (
	len(bitset) == len(tags) or every_bit_counts(bitset)
	):
	best_width = width
	best_lsb = lsb
	caught_all_tags = len(bitset) == len(tags)
	break
	if best_width != 0:
	break
	if best_width == 0:
	raise Exception(
	"Could not find a way to differentiate the encodings "
	+ "of the following tags:\n{}".format("\n".join(tags))
	)
	if caught_all_tags:
	for width in range(1, best_width):
	for lsb in range(enc_width - width, -1, -1):
	bitset = set([encs[tag][lsb : lsb + width] for tag in tags])
	if all(differentiator_opcode_bit[lsb : lsb + width]) and len(
	bitset
	) == len(tags):
	best_width = width
	best_lsb = lsb
	break
	else:
	continue
	break
	node["separator_lsb"] = best_lsb
	node["separator_width"] = best_width
	node["children"] = []
	for value in range(2**best_width):
	child = {}
	bits = "".join(reversed("{:0{}b}".format(value, best_width)))
	child["leaves"] = set(
	[tag for tag in tags if encs[tag][best_lsb : best_lsb + best_width] == bits]
	)
	node["children"].append(child)
	for child in node["children"]:
	auto_separate(child)


	auto_separate(dectree_normal)
	auto_separate(dectree_16bit)
	if subinsn_groupings:
	auto_separate(dectree_subinsn_groupings)
	for dectree_subinsn in dectree_subinsns.values():
	auto_separate(dectree_subinsn)
	for dectree_ext in dectree_extensions.values():
	auto_separate(dectree_ext)

	for tag in faketags:
	del encs[tag]


	def table_name(parents, node):
	path = parents + [node]
	root = path[0]
	tag = next(iter(node["leaves"]))
	if tag in subinsn_groupings:
	enc_width = len(subinsn_groupings[tag]["enc"].replace(" ", ""))
	else:
	tag = next(iter(node["leaves"] - faketags))
	enc_width = len(encs[tag])
	determining_bits = ["_"] * enc_width
	for parent, child in zip(path[:-1], path[1:]):
	lsb = parent["separator_lsb"]
	width = parent["separator_width"]
	value = parent["children"].index(child)
	determining_bits[lsb : lsb + width] = list(
	reversed("{:0{}b}".format(value, width))
	)
	if tag in subinsn_groupings:
	name = "DECODE_ROOT_EE"
	else:
	enc_class = iset.iset[tag]["enc_class"]
	if enc_class in ext_enc_classes:
	name = "DECODE_EXT_{}".format(enc_class)
	elif enc_class in subinsn_enc_classes:
	name = "DECODE_SUBINSN_{}".format(enc_class)
	else:
	name = "DECODE_ROOT_{}".format(enc_width)
	if node != root:
	name += "_" + "".join(reversed(determining_bits))
	return name


	def print_node(f, node, parents):
	if len(node["leaves"]) <= 1:
	return
	name = table_name(parents, node)
	lsb = node["separator_lsb"]
	width = node["separator_width"]
	print(
	"DECODE_NEW_TABLE({},{},DECODE_SEPARATOR_BITS({},{}))".format(
	name, 2**width, lsb, width
	),
	file=f,
	)
	for child in node["children"]:
	if len(child["leaves"]) == 0:
	print("INVALID()", file=f)
	elif len(child["leaves"]) == 1:
	(tag,) = child["leaves"]
	if tag in subinsn_groupings:
	class_a = subinsn_groupings[tag]["class_a"]
	class_b = subinsn_groupings[tag]["class_b"]
	enc = subinsn_groupings[tag]["enc"].replace(" ", "")
	if "RESERVED" in tag:
	print("INVALID()", file=f)
	else:
	print(
	'SUBINSNS({},{},{},"{}")'.format(tag, class_a, class_b, enc),
	file=f,
	)
	elif tag in iset.enc_ext_spaces:
	enc = iset.enc_ext_spaces[tag].replace(" ", "")
	print('EXTSPACE({},"{}")'.format(tag, enc), file=f)
	else:
	enc = "".join(reversed(encs[tag]))
	print('TERMINAL({},"{}")'.format(tag, enc), file=f)
	else:
	print("TABLE_LINK({})".format(table_name(parents + [node], child)), file=f)
	print(
	"DECODE_END_TABLE({},{},DECODE_SEPARATOR_BITS({},{}))".format(
	name, 2**width, lsb, width
	),
	file=f,
	)
	print(file=f)
	parents.append(node)
	for child in node["children"]:
	print_node(f, child, parents)
	parents.pop()


	def print_tree(f, tree):
	print_node(f, tree, [])


	def print_match_info(f):
	for tag in sorted(encs.keys(), key=iset.tags.index):
	enc = "".join(reversed(encs[tag]))
	mask = int(re.sub(r"[^1]", r"0", enc.replace("0", "1")), 2)
	match = int(re.sub(r"[^01]", r"0", enc), 2)
	suffix = ""
	print(
	"DECODE{}_MATCH_INFO({},0x{:x}U,0x{:x}U)".format(suffix, tag, mask, match),
	file=f,
	)


	regre = re.compile(r"((?<!DUP)[MNORCPQXSGVZA])([stuvwxyzdefg]+)([.]?[LlHh]?)(\d+S?)")
	immre = re.compile(r"[#]([rRsSuUm])(\d+)(?:[:](\d+))?")


	def ordered_unique(l):
	return sorted(set(l), key=l.index)


	implicit_registers = {"SP": 29, "FP": 30, "LR": 31}

	num_registers = {"R": 32, "V": 32}


	def print_op_info(f):
	for tag in sorted(encs.keys(), key=iset.tags.index):
	enc = encs[tag]
	print(file=f)
	print("DECODE_OPINFO({},".format(tag), file=f)
	regs = ordered_unique(regre.findall(iset.iset[tag]["syntax"]))
	imms = ordered_unique(immre.findall(iset.iset[tag]["syntax"]))
	regno = 0
	for reg in regs:
	reg_type = reg[0]
	reg_letter = reg[1][0]
	reg_num_choices = int(reg[3].rstrip("S"))
	reg_mapping = reg[0] + "".join(["_" for letter in reg[1]]) + reg[3]
	reg_enc_fields = re.findall(reg_letter + "+", enc)
	if len(reg_enc_fields) == 0:
	raise Exception('Tag "{}" missing register field!'.format(tag))
	if len(reg_enc_fields) > 1:
	raise Exception('Tag "{}" has split register field!'.format(tag))
	reg_enc_field = reg_enc_fields[0]
	if 2 ** len(reg_enc_field) != reg_num_choices:
	raise Exception(
	'Tag "{}" has incorrect register field width!'.format(tag)
	)
	print(
	" DECODE_REG({},{},{})".format(
	regno, len(reg_enc_field), enc.index(reg_enc_field)
	),
	file=f,
	)
	if reg_type in num_registers and reg_num_choices != num_registers[reg_type]:
	print(
	" DECODE_MAPPED_REG({},{})".format(regno, reg_mapping),
	file=f,
	)
	regno += 1

	def implicit_register_key(reg):
	return implicit_registers[reg]

	for reg in sorted(
	set(
	[
	r
	for r in (
	iset.iset[tag]["rregs"].split(",")
	+ iset.iset[tag]["wregs"].split(",")
	)
	if r in implicit_registers
	]
	),
	key=implicit_register_key,
	):
	print(
	" DECODE_IMPL_REG({},{})".format(regno, implicit_registers[reg]),
	file=f,
	)
	regno += 1
	if imms and imms[0][0].isupper():
	imms = reversed(imms)
	for imm in imms:
	if imm[0].isupper():
	immno = 1
	else:
	immno = 0
	imm_type = imm[0]
	imm_width = int(imm[1])
	imm_shift = imm[2]
	if imm_shift:
	imm_shift = int(imm_shift)
	else:
	imm_shift = 0
	if imm_type.islower():
	imm_letter = "i"
	else:
	imm_letter = "I"
	remainder = imm_width
	for m in reversed(list(re.finditer(imm_letter + "+", enc))):
	remainder -= m.end() - m.start()
	print(
	" DECODE_IMM({},{},{},{})".format(
	immno, m.end() - m.start(), m.start(), remainder
	),
	file=f,
	)
	if remainder != 0:
	if imm[2]:
	imm[2] = ":" + imm[2]
	raise Exception(
	'Tag "{}" has an incorrect number of '
	+ 'encoding bits for immediate "{}"'.format(tag, "".join(imm))
	)
	if imm_type.lower() in "sr":
	print(" DECODE_IMM_SXT({},{})".format(immno, imm_width), file=f)
	if imm_type.lower() == "n":
	print(" DECODE_IMM_NEG({},{})".format(immno, imm_width), file=f)
	if imm_shift:
	print(
	" DECODE_IMM_SHIFT({},{})".format(immno, imm_shift), file=f
	)
	print(")", file=f)


	if __name__ == "__main__":
	with open(sys.argv[1], "w") as f:
	print_tree(f, dectree_normal)
	print_tree(f, dectree_16bit)
	if subinsn_groupings:
	print_tree(f, dectree_subinsn_groupings)
	for name, dectree_subinsn in sorted(dectree_subinsns.items()):
	print_tree(f, dectree_subinsn)
	for name, dectree_ext in sorted(dectree_extensions.items()):
	print_tree(f, dectree_ext)
	print_match_info(f)
	print_op_info(f)