An emulator, assembler, and disassembler for the Sega Game Gear
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
 
 
 
 
 

383 lignes
13 KiB

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # Copyright (C) 2014-2015 Ben Kurtovic <ben.kurtovic@gmail.com>
  4. # Released under the terms of the MIT License. See LICENSE for details.
  5. """
  6. This script generates 'src/assembler/instructions.inc.c' from
  7. 'src/assembler/instructions.yml'. It should be run automatically by make
  8. when the latter is modified, but can also be run manually.
  9. """
  10. from __future__ import print_function
  11. from itertools import product
  12. import re
  13. import time
  14. SOURCE = "src/assembler/instructions.yml"
  15. DEST = "src/assembler/instructions.inc.c"
  16. ENCODING = "utf8"
  17. TAB = " " * 4
  18. try:
  19. import yaml
  20. except ImportError:
  21. print("Error: PyYAML is required (https://pypi.python.org/pypi/PyYAML)\n"
  22. "If you don't want to rebuild {0}, do:\n`make -t {0}`".format(DEST))
  23. exit(1)
  24. re_date = re.compile(r"^(\s*@AUTOGEN_DATE\s*)(.*?)$", re.M)
  25. re_inst = re.compile(
  26. r"(/\* @AUTOGEN_INST_BLOCK_START \*/\n*)(.*?)"
  27. r"(\n*/\* @AUTOGEN_INST_BLOCK_END \*/)", re.S)
  28. re_lookup = re.compile(
  29. r"(/\* @AUTOGEN_LOOKUP_BLOCK_START \*/\n*)(.*?)"
  30. r"(\n*/\* @AUTOGEN_LOOKUP_BLOCK_END \*/)", re.S)
  31. class Instruction(object):
  32. """
  33. Represent a single ASM instruction mnemonic.
  34. """
  35. ARG_TYPES = {
  36. "register": "AT_REGISTER",
  37. "immediate": "AT_IMMEDIATE",
  38. "indirect": "AT_INDIRECT",
  39. "indexed": "AT_INDEXED",
  40. "condition": "AT_CONDITION",
  41. "port": "AT_PORT"
  42. }
  43. PSEUDO_TYPES = {
  44. "indirect_hl_or_indexed": ["AT_INDIRECT", "AT_INDEXED"]
  45. }
  46. def __init__(self, name, data):
  47. self._name = name
  48. self._data = data
  49. def _get_arg_parse_mask(self, num):
  50. """
  51. Return the appropriate mask to parse_args() for the num-th argument.
  52. """
  53. types = set()
  54. optional = False
  55. for case in self._data["cases"]:
  56. if num < len(case["type"]):
  57. atype = case["type"][num]
  58. if atype in self.ARG_TYPES:
  59. types.add(self.ARG_TYPES[atype])
  60. else:
  61. types.update(self.PSEUDO_TYPES[atype])
  62. else:
  63. optional = True
  64. if not types:
  65. return "AT_NONE"
  66. if optional:
  67. types.add("AT_OPTIONAL")
  68. return "|".join(sorted(types))
  69. def _handle_return(self, ret, indent=1):
  70. """
  71. Return code to handle an instruction return statement.
  72. """
  73. data = ", ".join("0x%02X" % byte if isinstance(byte, int) else byte
  74. for byte in ret)
  75. return TAB * indent + "INST_RETURN({0}, {1})".format(len(ret), data)
  76. def _build_case_type_check(self, args):
  77. """
  78. Return the test part of an if statement for an instruction case.
  79. """
  80. conds = ["INST_TYPE({0}) == {1}".format(i, self.ARG_TYPES[cond])
  81. for i, cond in enumerate(args)]
  82. return "INST_NARGS == {0} && {1}".format(len(args), " && ".join(conds))
  83. def _build_register_check(self, num, cond):
  84. """
  85. Return an expression to check for a particular register value.
  86. """
  87. return "INST_REG({0}) == REG_{1}".format(num, cond.upper())
  88. def _build_immediate_check(self, num, cond):
  89. """
  90. Return an expression to check for a particular immediate value.
  91. """
  92. if "." in cond:
  93. itype, value = cond.split(".", 1)
  94. try:
  95. value = int(value)
  96. except ValueError:
  97. value = int(value, 16)
  98. vtype = "sval" if itype.upper() in ["S8", "REL"] else "uval"
  99. test1 = "INST_IMM({0}).mask & IMM_{1}".format(num, itype.upper())
  100. if (itype.upper() == "U16"):
  101. test1 += " && !INST_IMM({0}).is_label".format(num)
  102. test2 = "INST_IMM({0}).{1} == {2}".format(num, vtype, value)
  103. return "({0} && {1})".format(test1, test2)
  104. return "INST_IMM({0}).mask & IMM_{1}".format(num, cond.upper())
  105. def _build_indirect_check(self, num, cond):
  106. """
  107. Return an expression to check for a particular indirect value.
  108. """
  109. if cond.startswith("reg."):
  110. test1 = "INST_INDIRECT({0}).type == AT_REGISTER".format(num)
  111. test2 = "INST_INDIRECT({0}).addr.reg == REG_{1}".format(
  112. num, cond[len("reg."):].upper())
  113. return "({0} && {1})".format(test1, test2)
  114. if cond == "imm" or cond == "immediate":
  115. return "INST_INDIRECT({0}).type == AT_IMMEDIATE".format(num)
  116. err = "Unknown condition for indirect argument: {0}"
  117. return RuntimeError(err.format(cond))
  118. def _build_indexed_check(self, num, cond):
  119. """
  120. Return an expression to check for a particular indexed value.
  121. """
  122. raise RuntimeError("The indexed arg type does not support conditions")
  123. def _build_condition_check(self, num, cond):
  124. """
  125. Return an expression to check for a particular condition value.
  126. """
  127. return "INST_COND({0}) == COND_{1}".format(num, cond.upper())
  128. def _build_port_check(self, num, cond):
  129. """
  130. Return an expression to check for a particular port value.
  131. """
  132. if cond.startswith("reg."):
  133. test1 = "INST_PORT({0}).type == AT_REGISTER".format(num)
  134. test2 = "INST_PORT({0}).port.reg == REG_{1}".format(
  135. num, cond[len("reg."):].upper())
  136. return "({0} && {1})".format(test1, test2)
  137. if cond == "imm" or cond == "immediate":
  138. return "INST_PORT({0}).type == AT_IMMEDIATE".format(num)
  139. err = "Unknown condition for port argument: {0}"
  140. return RuntimeError(err.format(cond))
  141. _SUBCASE_LOOKUP_TABLE = {
  142. "register": _build_register_check,
  143. "immediate": _build_immediate_check,
  144. "indirect": _build_indirect_check,
  145. "indexed": _build_indexed_check,
  146. "condition": _build_condition_check,
  147. "port": _build_port_check
  148. }
  149. def _build_subcase_check(self, types, conds):
  150. """
  151. Return the test part of an if statement for an instruction subcase.
  152. """
  153. conds = [self._SUBCASE_LOOKUP_TABLE[types[i]](self, i, cond)
  154. for i, cond in enumerate(conds) if cond != "_"]
  155. return " && ".join(conds)
  156. def _iter_permutations(self, types, conds):
  157. """
  158. Iterate over all permutations of the given subcase conditions.
  159. """
  160. def split(typ, cond):
  161. if "|" in cond:
  162. splits = [split(typ, c) for c in cond.split("|")]
  163. merged = [choice for s in splits for choice in s]
  164. if len(merged) != len(set(merged)):
  165. msg = "Repeated conditions for {0}: {1}"
  166. raise RuntimeError(msg.format(typ, cond))
  167. return merged
  168. if typ == "register":
  169. if cond == "i":
  170. return ["ix", "iy"]
  171. if cond == "ih":
  172. return ["ixh", "iyh"]
  173. if cond == "il":
  174. return ["ixl", "iyl"]
  175. return [cond]
  176. splits = [split(typ, cond) for typ, cond in zip(types, conds)]
  177. num = max(len(cond) for cond in splits)
  178. if any(1 < len(cond) < num for cond in splits):
  179. msg = "Invalid condition permutations: {0}"
  180. raise RuntimeError(msg.format(conds))
  181. choices = [cond * num if len(cond) == 1 else cond for cond in splits]
  182. return zip(*choices)
  183. def _adapt_return(self, types, conds, ret):
  184. """
  185. Return a modified byte list to accomodate for prefixes and immediates.
  186. """
  187. ret = ret[:]
  188. for i, byte in enumerate(ret):
  189. if not isinstance(byte, int):
  190. if byte == "u8":
  191. index = types.index("immediate")
  192. ret[i] = "INST_IMM({0}).uval".format(index)
  193. elif byte == "u16":
  194. if i < len(ret) - 1:
  195. raise RuntimeError("U16 return byte must be last")
  196. try:
  197. index = types.index("immediate")
  198. imm = "INST_IMM({0})".format(index)
  199. except ValueError:
  200. indir = types.index("indirect")
  201. if not conds[indir].startswith("imm"):
  202. msg = "Passing non-immediate indirect as immediate"
  203. raise RuntimeError(msg)
  204. imm = "INST_INDIRECT({0}).addr.imm".format(indir)
  205. ret[i] = "INST_IMM_U16_B1({0})".format(imm)
  206. ret.append("INST_IMM_U16_B2({0})".format(imm))
  207. break
  208. else:
  209. msg = "Unsupported return byte: {0}"
  210. raise RuntimeError(msg.format(byte))
  211. for i, cond in enumerate(conds):
  212. if types[i] == "register" and cond[0] == "i":
  213. prefix = "INST_I{0}_PREFIX".format(cond[1].upper())
  214. if ret[0] != prefix:
  215. ret.insert(0, prefix)
  216. elif types[i] == "indexed":
  217. ret.insert(0, "INST_INDEX_PREFIX({0})".format(i))
  218. ret.insert(2, "INST_INDEX({0}).offset".format(i))
  219. return ret
  220. def _handle_pseudo_case(self, pseudo, case):
  221. """
  222. Return code to handle an instruction pseudo-case.
  223. Pseudo-cases are cases that have pseudo-types as arguments. This means
  224. they are expanded to cover multiple "real" argument types.
  225. """
  226. index = case["type"].index(pseudo)
  227. if pseudo == "indirect_hl_or_indexed":
  228. case["type"][index] = "indexed"
  229. indexed = self._handle_case(case)
  230. case["type"][index] = "indirect"
  231. indirect = self._handle_case(case)
  232. base_cond = self._build_case_type_check(case["type"])
  233. hl_reg = TAB * 3 + self._build_indirect_check(index, "reg.hl")
  234. indirect[0] = TAB + "if ({0} &&\n{1}) {{".format(base_cond, hl_reg)
  235. return indirect + indexed
  236. raise RuntimeError("Unknown pseudo-type: {0}".format(pseudo))
  237. def _handle_case(self, case):
  238. """
  239. Return code to handle an instruction case.
  240. """
  241. ctype = case["type"]
  242. for pseudo in self.PSEUDO_TYPES:
  243. if pseudo in ctype:
  244. return self._handle_pseudo_case(pseudo, case)
  245. lines = []
  246. cond = self._build_case_type_check(ctype)
  247. lines.append(TAB + "if ({0}) {{".format(cond))
  248. subcases = [(perm, sub["return"]) for sub in case["cases"]
  249. for perm in self._iter_permutations(ctype, sub["cond"])]
  250. for cond, ret in subcases:
  251. check = self._build_subcase_check(ctype, cond)
  252. ret = self._adapt_return(ctype, cond, ret)
  253. if check:
  254. lines.append(TAB * 2 + "if ({0})".format(check))
  255. lines.append(self._handle_return(ret, 3))
  256. else:
  257. lines.append(self._handle_return(ret, 2))
  258. break # Unconditional subcase
  259. else:
  260. lines.append(TAB * 2 + "INST_ERROR(ARG_VALUE)")
  261. lines.append(TAB + "}")
  262. return lines
  263. def render(self):
  264. """
  265. Convert data for an individual instruction into a C parse function.
  266. """
  267. lines = []
  268. if self._data["args"]:
  269. lines.append("{tab}INST_TAKES_ARGS(\n{tab2}{0},\n{tab2}{1},"
  270. "\n{tab2}{2}\n{tab})".format(
  271. self._get_arg_parse_mask(0), self._get_arg_parse_mask(1),
  272. self._get_arg_parse_mask(2), tab=TAB, tab2=TAB * 2))
  273. else:
  274. lines.append(TAB + "INST_TAKES_NO_ARGS")
  275. if "return" in self._data:
  276. lines.append(self._handle_return(self._data["return"]))
  277. elif "cases" in self._data:
  278. for case in self._data["cases"]:
  279. lines.extend(self._handle_case(case))
  280. lines.append(TAB + "INST_ERROR(ARG_TYPE)")
  281. else:
  282. msg = "Missing return or case block for {0} instruction"
  283. raise RuntimeError(msg.format(self._name))
  284. contents = "\n".join(lines)
  285. return "INST_FUNC({0})\n{{\n{1}\n}}".format(self._name, contents)
  286. def build_inst_block(data):
  287. """
  288. Return the instruction parser block, given instruction data.
  289. """
  290. return "\n\n".join(
  291. Instruction(k, v).render() for k, v in sorted(data.items()))
  292. def build_lookup_block(data):
  293. """
  294. Return the instruction lookup block, given instruction data.
  295. """
  296. macro = TAB + "HANDLE({0})"
  297. return "\n".join(macro.format(inst) for inst in sorted(data.keys()))
  298. def process(template, data):
  299. """
  300. Return C code generated from a source template and instruction data.
  301. """
  302. inst_block = build_inst_block(data)
  303. lookup_block = build_lookup_block(data)
  304. date = time.asctime(time.gmtime())
  305. result = re_date.sub(r"\1{0} UTC".format(date), template)
  306. result = re_inst.sub(r"\1{0}\3".format(inst_block), result)
  307. result = re_lookup.sub(r"\1{0}\3".format(lookup_block), result)
  308. return result
  309. def main():
  310. """
  311. Main script entry point.
  312. """
  313. with open(SOURCE, "r") as fp:
  314. text = fp.read().decode(ENCODING)
  315. with open(DEST, "r") as fp:
  316. template = fp.read().decode(ENCODING)
  317. data = yaml.load(text)
  318. result = process(template, data)
  319. with open(DEST, "w") as fp:
  320. fp.write(result.encode(ENCODING))
  321. if __name__ == "__main__":
  322. main()