def post_arg_func(asp, ins): post_arg_funcs = { 0xb80c: "WB", 0xb821: "WB", 0xb836: "W", 0xb846: "WWW", 0xb86c: "WWW", 0xb892: "WWW", 0xb989: "WWW", 0xbabc: "WW", 0xbb60: "WWW", 0xbca1: "WWW", 0xbdeb: "WW", } for f in ins.flow_out: i = post_arg_funcs.get(f.to) if i is None: continue ins.flow_out = [] ins += code.Call(to=f.to) a = ins.hi for j in i: if j == "W": d = asp.bu16(a) data.Dataptr(asp, a, a + 2, d) a += 2 if d >= 0x8000: d_q(asp, d) elif j == "B": cbyte(asp, a) # data.Data(asp, a, a + 1) a += 1 else: assert False ins += code.Jump(to=a)
def lexer(pj): assert pj.pg == 4 class lex(data.Data): def __init__(self, pj, lo, pfx): hi = lo + 4 self.f = pj.m[lo + 1] self.t = pj.m.bu16(lo + 2) self.pfx = pfx + "%c" % pj.m[lo] if self.f > 0: hi += 1 super().__init__(pj, lo, hi, "lex") if self.f > 0 and self.pfx in hpib: self.lcmt += hpib[self.pfx] + "\n" self.compact = True if self.f > 0: pj.m.set_label(self.t, "J_" + self.pfx) cpu.disass(self.t) h = hpib.get(self.pfx) if h == None: h = "UNDOC!" y=pj.m.find_lo(self.t) assert len(y) == 1 y[0].lcmt += "HPIB: " + h + "\n" def render(self, pj): s = ".LEX\t\"%s\", " % self.pfx s += "%d, " % pj.m[self.lo + 1] s += pj.render_adr(pj.m.bu16(self.lo + 2)) if self.f: s += ", 0x%02x" % pj.m[self.lo + 4] return s def tx(a, pfx): t0 = a while pj.m[a] != 0: y = lex(pj, a, pfx) a = y.hi if y.f == 0: b = pj.m.bu16(y.lo + 2) p = pfx + "%c" % pj.m[y.lo] pj.m.set_label(b, "LEX_" + p) tx(b, p) data.Const(pj, a, a + 1) pj.m.set_label(0x9780, "LEXTAB_ALPHABET") n = 65 for i in range(0x9780, 0x97b4, 2): data.Dataptr(pj.m, i, i + 2, pj.m.bu16(i)) a = pj.m.bu16(i) if n != 0x5a: pj.m.set_label(a, "LEX_%c" % n) else: pj.m.set_label(a, "LEX_NULL") tx(a, "%c" % n) n += 1 pj.m.set_label(0x9a22, "LEXTAB_OTHER") tx(0x9a22, "")
def inline_args(asp, ins): for f in ins.flow_out: i = i_args.get(f.to) if i is None: continue ins.flow_out = [] ins += code.Call(to=f.to) a = ins.hi for j in i: if j == "i": d = asp.bu16(a) data.Dataptr(asp, a, a + 2, d) a += 2 else: print("IARG:", j) assert False ins += code.Jump(to=a)
def inline_args(pj, ins): for f in ins.flow_out: i = i_args.get(f.to) if i == None: continue ins.flow_out = [] ins.add_flow(pj, "C", True, f.to) a = ins.hi for j in i: if j == "i": d = pj.m.bu16(a) data.Dataptr(pj, a, a + 2, d) a += 2 else: print("IARG:", j) assert False ins.add_flow(pj, ">", True, a) return
def post_arg_func(pj, ins): post_arg_funcs = { 0xb80c: "WB", 0xb821: "WB", 0xb836: "W", 0xb846: "WWW", 0xb86c: "WWW", 0xb892: "WWW", 0xb989: "WWW", 0xbabc: "WW", 0xbb60: "WWW", 0xbca1: "WWW", 0xbdeb: "WW", } for f in ins.flow_out: i = post_arg_funcs.get(f.to) if i == None: continue ins.flow_out = [] ins.add_flow(pj, "C", True, f.to) a = ins.hi for j in i: if j == "W": d = pj.m.bu16(a) data.Dataptr(pj, a, a + 2, d) a += 2 if d >= 0x8000: d_q(pj, d) elif j == "B": cbyte(pj, a) # data.Data(pj, a, a + 1) a += 1 else: assert False ins.add_flow(pj, ">", True, a) return
def dptr(pj, a): v = pj.m.bu16(a) data.Dataptr(pj, a, a + 2, v) return v
def example(): cx = mc6809.mc6809() cx.m.map( mem.Stackup((FILENAMES[0], ), nextto=__file__), 0x0000, ) cx.m.map( mem.Stackup((FILENAMES[1], ), nextto=__file__), 0xe000, ) s = 0 for a in range(0x0000, 0x2000, 2): s += cx.m.bu16(a) print("SUM 0x0000-0x1fff = 0x%x" % s) s = 0 for a in range(0xe000, 0x10000, 2): s += cx.m.bu16(a) print("SUM 0xe000-0xffff = 0x%x" % s) cx.add_ins(our_desc, our_ins) for a, b in SYMBOLS.items(): cx.m.set_label(a, b) gpu = hp1345a.hp1345a() cx.vectors(which=("RST", "NMI", "SWI", "IRQ", "FIRQ", "SWI2")) if True: # screen texts a = 0xd95 while a < 0xf4d: z = Scrtxt(cx.m, a) a = z.hi Scrtxt(cx.m, 0x01db) Scrtxt(cx.m, 0xea56) Scrtxt(cx.m, 0xea6a) Scrtxt(cx.m, 0xea7d) Scrtxt(cx.m, 0xee37) Scrtxt(cx.m, 0xee51) Scrtxt(cx.m, 0xfa6d) if True: n = 0 c = {} while cx.m.bu16(0xfd0 + n): y = data.Txt(cx.m, 0xfd0 + n, 0xfd0 + n + 2, align=1) ta = 0x1062 + n t = cx.m.bu16(ta) z = data.Codeptr(cx.m, ta, ta + 2, t) z.lcmt += y.txt cx.disass(t) if t not in c: c[t] = [] if y.txt not in CMDS: print("Undoc command", y.txt) CMDS[y.txt] = [t, "???"] else: CMDS[y.txt][0] = t c[t].append(y.txt) n += 2 for i in c: c[i].sort() cx.m.set_label(i, "CMD_" + "_".join(c[i])) for i in CMDS: c = CMDS[i] if c[0] == 0: print(i, "CMD not implemented (" + c[1] + ")") continue if c[1][0] == "?": print(i, "CMD not documented (%s)" % c[1][1:]) cx.m.set_block_comment(c[0], " COMMAND " + i + " - " + c[1]) if True: for a in (0x129d, 0x17e3, 0x181e, 0xe0e3, 0xee7e): w = cx.m[a + 1] + 1 t = cx.m.bu16(a + 4) for i in range(w): d = cx.m.bu16(t) data.Codeptr(cx.m, t, t + 2, d) cx.disass(d) t += 2 if True: # Random strings ttab(cx.m, 0xf019, 0xf03b) ttab(cx.m, 0xf1d1, 0xf25c) ttab(cx.m, 0xf412, 0xf44c) ttab(cx.m, 0xefd7, 0xeff7) if True: a = 0xf56e while cx.m[a]: y = data.Txt(cx.m, a, a + 6, label=False, align=1) a = y.hi if True: for a in range(0xf811, 0xf825, 2): #d = cx.m.bu16(a) cx.codeptr(a) #cx.disass(d) if True: # HP1345 testpatterns cx.m.set_label(0xfbed, "IMG_PIKES_PEAK") cx.m.set_label(0xfd41, "IMG_FOCUS") for a0 in (0xfbed, 0xfd41): a = a0 data.Const(cx.m, a, a + 2, func=cx.m.bu16, fmt="0x%x", size=2) l = cx.m.bu16(a) a += 2 hp1345_render.svg(cx.m, a, a + l * 2) while l > 0: gpu.disass(a, cx.m) a += 2 l -= 1 if True: # No idea, possibly length error in IMG_FOCUS ? data.Const(cx.m, 0xff17, 0xff19, fmt="0x%04x", func=cx.m.bu16, size=2) if True: # Special character handling b = 0xf75b c = 0xf778 cx.m.set_label(b, "CHR_TBL_KEY") cx.m.set_label(c, "CHR_TBL_PTR") data.Const(cx.m, b, c, fmt="0x%x") a = c while b < c: p = cx.m.bu16(a) y = data.Dataptr(cx.m, a, a + 2, p) cx.m.set_label(p, "CHR_TBL_%02x" % cx.m[b]) while True: z = data.Const(cx.m, p, p + 2, func=cx.m.bu16, fmt="0x%x", size=2) if cx.m[p + 1] & 0x80: break p += 2 b += 1 a += 2 # Stuff not accessed from anywhere cx.disass(0xe5a1) cx.m.set_block_comment(0xe5a1, "Unused ROM checksum code") cx.m.set_block_comment(0xe5a1, "NB: Expects low rom at 0xc000") cx.disass(0x1acf) cx.disass(0xebf0) cx.m.set_block_comment(0x003b9, "Outputs $0x0c - Term (not comma)") cx.m.set_block_comment(0x003b9, "Outputs $0x12 - Error") cx.m.set_block_comment(0x003b9, "Outputs $0x1a = 0") cx.m.set_block_comment(0x003b9, "Outputs $0x1b - Digits") cx.m.set_block_comment(0x003b9, "Outputs $0x1f - Decimals") cx.m.set_block_comment(0x003b9, "Outputs $0x27 - Negative") cx.m.set_block_comment(0x003b9, "Outputs $0x31+32 - Number") cx.m.set_block_comment(0xf895, "Set reset, clear interrupt, Clr reset") return NAME, (cx.m, )
def task(pj, cx): cx.register_labels(pj) cx.vectors(pj) def cbyte(pj, a): c = data.Const(pj, a, a + 1) c.val = pj.m.rd(a) c.typ = ".BYTE" c.fmt = "0x%02x" % c.val return c def cword(pj, a): c = data.Const(pj, a, a + 2) c.val = pj.m.bu16(a) c.typ = ".WORD" c.fmt = "0x%04x" % c.val return c class d_chain(data.Data): def __init__(self, pj, a): super(d_chain, self).__init__(pj, a, a + 4) self.num = '%c%c%c' % ( pj.m.rd(self.lo), pj.m.rd(self.lo + 1), pj.m.rd(self.lo + 2), ) def render(self, pj): return ".STRUCT chain { '%c%c%c', %d }" % ( pj.m.rd(self.lo), pj.m.rd(self.lo + 1), pj.m.rd(self.lo + 2), pj.m.rd(self.lo + 3), ) class d_asf(data.Data): def __init__(self, pj, a): super(d_asf, self).__init__(pj, a, a + 16) def render(self, pj): s = ".STRUCT asf {" t = " " for i in range(0, 16, 2): s += t + "%6d" % pj.m.bu16(self.lo + i) t = ", " s += "}" return s class d_q(data.Data): """ Numbers are sign + 31 bit binary q-complement fractions: [Sign][31 bit fraction] """ def __init__(self, pj, a, lbl=True): if pj.find(a, ".D4") != None: return super(d_q, self).__init__(pj, a, a + 4, ".D4") self.val = pj.m.bu32(a) self.dec = self.val if self.dec & 0x80000000: self.dec &= 0x7fffffff self.dec *= -1 self.dec *= 2**-31 if lbl: pj.set_label(self.lo, "Q_%04x_%g" % (self.lo, self.dec)) def render(self, pj): if self.dec != 0.0: b = 1.0 / self.dec else: b = 0. return ".D4 %12g = 1/%g" % (self.dec, b) ####################################################################### led_map = [1, 2, 4, 128, 64, 16, 32, 8, 0] seven_segment.table(pj, 0xecb4, 0xecd4, map=led_map, verbose=False) pj.set_label(0xecb4, "7SEG_TBL") LED_lbl = { 0xf94d: "_PL-99___LORAN-C", 0xf95d: "__Progr____PL-15", 0xf96d: "_Please___Choose", 0xf97d: "Lat-Lon___or_Gri", 0xf98d: "__L-L=4____Gri=7", 0xf99d: "Enter____Gri____", 0xf9ad: "Enter____Lat-Lon", 0xf9bd: "________________", 0xf9cd: "_Enter___Fn_no__", 0xf9dd: "_______A_Gri___0", 0xf9ed: "Search_A_Gri___0", 0xf9fd: "SAVE_in_____no__", 0xfa0d: "___no_______Fn__", 0xfa1d: "_________CAL____", 0xfa2d: "Enter______deg__", 0xfa3d: "8888888888888888", 0xfa4d: "Oscil___________", 0xfa5d: "__AREA____CHANGE", 0xfa6d: "__Pri=1____Alt=4", 0xfa7d: "_reset___spd_fil", 0xfa8d: "__speed___filter", 0xfa9d: "__slo_____15_set", 0xfaad: "regular___15_set", 0xfabd: "___fast___15_set", 0xfacd: "__slo=1____reg=2", 0xfadd: "_fast=3__A5_15=C", 0xfaed: "display_____no__", 0xfafd: "_Go_to______no__", 0xfb0d: "no_ASF___Entered", 0xfb1d: "__ASF____Entered", 0xfb2d: "CHANGE_____by__0", 0xfb3d: "Enter____ASF____", 0xfb4d: "Enter_______no__", 0xfb5d: "1_For0___2_For00", 0xfb6d: "Start_______no__", 0xfb7d: "__L-L=4____tds=7", 0xfb8d: "________________", 0xfb9d: "_fast____Average", 0xfbad: "regular__Average", 0xfbbd: "__Light_____on__", 0xfbcd: "__Light_____off_", 0xfbdd: "_dest_______no__", 0xfbed: "Select______no__", 0xfbfd: "__________Cntr__", 0xfc0d: "_____00__set_CL_", 0xfc1d: "_____00_____CL0C", 0xfc2d: "_____00__set_ttG", 0xfc3d: "_____00______ttG", 0xfc4d: "ASF______Entr___", 0xfc5d: "Arr_0____dist___", 0xfc6d: "Anchor______no__", 0xfc7d: "Anchor____dist__", 0xfc8d: "set_0____d55____", 0xfc9d: "Clr_cyc___Error_", 0xfcad: "__Plan______Fn__", 0xfcbd: "_CHANGE____Gri__", 0xfccd: "_Cold_____Start_", 0xfcdd: "reStart_________", 0xfced: "__YE5=1_____no=4", 0xfcfd: "reset____hot_t__", 0xfd0d: "reset____cold_t_", 0xfd1d: "__route_____no__", 0xfd2d: "__route_____no-_", 0xfd3d: "__Use=1__displ=4", 0xfd4d: "Pt___15___done=4", 0xfd5d: "__End=1___Cont=4", 0xfd6d: "speed____display", 0xfd7d: "_Crse=1___Grnd=4", 0xfd8d: "set_brg___corr=0", 0xfd9d: "_Seed____Lat-Lon", 0xfdad: "_Output__data_on", 0xfdbd: "_Output__dataoff", 0xfdcd: "_Auto=1____not=4", 0xfddd: "_Clear_____ASF__", 0xfded: "Input____OSC____", 0xfdfd: "___SELF_____TRAC", } for a in range(0xf94d, 0xfdfe, 16): c = seven_segment.table(pj, a, a + 16, map=led_map, verbose=False) t = LED_lbl.get(a) assert t != None if t == None: # Try to construct a string ourselves... t = "" for i in c: if i == None: t += "?" elif len(i) == 1: t += i elif i == "blank": t += "_" else: t += "?" pj.set_label(a, "MSG_" + t) ####################################################################### def post_arg_func(pj, ins): post_arg_funcs = { 0xb80c: "WB", 0xb821: "WB", 0xb836: "W", 0xb846: "WWW", 0xb86c: "WWW", 0xb892: "WWW", 0xb989: "WWW", 0xbabc: "WW", 0xbb60: "WWW", 0xbca1: "WWW", 0xbdeb: "WW", } for f in ins.flow_out: i = post_arg_funcs.get(f.to) if i == None: continue ins.flow_out = [] ins.add_flow(pj, "C", True, f.to) a = ins.hi for j in i: if j == "W": d = pj.m.bu16(a) data.Dataptr(pj, a, a + 2, d) a += 2 if d >= 0x8000: d_q(pj, d) elif j == "B": cbyte(pj, a) # data.Data(pj, a, a + 1) a += 1 else: assert False ins.add_flow(pj, ">", True, a) return cx.flow_check.append(post_arg_func) ####################################################################### def bogo_flow(pj, ins): for f in ins.flow_out: if f.to == None: pass elif f.to < 0x8000 or f.to > 0xffff: print("BOGO", ins) cx.flow_check.append(bogo_flow) ####################################################################### chains = [] x = pj.add(0x9d20, 0x9d68, "chain-tbl") pj.set_label(x.lo, "CHAINS") for a in range(x.lo, x.hi, 4): chains.append("GRI_" + d_chain(pj, a).num + "0") """ This is probably ASF data (Based partially on number of records = 204) """ x = pj.add(0x9d68, 0xaa28, "asf-tbl") for a in range(x.lo, x.hi, 16): d_asf(pj, a) # ON_KEY table x = pj.add(0xe072, 0xe0e2, "on-key-tbl") pj.set_label(x.lo, "ON_KEY_TBL") n = 0x80 for a in range(x.lo, x.hi, 2): x = cx.codeptr(pj, a) pj.set_label(x.dst, "ON_KEY_0x%02x" % n) n += 1 # CMD table x = pj.add(0x9b81, 0x9bff, "cmd-tbl") pj.set_label(x.lo, "CMDTBL") for a in range(x.lo, x.hi, 3): y = data.Txt(pj, a, a + 1, label=False) z = cx.codeptr(pj, a + 1) if y.txt == " ": pj.set_label(z.dst, "CMD_SP") else: pj.set_label(z.dst, "CMD_%s" % y.txt) # FN table x = pj.add(0xf885, 0xf94d, "fn-tbl") pj.set_label(x.lo, "FN_TBL") d = dict() n = 0 for a in range(x.lo, x.hi, 2): y = cx.codeptr(pj, a) if not y.dst in d: d[y.dst] = [] d[y.dst].append(n) n += 1 for i in d: e = d[i] if len(e) == 1: pj.set_label(i, "FN_%02d" % e[0]) elif len(e) > 10: pj.set_label(i, "FN_UNDEF") else: pj.set_label(i, "FN_%02d_%02d" % (e[0], e[-1])) def longitude(pj, a): """ This gives values closely matching table values """ x = d_q(pj, a, lbl=False) s = "" v = x.dec * 180. if v < 0: v *= -1 s += "W" v = 180. - v else: s += "E" deg = v.__trunc__() v -= deg s += "%4d" % deg v *= 60 mi = v.__trunc__() v -= mi s += " %2d'" % mi v *= 60 s += ' %2.3f"' % v x.lcmt = s return x def lattitude(pj, a): """ This calculation is not quite right. """ x = d_q(pj, a, lbl=False) s = "" v = x.dec * 90. v = 108 - v if v < 0: v *= -1 s += "S" v = 180. - v else: s += "N" deg = v.__trunc__() v -= deg s += "%4d" % deg v *= 60 mi = v.__trunc__() v -= mi s += " %2d'" % mi v *= 60 s += ' %2.3f"' % v x.lcmt = s return x # # Chain data, idx'ed by 0x9d20 # x = pj.add(0xaa29, 0xb131, "tbl") n = 0 for a in range(x.lo, x.hi, 100): x = pj.add(a, a + 100, "chain-tbl") pj.set_label(a, "CHAIN_" + chains[n]) x = cword(pj, a) x.lcmt = "GRI %d * 5" % (x.val / 5) #data.Data(pj, a, a + 100) x = pj.add(a + 0x02, a + 0x02 + 5 * 4, "alpha-tbl") x = pj.add(a + 0x16, a + 0x16 + 5 * 4, "beta-tbl") x = pj.add(a + 0x2a, a + 0x2a + 5 * 4, "gamma-tbl") for c in range(5): d_q(pj, a + 0x02 + c * 4, lbl=False) lat = lattitude(pj, a + 0x16 + c * 4) lon = longitude(pj, a + 0x2a + c * 4) x = pj.add(a + 0x3e, a + 0x3e + 4 * 4, "rho-tbl") x = pj.add(a + 0x4e, a + 0x4e + 4 * 4, "sigma-tbl") for c in range(4): x = d_q(pj, a + 0x3e + c * 4, lbl=False) x.lcmt = "%.3f us / 2^23" % (x.dec * 2**23) d_q(pj, a + 0x4e + c * 4, lbl=False) x = pj.add(a + 0x5e, a + 0x5e + 5, "epsilon-tbl") for c in range(5): cbyte(pj, a + 0x5e + c) x = cbyte(pj, a + 99) x.lcmt = "# slaves" n += 1 for a in range(0xc2fe, 0xc38e, 4): d_q(pj, a) # idx into tbl at b156 # Chain data (18 pieces) # x = pj.add(0xb132, 0xb155, "tbl") n = 0 for a in range(x.lo, x.hi, 2): y = cword(pj, a) y.lcmt = chains[n] pj.set_label(0xb156 + y.val, "CHAIN_I_" + chains[n]) n += 1 x = pj.add(0xb156, 0xb43e, "tbl") for a in range(x.lo, x.hi, 4): #data.Data(pj, a, a + 4) d_q(pj, a, lbl=False) for a in range(0xc3a6, 0xc41e, 4): d_q(pj, a) for a in range(0x906f, 0x9087, 2): c = cword(pj, a) c.fmt = "%d" % c.val x = pj.add(0x9d00, 0x9d20, "tbl") x.lcmt += "accessed via 0x9cc2 pointer" for a in range(x.lo, x.hi, 2): c = cword(pj, a) pj.todo(0x9102, cx.disass) pj.todo(0x95da, cx.disass) pj.todo(0x9b29, cx.disass) pj.todo(0x9a96, cx.disass) pj.todo(0x9b44, cx.disass) pj.todo(0x9b57, cx.disass) pj.todo(0xdda1, cx.disass) pj.todo(0xdde0, cx.disass) pj.todo(0xde00, cx.disass) pj.todo(0xde20, cx.disass) pj.todo(0xf719, cx.disass) for a in range(0x9789, 0x97a5, 4): d_q(pj, a) for i in range(0xf220, 0xf226, 2): data.Dataptr(pj, i, i + 2, pj.m.bu16(i)) cword(pj, i + 6) #for i in range(0x89d8, 0x8a20, 2): # data.Dataptr(pj, i, i + 2, pj.m.bu16(i)) for i in range(0xe363, 0xe369, 2): x = cx.codeptr(pj, i) x = pj.add(0xb963, 0xb975, "tbl") for i in range(x.lo, x.hi): cbyte(pj, i) data.Data(pj, 0xca73, 0xca7c) data.Data(pj, 0xec7c, 0xec81) data.Data(pj, 0xec81, 0xec85) data.Data(pj, 0xec85, 0xec8b) data.Data(pj, 0xec8b, 0xec91) d_q(pj, 0xcb70) d_q(pj, 0xd4f5) d_q(pj, 0xd4f9) d_q(pj, 0xd4fd) d_q(pj, 0xd501) while pj.run(): pass pj.set_label(0x6489, "CHAIN_PTR") pj.set_label(0xb800, "MEMCPY(X, Y, B)") pj.set_label(0xb80c, "SHR_Q") pj.set_label(0xb821, "SHL_Q") pj.set_label(0xb836, "COM_Q") pj.set_label(0xb846, "ADD_Q") pj.set_label(0xb86c, "SUB_Q") pj.set_label(0xb892, "MUL_Q") pj.set_label(0xec91, "7SEG_XLAT(0x66a9)") pj.set_label(0xecaa, "7SEG_DIG(B)") pj.set_label(0xecd4, "DISPLAY(Y)") pj.set_label(0xf1a9, "DISPLAY_YES_NO(Y)") pj.set_label(0xf1b7, "IS_YES()") pj.set_label(0xf878, "PAUSE()") pj.set_label(0xfe5c, "Analog_Capture") pj.set_label(0xfe6e, "Capture_One_Analog") pj.set_label(0xf9, "ON_KEY")
def hints(pj, cpu): if pj.pg == 0: Menu(pj, cpu, 0x433e, "CHANMENU") # @0x8948 data.Const(pj, 0x4003, 0x4004) # @0x8954 for a,n in [ [ 0x4008, "START_TONE_APP" ], [ 0x400a, "START_DTMF_APP" ], [ 0x400c, "START_DSEQ_APP" ], [ 0x4022, "START_DIAG_APP" ], [ 0x4024, "START_XX5_APP" ], [ 0x404f, "START_ERR_APP" ], ]: cpu.codeptr(a) u = pj.m.bu16(a) pj.m.set_label(u, n.lower()) pj.m.set_label(a, n) cpu.codeptr(0x4004) cpu.codeptr(0x4006) for a in range(0x400e, 0x4018, 2): cpu.codeptr(a) for a in range(0x4018, 0x4022, 2): y = data.Dataptr(pj.m, a, a + 2, pj.m.bu16(a)) u = pj.m.bu16(a) y = data.Txt(pj, u, u + 40, label=False) y.compact = True # @0xc4a5, @0xc318 for a in range(0x404f,0x4053,2): cpu.codeptr(a) for a,b in ( (0x4027, 0x28), (0x411b, 0x28), (0x4143, 0x28), (0x416b, 0x28), (0x4193, 0x28), (0x4391, 0x04), (0x4395, 0x0f), (0x43a4, 0x0c), (0x43b0, 0x0d), (0x5cce, 0x1), (0x5cd0, 0x1), (0x5cd2, 0x1), (0x5cd4, 0x1), ): y = data.Txt(pj, a, a + b, label=False) y.compact = True y = data.Txt(pj, 0x41bb, 0x41bb + 12, label=False) y.compact = True if pj.pg == 1: Menu(pj, cpu, 0x416b, "TONEMENU") Menu(pj, cpu, 0x4234, "DTMFMENU") for a,n in ( (0x5609, 7), (0x69a6, 0x28), (0x69d1, 5), ): y = data.Txt(pj, a, a + n, label=False) y.compact = True for a in (0x4142,0x4156): y = data.Txt(pj, a, a + 0x14, label=False) y.compact = True for a in range(0x43bc, 0x43f2, 3): data.Const(pj, a, a + 3) Num(pj, 0x4262) Num(pj, 0x4265) if pj.pg == 2: Menu(pj, cpu, 0x416b, "DSEQMENU") for a in range(0x4245, 0x4255, 2): cpu.codeptr(a) for a in range(0x4330, 0x4340, 2): cpu.codeptr(a) for a,b in ( (0x5144,20), (0x5159,20), (0x516f,3), (0x5173,3), (0x5177,3), (0x517b,5), ): y = data.Txt(pj, a, a + b, label=False) y.compact = True if pj.pg == 3: Menu(pj, cpu, 0x4178, "DIAGMENU") MenuPage(pj, cpu, 0x4196) for i in range(0x3f): a = 0x7349 + 4 * i y = data.Const(pj, a, a + 2) y.typ = ".BYTE" y.fmt = "%d, %d" % (pj.m[a], pj.m.[a + 1]) u = pj.m.bu16(a + 2) l = pj.m[a + 1] data.Dataptr(pj.m, a + 2, a + 4, pj.m.bu16(a + 2)) y = data.Txt(pj, u, u + l, label=False) y.compact = True for a,b in ( (0x4002,53), (0x4466,6), (0x7339,3), (0x733d,3), (0x550f,2), ): y = data.Txt(pj, a, a + b, label=False) y.compact = True for a in range(0x63da, 0x665a, 40): y = data.Txt(pj, a, a + 40, label=False) y.compact = True a = 0x4c64 while a < 0x4dcb: y = data.Txt(pj, a) y.compact = True a = y.hi a = 0x54cf while a < 0x550d: y = data.Txt(pj, a) y.compact = True a = y.hi a = 0x624d while a < 0x63a4: y = data.Txt(pj, a) y.compact = True a = y.hi for a in range(0x4a3f, 0x4aad, 2): y = pj.m.bu16(a) assert pj.m[y] == 0xcc x = pj.m.bu16(y + 1) z = pj.m.find_lo(x) if len(z) > 0: t = z[0].txt[:-4].strip().replace(" ","_") pj.m.set_label(y, "test_key_" + t) Num(pj, 0x684a) if pj.pg == 4: data.Const(pj, 0xfd6e, 0xfd70) for a in range(0xee62, 0xee88, 2): u = pj.m.bu16(a) y = data.Dataptr(pj.m, a, a + 2, u) y = data.Const(pj, u, u + 1) y = data.Txt(pj, u + 1, u + 1 + pj.m[u], label=False) y.compact = True for a in range(0xeeee, 0x0ef0e, 2): u = pj.m.bu16(a) y = data.Dataptr(pj.m, a, a + 2, u) y = data.Const(pj, u, u + 1) y = data.Txt(pj, u + 1, u + 1 + pj.m[u], label=False) y.compact = True for a in range(0xef94, 0xf014, 8): y = data.Const(pj, a, a + 8, fmt="0x%02x") for a,b in ( (0x8f7c,35), (0x977b, 5), (0xed11,40), (0xea99,0x23), (0xeb41,40), (0xeb69,40), (0xec5b,14), (0xec69,14), (0xec77,14), (0xec85,0x36), (0xecbb,6), (0xecc1,40), (0xece9,40), ): y = data.Txt(pj, a, a + b, label=False) y.compact = True def char_def(pj, a): for i in range(8): y = data.Data(pj, a + i, a + i + 1) x = pj.m[a + i] y.fmt = ".BITS\t" for j in range(8): if x & 0x80: y.fmt += "#" else: y.fmt += "-" x = x << 1 l = [ "LCD_CHR_f", "LCD_CHR_1", "LCD_CHR_2", "LCD_CHR_3", "LCD_CHR_4", "LCD_CHR_phi", "LCD_CHR_mu", "LCD_CHR_is", ] for a in range(0xea15, 0xea4e, 8): pj.m.set_label(a, l.pop(0)) char_def(pj, a) data.Const(pj, 0x929d, 0x929d + 8) data.Const(pj, 0x9777, 0x9777 + 4) data.Const(pj, 0xdd73, 0xdd9d) # 2 x 35 bytes, no idea... for a in range(0xed89, 0xedcf, 5): data.Const(pj, a, a + 5, "0x%02x") n = 1 for a in range(0xae3d, 0xaea5, 2): print("%x -> " % a + keys[n]) u = pj.m.bu16(a) if u != 0xae22: pj.m.set_label(u, "key_" + keys[n]) n += 1 Num(pj, 0xea55) Num(pj, 0xea6e) Num(pj, 0xea65) Num(pj, 0xea6b) Num(pj, 0xea62) Num(pj, 0xea68) for a in range(0xee4a,0xee62, 3): Num(pj,a) for a in range(0xef4a, 0xef94, 2): y = data.Const(pj, a, a + 2, fmt="0x%02x") i = keys.get(pj.m[a]) j = keys.get(pj.m[a + 1]) y.lcmt += "%8s | %-8s\n" % (i, j)
def __init__(self, pj, adr, cx): super(vector, self).__init__(pj, adr, adr + 4) self.ws = data.Dataptr(pj, adr + 0x00, adr + 0x02, pj.m.bu16(adr)) self.ip = cx.codeptr(pj, adr + 0x02) self.dstadr = self.ip.dst
def task(pj, cpu): # Where ? # y = data.Const(pj, 0xfffe, 0x10000) # pj.set_label(y.lo, "eprom_lo_chksum") y = data.Const(pj, 0x19854, 0x19856) pj.set_label(y.lo, "eprom_hi_chksum") ############################################################### ############################################################### # Functions taking arguments after call instruction post_arg = { 0x1bc8: ("BCD_CMP", "brel", "D01"), 0x1bcc: ("BCD_CMP", "babs", "D01"), 0x1bd0: ("BCD_CMP", "bA6rel", "D01"), 0x1bdc: ("BCD_CMP", "D01", "babs"), 0x1be0: ("BCD_CMP", "D01", "bA6rel"), 0x1c52: ("BCD_ADD", "brel", "D01"), 0x1c56: ("BCD_ADD", "babs", "D01"), 0x1c5a: ("BCD_ADD", "bA6rel", "D01"), 0x1c5e: ("BCD_ADD", "stk", "D01"), 0x1c76: ("BCD_SUB", "brel", "D01"), 0x1c7a: ("BCD_SUB", "babs", "D01"), 0x1c7e: ("BCD_SUB", "bA6rel", "D01"), 0x1c88: ("BCD_SUB", "brel", "D01"), 0x1c8c: ("BCD_SUB", "babs", "D01"), 0x1c90: ("BCD_SUB", "bA6rel", "D01"), 0x1ccc: ("", "dabs", "FPXXX"), 0x2218: ("BCD_LD_D01", "bcd"), 0x223c: ("BCD_LD_D23", "bcd"), 0x238e: ("", "drel", "FPXXX"), 0x239a: ("", "dA6rel", "FPXXX"), 0x23f6: ("", "drel", "FPXXX"), 0x2402: ("", "D0+D1", "dA6rel"), 0x24ac: ("", "drel", "FPXXX"), 0x24b8: ("", "dA6rel", "FPXXX"), 0x24c4: ("", "drel", "FPXXX"), 0x25b0: ("", "drel", "FPXXX"), 0x25c8: ("", "drel", "FPXXX"), 0x25fa: ("", "dA6rel", "FPXXX"), 0x27ee: ("", "lrel", "FPXXX"), 0x2862: ("", "lrel", "LFXXX"), 0x28c2: ("", "lrel", "LFXXX"), 0x28ce: ("", "fabs", "LFXXX"), 0x297c: ("", "fA6rel", "LFXXX"), 0x2982: ("", "fabs", "LFXXX"), 0x2988: ("", "frel", "FFXXX"), 0x29ba: ("", "fA6rel", "LFXXX"), 0x29c6: ("", "frel", "FFXXX"), 0x29ea: ("", "fA6rel", "LFXXX"), 0x29f6: ("", "frel", "FFXXX"), 0x2a02: ("", "fA6rel", "LFXXX"), 0x2a0e: ("", "frel", "FFXXX"), 0x2a34: ("", "frel", "FFXXX"), 0x2a6e: ("", "frel", "FFXXX"), 0x2b08: ("", "fA6rel", "LFXXX"), 0x2b14: ("", "frel", "FFXXX"), 0x2b2c: ("", "frel", "FFXXX"), } for i in post_arg: j = post_arg[i] if len(j) > 0 and j[0] != "": pj.set_label(i, j[0]) def flow_post_arg(pj, ins): z = post_arg.get(ins.dstadr) if z == None: return ins.flow_out.pop(-1) if len(z) <= 1: a = data.Pstruct(pj, ins.hi, ">h", "%d", ".INFIX").hi ins.add_flow(pj, ">", True, a) return l = [] for i in z[1:]: if i[1:] == "A6rel": r = pj.m.bs16(ins.hi) ins.hi += 2 if r < 0: l.append("(A6-0x%x)" % -r) else: l.append("(A6+0x%x)" % r) elif i[1:] == "abs": r = pj.m.bu16(ins.hi) if r & 0x8000: r |= 0xffff0000 ins.hi += 2 l.append("0x%08x" % r) elif i == "drel": r = ins.hi + pj.m.bs16(ins.hi) ins.hi += 2 ins.lcmt += " @0x%x\n" % r y = data_double(pj, r) l.append("%g" % y.data[0]) elif i == "brel": r = ins.hi + pj.m.bs16(ins.hi) ins.hi += 2 ins.lcmt += " @0x%x\n" % r y = data_bcd(pj, r); l.append("%x" % y.data[0]) elif i == "lrel": r = ins.hi + pj.m.bs16(ins.hi) ins.hi += 2 ins.lcmt += " @0x%x\n" % r y = data.Pstruct(pj, r, ">L", "%d", ".LONG") l.append("%d" % y.data[0]) elif i == "frel": r = ins.hi + pj.m.bs16(ins.hi) ins.hi += 2 ins.lcmt += " @0x%x\n" % r y = data_float(pj, r) l.append("%g" % y.val) elif i == "bcd": r = pj.m.bu16(ins.hi) y = data.Pstruct(pj, ins.hi, ">H", "%x", ".BCD") l.append("%04x" % r) ins.hi += 2 else: l.append(i) ins.oper.append(assy.Arg_verbatim(pj, "(" + ",".join(l) + ")")) ins.add_flow(pj, True, True, ins.hi) cpu.flow_check.append(flow_post_arg) ############################################################### switches = { 0x13624: { 0: "ALL", 1: "ONEOS", 2: "ONSWP", 3: "TRMATH", }, } def flow_switch(pj, ins): if ins.dstadr != 0x2f38: return ins.flow_out.pop(0) ins.add_flow(pj, ">", "?", ins.hi) pj.set_label(ins.hi, "break_%04x" % ins.lo) y = data.Const(pj, ins.lo - 2, ins.lo) ncase = pj.m.bu16(ins.lo - 2) y.typ = ".NCASE" y.fmt = "%d" % ncase cs = switches.get(ins.lo) if cs == None: cs = {} a = ins.lo - 2 for i in range(ncase): a -= 2 ct = cs.get(i) if ct == None: ct = "_%d" % i w = data.Const(pj, a, a + 2) z = pj.m.bs16(a) w.typ = ".CASE" w.fmt = "0x%x, %d" % (i,z) w.fmt += ", 0x%04x" % (ins.hi + z) ins.add_flow(pj, ">", "0x%x" % i, ins.hi + z) if z < 0: pj.set_label(ins.hi + z, ".case_%04x_%s" % (ins.lo, ct)) cpu.flow_check.append(flow_switch) pj.todo(0x2f38, cpu.disass) ############################################################### keyboard = ( # Row, Column, Text ( 0, 0, "HZ_UV_USEC"), ( 0, 3, "MHZ_DBM_SEC"), ( 0, 5, "BACK_SPACE"), ( 0, 6, "KHZ_MV_MSEC"), ( 1, 0, "SAVE"), ( 1, 1, "RECALL"), ( 1, 2, "HOLD"), ( 1, 4, "0_1_5_GHZ"), ( 1, 6, "POINT"), ( 1, 7, "GHZ_DBM_DB"), ( 2, 0, "DIG_0"), ( 2, 1, "DIG_1"), ( 2, 2, "DIG_2"), ( 2, 3, "DIG_3"), ( 2, 4, "DIG_4"), ( 2, 5, "DIG_5"), ( 2, 6, "DIG_6"), ( 2, 7, "DIG_7"), ( 3, 0, "DIG_8"), ( 3, 1, "DIG_9"), ( 3, 4, "INPUT_1"), ( 3, 5, "FREQ_COUNT"), ( 3, 6, "INPUT_1"), ( 4, 1, "AUTO_RES_BW"), ( 4, 2, "AUTO_VIDEO_BW"), ( 4, 3, "AUTO_SWEEP_TIME"), ( 4, 4, "AUTO_ATTEN"), ( 4, 5, "AUTO_CF_STEP"), ( 4, 6, "RES_BW"), ( 4, 7, "VIDEO_BW"), ( 5, 0, "SWEEP_TIME"), ( 5, 1, "ATTEN"), ( 5, 2, "CF_STEP"), ( 5, 3, "PEAK_SEARCH"), ( 5, 4, "MARKER_OFF"), ( 5, 5, "MARKER_NORMAL"), ( 5, 6, "MARKER_CF"), ( 5, 7, "MARKER_DELTA"), ( 6, 0, "ZOOM"), ( 6, 1, "MKR_DELTA_STP_SIZE"), ( 6, 2, "MKR_REF_LVL"), ( 6, 3, "SIGNAL_TRACK"), ( 6, 4, "DOWN"), ( 6, 5, "UP"), ( 6, 6, "CENTER_FREQ"), ( 6, 7, "FREQ_SPAN"), ( 7, 0, "START_FREQ"), ( 7, 1, "STOP_FREQ"), ( 7, 2, "REF_LEVEL"), ( 8, 0, "NORMAL"), ( 8, 1, "CLEAR_A"), ( 8, 2, "MAX_A"), ( 8, 3, "OFF_A_B"), ( 8, 4, "VIEW_A"), ( 8, 5, "BLANK_A"), ( 8, 6, "A_B"), ( 8, 7, "CLEAR_B"), ( 9, 0, "MAX_B"), ( 9, 1, "A_EX_B"), ( 9, 2, "VIEW_B"), ( 9, 3, "BLANK_B"), ( 9, 4, "B-DL-B"), ( 9, 5, "LINE_OFF"), ( 9, 6, "LINE_ENTER"), ( 9, 7, "THRSH_OFF"), ( 10, 0, "THRSH_ENTER"), ( 10, 1, "ENTER_DB"), ( 10, 2, "LIN"), ( 10, 3, "SHIFT"), ( 10, 4, "CONT"), ( 10, 5, "SINGLE"), ( 10, 6, "TRIG_FREE_RUN"), ( 10, 7, "TRIG_LINE"), ( 11, 0, "TRIG_EXT"), ( 11, 1, "TRIG_VIDEO"), ( 11, 2, "LOWER_LEFT"), ( 11, 4, "LOWER_RIGHT"), ) keynos = {} for r,c,t in keyboard: n = 0x20 + r * 8 + c keynos[n] = t ############################################################### class params(data.Data): def __init__(self, pj, nm, i, j): self.nm = nm self.b = 0x195c4 self.i = i self.j = j self.fi = pj.m.rd(self.b + i) self.args = [] for a in range(j): self.args.append(pj.m.rd(self.b + i + 1 + a)) super(params, self).__init__(pj, self.b + i, self.b + i + 1 + j) self.fp = 0x196b6 + self.fi * 4 self.fa = pj.m.bu32(self.fp) pj.todo(self.fa, cpu.disass) data.Codeptr(pj, self.fp, self.fp + 4, self.fa) pj.set_label(self.fa, "F_" + nm + "(" + self.summ() + ")") def render(self, pj): t = ".PARAM\t" t += "func=%d" % self.fi t += " call=%s" % self.nm t += "(" + self.summ() + ")" return t def summ(self): t = [] for i in self.args: if i == 0x03: t.append("STR") elif i == 0x16: t.append("int") elif i == 0x18: t.append("INT") elif i == 0x19: t.append("REAL") else: t.append("0x%02x" % i) return ",".join(t) def funcidx(self): return self.fi class mnem(data.Data): def __init__(self, pj, hi): lo = hi lo -= 2 self.c = pj.m.bu16(lo) lo -= 2 self.b = pj.m.bu16(lo) lo -= 2 self.a = pj.m.bu16(lo) self.len = self.c & 0xfff self.type = self.c >> 12 lo -= (self.len + 1) & 0xffe super(mnem, self).__init__(pj, lo, hi) self.compact = True a,b,c = data.stringify(pj, self.lo, self.len) self.string = b self.hash = 0 for i in bytearray(self.string, 'ascii'): self.hash += i self.hash %= 13 self.pp = None self.args = None if self.type == 3: self.pp = params(pj, self.string, self.b, self.a >> 8) if self.type == 1: if self.b not in keynos: keynos[self.b] = "CMD_" + self.string def render(self, pj): t = ".MNEM\t" t += "0x%04x" % self.a t += ", 0x%04x" % self.b t += ", 0x%x" % self.type t += ", len=0x%03x" % self.len t += ", hash=%2d" % self.hash t += ", '" + self.string + "'" return t if True: pj.set_label(0x18c3a, "MNETABLE") a = 0x193a0 while a > 0x18c3a: y = mnem(pj, a) x = pj.m.bu16(y.lo - 2) a = y.lo ############################################################### class oldcmd(data.Data): def __init__(self, pj, lo, n): super(oldcmd, self).__init__(pj, lo, lo + 2) x,self.name,y = data.stringify(pj, self.lo, 2) self.key = pj.m.rd(0x194b2 + n) self.imm = (pj.m.rd(0x1951e + (n >> 3)) >> (n & 7)) & 1 if not self.imm: self.svf1 = pj.m.bu16(0x1952c + self.key * 4) self.svf2 = pj.m.bu16(0x1952c + self.key * 4 + 2) if not self.svf2 in keynos: keynos[self.svf2] = "CMD_" + self.name def render(self, pj): t = ".OLDCMD\t" t += "'" + self.name + "'" t += " imm=%x" % self.imm t += " key=%02x" % self.key if self.imm and self.key in keynos: t += " ('" + keynos[self.key] + "')" if not self.imm: t += " svf=0x%04x,0x%04x" % (self.svf1, self.svf2) t += " xxx=%02x" % (self.svf1 & 0x1e) return t if True: pj.set_label(0x193da, "OLDCMDS") n = 0 for a in range(0x193da, 0x194b2, 2): y = oldcmd(pj, a, n) n += 1 # print("OLDCMDS %d" % ((0x194b2-0x193da)/2)) pj.set_label(0x194b2, "KEYTAB") for a in range(0x194b2, 0x1951e, 8): y = data.Const(pj, a, min(a + 8, 0x1951e), fmt="0x%02x") # print("KEYTAB %d" % ((0x1951e-0x194b2)/1)) pj.set_label(0x1951e, "IMEDBITS") for a in range(0x1951e, 0x1952c, 8): y = data.Const(pj, a, min(a + 8, 0x1952c), fmt="0x%02x") # print("IMEDBITS %d" % ((0x1952c-0x1951e)/1)) pj.set_label(0x1952c, "SFLGVAL") for a in range(0x1952c, 0x195c4, 16): y = data.Const(pj, a, min(a + 16, 0x195c4), "0x%08x", pj.m.bu32, 4) # print("SFLGVAL %d" % ((0x195c4-0x1952c)/2)) ############################################################### switches[0x09ae8] = {} switches[0x09d78] = {} switches[0x0a5de] = {} switches[0x0af5c] = {} switches[0x0b5ec] = {} switches[0x0bb4e] = {} switches[0x0bd5a] = {} switches[0x0bd6e] = { 0: "KEYS_00_1f", 1: "KEYS_20_3f", 2: "KEYS_40_5f", 3: "KEYS_60_7f", 4: "KEYS_80_9f", 5: "KEYS_a0_bf", } for n in keynos: t = keynos[n] # print("KEY_%02x" % n, t) sk = "KS%c" % n ksk = hp856x_cmds.cmds.get(sk) if ksk != None and type(ksk) != str: ksk = ksk[1] if ksk == None: ksk = "==" + t if n < 0x20: switches[0x9ae8][n] = "KEY_%02x_" % n + t if n >= 0x20 and n < 0x30: switches[0x9d78][n - 0x20] = "KEY_%02x_" % n + t if n >= 0x40 and n < 0x60: switches[0xa5de][n - 0x41] = "KEY_%02x_" % n + t switches[0xaf5c][n - 0x41] = "KEY_S%02x_KS%c_" % (n, n) + ksk if n >= 0x60 and n < 0x80: switches[0xb5ec][n - 0x61] = "KEY_%02x_" % n + t switches[0xbb4e][n - 0x60] = "KEY_S%02x_KS%c_" % (n, n) + ksk if n >= 0xa0 and n <= 0xbf: switches[0xbd5a][n - 0xa0] = "KEY_%02x_" % n + t if True: for b,e in ( ( 0x0e750, 0x0e778), ( 0x15ca4, 0x15cb4), ): for a in range(b, e, 8): data_double(pj, a) ############################################################### if True: cpu.vectors(pj, hi = 0xc0) ####################################################### for b,e in ( (0x06936, 0x0693a), (0x06a2c, 0x06b84), (0x070ca, 0x070d6), (0x081ae, 0x081ba), (0x1357a, 0x1358a), (0x13e58, 0x13e70), (0x14960, 0x1497c), (0x14c94, 0x14cb4), (0x14f98, 0x14fa8), (0x15094, 0x150a4), (0x15140, 0x15150), (0x15e0e, 0x15e32), (0x172b8, 0x172c4), (0x17dbe, 0x17dce), ): for a in range(b, e, 4): x = pj.m.bu32(a) data.Dataptr(pj, a, a + 4, x) data.Txt(pj, x, pfx=1, align=2) data.Txt(pj, 0x15dfc, pfx=1, align=2) ####################################################### for a in ( 0x0e2fa, 0x0e308, 0x0e318, 0x12986, 0x12988, 0x1298c, 0x12990, 0x1694e, 0x16954, ): y = data.Txt(pj, a, pfx=1, align=2) ####################################################### data.Dataptr(pj, 0xe39a, 0xe39a + 4, pj.m.bu32(0xe39a)) data.Const(pj, 0x2140, 0x2148, "%d", pj.m.bu64, 8) data.Const(pj, 0x2148, 0x214c, "%d", pj.m.bu32, 4) for a in ( 0x0645e, 0x06476, 0x0647e, 0x0648a, 0x06492, 0x0649a, 0x064a6, 0x064be, 0x0e2c4, 0x0e2d4, 0x0e2cc, 0x0e32a, 0x0e332, 0x0e37c, 0x0e384, 0x128ca, 0x15da0, ): y = data_bcd(pj, a) pj.set_label(a, "BCD_%x" % y.data[0]) ####################################################### pj.set_label(0x0693c, "MSG_ADR_X_Y") for a in range(0x693c, 0x6a2c, 6): data.Const(pj, a, a+6, "0x%04x", pj.m.bu16, 2) ####################################################### pj.set_label(0x6b84, "G_CTRL") pj.set_label(0x6ba8, "G_CENTER") pj.set_label(0x6bcc, "G_MARKER") pj.set_label(0x6be2, "G_DSP_LINE") pj.set_label(0x6bf8, "G_GRATICULE") pj.set_label(0x6c4c, "G_HP_LOGO") pj.set_label(0x6c5e, "G_ACT_FUNC") a = 0x6b84 dsp = hp85662a.hp85662a() while a < 0x6c98: x = pj.m.bs16(a) if x < 0: y = data.Data(pj, a, a + 2) y.fmt = ".DSPLOC\t0x%04x" % -x y.lcmt = "adr=%d" % -x dsp = hp85662a.hp85662a() else: y = dsp.disass(pj, a) a = y.hi ####################################################### pj.set_label(0x0e3be, "UNITS") for a in range(0x0e3be, 0x0e3d4, 2): data.Txt(pj, a, a + 2, label=False) ####################################################### # 0ee98 00 01 93 be # 0eeaa 00 01 93 da | | # 0ee8e 00 01 da ee | | ####################################################### # Orphans ? if False: pj.todo(0x01b88, cpu.disass) pj.todo(0x01b8e, cpu.disass) pj.todo(0x01b94, cpu.disass) pj.todo(0x01b9a, cpu.disass) pj.todo(0x01b9e, cpu.disass) pj.todo(0x01ba2, cpu.disass) pj.todo(0x01ba8, cpu.disass) pj.todo(0x01c76, cpu.disass) pj.todo(0x01c82, cpu.disass) pj.todo(0x01c90, cpu.disass) pj.todo(0x01cd2, cpu.disass) pj.todo(0x01d14, cpu.disass) pj.todo(0x01578, cpu.disass) pj.todo(0x01594, cpu.disass) pj.todo(0x0171a, cpu.disass) pj.todo(0x01906, cpu.disass) pj.todo(0x02dee, cpu.disass) pj.todo(0x02df4, cpu.disass) pj.todo(0x03412, cpu.disass) pj.todo(0x11e74, cpu.disass) # from 0x2272 pj.todo(0x2282, cpu.disass) # filled in 0xffffabd2 pj.todo(0x0ed98, cpu.disass) pj.todo(0x0df5e, cpu.disass) # Arg to 0x802 pj.todo(0x3292, cpu.disass) # 0x3284 ####################################################### # pat 4,244,024 pg 262 lin 3700 pj.set_label(0x4fac, "SCANTAB") for a in range(0x4fac, 0x4fec, 2): y = data.Const(pj, a, a+2, "0x%04x", pj.m.bu16, 2) ####################################################### y = data.Const(pj, 0x193a2, 0x193be, "%d", pj.m.bu16, 2) pj.set_label(y.lo, "HASHPTR2") y = data.Const(pj, 0x193be, 0x193da, "%d", pj.m.bu16, 2) pj.set_label(y.lo, "HASHPTR") ####################################################### pj.set_label(0x19826, "PFXSCALE") for a in range(0x19826, 0x19853, 1): y = data.Const(pj, a, a + 1, fmt="0x%02x") # print("PFXSCALE %d" % ((0x19853-0x19826)/1)) else: y = cpu.disass(pj, 0xda1e) for i in y.__dict__: print("\t", i, y.__dict__[i]) while pj.run(): pass for i in pj.t: if i.tag != "m68000": continue if i.dstadr in (0x940c, 0xed54): y = pj.t.find_hi(i.lo) if len(y) != 1: continue y = y[0] if pj.m.rd(y.lo) == 0x70: k = pj.m.rd(y.lo + 1) elif pj.m.bu16(y.lo) == 0x103c: k = pj.m.bu16(y.lo + 2) else: continue if not k in keynos: continue y.oper[0].txt = "#KEY_" + keynos[k] if i.dstadr in (0xe4e8,): y = pj.t.find_hi(i.lo) if len(y) != 1: continue y = y[0] if y.mne != "PEA.L": continue z = data.Txt(pj, y.dstadr, pfx=1, align=2) y.lcmt = "'" + z.txt + "'" if i.dstadr in (0xe718, 0x3456, 0x6ce0): y = pj.t.find_hi(i.lo) if len(y) != 1: continue y = y[0] if pj.m.bu16(y.lo) != 0x203c: continue a = pj.m.bu32(y.lo + 2) z = data.Txt(pj, a, pfx=1, align=2) y.lcmt = "'" + z.txt + "'" if i.dstadr == 0xe718: w = pj.t.find_hi(y.lo) if len(w) != 1: continue w = w[0] if w.mne != "PEA.L": continue z = data.Txt(pj, w.dstadr, pfx=1, align=2) w.lcmt = "'" + z.txt + "'" y = data.Const(pj, 0x693a, 0x693c, "%d", pj.m.bu16, 2) pj.set_label(0x009b8, "RESET") pj.set_label(0x00c2e, "SELFTEST") pj.set_label(0x00d7a, "CPUTEST_FAIL") pj.set_label(0x00e9a, "epromsize") y = data.Const(pj, 0x00e9a, 0x00e9e, "%d", pj.m.bu32, 4) pj.set_label(0x00ef2, "ramaddress") y = data.Const(pj, 0x00ef2, 0x00efe, "0x%08x", pj.m.bu32, 4) pj.set_label(0x00e9e, "ROMSUM") pj.set_label(0x00ec0, "ROMTEST") pj.set_label(0x01ae2, "BCD_FMT(BCD, PTR)") pj.set_label(0x01b34, "BCD_ABS(BCD)") pj.set_label(0x01b38, "BCD_NEG(BCD)") pj.set_label(0x01be6, "BCD_CMP(R01,R23)") pj.set_label(0x01bea, "BCD_CMP(R23,R01)") pj.set_label(0x01c00, "stk_64") pj.set_label(0x01c14, "rel_64") pj.set_label(0x01c28, "abs_64") pj.set_label(0x01c3c, "loc_64") pj.set_label(0x01b48, "BCD_NEG8(&A0)") pj.set_label(0x01b62, "BCD_NEG(D23)") pj.set_label(0x01b72, "BCD_ADD8(&A0,&A1)") pj.set_label(0x01c60, "BCD_ADD(D01, D23)") pj.set_label(0x01c98, "BCD_SUBR(D23, D01(order?)") pj.set_label(0x01c9c, "BCD_SUB(D01, D23(order?)") pj.set_label(0x01cb0, "BCD_SUB8(&A0,&A1)") pj.set_label(0x0214c, "BCD_MUL5(D01)") pj.set_label(0x0217e, "BCD_MUL3(D01)") pj.set_label(0x0218c, "BCD_MUL6(D01)") pj.set_label(0x021be, "BCD_MUL8(D01)") pj.set_label(0x021c0, "BCD_MUL4(D01)") pj.set_label(0x021c4, "BCD_MUL2(D01)") pj.set_label(0x021f6, "BCD_DIV2(D01)") pj.set_label(0x02224, "BCD_LD(D0.W)") pj.set_label(0x0222c, "BCD_LD(D0.L)") pj.set_label(0x023ec, "FD_ABS(R2+R3)") pj.set_label(0x0287e, "rel_32") pj.set_label(0x02892, "abs_32") pj.set_label(0x028a4, "loc_32") pj.set_label(0x02f38, "SWITCH") pj.set_label(0x0320e, "BZERO(PTR,INT)") pj.set_label(0x033fc, "SHOW_CHAR") pj.set_label(0x03412, "SHOW_SEMI") pj.set_label(0x0341a, "SHOW_COMMA") pj.set_label(0x03422, "SHOW_CRNL") pj.set_label(0x03428, "SHOW_NL") pj.set_label(0x03430, "SHOW_MINUS") pj.set_label(0x03438, "SHOW_2CHAR") pj.set_label(0x03498, "SHOW_INT") pj.set_label(0x03932, "DISP_RD(INT ADR)") pj.set_label(0x03958, "SHOW_TXT_AT(ADR,STR)") pj.set_label(0x03906, "DISP_WR(INT ADR, INT DATA)") pj.set_label(0x039b0, "SHOW_WORD(INT)") pj.set_label(0x03c0a, "FREQ_CNT_SET_PERIOD(INT)") pj.set_label(0x03c26, "FREQ_CNT_WAIT()") pj.set_label(0x03c3a, "FREQ_CNT_10MHZ(INT)") pj.set_label(0x06936, "REVISION") pj.set_label(0x0693a, "MODEL") pj.set_label(0x06a2c, "MSG_TXT") pj.set_label(0x06ce0, "SHOW_TXT(STR)") pj.set_label(0x06cf2, "SHOW_CRNL") pj.set_label(0x06cfc, "SET_IF_LEDS(INT)") pj.set_label(0x06d20, "SHOW_MSG") pj.set_label(0x070be, "UPD_DETECTOR") pj.set_label(0x07b4e, "FILL_DISPLAY") pj.set_label(0x08164, "SHOW_CR[NL]") pj.set_label(0x0940c, "EXEC(INT KEY)") pj.set_label(0x0e39a, "VAR_HEAD") pj.set_label(0x0ed54, "EXEC2(INT KEY)") pj.set_label(0x0eddc, "SEARCH(NAMLEN.W, CHAIN.L, HASH.L, NAME.L)") pj.set_label(0x0ee6a, "FIND_OLDCMD(INT)") pj.set_label(0x0f72c, "NAME2TRACE") pj.set_label(0x0a986, "CALIBRATING") pj.set_label(0x0aa7a, "AUTOCAL") pj.set_label(0x13092, "WHICH(PTR TABLE, STR KEY, INT N)") pj.set_label(0x14158, "TRACE_MATH(LONG, INT, STR, STR, STR)") pj.set_label(0x17dce, "SHOW_COMMA") pj.set_label(0x17e9e, "PL_MOVE") pj.set_label(0x17eac, "PL_LINE") #pj.set_label(0x18d24, "MNEM") #pj.set_label(0x195c4, "PARMTYPE") #pj.set_label(0x196b6, "PRCADRS") # 0xffff0005 # 0xffff0007 # 0xffff0009 # 0xffff0013 # 0xffff0019 # 0xffff0021 # 0xffff0027 # 0xffff0035 #pj.set_label(0xffff4000, "PIT_PGCR") #pj.set_label(0xffff4002, "PIT_PSRR") #pj.set_label(0xffff4004, "PIT_PADDR") #pj.set_label(0xffff4006, "PIT_PBDDR") #pj.set_label(0xffff4008, "PIT_PCDDR") #pj.set_label(0xffff4010, "PIT_PADR") #pj.set_label(0xffff4012, "PIT_PBDR") # 0xffff8000 # 0xffffa6ae = stack # 0xffffa6ae # 0xffffa6b2 # 0xffffa6b6 # 0xffffa6ba # 0xffffa6bc # 0xffffa6be # 0xffffa6c2 # 0xffffa6c6 # 0xffffa6ca # 0xffffa6ce pj.set_label(0xffffa6d2, "ram_var_hash") # 0xffffa6ec # 0xffffa6f0 # 0xffffa6f2 # 0xffffa6f8 # 0xffffa6fe # 0xffffa704 # 0xffffa707 # 0xffffa708 # 0xffffa70a # 0xffffa70c # 0xffffa70e # 0xffffa710 # 0xffffa712 # 0xffffa714 # 0xffffa716 # 0xffffa71a # 0xffffa71c # 0xffffa890 # 0xffffa89e # 0xffffa8a0 # 0xffffa8a4 # 0xffffa8a6 # 0xffffa8a8 # 0xffffa972 # 0xffffa973 # 0xffffa974 # 0xffffa975 # 0xffffa976 # 0xffffa9af # 0xffffa9b0 # 0xffffa9b2 # 0xffffa9b4 # 0xffffa9b6 # 0xffffa9ba # 0xffffa9bb # 0xffffa9bc # 0xffffa9be # 0xffffa9c0 # 0xffffa9f4 # 0xffffa9f6 # 0xffffa9f8 # 0xffffa9fa # 0xffffa9fc # 0xffffaa1e # 0xffffaa20 # 0xffffaa24 # 0xffffaa26 # 0xffffaa28 # 0xffffaa29 # 0xffffaa2a pj.set_label(0xffffaa2c, "ram_center_freq") # 0xffffaa2d pj.set_label(0xffffaa34, "ram_freq_span") # 0xffffaa38 pj.set_label(0xffffaa3c, "ram_rf_fp_leds") pj.set_label(0xffffaa3e, "ram_if_fp_leds") # 0xffffaa3f # 0xffffaa40 if_scale_gain copy # 0xffffaa41 # 0xffffaa42 # 0xffffaa44 # 0xffffaa46 # 0xffffaa47 # 0xffffaa48 # 0xffffaa4a # 0xffffaa4c # 0xffffaa4e # 0xffffaa50 # 0xffffaa51 # 0xffffaa58 # 0xffffaa59 # 0xffffaa60 # 0xffffaa62 # 0xffffaa64 # 0xffffaa66 # 0xffffaa68 # 0xffffaa69 # 0xffffaa6a # 0xffffaa6b # 0xffffaa72 # 0xffffaa73 # 0xffffaa74 # 0xffffaa76 # 0xffffaa78 # 0xffffaa79 # 0xffffaa82 # 0xffffaa84 # 0xffffaa8a # 0xffffaa8e # 0xffffaa92 # 0xffffaa9a # 0xffffaaa2 # 0xffffaaa6 # 0xffffaaaa # 0xffffaaae # 0xffffaab2 # 0xffffaaba # 0xffffaabc # 0xffffaabe # 0xffffaac0 # 0xffffaac2 # 0xffffaaca # 0xffffaad2 # 0xffffaad4 # 0xffffaad6 # 0xffffaad8 # 0xffffaad9 # 0xffffaada # 0xffffaadc # 0xffffaade # 0xffffaae0 # 0xffffaae2 # 0xffffaae4 # 0xffffaae6 # 0xffffaae8 # 0xffffaaea # 0xffffaaeb # 0xffffaaec # 0xffffaaed # 0xffffaaee # 0xffffaaef # 0xffffaaf0 # 0xffffaaf1 # 0xffffaaf2 # 0xffffaaf4 # 0xffffaaf6 pj.set_label(0xffffaaf8, "ram_kbd_row") # 0xffffaafa # 0xffffaafc # 0xffffaafe # 0xffffaaff # 0xffffab00 # 0xffffab02 # 0xffffab04 # 0xffffab06 # 0xffffab07 # 0xffffab08 # 0xffffab0a # 0xffffab0c # 0xffffab0e # 0xffffab10 # 0xffffab11 # 0xffffab12 # 0xffffab13 # 0xffffab14 # 0xffffab16 # 0xffffab18 # 0xffffab1a # 0xffffab9a # 0xffffaba8 # 0xffffabb0 # 0xffffabba # 0xffffabbc # 0xffffabbe # 0xffffabc8 # 0xffffabce # 0xffffabd0 pj.set_label(0xffffabd2, "func_ptr+a6+a7") # 0xffffabd6 # 0xffffabda # 0xffffabde # 0xffffabe2 # 0xffffabe4 # 0xffffabe6 # 0xffffabe8 # 0xffffabea # 0xffffabec # 0xffffabee # 0xffffabf0 # 0xffffabf2 # 0xffffabfa # 0xffffae24 # 0xffffb628 # 0xffffb62a # 0xffffb630 # 0xffffbe2c # 0xffffbe2e # 0xffffbe30 # 0xffffbe32 # 0xffffbe34 # 0xffffbe38 # 0xffffbe3c # 0xffffbe40 # 0xffffbe42 # 0xffffbe44 # 0xffffbe46 # 0xffffbe48 # 0xffffbe50 # 0xffffbe54 # 0xffffbe5c # 0xffffbe5e # 0xffffbe60 # 0xffffbe62 # 0xffffbe64 # 0xffffbe68 # 0xffffbe6a # 0xffffbe78 # 0xffffbe86 # 0xffffbe88 # 0xffffbe8c # 0xffffbe8e # 0xffffbe9c # 0xffffbeaa # 0xffffbeac # 0xffffbeb0 # 0xffffbeb2 # 0xffffbec0 # 0xffffbf1f # 0xffffbf7e # 0xffffbfde # 0xffffbfdf # 0xffffbfe0 # 0xffffbfe1 pj.set_label(0xffffbfe2, "ram_hpib_address") pj.set_label(0xffffbfe3, "ram_not_hpib_address") # 0xffffbfe4 # 0xffffbfe5 # 0xffffbfe6 # 0xffffbfe7 # 0xffffbfe8 # 0xffffbfe9 # 0xffffbfea # 0xffffbfec # 0xffffbff0 # 0xffffbff4 # 0xffffbff8 # 0xffffbffc # 0xffffbffd # 0xffffbffe # I/O Decoding on A15 ##################### # 0x...00 BIO - BOTTOM/RF # 0x...20 DBCLK #2 # 0x...40 TIO - TOP/IF # 0x...64 LDBTEST #7 # 0x...80 LHPIB # 0x...a4 LDBTEST #7 # 0x...c0 LBUS # 0x...e0 HPIBSW #1 # 0x...e4 LATR #5 # BIO/BOTTOM/RF ############### pj.set_label(0xffffc000, "rf_50vto_lo_dac") pj.set_label(0xffffc002, "rf_50vto_hi_dac") pj.set_label(0xffffc006, "rf_yig_dac") pj.set_label(0xffffc008, "rf_scan_atten_vto") pj.set_label(0xffffc00a, "rf_scantime") pj.set_label(0xffffc00c, "rf_yig_lock_scan") pj.set_label(0xffffc00e, "rf_scan_mode") # A12 pj.set_label(0xffffc010, "rf_fp_leds") pj.set_label(0xffffc012, "rf_kbd_row") pj.set_label(0xffffc014, "rf_kbd_col") pj.set_label(0xffffc016, "rf_rpg") pj.set_label(0xffffc018, "rf_srq_resets") pj.set_label(0xffffc01a, "rf_phase_lock") pj.set_label(0xffffc01c, "rf_245_lock") pj.set_label(0xffffc01e, "rf_attn") # A15 pj.set_label(0xffffc020, "dbus_test_0") pj.set_label(0xffffc022, "dbus_test_2") pj.set_label(0xffffc025, "dbus_test_5") # A17 pj.set_label(0xffffc028, "rf_freqcnt_ctrl") pj.set_label(0xffffc02a, "rf_freqcnt_msb") pj.set_label(0xffffc02c, "rf_freqcnt_lsb") # pj.set_label(0xffffc030, "rf_inputs_atten_20") pj.set_label(0xffffc032, "rf_vunit_atten_30") pj.set_label(0xffffc034, "rf_atten_40") pj.set_label(0xffffc034, "rf_atten_50") pj.set_label(0xffffc034, "rf_atten_60") pj.set_label(0xffffc034, "rf_atten_70") # TIO/TOP/IF ############ pj.set_label(0xffffc040, "display_address") pj.set_label(0xffffc042, "display_rd_store") pj.set_label(0xffffc044, "display_wr_store") pj.set_label(0xffffc046, "display_wr_offset") pj.set_label(0xffffc048, "display_control") pj.set_label(0xffffc04a, "display_rd_scan") pj.set_label(0xffffc04c, "display_wr_marker") pj.set_label(0xffffc04e, "display_wr_scan") # SWEEP pj.set_label(0xffffc064, "if_sweep_src_trig") pj.set_label(0xffffc066, "if_sweep_time") pj.set_label(0xffffc068, "if_scale_gain") pj.set_label(0xffffc06a, "if_bw_fine") pj.set_label(0xffffc06c, "if_fp_leds") # HPIB ###### # 0xffffc081 # 0xffffc083 # 0xffffc085 # 0xffffc087 # 0xffffc089 # 0xffffc08b # 0xffffc08d # 0xffffc08f # LBUS ###### # 0xffffc0e0 ? # HPIBSW pj.set_label(0xffffc0e1, "adrsw_srq_display_ready") pj.set_label(0xffffc0e5, "latr_test") ############################################################### if False: for a in ( 0x01298, 0x013a8, 0x013d8, 0x013de, 0x013e4, 0x01e12, 0x01e94, 0x0217e, 0x0218c, 0x02194, 0x021a8, 0x02268, ): # print("ORPHAN %x" % a) y = cpu.disass(pj, a) y.lcmt = "ORPHAN - " nondisc = { 0x14ce: 0, } while True: l = [] for b,e in pj.gaps(): if b in nondisc: continue if e - b < 2: continue if pj.m.bu16(b) in (0x4eb8, 0x4e56): l.append(b) elif pj.m.rd(b) in (0x61,): l.append(b) # print(l) for i in l: y = cpu.disass(pj, i) y.lcmt = "DISCOVER - " while pj.run(): pass if len(l) == 0: break
def ptr(pj, a): return data.Dataptr(pj, a, a + 2, pj.m.bu16(a))
def dataptr(self, adr): return data.Dataptr(self.m, adr, adr + 4, self.m.bu32(adr))
def example(): m0 = mem.Stackup(FILENAMES, nextto=__file__) cx = my68k20() cx.flow_check.append(inline_text) cx.trap_returns[0] = True cx.m.map(m0, 0x0, 0x8) cx.m.map(m0, 0x80000000, 0x80002000, 0x0000) cx.m.map(m0, 0x80004000, 0x80006000, 0x2000) cx.m.map(m0, 0x80002000, 0x80004000, 0x4000) cx.m.map(m0, 0x80006000, 0x80008000, 0x6000) cx.m.map(m0, 0x00070000, 0x00072000, 0x8000) cx.m.map(m0, 0x00072000, 0x00074000, 0xa000) cx.m.map(m0, 0x00074000, 0x00076000, 0xc000) cx.m.map(m0, 0x00076000, 0x00078000, 0xe000) for a, b in SYMBOLS.items(): cx.m.set_label(a, b) resha_section( cx.m, 0x70000, { 0: (None, cx.disass), 1: (None, cx.disass), 2: (None, cx.disass), 3: (None, cx.disass), 4: (None, cx.disass), 5: (None, cx.disass), }) resha_section(cx.m, 0x72000, { 0: (None, cx.disass), 2: (None, cx.disass), 3: (None, cx.disass), }) resha_section(cx.m, 0x74000, { 0: (None, cx.disass), 1: (None, cx.disass), }) resha_section(cx.m, 0x76000, { 0: (None, cx.disass), }) cx.disass(0x80000024) for a in ( 0x80000072, 0x80000156, 0x800001c4, 0x80000314, 0x80000374, 0x80000552, 0x80002a24, 0x80002a2c, 0x800033ce, 0x80003690, 0x80004afe, 0x80004b42, 0x80004b68, 0x80007e0b, ): data.Txt(cx.m, a, label=False, align=2) def txts(a, b, align=2, label=False): while a < b: y = data.Txt(cx.m, a, label=label, align=align, splitnl=True) a = y.hi txts(0x7063e, 0x70708, align=1) txts(0x712a6, 0x71308, align=1) txts(0x719f2, 0x71ab8, align=1) txts(0x74006, 0x7412c, align=1, label=True) txts(0x76248, 0x763b0, align=1) for a in range(0x76084, 0x760c8, 4): y = cx.dataptr(a) data.Txt(cx.m, y.dst) for a in range(0x76a4c, 0x76a54, 4): y = cx.dataptr(a) data.Txt(cx.m, y.dst) a = 0x765e4 while a < 0x76656: w = data.Pstruct(cx.m, a, "<H", fmt="0x%x") y = cx.dataptr(w.hi) if y.dst: data.Txt(cx.m, y.dst) a = y.hi a = 0x7351e while True: w = data.Pstruct(cx.m, a, "<H", fmt="0x%x") if not w.data[0]: break y = cx.codeptr(w.hi) a = y.hi for a in range(0x7352e, 0x7353c, 4): y = cx.codeptr(a) cx.m.set_line_comment(y.dst, "VIA 0x%x" % a) for a in range(0x734ea, 0x7351e, 4): y = cx.codeptr(a) cx.m.set_line_comment(y.dst, "VIA 0x%x" % a) for a in range(0x76040, 0x76080, 4): y = cx.codeptr(a) cx.m.set_line_comment(y.dst, "VIA 0x%x" % a) for a in ( 0x7051c, 0x70554, 0x705d4, 0x705df, 0x705e8, 0x705f5, 0x70628, 0x70746, 0x709ea, 0x71010, 0x71025, 0x71039, 0x7104c, 0x71b10, 0x7200a, 0x76128, 0x762b0, 0x76a0a, 0x76a28, 0x76a46, 0x76990, 0x76a46, 0x76220, # 0x77666, ): data.Txt(cx.m, a) txts(0x800010cc, 0x80001122, align=1, label=True) txts(0x80001bb0, 0x80001bc2) txts(0x80002c14, 0x80002e04, align=1) txts(0x80004ece, 0x80004fbf, align=1) txts(0x800027ee, 0x800028ca, align=1) ########## data.Txt(cx.m, 0x8000221c, align=1) data.Txt(cx.m, 0x80002232, align=1, splitnl=True) data.Txt(cx.m, 0x8000223d, align=1, splitnl=True) l = [] for a in range(0x8000228f, 0x800024a8): x = cx.m[a] if not x: l.append(a) break if x & 0x80: l.append(a) for i in range(len(l) - 1): data.Txt(cx.m, l[i], l[i + 1], align=1, label=not i) data.Txt(cx.m, l[-1] + 1, align=1, label=False) # 0x8000298e y = data.Txt(cx.m, 0x8000240c, splitnl=True, align=1) y = data.Txt(cx.m, 0x80002481, splitnl=True, align=1) y = data.Txt(cx.m, 0x8000254e, splitnl=True, align=1) y = data.Txt(cx.m, 0x8000256e, splitnl=True, align=1) y = data.Txt(cx.m, 0x8000257d, splitnl=True, align=1) y = data.Txt(cx.m, 0x8000258c, splitnl=True, align=1) y = data.Txt(cx.m, 0x8000259b, splitnl=True, align=1) for a, b in ( (0x704e8, None), (0x70708, None), (0x72c5e, None), (0x730a8, None), # via 0x734f2 (0x73134, None), # via 0x734ee (0x73258, None), # via 0x731b2 (0x7338a, None), (0x73396, None), # via 0x731b2 (0x734ca, None), (0x733a2, None), (0x731b6, None), (0x7412e, None), (0x7665a, None), (0x74208, None), (0x74212, None), (0x77662, None), ( 0x8000000c, None, ), ( 0x80000010, None, ), ( 0x80000014, None, ), ( 0x80000018, None, ), ( 0x8000001c, None, ), ( 0x80000020, None, ), ( 0x800001f6, None, ), ( 0x80000208, None, ), ( 0x8000021a, None, ), ( 0x80001524, None, ), ( 0x80001566, None, ), ( 0x800015a8, None, ), ( 0x80001628, None, ), ( 0x800016c2, None, ), ( 0x80002796, None, ), ( 0x800027ca, None, ), ( 0x80002bbe, None, ), ( 0x80002bc4, None, ), ( 0x800040a0, None, ), ): cx.disass(a) if not b: b = "MANUAL" cx.m.set_line_comment(a, b) for a in range(0x80002000, 0x80002074, 4): cx.disass(a) for a in range(0x8000310e, 0x80003122, 4): cx.codeptr(a) for a in range(0x800038ce, 0x800038ee, 4): cx.codeptr(a) for a in range(0x80004000, 0x80004008, 4): cx.disass(a) for a in range(0x800043aa, 0x80004492, 6): y = data.Const(cx.m, a, a + 4, func=cx.m.bu32, size=4) z = data.Const(cx.m, y.hi, y.hi + 2, func=cx.m.bu16, size=2) w = cx.m.bu16(a + 4) w >>= 4 w &= 0xffe d = 0x800043aa + w cx.disass(d) for a in range(0x80004a7a, 0x80004a98, 4): d = cx.m.bu32(a) data.Dataptr(cx.m, a, a + 4, d) data.Txt(cx.m, d, align=1) for a in range(0x800036e8, 0x800036fc, 4): d = cx.m.bu32(a) data.Dataptr(cx.m, a, a + 4, d) data.Txt(cx.m, d) data.Const(cx.m, 0x80001ffa, 0x80002000) data.Const(cx.m, 0x80003ffa, 0x80004000) data.Const(cx.m, 0x80005ffa, 0x80006000) data.Const(cx.m, 0x80007dfa, 0x80007e00) # See 0x800039e0 data.Const(cx.m, 0x80003a2a, 0x80003a2a + 0x16) y = data.Pstruct(cx.m, 0x80007e84, ">L") y.lcmt = "Machine Number" d = discover.Discover(cx) return NAME, (cx.m, )
def example(): m = mem.Stackup(( ("85680-80115.BIN", "85680-80116.BIN"), ("85680-80113.BIN", "85680-80114.BIN"), ), nextto=__file__) # Checum EPROMS # See 00e9e/ROMSUM s = [0xff, 0xff, 0xff, 0xff] for a in range(32768): s[0] += m[a * 2] s[1] += m[a * 2 + 1] s[2] += m[a * 2 + 65536] s[3] += m[a * 2 + 65536 + 1] for i in s: assert i & 0xff == 0 cx = mycpu() cx.m.map(m, 0) cx.macro("DISPLAY_READY()", "0838 0007 c0e1 66f8") cx.flow_check.append(flow_post_arg) for a, b in SYMBOLS.items(): cx.m.set_label(a, b) # Where ? # y = data.Const(cx.m, 0xfffe, 0x10000) # cx.m.set_label(y.lo, "eprom_lo_chksum") y = data.Const(cx.m, 0x19854, 0x19856) cx.m.set_label(y.lo, "eprom_hi_chksum") for i in post_arg: j = post_arg[i] if j and j[0] != "": cx.m.set_label(i, j[0]) if True: for b, e in ( (0x06936, 0x0693a), (0x06a2c, 0x06b84), (0x070ca, 0x070d6), (0x081ae, 0x081ba), (0x1357a, 0x1358a), (0x13e58, 0x13e70), (0x14960, 0x1497c), (0x14c94, 0x14cb4), (0x14f98, 0x14fa8), (0x15094, 0x150a4), (0x15140, 0x15150), (0x15e0e, 0x15e32), (0x172b8, 0x172c4), (0x17dbe, 0x17dce), ): for a in range(b, e, 4): x = cx.m.bu32(a) data.Dataptr(cx.m, a, a + 4, x) if not cx.m.occupied(x): data.Txt(cx.m, x, pfx=1, align=2) data.Txt(cx.m, 0x15dfc, pfx=1, align=2) cx.flow_check.append(flow_switch) cx.vectors(hi=0xc0) if True: n = 0 for a in range(0x193da, 0x194b2, 2): y = oldcmd(cx.m, a, n) n += 1 # print("OLDCMDS %d" % ((0x194b2-0x193da)/2)) for a in range(0x194b2, 0x1951e, 8): y = data.Const(cx.m, a, min(a + 8, 0x1951e), fmt="0x%02x") # print("KEYTAB %d" % ((0x1951e-0x194b2)/1)) for a in range(0x1951e, 0x1952c, 8): y = data.Const(cx.m, a, min(a + 8, 0x1952c), fmt="0x%02x") # print("IMEDBITS %d" % ((0x1952c-0x1951e)/1)) for a in range(0x1952c, 0x195c4, 16): y = data.Const(cx.m, a, min(a + 16, 0x195c4), "0x%08x", cx.m.bu32, 4) # print("SFLGVAL %d" % ((0x195c4-0x1952c)/2)) if True: a = 0x193a0 while a > 0x18c3a: y = mnem(cx, a) x = cx.m.bu16(y.lo - 2) a = y.lo ############################################################### switches[0x09ae8] = {} switches[0x09d78] = {} switches[0x0a5de] = {} switches[0x0af5c] = {} switches[0x0b5ec] = {} switches[0x0bb4e] = {} switches[0x0bd5a] = {} switches[0x0bd6e] = { 0: "KEYS_00_1f", 1: "KEYS_20_3f", 2: "KEYS_40_5f", 3: "KEYS_60_7f", 4: "KEYS_80_9f", 5: "KEYS_a0_bf", } for n in KEYNOS: t = KEYNOS[n] # print("KEY_%02x" % n, t) sk = "KS%c" % n ksk = hp856x_cmds.cmds.get(sk) if ksk is not None and type(ksk) != str: ksk = ksk[1] if ksk is None: ksk = "==" + t if n < 0x20: switches[0x9ae8][n] = "KEY_%02x_" % n + t if n >= 0x20 and n < 0x30: switches[0x9d78][n - 0x20] = "KEY_%02x_" % n + t if n >= 0x40 and n < 0x60: switches[0xa5de][n - 0x41] = "KEY_%02x_" % n + t switches[0xaf5c][n - 0x41] = "KEY_S%02x_KS%c_" % (n, n) + ksk if n >= 0x60 and n < 0x80: switches[0xb5ec][n - 0x61] = "KEY_%02x_" % n + t switches[0xbb4e][n - 0x60] = "KEY_S%02x_KS%c_" % (n, n) + ksk if n >= 0xa0 and n <= 0xbf: switches[0xbd5a][n - 0xa0] = "KEY_%02x_" % n + t if True: for b, e in ( (0x0e750, 0x0e778), (0x15ca4, 0x15cb4), ): for a in range(b, e, 8): data_double(cx.m, a) ############################################################### if True: cx.disass(0x2f38) ####################################################### ####################################################### for a in ( 0x0e2fa, 0x0e308, 0x0e318, 0x12986, 0x12988, 0x1298c, 0x12990, 0x1694e, 0x16954, ): y = data.Txt(cx.m, a, pfx=1, align=2) ####################################################### data.Dataptr(cx.m, 0xe39a, 0xe39a + 4, cx.m.bu32(0xe39a)) data.Const(cx.m, 0x2140, 0x2148, "%d", cx.m.bu64, 8) data.Const(cx.m, 0x2148, 0x214c, "%d", cx.m.bu32, 4) for a in ( 0x0645e, 0x06476, 0x0647e, 0x0648a, 0x06492, 0x0649a, 0x064a6, 0x064be, 0x0e2c4, 0x0e2d4, 0x0e2cc, 0x0e32a, 0x0e332, 0x0e37c, 0x0e384, 0x128ca, 0x15da0, ): if not cx.m.occupied(a): y = data_bcd(cx.m, a) cx.m.set_label(a, "BCD_%x" % y.data[0]) ####################################################### for a in range(0x693c, 0x6a2c, 6): data.Const(cx.m, a, a + 6, "0x%04x", cx.m.bu16, 2) ####################################################### a = 0x6b84 dsp = hp85662a.hp85662a() while a < 0x6c98: x = cx.m.bs16(a) if x < 0: y = data.Data(cx.m, a, a + 2) y.fmt = ".DSPLOC\t0x%04x" % -x y.lcmt = "adr=%d" % -x dsp = hp85662a.hp85662a() else: y = dsp.disass(a, cx.m) a = y.hi ####################################################### for a in range(0x0e3be, 0x0e3d4, 2): data.Txt(cx.m, a, a + 2, label=False) ####################################################### # 0ee98 00 01 93 be # 0eeaa 00 01 93 da | | # 0ee8e 00 01 da ee | | ####################################################### # Orphans ? if False: cx.disass(0x01b88) cx.disass(0x01b8e) cx.disass(0x01b94) cx.disass(0x01b9a) cx.disass(0x01b9e) cx.disass(0x01ba2) cx.disass(0x01ba8) cx.disass(0x01c76) cx.disass(0x01c82) cx.disass(0x01c90) cx.disass(0x01cd2) cx.disass(0x01d14) cx.disass(0x01578) cx.disass(0x01594) cx.disass(0x0171a) cx.disass(0x01906) cx.disass(0x02dee) cx.disass(0x02df4) cx.disass(0x03412) cx.disass(0x11e74) # from 0x2272 cx.disass(0x2282) # filled in 0xffffabd2 cx.disass(0x0ed98) cx.disass(0x0df5e) # Arg to 0x802 cx.disass(0x3292) # 0x3284 ####################################################### # pat 4,244,024 pg 262 lin 3700 for a in range(0x4fac, 0x4fec, 2): y = data.Const(cx.m, a, a + 2, "0x%04x", cx.m.bu16, 2) ####################################################### y = data.Const(cx.m, 0x193a2, 0x193be, "%d", cx.m.bu16, 2) cx.m.set_label(y.lo, "HASHPTR2") y = data.Const(cx.m, 0x193be, 0x193da, "%d", cx.m.bu16, 2) cx.m.set_label(y.lo, "HASHPTR") ####################################################### for a in range(0x19826, 0x19853, 1): y = data.Const(cx.m, a, a + 1, fmt="0x%02x") else: y = cx.disass(0xda1e) for i in y.__dict__: print("\t", i, y.__dict__[i]) for i in cx.m: if i.tag != "m68000": continue if i.dstadr in (0x940c, 0xed54): y = list(cx.m.find(hi=i.lo)) if len(y) != 1: continue y = y[0] if cx.m[y.lo] == 0x70: k = cx.m[y.lo + 1] elif cx.m.bu16(y.lo) == 0x103c: k = cx.m.bu16(y.lo + 2) else: continue if not k in KEYNOS: continue y.oper[0].txt = "#KEY_" + KEYNOS[k] if i.dstadr in (0xe4e8, ): y = list(cx.m.find(hi=i.lo)) if len(y) != 1: continue y = y[0] if y.mne != "PEA.L": continue z = data.Txt(cx.m, y.dstadr, pfx=1, align=2) y.lcmt = "'" + z.txt + "'" if i.dstadr in (0xe718, 0x3456, 0x6ce0): y = list(cx.m.find(hi=i.lo)) if len(y) != 1: continue y = y[0] if cx.m.bu16(y.lo) != 0x203c: continue a = cx.m.bu32(y.lo + 2) z = data.Txt(cx.m, a, pfx=1, align=2) y.lcmt = "'" + z.txt + "'" if i.dstadr == 0xe718: w = list(cx.m.find(hi=y.lo)) if len(w) != 1: continue w = w[0] if w.mne != "PEA.L": continue z = list(cx.m.find(w.dstadr)) if not z: z = [data.Txt(cx.m, w.dstadr, pfx=1, align=2)] w.lcmt = "'" + z[0].txt + "'" y = data.Const(cx.m, 0x693a, 0x693c, "%d", cx.m.bu16, 2) y = data.Const(cx.m, 0x00e9a, 0x00e9e, "%d", cx.m.bu32, 4) y = data.Const(cx.m, 0x00ef2, 0x00efe, "0x%08x", cx.m.bu32, 4) #cx.m.set_label(0x18d24, "MNEM") #cx.m.set_label(0x195c4, "PARMTYPE") #cx.m.set_label(0x196b6, "PRCADRS") # 0xffff0005 # 0xffff0007 # 0xffff0009 # 0xffff0013 # 0xffff0019 # 0xffff0021 # 0xffff0027 # 0xffff0035 #cx.m.set_label(0xffff4000, "PIT_PGCR") #cx.m.set_label(0xffff4002, "PIT_PSRR") #cx.m.set_label(0xffff4004, "PIT_PADDR") #cx.m.set_label(0xffff4006, "PIT_PBDDR") #cx.m.set_label(0xffff4008, "PIT_PCDDR") #cx.m.set_label(0xffff4010, "PIT_PADR") #cx.m.set_label(0xffff4012, "PIT_PBDR") # 0xffff8000 # 0xffffa6ae = stack # I/O Decoding on A15 ##################### # 0x...00 BIO - BOTTOM/RF # 0x...20 DBCLK #2 # 0x...40 TIO - TOP/IF # 0x...64 LDBTEST #7 # 0x...80 LHPIB # 0x...a4 LDBTEST #7 # 0x...c0 LBUS # 0x...e0 HPIBSW #1 # 0x...e4 LATR #5 # HPIB ###### # 0xffffc081 # 0xffffc083 # 0xffffc085 # 0xffffc087 # 0xffffc089 # 0xffffc08b # 0xffffc08d # 0xffffc08f # LBUS ###### # 0xffffc0e0 ? ############################################################### if False: for a in ( 0x01298, 0x013a8, 0x013d8, 0x013de, 0x013e4, 0x01e12, 0x01e94, 0x0217e, 0x0218c, 0x02194, 0x021a8, 0x02268, ): # print("ORPHAN %x" % a) y = cx.disass(a) y.lcmt = "ORPHAN - " nondisc = { 0x14ce: 0, } while True: l = [] for b, e in cx.m.gaps(): if b in nondisc: continue if e - b < 2: continue if cx.m.bu16(b) in (0x4eb8, 0x4e56): l.append(b) elif cx.m[b] in (0x61, ): l.append(b) # print(l) for i in l: y = cx.disass(i) y.lcmt = "DISCOVER - " if l: break ############################################################### return NAME, (cx.m, )
def dataptr(self, a): return data.Dataptr(self.m, a, a + 2, self.m.bu16(a))
def example(): m = mem.ByteMem(0x8000, 0x10000) for i in open(fwd + "06626-80005-REV-A-00-04.hex"): j = i.split() m[int(j[0],16)] = int(j[1],16) cx = mc6809.mc6809() cx.m.map(m, 0x8000, offset=0x8000) for i, j in SYMBOLS.items(): cx.m.set_label(i, j) cx.vectors(which=("RST", "NMI", "SWI", "IRQ", "FIRQ")) token = { 1: '?', 2: 'end', 3: 'sep', 4: 'number', 6: 'string', } err = { } # 6624 6626 kbd_tbl = { 0x01: [ '9', '9' ], 0x02: [ '.', '.' ], 0x03: [ 'enter', 'enter' ], 0x04: [ '6', '6' ], 0x05: [ 'meter', 'range' ], 0x06: [ 'rcl', 'rcl' ], 0x07: [ 'unmask', 'ocp' ], 0x08: [ 'addr', 'addr' ], 0x09: [ '7', '7' ], 0x0a: [ '0', '0' ], 0x0b: [ '2', '2' ], 0x0c: [ '4', '4' ], 0x0d: [ 'output>', 'output>' ], 0x0e: [ 'on_off', 'on_off' ], 0x0f: [ '1', '1' ], 0x10: [ 'vset', 'vset' ], 0x11: [ None, None ], 0x12: [ 'sto', 'sto' ], 0x13: [ 'err', 'err' ], 0x14: [ 'lcl', 'lcl' ], 0x15: [ 'ovset', 'V_up' ], 0x16: [ 'fault', 'reset' ], 0x17: [ 'ocp', 'I_up' ], 0x18: [ 'dly', 'ovset' ], 0x19: [ '<output', '<output' ], 0x1a: [ 'ocrst', 'I_dn' ], 0x1b: [ 'iset', 'iset' ], 0x1c: [ 'ovrst', 'V_dn' ], 0x1d: [ '8', '8' ], 0x1e: [ 'backsp', 'backsp' ], 0x1f: [ '3', '3' ], 0x20: [ '5', '5' ], } for i in range(1,33): s = "%02x" % i a = cx.m[0x87f0+i-1] b = cx.m[0x87d0+i-1] s += " " s += " %x" % a s += " %04x" % cx.m.bu16(0x87b2 + a * 2) s += " %-10s" % kbd_tbl[i][0] s += " " s += " %x" % b s += " %04x" % cx.m.bu16(0x87b2 + b * 2) s += " %-10s" % kbd_tbl[i][1] print(s) def softlbl(a, n): cx.m.set_label(a, n) data.Const(cx.m, 0x8000, 0x8002) cx.m.set_label(0xd472, "chan_ptr") for a in range(0xd472, 0xd47a, 2): data.Dataptr(cx.m, a, a + 2, cx.m.bu16(a)) for a,b in ( (0x8002, 0x802a), ): y = data.Txt(cx.m, a, b, align=1) for a in ( 0x827b, 0x849b, 0x84a7, 0x84b3, 0x84bf, 0x84cb, 0x84d7, 0xbcb1, 0xbcbd, 0xbcc9, 0xc255, 0xcf01, 0xd262, ): y = data.Txt(cx.m, a, a + 12, align=1) for a in ( 0xa183, 0xa186, 0xa18f, 0xa198, 0xaffe, ): y = data.Txt(cx.m, a, pfx=1, align=1) cx.m.set_label(0x8ec2, "ERROR_TEXTS") n = 0 for a in range(0x8ec2, 0x9036, 12): y = data.Txt(cx.m, a, a + 12, align=1, label=False) err[n] = y.txt n += 1 a = 0xa225 nn = 7 while a < 0xa370: b = cx.m[a] if b == 0: break y = data.Txt(cx.m, a, pfx=1, align=1, label=False) token[nn] = y.txt a = y.hi nn += 1 print("NN", nn) for a in range(0x87d0, 0x8810, 8): data.Const(cx.m, a, a + 8) def t1(a, l): cx.m.set_label(a, l) while True: data.Const(cx.m, a, a + 1) if cx.m[a] == 0: return; a += 1 y = data.Txt(cx.m, a, align=1, label=False) a = y.hi cx.codeptr(a) z = cx.m.bu16(a) if False: # XXX: doesn't work for ERROR print("XXX %04x" % (z-3), y.txt) cx.disass(z - 3) cx.m.set_label(z, "func_" + y.txt) a += 2 t1(0x8824, "HP6626_func_01_key") t1(0x8860, "HP6624_func_01_key") n = 1 for a in range(0x87b4, 0x87d0, 2): x = cx.m.bu16(a) softlbl(x, "key_%02x_%04x" % (n, x)) n += 1 cx.codeptr(a) n = 1 for a in range(0xa5d3, 0xa687, 2): x = cx.m.bu16(a) softlbl(x, "cmd_%02x_%04x" % (n,x)) n += 1 cx.codeptr(a) class tt_5(data.Data): def __init__(self, asp, lo): hi = lo + 4 super().__init__(asp, lo, hi, "tt_5") def render(self): s = ".TT5\t" t = self.aspace[self.lo] if t in token: s += (token[t] + ", ").ljust(8) else: s += "T%02x, " % t s += "0x%02x, " % self.aspace[self.lo + 1] w = self.aspace.bu16(self.lo + 2) s += self.aspace.adr(w) return s tt5s = {} def tt5(a, f, l = None, ex = 0): if l == None: l = [] cx.m.set_label(a, "tt5_%04x" % a) while True: ll = list(l) if cx.m[a] == 0: if not cx.m.occupied(a): data.Const(cx.m, a, a + 1) break t = cx.m[a] if t in token: ll.append(token[t]) else: ll.append("T%02x" % t) e = cx.m[a + 1] if e != 0: ex = f + e * 2 z = cx.m.bu16(ex) # print("%04x" % a, "%04x" % z, "A %02x" % e, ll) cx.m.set_label(z, "cmd_" + "_".join(ll)) if a not in tt5s: tt5s[a] = tt_5(cx.m, a) x = cx.m.bu16(a + 2) if x != 0: tt5(x, f, ll, ex) else: #print("%04x" % a, ll, "%04x" % ex) for y in cx.m.find(ex): y.lcmt += " ".join(ll) + "\n" #print(y) a += 4 tt5(0xa3a2, 0xa5d1) for a in range(0xb7ac, 0xb7c4, 2): data.Const(cx.m, a, a + 2) # Task or coroutine table for a in range(0xce62, 0xce80, 6): data.Dataptr(cx.m, a, a + 2, cx.m.bu16(a)) z = cx.m.bu16(a + 2) softlbl(z, "task_%04x" % z) cx.codeptr(a + 2) data.Dataptr(cx.m, a + 4, a + 6, cx.m.bu16(a + 4)) if True: cx.disass(0x8631) cx.disass(0x8b64) cx.disass(0x8d6d) cx.disass(0x8d76) cx.disass(0x8e84) cx.disass(0x8e87) cx.disass(0xab5c) cx.disass(0xc7a2) cx.disass(0xc7ad) cx.disass(0xc7b8) cx.disass(0xc7c5) cx.disass(0xc7d9) cx.disass(0xc7e6) cx.disass(0xc7fc) cx.disass(0xc809) cx.disass(0xc814) cx.disass(0xc821) cx.disass(0xc835) cx.disass(0xc842) cx.disass(0xc84b) cx.disass(0xcf0d) cx.disass(0xc855) cx.disass(0xd3b8) cx.disass(0xd3f8) if True: # See above in t1 cx.disass(0x8b03) cx.disass(0x8b14) cx.disass(0x8b25) cx.disass(0x8b36) cx.disass(0x8b44) cx.disass(0x8b65) cx.disass(0x8b78) cx.disass(0x8b86) cx.disass(0x8b91) ############## def fp_val(cx, lo, hi): e = cx.m.s8(hi - 1) m = 0 i = 0 a = hi - 2 while a >= lo: m |= cx.m[a] << i i += 8 a -= 1 m *= 10 ** e return m class fp(data.Data): def __init__(self, cx, lo, hi): super().__init__(cx.m, lo, hi, "fp") self.val = fp_val(cx, lo, hi) def render(self): return ".FP\t%g" % self.val class tt_2(data.Data): def __init__(self, cx, lo): hi = lo + 5 + cx.m[lo + 4] * 4 super().__init__(cx.m, lo, hi, "tt_2") def render(self): s = ".TT2\t{\n" w = self.aspace.bu16(self.lo + 0) s += "\t.next = " + self.aspace.adr(w) + "\n" s += "\t.model = %4d\n" % self.aspace.bu16(self.lo + 2) n = self.aspace[self.lo + 4] s += "\t.outputs = %d\n" % n a = self.lo + 5 for i in range(n): w = self.aspace.bu16(a) s += "\t.out1[%d] = " % i + self.aspace.adr(w) + "\n" a += 2 w = self.aspace.bu16(a) s += "\t.out2[%d] = " % i + self.aspace.adr(w) + "\n" a += 2 return s + "\t}" class tt_output1(data.Data): def __init__(self, cx, lo): hi = lo + 39 super().__init__(cx.m, lo, hi, "tt_output1") self.compact = True def render(self): s = ".OUTPUT1\t" a = self.lo f = [ "%4.1f", "%4.1f", "%6.3f", "%6.3f", "%4.1f"] for i in range(5): s += "0x%04x, " % self.aspace.bu16(a) a += 2 s += (f[i] + ", ") % fp_val(cx, a, a + 4) a += 4 for i in range(3): s += "%5.2f, " % fp_val(cx, a, a + 3) a += 3 return s[:-2] class tt_output2(data.Data): def __init__(self, cx, lo): hi = lo + 44 super().__init__(cx.m, lo, hi, "tt_output2") self.compact = True def render(self): s = ".OUTPUT2\t" a = self.lo f = [ "%4.1f", "%4.1f", "%6.3f", "%6.3f", "%4.1f", "%5.3f", "%4.1f"] for i in range(7): s += "0x%04x, " % self.aspace.bu16(a) a += 2 s += (f[i] + ", ") % fp_val(cx, a, a + 4) a += 4 s += "0x%04x" % self.aspace.bu16(a) return s tt = {} def tt3_1(a): if a in tt: return tt[a] = True tt_output1(cx, a) def tt3_2(a): if a in tt: return tt[a] = True tt_output2(cx, a) return softlbl(a, "tt3_2_%04x" % a) while True: if cx.m[a + 2] > 2: break data.Const(cx.m, a, a+2, fmt="0x%02x") fp(cx, a + 2, a + 6) a += 6 data.Const(cx.m, a, a+2, fmt="0x%02x") a = 0xb39c while a: cx.m.set_label(a, "tt2_%04x" % a) x = cx.m.bu16(a) if x == 0: data.Dataptr(cx.m, a, a + 2, x) break y = tt_2(cx, a); a = x continue data.Const(cx.m, a + 2, a + 4, fmt="%d") data.Const(cx.m, a + 4, a + 5) y = cx.m[a + 4] a += 5 for i in range(y * 2): z = cx.m.bu16(a) tt3_1(z) data.Dataptr(cx.m, a, a + 2, z) a += 2 z = cx.m.bu16(a) tt3_2(z) data.Dataptr(cx.m, a, a + 2, z) a += 2 a = x ############## for a in range(0xb437, 0xb46e, 5): cx.m.set_label(a, "tt1_%04x" % a) data.Const(cx.m, a, a+1) z = cx.m.bu16(a + 1) data.Dataptr(cx.m, a + 1, a + 3, z) tt3_1(z) z = cx.m.bu16(a + 3) data.Dataptr(cx.m, a + 3, a + 5, z) tt3_2(z) ############# # Add comment with error message for i in cx.m: if i.tag != "mc6809": continue if i.dstadr != 0x91d7: continue j = list(cx.m.find(hi=i.lo)) if len(j) != 1: continue j=j[0] x = cx.m[j.lo] if x != 0x86: continue y = cx.m[j.lo + 1] j.lcmt += "Error: " + err[y] + "\n" ############# # discover.Discover(cx) return NAME, (cx.m,)
def task(pj, cpu): gpu = hp1345a.hp1345a() cpu.vectors(pj) if True: # screen texts a = 0xd95 while a < 0xf4d: z = Scrtxt(pj, a) a = z.hi continue y = data.Pstruct(pj, a, ">HH") y = data.Pstruct(pj, a + 4, ">bbb") l = pj.m.bu16(a) y = data.Txt(pj, a + 7, a + 7 + l, align=1) a += 7 + l Scrtxt(pj, 0x01db) Scrtxt(pj, 0xea56) Scrtxt(pj, 0xea6a) Scrtxt(pj, 0xea7d) Scrtxt(pj, 0xee37) Scrtxt(pj, 0xee51) Scrtxt(pj, 0xfa6d) if True: n = 0 c = {} while pj.m.bu16(0xfd0 + n): y = data.Txt(pj, 0xfd0 + n, 0xfd0 + n + 2, align=1) ta = 0x1062 + n t = pj.m.bu16(ta) z = data.Codeptr(pj, ta, ta + 2, t) z.lcmt += y.txt pj.todo(t, cpu.disass) if t not in c: c[t] = [] if y.txt not in CMDS: print("Undoc command", y.txt) CMDS[y.txt] = [t, "???"] else: CMDS[y.txt][0] = t c[t].append(y.txt) n += 2 for i in c: c[i].sort() pj.set_label(i, "CMD_" + "_".join(c[i])) for i in CMDS: c = CMDS[i] if c[0] == 0: print(i, "CMD not implemented (" + c[1] + ")") continue if c[1][0] == "?": print(i, "CMD not documented (%s)" % c[1][1:]) pj.set_block_comment(c[0], " COMMAND " + i + " - " + c[1]) if True: for a in (0x129d, 0x17e3, 0x181e, 0xe0e3, 0xee7e): w = pj.m.rd(a + 1) + 1 t = pj.m.bu16(a + 4) for i in range(w): d = pj.m.bu16(t) data.Codeptr(pj, t, t + 2, d) pj.todo(d, cpu.disass) t += 2 if True: # Random strings ttab(pj, 0xf019, 0xf03b) ttab(pj, 0xf1d1, 0xf25c) ttab(pj, 0xf412, 0xf44c) ttab(pj, 0xefd7, 0xeff7) if True: a = 0xf56e while pj.m.rd(a): y = data.Txt(pj, a, a + 6, label=False, align=1) a = y.hi if True: for a in range(0xf811, 0xf825, 2): d = pj.m.bu16(a) data.Codeptr(pj, a, a + 2, d) pj.todo(d, cpu.disass) if True: # HP1345 testpatterns pj.set_label(0xfbed, "IMG_PIKES_PEAK") pj.set_label(0xfd41, "IMG_FOCUS") for a0 in (0xfbed, 0xfd41): a = a0 data.Const(pj, a, a + 2, func=pj.m.bu16, fmt="0x%x", size=2) l = pj.m.bu16(a) a += 2 hp1345_render.svg(pj, a, a + l*2) while l > 0: gpu.disass(pj, a) a += 2 l -= 1 if True: # No idea, possibly length error in IMG_FOCUS ? data.Const(pj, 0xff17, 0xff19, fmt="0x%04x", func=pj.m.bu16, size=2) if True: # Special character handling b = 0xf75b c = 0xf778 pj.set_label(b, "CHR_TBL_KEY") pj.set_label(c, "CHR_TBL_PTR") data.Const(pj, b, c, fmt="0x%x") a = c while b < c: p = pj.m.bu16(a) y = data.Dataptr(pj, a, a + 2, p) pj.set_label(p, "CHR_TBL_%02x" % pj.m.rd(b)) while True: z = data.Const(pj, p, p + 2, func=pj.m.bu16, fmt="0x%x", size=2) if pj.m.rd(p + 1) & 0x80: break p += 2 b += 1 a += 2 # Stuff not accessed from anywhere pj.todo(0xe5a1, cpu.disass) pj.set_label(0xe5a1, "BOGO_TEST_ROM") pj.set_block_comment(0xe5a1, "Unused ROM checksum code") pj.set_block_comment(0xe5a1, "NB: Expects low rom at 0xc000") pj.set_label(0xe5ed, "TEST_IMGRAM") pj.todo(0xebf0, cpu.disass) while pj.run(): pass pj.set_label(0x0291, "A=GETCHAR()") pj.set_label(0x02d0, "PUTCHAR(A)") pj.set_label(0x0312, "Y=FIND_CMD()") pj.set_label(0x0338, "CLEAR_SCREEN()") pj.set_label(0x0395, "PUTSTR(',')") pj.set_label(0x039a, "PUTSTR(CRNL)") pj.set_label(0x03a9, "memcpy(Y,X+2,@X)") pj.set_label(0x03b9, "GETNBR()") pj.set_block_comment(0x003b9, "Outputs $0x0c - Term (not comma)") pj.set_block_comment(0x003b9, "Outputs $0x12 - Error") pj.set_block_comment(0x003b9, "Outputs $0x1a = 0") pj.set_block_comment(0x003b9, "Outputs $0x1b - Digits") pj.set_block_comment(0x003b9, "Outputs $0x1f - Decimals") pj.set_block_comment(0x003b9, "Outputs $0x27 - Negative") pj.set_block_comment(0x003b9, "Outputs $0x31+32 - Number") pj.set_label(0x04a2, "PUTNBR(D)") pj.set_label(0x0bcb, "ERR_1_UNKNOWN_INSN()") pj.set_label(0x0bdc, "ERR_2_WRONG_NO_PARAMS()") pj.set_label(0x0bed, "ERR_3_XXX_OUT_OF_RANGE()") pj.set_label(0x0c2e, "ERR_4_ILLEGAL_CHAR()") pj.set_label(0x0c41, "ERR_11_NO_PLOTTER_HANDSHAKE()") pj.set_label(0x0c5d, "ERR_12_UNRECOG_PLOTTER()") pj.set_label(0x0c79, "ERR_22_FILE_NOT_OPEN_ON()") pj.set_label(0x0c8c, "ERR_24_NOT_IN_SCROLL_MODE()") pj.set_label(0x0c9f, "ERR_25_MEMORY_NOT_INIT()") pj.set_label(0x0cb2, "ERR_32_ALL_FILES_NOT_CONFIG()") pj.set_label(0x0cc5, "ERR_33_NO_DATA_TO_SCROLL()") pj.set_label(0x0cd8, "ERR_34_MEMORY_OVERFLOW_ON()") pj.set_label(0x0ceb, "ERR_35_FILE_ALREADY_OPEN_ON()") pj.set_label(0x0f4e, "SCR_MSG(X)") pj.set_label(0x0f77, "X = PREP_SCREEN()") pj.set_label(0x0f8e, "D = ADR2JMP(D)") pj.set_label(0x0fac, "DELAY(@U)") pj.set_label(0x2800, "dip_switch") pj.set_label(0xe77e, "CMD_nop") pj.set_label(0xef76, "PLOT_pu_sp_lt()") pj.set_label(0xef90, "PLOT_SELECT_PEN(A)") pj.set_label(0xefb9, "PLOT_LINE_TYPE(A)") pj.set_label(0xf004, "PUTSTR(X+1,@X)") pj.set_label(0xf0c0, "SPEC_CHAR()") pj.set_label(0xf56e, "plotter_table") pj.set_label(0xf7fd, "DIAG_MODE()") pj.set_label(0xf825, "DIAG_HPIB_BACK2BACK()") pj.set_label(0xf895, "HPIB_RESET_CHIPS()") pj.set_label(0xf8ae, "HPIB_IFC()") pj.set_block_comment(0xf895, "Set reset, clear interrupt, Clr reset") pj.set_label(0xfa9f, "DIAG_SIGNATURE_EPROM1()") pj.set_label(0xfaaf, "DIAG_SIGNATURE_EPROM2()") pj.set_label(0xfac2, "DIAG_SIGNATURE_3000()") pj.set_label(0xfade, "DIAG_SIGNATURE_RAM()") pj.set_label(0xfaee, "DIAG_RAM()") pj.set_label(0xfb03, "DIAG_IMGRAM()") pj.set_label(0xfbcb, "DIAG_PIKES_PEAK()") pj.set_label(0xfbdc, "DIAG_FOCUS()")
def misc_stuff(cx): for a in range(0xc2fe, 0xc38e, 4): d_q(cx.m, a) # idx into tbl at b156 # Chain data (18 pieces) # x = cx.m.add_range(0xb132, 0xb155, txt="tbl") n = 0 for a in range(x.lo, x.hi, 2): y = cword(cx.m, a) y.lcmt = CHAINS[n] cx.m.set_label(0xb156 + y.val, "CHAIN_I_" + CHAINS[n]) n += 1 x = cx.m.add_range(0xb156, 0xb43e, txt="tbl") for a in range(x.lo, x.hi, 4): #data.Data(cx.m, a, a + 4) d_q(cx.m, a, lbl=False) for a in range(0xc3a6, 0xc41e, 4): d_q(cx.m, a) for a in range(0x906f, 0x9087, 2): c = cword(cx.m, a) c.fmt = "%d" % c.val x = cx.m.add_range(0x9d00, 0x9d20, txt="tbl") cx.m.set_line_comment(x.lo, "accessed via 0x9cc2 pointer") for a in range(x.lo, x.hi, 2): c = cword(cx.m, a) cx.disass(0x9102) cx.disass(0x95da) cx.disass(0x9b29) cx.disass(0x9a96) cx.disass(0x9b44) cx.disass(0x9b57) cx.disass(0xdda1) cx.disass(0xdde0) cx.disass(0xde00) cx.disass(0xde20) cx.disass(0xf719) for a in range(0x9789, 0x97a5, 4): d_q(cx.m, a) for i in range(0xf220, 0xf226, 2): data.Dataptr(cx.m, i, i + 2, cx.m.bu16(i)) cword(cx.m, i + 6) #for i in range(0x89d8, 0x8a20, 2): # data.Dataptr(cx.m, i, i + 2, cx.m.bu16(i)) for i in range(0xe363, 0xe369, 2): x = cx.codeptr(i) x = cx.m.add_range(0xb963, 0xb975, txt="tbl") for i in range(x.lo, x.hi): cbyte(cx.m, i) data.Data(cx.m, 0xca73, 0xca7c) data.Data(cx.m, 0xec7c, 0xec81) data.Data(cx.m, 0xec81, 0xec85) data.Data(cx.m, 0xec85, 0xec8b) data.Data(cx.m, 0xec8b, 0xec91) d_q(cx.m, 0xcb70) d_q(cx.m, 0xd4f5) d_q(cx.m, 0xd4f9) d_q(cx.m, 0xd4fd) d_q(cx.m, 0xd501)
def task(pj, cpu): cpu.vectors(pj) token = { 1: '?', 2: 'end', 3: 'sep', 4: 'number', 6: 'string', } err = {} # 6624 6626 kbd_tbl = { 0x01: ['9', '9'], 0x02: ['.', '.'], 0x03: ['enter', 'enter'], 0x04: ['6', '6'], 0x05: ['meter', 'range'], 0x06: ['rcl', 'rcl'], 0x07: ['unmask', 'ocp'], 0x08: ['addr', 'addr'], 0x09: ['7', '7'], 0x0a: ['0', '0'], 0x0b: ['2', '2'], 0x0c: ['4', '4'], 0x0d: ['output>', 'output>'], 0x0e: ['on_off', 'on_off'], 0x0f: ['1', '1'], 0x10: ['vset', 'vset'], 0x11: [None, None], 0x12: ['sto', 'sto'], 0x13: ['err', 'err'], 0x14: ['lcl', 'lcl'], 0x15: ['ovset', 'V_up'], 0x16: ['fault', 'reset'], 0x17: ['ocp', 'I_up'], 0x18: ['dly', 'ovset'], 0x19: ['<output', '<output'], 0x1a: ['ocrst', 'I_dn'], 0x1b: ['iset', 'iset'], 0x1c: ['ovrst', 'V_dn'], 0x1d: ['8', '8'], 0x1e: ['backsp', 'backsp'], 0x1f: ['3', '3'], 0x20: ['5', '5'], } for i in range(1, 33): s = "%02x" % i a = pj.m.rd(0x87f0 + i - 1) b = pj.m.rd(0x87d0 + i - 1) s += " " s += " %x" % a s += " %04x" % pj.m.bu16(0x87b2 + a * 2) s += " %-10s" % kbd_tbl[i][0] s += " " s += " %x" % b s += " %04x" % pj.m.bu16(0x87b2 + b * 2) s += " %-10s" % kbd_tbl[i][1] print(s) def softlbl(a, n): if a not in pj.labels: pj.set_label(a, n) for a, n in ( (0x002b, "display_chan"), (0x0085, "n_chan"), (0x0086, "model_desc_ptr"), (0x038f, "B_flag1"), (0x0390, "B_flag2"), (0x01bc, "cal_lock_flag"), (0x1000, "i8291_data"), (0x1001, "i8291_intrrupt1"), (0x1002, "i8291_intrrupt2"), (0x1003, "i8291_spoll"), (0x1004, "i8291_addressed"), (0x1005, "i8291_cmd_aux"), (0x1006, "i8291_addr1"), (0x1007, "i8291_addr2_eos"), (0x2000, "slv_force"), (0x3000, "slv_sense"), (0x4000, "dip_kbd_sense"), (0x5000, "kbd_dsply_scan"), (0x8100, "B=dsply_needs_update()"), (0x819b, "p4_p5()"), (0x81ac, "p4_p5(B)"), (0x81c0, "dsply_shift_bits(B,Y)"), (0x8236, "task__display"), (0x84e3, "i8291_init"), (0x8465, "MSG(X)"), (0x8775, "task__keyboard"), (0x87d0, "HP6626_keytbl"), (0x87f0, "HP6624_keytbl"), (0x88b6, "GETKEY"), (0x897f, "key_08_METER"), (0x89d5, "key_01_func"), (0x8992, "key_06_ENTER"), (0x89c0, "key_05_BS"), (0x8bb0, "key_09_output_control"), (0x8c1a, "key_04_LCL"), (0x8a2b, "key_03_OUTPUT_SELECT"), (0x8a81, "key_02_digit"), (0x8acd, "key_07_PERIOD"), (0x8bfa, "key_09_output_ONOFF"), (0x8c05, "key_09_output_OCP_UNMASK"), (0x8c40, "key_0e_RANGE"), (0x8cb3, "key_0a_V_UP"), (0x8d05, "key_0b_V_DOWN"), (0x8dce, "key_0c_I_UP"), (0x8e32, "key_0d_I_DOWN"), (0x91d7, "ERR=A"), (0x93f7, "err_NUMBER_RANGE"), (0x9463, "Get_Chan"), (0x9468, "Chan_Nr_Check"), (0x99d5, "cmd_A"), (0x99d9, "cmd_B"), (0x99dd, "cmd_S"), (0x9acb, "func_09_output_OCRST"), (0x9b4a, "func_09_output_OVRST"), (0x9b21, "get_chan"), (0x9ea6, "put_char"), (0x9ead, "put_CRNL"), (0x9ebc, "reset_outbuf"), (0x9ec4, "put_string"), (0x9ed2, "put_digits"), (0xa14b, "cmd_ID"), (0xaaf9, "Get_Nbr"), (0xb00b, "Output_40W20V_1"), (0xb032, "Output_40W50V_1"), (0xb059, "Output_80W20V_1"), (0xb080, "Output_80W50V_1"), (0xb0a7, "Output_25W_1"), (0xb0ce, "Output_50W_1"), (0xb0f5, "Output_100W20V_1"), (0xb11c, "Output_100W50V_1"), (0xb143, "Output_200W20V_1"), (0xb16a, "Output_200W50V_1"), (0xb191, "Output_10W10V_1"), (0xb1b8, "Output_40W20V_2"), (0xb1e4, "Output_40W50V_2"), (0xb210, "Output_80W20V_2"), (0xb23c, "Output_80W50V_2"), (0xb268, "Output_25W_2"), (0xb294, "Output_50W_2"), (0xb2c0, "Output_100W20V_2"), (0xb2ec, "Output_100W50V_2"), (0xb318, "Output_200W20V_2"), (0xb344, "Output_200W50V_2"), (0xb370, "Output_10W10V_2"), (0xb476, "Config_Model"), (0xb4c5, "ERR_NO_MODEL"), (0xb5ca, "special_model"), (0xb7c4, "tx_slave"), (0xb873, "rx_slave_byte"), (0xbacc, "yield"), (0xbade, "EE_Write_Word"), (0xbae9, "EE_Write_Byte"), (0xbb1e, "I2C_Ready"), (0xbb37, "EE_Read_Word"), (0xbb7f, "EE_Read_Byte"), (0xbbbf, "I2C_Error"), (0xbbcb, "I2C_Start_Byte"), (0xbbd2, "I2C_Poll_Ack"), (0xbbf5, "EE_SCL_LH"), (0xbc00, "EE_SCL_L"), (0xbc06, "I2C_Read_Byte"), (0xbc23, "I2C_Write_Byte"), (0xbc45, "I2C_Start"), (0xbc70, "I2C_Stop"), (0xbc8d, "I2C_Get_Ack"), (0xbc9f, "EE_Ack"), (0xbcd5, "cmd_OVCAL"), (0xc36a, "err_CAL_ERROR"), (0xc5cf, "cmd_CMODE"), (0xc62f, "err_CAL_LOCKED"), (0xc637, "err_STORE_LIMIT"), (0xcb22, "ROMSUM"), (0xce80, "task_setup"), (0xcea5, "task_switch"), (0xceb7, "task__vimes"), (0xd448, "init_slavetbl"), ): pj.set_label(a, n) data.Const(pj, 0x8000, 0x8002) pj.set_label(0xd472, "chan_ptr") for a in range(0xd472, 0xd47a, 2): data.Dataptr(pj, a, a + 2, pj.m.bu16(a)) for a, b in ((0x8002, 0x802a), ): y = data.Txt(pj, a, b, align=1) for a in ( 0x827b, 0x849b, 0x84a7, 0x84b3, 0x84bf, 0x84cb, 0x84d7, 0xbcb1, 0xbcbd, 0xbcc9, 0xc255, 0xcf01, 0xd262, ): y = data.Txt(pj, a, a + 12, align=1) for a in ( 0xa183, 0xa186, 0xa18f, 0xa198, 0xaffe, ): y = data.Txt(pj, a, pfx=1, align=1) pj.set_label(0x8ec2, "ERROR_TEXTS") n = 0 for a in range(0x8ec2, 0x9036, 12): y = data.Txt(pj, a, a + 12, align=1, label=False) err[n] = y.txt n += 1 a = 0xa225 nn = 7 while a < 0xa370: b = pj.m.rd(a) if b == 0: break y = data.Txt(pj, a, pfx=1, align=1, label=False) token[nn] = y.txt a = y.hi nn += 1 print("NN", nn) for a in range(0x87d0, 0x8810, 8): data.Const(pj, a, a + 8) def t1(a, l): pj.set_label(a, l) while True: data.Const(pj, a, a + 1) if pj.m.rd(a) == 0: return a += 1 y = data.Txt(pj, a, align=1, label=False) a = y.hi cpu.codeptr(pj, a) z = pj.m.bu16(a) if False: # XXX: doesn't work for ERROR print("XXX %04x" % (z - 3), y.txt) pj.todo(z - 3, cpu.disass) pj.set_label(z, "func_" + y.txt) a += 2 t1(0x8824, "HP6626_func_01_key") t1(0x8860, "HP6624_func_01_key") n = 1 for a in range(0x87b4, 0x87d0, 2): x = pj.m.bu16(a) softlbl(x, "key_%02x_%04x" % (n, x)) n += 1 cpu.codeptr(pj, a) n = 1 for a in range(0xa5d3, 0xa687, 2): x = pj.m.bu16(a) softlbl(x, "cmd_%02x_%04x" % (n, x)) n += 1 cpu.codeptr(pj, a) class tt_5(data.Data): def __init__(self, pj, lo): hi = lo + 4 super(tt_5, self).__init__(pj, lo, hi, "tt_5") def render(self, pj): s = ".TT5\t" t = pj.m.rd(self.lo) if t in token: s += (token[t] + ", ").ljust(8) else: s += "T%02x, " % t s += "0x%02x, " % pj.m.rd(self.lo + 1) w = pj.m.bu16(self.lo + 2) s += pj.render_adr(w) return s def tt5(a, f, l=None, ex=0): if l == None: l = [] pj.set_label(a, "tt5_%04x" % a) while True: ll = list(l) if pj.m.rd(a) == 0: data.Const(pj, a, a + 1) break t = pj.m.rd(a) if t in token: ll.append(token[t]) else: ll.append("T%02x" % t) e = pj.m.rd(a + 1) if e != 0: ex = f + e * 2 z = pj.m.bu16(ex) # print("%04x" % a, "%04x" % z, "A %02x" % e, ll) pj.set_label(z, "cmd_" + "_".join(ll)) tt_5(pj, a) x = pj.m.bu16(a + 2) if x != 0: tt5(x, f, ll, ex) else: # print("%04x" % a, ll, "%04x" % ex) y = pj.t.find_lo(ex) y[0].lcmt += " ".join(ll) + "\n" # print(y) a += 4 tt5(0xa3a2, 0xa5d1) for a in range(0xb7ac, 0xb7c4, 2): data.Const(pj, a, a + 2) # Task or coroutine table for a in range(0xce62, 0xce80, 6): data.Dataptr(pj, a, a + 2, pj.m.bu16(a)) z = pj.m.bu16(a + 2) softlbl(z, "task_%04x" % z) cpu.codeptr(pj, a + 2) data.Dataptr(pj, a + 4, a + 6, pj.m.bu16(a + 4)) if True: cpu.disass(pj, 0x8631) cpu.disass(pj, 0x8b64) cpu.disass(pj, 0x8d6d) cpu.disass(pj, 0x8d76) cpu.disass(pj, 0x8e84) cpu.disass(pj, 0x8e87) cpu.disass(pj, 0xab5c) cpu.disass(pj, 0xc7a2) cpu.disass(pj, 0xc7ad) cpu.disass(pj, 0xc7b8) cpu.disass(pj, 0xc7c5) cpu.disass(pj, 0xc7d9) cpu.disass(pj, 0xc7e6) cpu.disass(pj, 0xc7fc) cpu.disass(pj, 0xc809) cpu.disass(pj, 0xc814) cpu.disass(pj, 0xc821) cpu.disass(pj, 0xc835) cpu.disass(pj, 0xc842) cpu.disass(pj, 0xc84b) cpu.disass(pj, 0xcf0d) cpu.disass(pj, 0xc855) cpu.disass(pj, 0xd3b8) cpu.disass(pj, 0xd3f8) if True: # See above in t1 cpu.disass(pj, 0x8b03) cpu.disass(pj, 0x8b14) cpu.disass(pj, 0x8b25) cpu.disass(pj, 0x8b36) cpu.disass(pj, 0x8b44) cpu.disass(pj, 0x8b65) cpu.disass(pj, 0x8b78) cpu.disass(pj, 0x8b86) cpu.disass(pj, 0x8b91) ############## def fp_val(pj, lo, hi): e = pj.m.s8(hi - 1) m = 0 i = 0 a = hi - 2 while a >= lo: m |= pj.m.rd(a) << i i += 8 a -= 1 m *= 10**e return m class fp(data.Data): def __init__(self, pj, lo, hi): super(fp, self).__init__(pj, lo, hi, "fp") self.val = fp_val(pj, lo, hi) def render(self, pj): return ".FP\t%g" % self.val class tt_2(data.Data): def __init__(self, pj, lo): hi = lo + 5 + pj.m.rd(lo + 4) * 4 super(tt_2, self).__init__(pj, lo, hi, "tt_2") def render(self, pj): s = ".TT2\t{\n" w = pj.m.bu16(self.lo + 0) s += "\t.next = " + pj.render_adr(w) + "\n" s += "\t.model = %4d\n" % pj.m.bu16(self.lo + 2) n = pj.m.rd(self.lo + 4) s += "\t.outputs = %d\n" % n a = self.lo + 5 for i in range(n): w = pj.m.bu16(a) s += "\t.out1[%d] = " % i + pj.render_adr(w) + "\n" a += 2 w = pj.m.bu16(a) s += "\t.out2[%d] = " % i + pj.render_adr(w) + "\n" a += 2 return s + "\t}" class tt_output1(data.Data): def __init__(self, pj, lo): hi = lo + 39 super(tt_output1, self).__init__(pj, lo, hi, "tt_output1") self.compact = True def render(self, pj): s = ".OUTPUT1\t" a = self.lo f = ["%4.1f", "%4.1f", "%6.3f", "%6.3f", "%4.1f"] for i in range(5): s += "0x%04x, " % pj.m.bu16(a) a += 2 s += (f[i] + ", ") % fp_val(pj, a, a + 4) a += 4 for i in range(3): s += "%5.2f, " % fp_val(pj, a, a + 3) a += 3 return s[:-2] class tt_output2(data.Data): def __init__(self, pj, lo): hi = lo + 44 super(tt_output2, self).__init__(pj, lo, hi, "tt_output2") self.compact = True def render(self, pj): s = ".OUTPUT2\t" a = self.lo f = ["%4.1f", "%4.1f", "%6.3f", "%6.3f", "%4.1f", "%5.3f", "%4.1f"] for i in range(7): s += "0x%04x, " % pj.m.bu16(a) a += 2 s += (f[i] + ", ") % fp_val(pj, a, a + 4) a += 4 s += "0x%04x" % pj.m.bu16(a) return s tt = {} def tt3_1(a): if a in tt: return tt[a] = True tt_output1(pj, a) def tt3_2(a): if a in tt: return tt[a] = True tt_output2(pj, a) return softlbl(a, "tt3_2_%04x" % a) while True: if pj.m.rd(a + 2) > 2: break data.Const(pj, a, a + 2, fmt="0x%02x") fp(pj, a + 2, a + 6) a += 6 data.Const(pj, a, a + 2, fmt="0x%02x") a = 0xb39c while a: pj.set_label(a, "tt2_%04x" % a) x = pj.m.bu16(a) if x == 0: data.Dataptr(pj, a, a + 2, x) break y = tt_2(pj, a) a = x continue data.Const(pj, a + 2, a + 4, fmt="%d") data.Const(pj, a + 4, a + 5) y = pj.m.rd(a + 4) a += 5 for i in range(y * 2): z = pj.m.bu16(a) tt3_1(z) data.Dataptr(pj, a, a + 2, z) a += 2 z = pj.m.bu16(a) tt3_2(z) data.Dataptr(pj, a, a + 2, z) a += 2 a = x ############## for a in range(0xb437, 0xb46e, 5): pj.set_label(a, "tt1_%04x" % a) data.Const(pj, a, a + 1) z = pj.m.bu16(a + 1) data.Dataptr(pj, a + 1, a + 3, z) tt3_1(z) z = pj.m.bu16(a + 3) data.Dataptr(pj, a + 3, a + 5, z) tt3_2(z) ############## while pj.run(): pass ############# # Add comment with error message for i in pj: if i.tag != "mc6809": continue if i.dstadr != 0x91d7: continue j = pj.t.find_hi(i.lo) if len(j) != 1: continue j = j[0] x = pj.m.rd(j.lo) if x != 0x86: continue y = pj.m.rd(j.lo + 1) j.lcmt += "Error: " + err[y] + "\n"
def dataptr(self, adr): y = data.Dataptr(self.m, adr, adr + 4, self.m.bu32(adr) & 0x7f00ffff) return y