![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to debugger.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / debugger|
Return to debugger.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / debugger |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2019 [email protected]
4: //
5:
6: #include "header.h"
7: #include "bus.h"
8: #include "consio.h"
9: #include "cvprompt.h"
10: #include "disasm.h"
11: #include "m68030core.h"
12: #include "memdump.h"
13: #include "mpu.h"
14: #include "mystring.h"
15: #include <csignal>
16:
17: class Debugger
18: {
19: private:
20: // 型
21: typedef void (Debugger::*cmdfunc_t)();
22: typedef struct {
23: const char *name;
24: cmdfunc_t func;
25: } cmddef_t;
26:
27: // ブレークポイント
28: typedef struct {
29: bool enable;
30: bool ismemory;
31: uint32 addr;
32: uint32 count;
33: } breakpoint_t;
34: static const int MAX_BREAKPOINTS = 8;
35:
36: public:
37: Debugger();
38: virtual ~Debugger() { }
39:
40: void Init();
41: void ThreadRun();
42: bool Check();
43:
44: private:
45: bool MainLoop();
46: cmddef_t *ParseCmd();
47: // コマンド名は大文字小文字を区別する関係でスネークスタイル。
48: void cmd_b();
49: void cmd_b_list();
50: void cmd_brhist();
51: void cmd_bx();
52: void cmd_c();
53: void cmd_d();
54: void cmd_dt();
55: void cmd_D();
56: void cmd_h();
57: void cmd_L();
58: void cmd_m();
59: void cmd_mt();
60: void cmd_M();
61: void cmd_minus();
62: void cmd_n();
63: void cmd_q();
64: void cmd_r();
65: void cmd_ra();
66: void cmd_rf();
67: void cmd_rm();
68: void cmd_ro();
69: void cmd_s();
70: void cmd_so();
71: void cmd_show();
72: void cmd_t();
73: void cmd_unknown();
74:
75: int AddBreakpoint(uint32 addr, bool ismemory);
76: void Continue();
77: bool GetAddr(uint32& addr, uint32& lastaddr);
78: void cmd_d_common(MemdumpMode mode);
79: void cmd_m_common(MemdumpMode mode);
80: bool ParseAddr(const char *arg, uint32_t *addrp);
81: const char *OPccCondStr(uint32);
82: bool IsOPcc(uint16);
83: bool IsDBcc(uint16);
84: bool IsCond(uint16);
85: bool SetNBreakpoint();
86:
87: void HelpMain();
88:
89: void ShowRegMain();
90: void ShowRegFPU();
91: void ShowRegMMU();
92: void ShowRegOther();
93: void ShowMonitor(TextScreen& monitor);
94:
95: m68kcpu *cpu = NULL; // CPU コア
96: m68kreg prev {}; // 前回のレジスタセットのコピー
97:
98: Consio *cons = NULL; // 入出力
99: char cmdbuf[256] {}; // 現在のコマンドライン
100: char last_cmdbuf[256] {}; // 直前のコマンドライン
101: int ac = 0;
102: char *av[10] {};
103:
104: uint32 pc = 0;
105: uint32 nextpc = 0;
106: breakpoint_t bpoint[MAX_BREAKPOINTS] {};
107: bool bc_enable = false;
108: uint32 bc_addr = 0;
109: uint32 d_last_addr = 0;
110: uint32 m_last_addr = 0;
111: bool n_enable = false;
112: bool n_breakenable = false;
113: uint32 n_breakaddr = 0;
114: uint32 n_count = 0;
115: bool s_enable = false;
116: uint32 s_count = 0;
117: bool so_enable = false;
118: uint32 so_a7 = 0;
119: uint16 so_sr = 0;
120: bool t_enable = false;
121: uint32 t_count = 0;
122:
123: // 一度VMを実行して再びプロンプトに来たら true
124: bool is_continued = false;
125:
126: static cmddef_t cmdtable[];
127: static cmddef_t cmdtable_unknown;
128: };
129:
130: Debugger *gDebugger;
131: CVPrompt *gCVPrompt;
132:
133: // コマンドラインオプション
134: bool debug_on_start;
135: uint32 debug_breakaddr;
136:
137: static void *debugger_run(void *);
138:
139: // 初期化。
140: // この時点で VM が初期化されていること。
141: void
142: debugger_init()
143: {
144: gDebugger = new Debugger();
145: gDebugger->Init();
146:
147: gCVPrompt = new CVPrompt();
148:
149: // デバッガスレッド起動
150: pthread_t th;
151: pthread_create(&th, NULL, debugger_run, NULL);
152: }
153:
154: // デバッガスレッドのエントリポイント
155: static void *
156: debugger_run(void *dummy)
157: {
158: pthread_setname_np("Debugger");
159: pthread_detach(pthread_self());
160:
161: gDebugger->ThreadRun();
162: return NULL;
163: }
164:
165: // コンストラクタ
166: Debugger::Debugger()
167: {
168: cpu = gMPU->GetCPU();
169: }
170:
171: // コマンドライン引数によって動作を決めるところ。
172: // 名前がこれでいいのかはあるけど。
173: void
174: Debugger::Init()
175: {
176: // -d なら CPU 起動時点で停止してプロンプトを待つ
177: if (debug_on_start) {
178: cpu->atomic_reqflag |= CPU_REQ_PROMPT;
179: }
180:
181: // -b <addr> ならブレークポイント設定
182: if (debug_breakaddr != 0xffffffff) {
183: cpu->atomic_reqflag |= CPU_REQ_TRACE;
184: AddBreakpoint(debug_breakaddr, false);
185: }
186:
187: // どこでやるべか
188: signal(SIGPIPE, SIG_IGN);
189: }
190:
191: // デバッガスレッド
192: void
193: Debugger::ThreadRun()
194: {
195: // XXX どこかでコンソールの選択とパラメータの取得
196: cons = new ConsioTCP();
197: if (cons->Init() == false) {
198: return;
199: }
200:
201: for (;;) {
202: cons->Open();
203: cons->Print("This is debugger console\n");
204:
205: // 接続ごとに初期化する値
206: // XXX もうちょっときれいにしたい
207: d_last_addr = 0xffffffff;
208: m_last_addr = 0xffffffff;
209: n_enable = false;
210: s_enable = false;
211: t_enable = false;
212: is_continued = true;
213:
214: // コンソールが繋がっている間がトレースオン
215: // コンソールが繋がるとプロンプトになる
216: cpu->atomic_reqflag |= CPU_REQ_TRACE | CPU_REQ_PROMPT;
217: while (MainLoop() == true)
218: ;
219: // コンソールを抜ける時はCPUの停止を解除。
220: cpu->atomic_reqflag &= ~CPU_REQ_TRACE;
221: gCVPrompt->NotifyRelease();
222:
223: cons->Close();
224: }
225:
226: delete cons;
227: }
228:
229: // プロンプト処理のメイン部分。
230: // false を返すとコンソールをクローズする。
231: bool
232: Debugger::MainLoop()
233: {
234: // プロンプトが取れるのを待つ
235: gCVPrompt->WaitAcquire(cons);
236:
237: // VM 実行からプロンプトに来たとき
238: if (is_continued) {
239: is_continued = false;
240:
241: pc = RegPC;
242: d_last_addr = pc;
243: // プロンプトに来た時に表示するいつものやつ
244: cmd_minus();
245: }
246:
247: cons->Print("> ");
248: cons->Flush();
249: if (cons->Gets(cmdbuf, sizeof(cmdbuf)) < 1) {
250: return false;
251: }
252:
253: // chomp
254: for (int i = 0; cmdbuf[i] != '\0'; i++) {
255: if (cmdbuf[i] == '\r' || cmdbuf[i] == '\n') {
256: cmdbuf[i] = '\0';
257: break;
258: }
259: }
260:
261: if (cmdbuf[0] != '\0') {
262: // コマンドが入力されれば次回のために保存
263: strcpy(last_cmdbuf, cmdbuf);
264: } else {
265: // 空行が入力されれば直前のコマンドをもう一度
266: // 前行がなければ何もせずもう一度プロンプトを表示するかね
267: if (last_cmdbuf[0] == '\0')
268: return true;
269: strcpy(cmdbuf, last_cmdbuf);
270: }
271:
272: // 行を cmd, ac, av に分解
273: cmddef_t *cmd = ParseCmd();
274: if (cmd == NULL) {
275: // NULL は知らないコマンドではなく終了コマンド
276: return false;
277: }
278:
279: // 前回の値が有効なのはコマンドが連続した時だけ
280:
281: // コマンド実行
282: (this->*(cmd->func))();
283: return true;
284: }
285:
286: // ブレークポイントとかを調べる。
287: // CPU_REQ_TRACE フラグが立っている間1命令ごとに呼び出される。
288: bool
289: debugger_check()
290: {
291: return gDebugger->Check();
292: }
293:
294: // デバッガ実行中なら命令開始前にメインルーチンから呼ばれる。
295: // プロンプトに降りるなら true を返す。
296: bool
297: Debugger::Check()
298: {
299: if (t_enable) {
300: t_count--;
301: if (t_count == 0) {
302: t_enable = false;
303: return true;
304: }
305: }
306:
307: if (s_enable) {
308: s_count--;
309: if (s_count == 0) {
310: s_enable = false;
311: return true;
312: }
313: }
314:
315: // n による1命令実行のブレークポイントか
316: if (n_enable && n_breakenable && n_breakaddr == RegPC) {
317: n_breakenable = false;
318: return true;
319: }
320:
321: // アドレス
322: for (int i = 0; i < countof(bpoint); i++) {
323: breakpoint_t *bp = &bpoint[i];
324: if (bp->enable) {
325: if (bp->addr == RegPC) {
326: bp->count++;
327: return true;
328: }
329: }
330: }
331:
332: // ステップアウト
333: if (so_enable) {
334: if (RegA(7) > so_a7 || (RegSR & 0x3000) != so_sr) {
335: so_enable = false;
336: return true;
337: }
338: }
339:
340: // アドレス指定付き continue
341: if (bc_enable) {
342: if (bc_addr == RegPC) {
343: bc_enable = false;
344: return true;
345: }
346: }
347:
348: return false;
349: }
350:
351: // コマンド一覧。
352: // quit コマンドは ParseCmd() 側で処理してある。
353: Debugger::cmddef_t Debugger::cmdtable[] = {
354: { "bx", &Debugger::cmd_bx, },
355: { "b", &Debugger::cmd_b, },
356: { "brhist", &Debugger::cmd_brhist },
357: { "c", &Debugger::cmd_c, },
358: { "d", &Debugger::cmd_d, },
359: { "dt", &Debugger::cmd_dt, },
360: { "D", &Debugger::cmd_D, },
361: { "h", &Debugger::cmd_h, },
362: { "L", &Debugger::cmd_L, },
363: { "m", &Debugger::cmd_m, },
364: { "mt", &Debugger::cmd_mt, },
365: { "M", &Debugger::cmd_M, },
366: { "n", &Debugger::cmd_n, },
367: { "r", &Debugger::cmd_r, },
368: { "ra", &Debugger::cmd_ra, },
369: { "rf", &Debugger::cmd_rf, },
370: { "rm", &Debugger::cmd_rm, },
371: { "ro", &Debugger::cmd_ro, },
372: { "s", &Debugger::cmd_s, },
373: { "so", &Debugger::cmd_so, },
374: { "show", &Debugger::cmd_show, },
375: { "t", &Debugger::cmd_t, },
376: { "-", &Debugger::cmd_minus },
377: };
378: Debugger::cmddef_t Debugger::cmdtable_unknown = {
379: .name = "",
380: .func = &Debugger::cmd_unknown,
381: };
382:
383: // ヘルプ
384: void
385: Debugger::cmd_h()
386: {
387: if (ac == 1) {
388: // 引数なし
389: HelpMain();
390: return;
391: } else {
392: // 引数あり(今の所対応していない)
393: HelpMain();
394: return;
395: }
396: }
397:
398: void
399: Debugger::HelpMain()
400: {
401: cons->Print(" b ブレークポイント一覧表示\n");
402: cons->Print(" b #n ブレークポイント n を削除\n");
403: cons->Print(" b $<addr> メモリブレークポイント設定\n");
404: cons->Print(" b <addr> ブレークポイント設定\n");
405: cons->Print(" bx ブレークポイント全削除\n");
406: cons->Print(" brhist ブランチ履歴表示\n");
407: cons->Print(" c [<addr>] 実行再開(continue)\n");
408: cons->Print(" d [<addr> [<lines>] 逆アセンブル(論理、テーブルサーチなし)\n");
409: cons->Print(" dt [<addr> [<lines>] 逆アセンブル(論理、テーブルサーチあり)\n");
410: cons->Print(" D [<addr> [<lines>] 逆アセンブル(物理)\n");
411: cons->Print(" h ヘルプ(help)\n");
412: cons->Print(" L <name>=<lv> ログレベル設定\n");
413: cons->Print(" m [<addr> [<lines>] メモリダンプ(論理、テーブルサーチなし)\n");
414: cons->Print(" mt [<addr> [<lines>] メモリダンプ(論理、テーブルサーチあり)\n");
415: cons->Print(" M [<addr> [<lines>] メモリダンプ(物理)\n");
416: cons->Print(" n <cnt?:1> ステップ実行 (サブルーチンを飛ばす)\n");
417: cons->Print(" q quit\n");
418: cons->Print(" r [a|f|m|o] レジスタ表示\n");
419: cons->Print(" so ステップアウト\n");
420: cons->Print(" show <monitor> モニター表示\n");
421: cons->Print(" t <cnt?:1> トレース実行\n");
422: }
423:
424: // 知らないコマンドを処理するというコマンド
425: void
426: Debugger::cmd_unknown()
427: {
428: cons->Print("%s: unknown command\n", av[0]);
429: }
430:
431: // cmdbuf を cmd, ac, av に分解する。
432: // cmdbuf は破壊されるので以後は cmd, ac, av で参照のこと。
433: // コマンド(の1ワード目)が一致しなければ cmd_unknown を返し、
434: // 終了コマンドと一致したら NULL を返す。
435: Debugger::cmddef_t *
436: Debugger::ParseCmd()
437: {
438: char *p;
439: cmddef_t *cmd;
440:
441: p = cmdbuf;
442: ac = 0;
443: memset(&av, 0, sizeof(av));
444:
445: // 引数を空白で分解
446: for (; ac < countof(av); ) {
447: // 先頭の空白は取り除く
448: while (isspace((int)*p))
449: p++;
450: if (*p == '\0')
451: break;
452:
453: av[ac++] = p;
454: // 次の空白まで進める
455: for (; *p != '\0'; p++) {
456: if (isspace((int)*p))
457: break;
458: }
459: if (*p != '\0')
460: *p++ = '\0';
461: }
462:
463: // コマンドを探す
464: for (int i = 0; i < countof(cmdtable); i++) {
465: cmd = &cmdtable[i];
466:
467: // デバッガから抜ける(終了する)コマンドだけここで処理
468: if (strcmp(av[0], "q") == 0 || strcmp(av[0], "quit") == 0)
469: return NULL;
470:
471: if (strcmp(av[0], cmd->name) == 0)
472: return cmd;
473: }
474:
475: // 見つからなければ cmd_unknown コマンドを実行。
476: return &cmdtable_unknown;
477: }
478:
479: //
480: // デバッガコマンド
481: //
482:
483: // ブレークポイント
484: void
485: Debugger::cmd_b()
486: {
487: // 引数なしなら一覧表示
488: if (ac < 2) {
489: return cmd_b_list();
490: }
491:
492: // 引数取得
493: if (av[1][0] == '#') {
494: // #<n> 形式なら、指定番号のブレークポイントを削除
495: int i = atoi(&av[1][1]);
496: if (i < 0 || i >= MAX_BREAKPOINTS) {
497: cons->Print("invaild break point number: #%d\n", i);
498: return;
499: }
500: breakpoint_t *bp = &bpoint[i];
501: if (bp->enable) {
502: cons->Print("%sbreakpoint #%d (%08x) removed\n",
503: bp->ismemory ? "memory " : "", i, bp->addr);
504: bp->enable = false;
505: } else {
506: cons->Print("breakpoint #%d not enabled\n", i);
507: }
508: return;
509: }
510:
511: bool ismemory;
512: uint32 addr;
513: if (av[1][0] == '$') {
514: // $<n> 形式ならメモリブレークポイント
515: ismemory = true;
516: addr = strtoul(&av[1][1], NULL, 16);
517: } else {
518: // そうでなければアドレス指定
519: ismemory = false;
520: addr = strtoul(av[1], NULL, 16);
521: }
522:
523: // すでにあればそのブレークポイントを削除
524: for (int i = 0; i < MAX_BREAKPOINTS; i++) {
525: breakpoint_t *bp = &bpoint[i];
526: if (bp->enable && bp->ismemory == ismemory && bp->addr == addr) {
527: bp->enable = false;
528: cons->Print("%sbreakpoint #%d (%08x) removed\n",
529: bp->ismemory ? "memory " : "", i, bp->addr);
530: return;
531: }
532: }
533:
534: // 空いてるところにセット
535: int bi = AddBreakpoint(addr, ismemory);
536: if (bi == -1) {
537: cons->Print("no free breakpoints!\n");
538: } else {
539: breakpoint_t *bp = &bpoint[bi];
540: cons->Print("%sbreakpoint #%d (%08x) added\n",
541: bp->ismemory ? "memory " : "", bi, bp->addr);
542: }
543: }
544:
545: // ブレークポイント一覧表示
546: void
547: Debugger::cmd_b_list()
548: {
549: int found = 0;
550:
551: for (int i = 0; i < MAX_BREAKPOINTS; i++) {
552: breakpoint_t *bp = &bpoint[i];
553: if (bp->enable) {
554: cons->Print(" #%d %s%08x %d\n",
555: i,
556: bp->ismemory ? "memory $" : "",
557: bp->addr, bp->count);
558: found = 1;
559: }
560: }
561: if (found == 0) {
562: cons->Print(" No breakpoints enabled\n");
563: }
564: }
565:
566: // ブレークポイント全削除
567: void
568: Debugger::cmd_bx()
569: {
570: for (int i = 0; i < MAX_BREAKPOINTS; i++) {
571: breakpoint_t *bp = &bpoint[i];
572: bp->enable = false;
573: }
574: cons->Print(" All breakpoints disabled\n");
575: }
576:
577: // ブレークポイントを設定。
578: // 設定できればその番号、できなければ -1 を返す
579: // TODO 重複の処理とか
580: int
581: Debugger::AddBreakpoint(uint32 addr, bool ismemory)
582: {
583: for (int i = 0; i < countof(bpoint); i++) {
584: breakpoint_t *bp = &bpoint[i];
585: if (!bp->enable) {
586: bp->enable = true;
587: bp->addr = addr;
588: bp->ismemory = ismemory;
589: bp->count = 0;
590: return i;
591: }
592: }
593: return -1;
594: }
595:
596: // ブランチ履歴表示
597: void
598: Debugger::cmd_brhist()
599: {
600: gMPUBrHist->MonitorUpdate();
601: ShowMonitor(gMPUBrHist->monitor);
602: }
603:
604: // 実行再開(continue): c [<addr>]
605: // <addr> 指定があれば <addr> まで実行。
606: void
607: Debugger::cmd_c()
608: {
609: if (ac > 1) {
610: // 引数があれば
611: if (!ParseAddr(av[1], &bc_addr)) {
612: return;
613: }
614: // 偶数番地に丸める
615: bc_addr &= 0xfffffffe;
616:
617: bc_enable = true;
618: }
619: Continue();
620: }
621:
622: // 実行再開
623: void
624: Debugger::Continue()
625: {
626: is_continued = true;
627:
628: // 今のレジスタセットを次回との差分のためにバックアップしておく
629: prev = cpu->reg;
630:
631: gCVPrompt->NotifyRelease();
632: }
633:
634: // 引数などからアドレスを取得する共通ルーチン。
635: // 引数が1つ(以上)あれば av[1] をアドレスとしてパースする。
636: // なければ、lastaddr が指定されていればそれを使う。
637: // それもなければ、RegPC を使う。
638: bool
639: Debugger::GetAddr(uint32& addr, uint32& lastaddr)
640: {
641: if (ac > 1) {
642: // 1つ目の引数があれば、開始アドレス
643: if (ParseAddr(av[1], &addr) == false) {
644: return false;
645: }
646: // 偶数番地からに丸める
647: addr &= 0xfffffffe;
648: } else if (lastaddr != 0xffffffff) {
649: // 引数なしで前回値があれば前回の続き
650: addr = lastaddr;
651: } else {
652: // そうでなければ、今の PC
653: addr = RegPC;
654: }
655: return true;
656: }
657:
658: // 逆アセンブル: d [<addr> [<cnt>]] (論理、テーブルサーチなし)
659: void
660: Debugger::cmd_d()
661: {
662: cmd_d_common(MemdumpMode::Logical_atc);
663: }
664:
665: // 逆アセンブル: dt [<addr>] [<cnt>]] (論理、テーブルサーチあり)
666: void
667: Debugger::cmd_dt()
668: {
669: cmd_d_common(MemdumpMode::Logical_search);
670: }
671:
672: // 逆アセンブル: D [<addr> [<cnt>]] (物理)
673: void
674: Debugger::cmd_D()
675: {
676: cmd_d_common(MemdumpMode::Physical);
677: }
678:
679: // 逆アセンブル共通
680: void
681: Debugger::cmd_d_common(MemdumpMode mode)
682: {
683: uint32 addr;
684: int cnt;
685:
686: cnt = 10;
687:
688: // 開始アドレス
689: if (GetAddr(addr, d_last_addr) == false) {
690: return;
691: }
692: // 2つ目の引数があれば行数
693: if (ac > 2) {
694: cnt = strtol(av[2], NULL, 10);
695: }
696:
697: DisasmLine dis(cpu, addr, mode);
698: for (int i = 0; i < cnt; i++) {
699: std::string buf = dis.Output();
700: cons->Print("%s\n", buf.c_str());
701: // バスエラーならこの行で終了。
702: // XXX バスエラーかどうかを文字列判定してるのはさすがにどうかと
703: if (buf.find("BusErr") != std::string::npos) {
704: break;
705: }
706: }
707: d_last_addr = dis.GetNextAddr();
708: }
709:
710: // ログレベル設定: L <name> <level>
711: void
712: Debugger::cmd_L()
713: {
714: const char *name;
715: int level;
716:
717: if (ac < 3) {
718: cons->Print("L <name> <level>\n");
719: return;
720: }
721:
722: name = av[1];
723: level = atoi(av[2]);
724:
725: // 短縮形とかエイリアスとか
726: // lib/mainapp.cpp に同じものがあるのでどうにかしたほうがいい
727: if (strcmp(name, "sch") == 0)
728: name = "scheduler";
729: if (strcmp(name, "pio") == 0)
730: name = "ppi";
731: if (strcmp(name, "scc") == 0)
732: name = "sio";
733:
734: // all はどうするか
735: std::string sname = name;
736: bool found = false;
737: for (auto& obj : gObjects) {
738: if (obj->logname == sname) {
739: obj->loglevel = level;
740: cons->Print("%s=%d\n", name, obj->loglevel);
741: found = true;
742: break;
743: }
744: }
745: // 見付からない場合はエラー
746: if (!found) {
747: cons->Print("%s: invalid logname\n", name);
748: }
749: }
750:
751: // メモリダンプ: m [<addr> [<cnt>]] (論理、テーブルサーチなし)
752: void
753: Debugger::cmd_m()
754: {
755: cmd_m_common(MemdumpMode::Logical_atc);
756: }
757:
758: // メモリダンプ: mt [<addr> [<cnt>]] (論理、テーブルサーチあり)
759: void
760: Debugger::cmd_mt()
761: {
762: cmd_m_common(MemdumpMode::Logical_search);
763: }
764:
765: // メモリダンプ: M [<addr> [<cnt>]] (物理)
766: void
767: Debugger::cmd_M()
768: {
769: cmd_m_common(MemdumpMode::Physical);
770: }
771:
772: // メモリダンプ共通
773: void
774: Debugger::cmd_m_common(MemdumpMode mode)
775: {
776: uint32 addr;
777: int cnt;
778:
779: cnt = 10;
780:
781: // 開始アドレス
782: if (GetAddr(addr, m_last_addr) == false) {
783: return;
784: }
785: // 2つ目の引数があれば行数
786: if (ac > 2) {
787: cnt = strtol(av[2], NULL, 10);
788: }
789:
790: MemdumpLine mem(cpu, addr, mode);
791: for (int i = 0; i < cnt; i++) {
792: cons->Print("%s\n", mem.Output().c_str());
793: }
794: m_last_addr = mem.GetNextAddr();
795: }
796:
797: // プロンプトに来た最初に表示するいつものやつを再表示する
798: void
799: Debugger::cmd_minus()
800: {
801: cmd_r();
802:
803: // 論理アクセス時、ATC ミスが分かったほうが便利だと思う
804: MemdumpMode mode = (cpu->mmu_enable)
805: ? MemdumpMode::Logical_atc
806: : MemdumpMode::Physical;
807: DisasmLine dis(cpu, pc, mode);
808: cons->Print("%s%s\n", dis.Output().c_str(), OPccCondStr(pc));
809: nextpc = dis.GetNextAddr();
810: }
811:
812: // ステップ実行: n[<count>?=1] (サブルーチンを飛ばす)
813: void
814: Debugger::cmd_n()
815: {
816: if (ac > 1) {
817: int count;
818: count = strtol(av[1], NULL, 10);
819: if (count < 1) {
820: cons->Print(" invalid step count: %d\n", count);
821: return;
822: }
823:
824: n_count = count;
825: } else {
826: n_count = 1;
827: }
828: n_enable = true;
829: SetNBreakpoint();
830: Continue();
831: }
832:
833: // n コマンド用のサブルーチンを飛ばすブレークポイントを設定。
834: // 戻り値は、プロンプトをスキップするなら true。
835: bool
836: Debugger::SetNBreakpoint()
837: {
838: // n コマンドは、通常はブレークポイントを次の命令に仕掛けながら
839: // 実行するが、いくつかの命令ではブレークポイントではなく、
840: // 命令トレース (t コマンド) のように動作させる。
841: // トレース動作する命令は以下の通り。
842: // Bcc, BRA
843: // JMP
844: // RTD, RTR, RTS
845: // RTE
846: // FBcc
847: // FDBcc (2ワード目無視)
848: // (RTM は 68020 専用なので対応しない)
849: #define IsBcc(x) ((((x) & 0xf000) == 0x6000) && (((x) & 0xff00) != 0x6100))
850: #define IsJMP(x) (((x) & 0xffc0) == 0x4ec0)
851: #define IsRTD(x) (((x) & 0xffff) == 0x4e74)
852: #define IsRTE(x) (((x) & 0xffff) == 0x4e73)
853: #define IsRTR(x) (((x) & 0xffff) == 0x4e77)
854: #define IsRTS(x) (((x) & 0xffff) == 0x4e75)
855: #define IsFBcc(x) (((x) & 0xf180) == 0xf080)
856: #define IsFDBcc(x) (((x) & 0xf1f8) == 0xf048)
857:
858: uint16 op;
859:
860: // XXX この辺統一的にしたほうがいい
861: // XXX logical peek のような気がする
862: op = (((uint16)m68030_phys_peek_8(pc)) << 8)
863: | m68030_phys_peek_8(pc + 1);
864:
865: if (IsBcc(op)
866: || IsJMP(op)
867: || IsRTD(op)
868: || IsRTE(op)
869: || IsRTR(op)
870: || IsRTS(op)
871: || IsFBcc(op)
872: || IsFDBcc(op)
873: ) {
874: n_breakenable = false;
875: s_enable = true;
876: s_count = 1;
877: return false;
878: } else {
879: n_breakenable = true;
880: n_breakaddr = nextpc;
881: return true;
882: }
883: }
884:
885: // レジスタ表示
886: // rf: FPU レジスタを表示
887: // rm: MMU レジスタを表示
888: // r<それ以外>: 通常レジスタを表示?
889: void
890: Debugger::cmd_r()
891: {
892: if (ac > 1) {
893: int arg = av[1][0];
894: switch (arg) {
895: case 'a':
896: ShowMonitor(gMPUATC->monitor);
897: return;
898: case 'f':
899: ShowRegFPU();
900: return;
901: case 'm':
902: ShowRegMMU();
903: return;
904: case 'o':
905: ShowRegOther();
906: return;
907: }
908: }
909: ShowRegMain();
910: }
911:
912: // ショートカット
913: void
914: Debugger::cmd_ra()
915: {
916: gMPUATC->MonitorUpdate();
917: ShowMonitor(gMPUATC->monitor);
918: }
919: void
920: Debugger::cmd_rf()
921: {
922: ShowRegFPU();
923: }
924: void
925: Debugger::cmd_rm()
926: {
927: ShowRegMMU();
928: }
929: void
930: Debugger::cmd_ro()
931: {
932: ShowRegOther();
933: }
934:
935: // モニター表示
936: void
937: Debugger::cmd_show()
938: {
939: if (ac != 2) {
940: cons->Print("usage: show <monitor>\n");
941: for (auto& d : gObjects) {
942: if (d->logname != "?") {
943: cons->Print(" %s\n", d->logname.c_str());
944: }
945: }
946: return;
947: }
948:
949: std::string name(av[1]);
950: for (auto& d : gObjects) {
951: if (d->logname == name) {
952: // ここで更新して..
953: if (d->MonitorUpdate()) {
954: // 表示
955: ShowMonitor(d->monitor);
956: } else {
957: // モニターがない場合
958: cons->Print("show: %s has no monitor\n", av[1]);
959: }
960: return;
961: }
962: }
963: // 一致しない
964: cons->Print("show: no such objects\n");
965: }
966:
967: // モニタースクリーンを表示。
968: void
969: Debugger::ShowMonitor(TextScreen& monitor)
970: {
971: char sbuf[1024]; // 適当
972:
973: // monitor 内部バッファから ShiftJIS バッファを作成。
974: // その際属性もエスケープシーケンスで再現する。
975: int col = monitor.GetCol();
976: int row = monitor.GetRow();
977: const uint16 *src = monitor.GetBuf();
978:
979: for (int y = 0; y < row; y++) {
980: int sy = y * col;
981: int sx;
982: uint attr;
983: char *d;
984:
985: memset(sbuf, 0, sizeof(sbuf));
986: d = sbuf;
987: attr = TA::Normal;
988: for (sx = 0; sx < col; sx++) {
989: uint a = src[sy + sx] & 0xff00;
990: uint ch = src[sy + sx] & 0x00ff;
991:
992: // 属性の変わり目
993: if (attr != a) {
994: switch (a) {
995: case TA::Normal:
996: case TA::Off:
997: *d++ = 0x1b;
998: *d++ = '[';
999: *d++ = 'm';
1000: break;
1001: case TA::On:
1002: *d++ = 0x1b;
1003: *d++ = '[';
1004: *d++ = '7';
1005: *d++ = 'm';
1006: break;
1007: case TA::Disable:
1008: *d++ = 0x1b;
1009: *d++ = '[';
1010: *d++ = '2';
1011: *d++ = 'm';
1012: break;
1013: case TA::Em:
1014: *d++ = 0x1b;
1015: *d++ = '[';
1016: *d++ = '1';
1017: *d++ = 'm';
1018: break;
1019: }
1020: attr = a;
1021: }
1022: *d++ = ch;
1023: }
1024: *d = '\0';
1025:
1026: // XXX 日本語が使われてれば UTF-8 にしないといけないはず
1027:
1028: cons->Print("%s\n", sbuf);
1029: }
1030: }
1031:
1032: // ステップ実行: s[<count>?:1]
1033: void
1034: Debugger::cmd_s()
1035: {
1036: if (ac > 1) {
1037: int count;
1038: count = strtol(av[1], NULL, 10);
1039: if (count < 1) {
1040: cons->Print(" invalid step count: %d\n", count);
1041: return;
1042: }
1043:
1044: s_count = count;
1045: } else {
1046: s_count = 1;
1047: }
1048: s_enable = true;
1049: Continue();
1050: }
1051:
1052: // ステップアウト
1053: void
1054: Debugger::cmd_so()
1055: {
1056: so_enable = true;
1057: so_a7 = RegA(7);
1058: so_sr = RegSR & 0x3000;
1059: Continue();
1060: }
1061:
1062: // トレース実行: t[<count>?:1]
1063: // レジスタを表示しながら実行する
1064: void
1065: Debugger::cmd_t()
1066: {
1067: if (ac > 1) {
1068: int count;
1069: count = strtol(av[1], NULL, 10);
1070: if (count < 1) {
1071: cons->Print(" invalid trace count: %d\n", count);
1072: return;
1073: }
1074: t_count = count;
1075: } else {
1076: t_count = 1;
1077: }
1078: t_enable = true;
1079: Continue();
1080: }
1081:
1082: // 引数で示されるアドレスを返す。
1083: // '%' で始まればレジスタ。
1084: // そうでなければ16進数値。
1085: // アドレスが正しく取得できればアドレスを addr に格納し真を返す。
1086: // そうでなければエラーメッセージを表示して偽を返す。
1087: bool
1088: Debugger::ParseAddr(const char *arg, uint32_t *addrp)
1089: {
1090: uint32_t addr;
1091: char *end;
1092:
1093: if (arg[0] == '%') {
1094: /* '%' から始まればレジスタ */
1095: const char *regname = &arg[1];
1096: if ((*regname | 0x20) == 'a') {
1097: addr = RegA(arg[2] - '0');
1098:
1099: } else if ((*regname | 0x20) == 'd') {
1100: addr = RegD(arg[2] - '0');
1101:
1102: } else if (strcmp(regname, "sp") == 0) {
1103: addr = RegA(7);
1104:
1105: #if 0
1106: } else if (strcmp(regname, "usp") == 0) {
1107: addr = RegUSP;
1108:
1109: } else if (strcmp(regname, "isp") == 0) {
1110: addr = RegISP;
1111:
1112: } else if (strcmp(regname, "msp") == 0) {
1113: addr = RegMSP;
1114: #endif
1115:
1116: } else if (strcmp(regname, "pc") == 0) {
1117: addr = RegPC;
1118:
1119: } else if (strcmp(regname, "vbr") == 0) {
1120: addr = RegVBR;
1121:
1122: } else if (strcmp(regname, "srp") == 0) {
1123: addr = cpu->GetSRPl();
1124:
1125: } else if (strcmp(regname, "crp") == 0) {
1126: addr = cpu->GetCRPl();
1127:
1128: } else {
1129: cons->Print("valid register name are: %s%s\n",
1130: "%d0-%d7,%a0-%a7,%sp,%usp,%isp,%pc",
1131: ",%msp,%vbr,%srp,%crp");
1132: return false;
1133: }
1134: } else {
1135: /* そうでなければ番地指定 */
1136: errno = 0;
1137: addr = strtoul(arg, &end, 16);
1138: if (arg[0] == '\0' || end[0] != '\0') {
1139: cons->Print("invalid address: '%s'\n", arg);
1140: return false;
1141: }
1142: if (errno == ERANGE) {
1143: cons->Print("out of range: %s\n", arg);
1144: return false;
1145: }
1146: }
1147:
1148: *addrp = addr;
1149: return true;
1150: }
1151:
1152: //
1153: // レジスタ表示
1154: //
1155:
1156: #define NORM "\x1b[0m"
1157: #define BOLD "\x1b[1m"
1158: #define BOLDIF(n) ((n) ? BOLD : "")
1159:
1160: // 基本セット
1161: void
1162: Debugger::ShowRegMain()
1163: {
1164: /*
1165: D0:00000070 D4:CCCCCCCC A0:00FFAA32 A4:CCCCCCCC SR=F810(S I=0 X----)
1166: D1:0000FFFF D5:00000000 A1:00000A7A A5:00000A7A
1167: D2:00FF0000 D6:00000000 A2:CCCCCCCC A6:CCCCCCCC
1168: D3:CCCCCCCC D7:00000003 A3:CCCCCCCC A7:00001FD8
1169: */
1170: bool vr[16];
1171:
1172: for (int i = 0; i < 16; i++) {
1173: vr[i] = (cpu->reg.da[i] != prev.da[i]);
1174: }
1175:
1176: // 1行目
1177: cons->Print("%sD%d:%08x%s %sD%d:%08x%s %sA%d:%08x%s %sA%d:%08x%s ",
1178: BOLDIF(vr[ 0]), 0, RegR( 0), NORM,
1179: BOLDIF(vr[ 4]), 4, RegR( 4), NORM,
1180: BOLDIF(vr[ 8]), 0, RegR( 8), NORM,
1181: BOLDIF(vr[12]), 4, RegR(12), NORM);
1182:
1183: // 1行目 SR
1184: uint16 sr = RegSR;
1185: uint16 prevsr = prev.sr_h()
1186: | (prev.ccr.IsX() ? M68K_CCR_X : 0)
1187: | (prev.ccr.IsN() ? M68K_CCR_N : 0)
1188: | (prev.ccr.IsZ() ? M68K_CCR_Z : 0)
1189: | (prev.ccr.IsV() ? M68K_CCR_V : 0)
1190: | (prev.ccr.IsC() ? M68K_CCR_C : 0);
1191: // SR は上位バイトと下位バイトが変化したくらいでいいか?
1192: cons->Print(" SR:%s%02x%s%s%02x%s",
1193: BOLDIF((sr & 0xff00) != (prevsr & 0xff00)),
1194: sr >> 8,
1195: NORM,
1196: BOLDIF((sr & 0x00ff) != (prevsr & 0x00ff)),
1197: sr & 0xff,
1198: NORM);
1199: cons->Print("(%c I=%d %c%c%c%c%c)\n",
1200: (sr & 0x2000) ? 'S' : '-',
1201: (sr >> 8) & 7,
1202: (sr & M68K_CCR_X) ? 'X' : '-',
1203: (sr & M68K_CCR_N) ? 'N' : '-',
1204: (sr & M68K_CCR_Z) ? 'Z' : '-',
1205: (sr & M68K_CCR_V) ? 'V' : '-',
1206: (sr & M68K_CCR_C) ? 'C' : '-');
1207:
1208: // 2行目
1209: cons->Print("%sD%d:%08x%s %sD%d:%08x%s %sA%d:%08x%s %sA%d:%08x%s\n",
1210: BOLDIF(vr[ 1]), 1, RegR( 1), NORM,
1211: BOLDIF(vr[ 5]), 5, RegR( 5), NORM,
1212: BOLDIF(vr[ 9]), 1, RegR( 9), NORM,
1213: BOLDIF(vr[13]), 5, RegR(13), NORM);
1214:
1215: // 3行目
1216: cons->Print("%sD%d:%08x%s %sD%d:%08x%s %sA%d:%08x%s %sA%d:%08x%s\n",
1217: BOLDIF(vr[ 2]), 2, RegR( 2), NORM,
1218: BOLDIF(vr[ 6]), 6, RegR( 6), NORM,
1219: BOLDIF(vr[10]), 2, RegR(10), NORM,
1220: BOLDIF(vr[14]), 6, RegR(14), NORM);
1221:
1222: // 4行目
1223: cons->Print("%sD%d:%08x%s %sD%d:%08x%s %sA%d:%08x%s %sA%d:%08x%s\n",
1224: BOLDIF(vr[ 3]), 3, RegR( 3), NORM,
1225: BOLDIF(vr[ 7]), 7, RegR( 7), NORM,
1226: BOLDIF(vr[11]), 3, RegR(11), NORM,
1227: BOLDIF(vr[15]), 7, RegR(15), NORM);
1228: }
1229:
1230: // FPU レジスタ表示
1231: void
1232: Debugger::ShowRegFPU()
1233: {
1234: /*
1235: FP0:0000_12345678_12345678 (-0.1234567890123456789) FPCR:1234
1236: FP1: BS,SN,OP,OV,UF,DZ,I2,I1
1237: FP2: RP=xx RM=xx
1238: FP3: FPSR:12345678
1239: FP4: N,Z,Inf,NAN Q=$xx
1240: FP5: BS,SN,OP,OV,UF,DZ,I2,I1
1241: FP6: AXEC
1242: FP7: FPIAR:12345678
1243: */
1244:
1245: #define PUT_FP(n) do { \
1246: uint32 *c_ = cpu->reg.fpframe.fpf_regs + (n) * 3; \
1247: uint32 *p_ = prev.fpframe.fpf_regs + (n) * 3; \
1248: bool d = (c_[0] ^ p_[0]) | (c_[1] ^ p_[1]) | (c_[2] ^ p_[2]); \
1249: cons->Print("%sFP%d:%04xxxxx_%08x_%08x (%-20s)%s ", \
1250: BOLDIF(d), (n), c_[0] >> 16, c_[1], c_[2], "notyet", NORM); \
1251: } while (0)
1252:
1253: uint32 fpcr, fpsr, fpiar;
1254: uint32 ppcr, ppsr, ppiar;
1255: static const char * const rpstr[] = {
1256: ".EXT",
1257: ".SGL",
1258: ".DBL",
1259: ".???",
1260: };
1261: static const char * const rmstr[] = {
1262: "Near",
1263: "Zero",
1264: "Minus",
1265: "Plus",
1266: };
1267:
1268: fpcr = cpu->reg.fpframe.fpf_fpcr;
1269: fpsr = cpu->reg.fpframe.fpf_fpsr;
1270: fpiar = cpu->reg.fpframe.fpf_fpiar;
1271: ppcr = prev.fpframe.fpf_fpcr;
1272: ppsr = prev.fpframe.fpf_fpsr;
1273: ppiar = prev.fpframe.fpf_fpiar;
1274:
1275: PUT_FP(0);
1276: cons->Print("%sFPCR:%04x%s\n", BOLDIF(fpcr != ppcr), fpcr, NORM);
1277:
1278: PUT_FP(1);
1279: cons->Print(" %s %s %s %s %s %s %s %s\n",
1280: (fpcr & 0x8000) ? "BS" : "--",
1281: (fpcr & 0x4000) ? "SN" : "--",
1282: (fpcr & 0x2000) ? "OP" : "--",
1283: (fpcr & 0x1000) ? "OV" : "--",
1284: (fpcr & 0x0800) ? "UF" : "--",
1285: (fpcr & 0x0400) ? "DZ" : "--",
1286: (fpcr & 0x0200) ? "I2" : "--",
1287: (fpcr & 0x0100) ? "I1" : "--");
1288:
1289: PUT_FP(2);
1290: cons->Print(" RP=%s RM=%s\n",
1291: rpstr[(fpcr >> 6) & 3],
1292: rmstr[(fpcr >> 4) & 3]);
1293:
1294: PUT_FP(3);
1295: cons->Print("%sFPSR:%08x%s\n", BOLDIF(fpsr != ppsr), fpsr, NORM);
1296:
1297: PUT_FP(4);
1298: uint cc = fpsr >> 24;
1299: cons->Print(" %c %c %s %s Q=$%02x\n",
1300: (cc & 0x08) ? 'N' : '-',
1301: (cc & 0x04) ? 'Z' : '-',
1302: (cc & 0x02) ? "Inf" : "---",
1303: (cc & 0x01) ? "NAN" : "---",
1304: (fpsr >> 16) & 0xff);
1305:
1306: PUT_FP(5);
1307: cons->Print(" %s %s %s %s %s %s %s %s\n",
1308: (fpsr & 0x8000) ? "BS" : "--",
1309: (fpsr & 0x4000) ? "SN" : "--",
1310: (fpsr & 0x2000) ? "OP" : "--",
1311: (fpsr & 0x1000) ? "OV" : "--",
1312: (fpsr & 0x0800) ? "UF" : "--",
1313: (fpsr & 0x0400) ? "DZ" : "--",
1314: (fpsr & 0x0200) ? "I2" : "--",
1315: (fpsr & 0x0100) ? "I1" : "--");
1316:
1317: PUT_FP(6);
1318: cons->Print(" %s %s %s %s %s\n",
1319: (fpsr & 0x80) ? "IOP" : "---",
1320: (fpsr & 0x40) ? "OVFL" : "----",
1321: (fpsr & 0x20) ? "UNFL" : "----",
1322: (fpsr & 0x10) ? "DZ" : "--",
1323: (fpsr & 0x08) ? "INEX" : "----");
1324:
1325: PUT_FP(7);
1326: cons->Print("%sFPIAR:%08x%s\n", BOLDIF(fpiar != ppiar), fpiar, NORM);
1327: }
1328:
1329: void
1330: Debugger::ShowRegMMU()
1331: {
1332: /*
1333: SRP:00001111_22223333 TT0:00001111 TC:00001111 (---)
1334: CRP:00001111_22223333 TT1:00001111 MMUSR: 0011 (
1335: */
1336: uint64 srp, osrp;
1337: uint64 crp, ocrp;
1338: uint32 tt0, ott0;
1339: uint32 tt1, ott1;
1340: uint32 tc, otc;
1341: uint16 sr, osr;
1342: bool p;
1343: bool t;
1344: bool c;
1345:
1346: srp = cpu->GetSRP();
1347: crp = cpu->GetCRP();
1348: tt0 = cpu->GetTT(0);
1349: tt1 = cpu->GetTT(1);
1350: tc = cpu->GetTC();
1351: sr = cpu->GetMMUSR();
1352:
1353: osrp = prev.srp.q;
1354: ocrp = prev.crp.q;
1355: ott0 = prev.tt[0];
1356: ott1 = prev.tt[1];
1357: otc = prev.tc;
1358: osr = prev.mmusr;
1359:
1360: // 1行目
1361: p = (srp != osrp);
1362: t = (tt0 != ott0);
1363: c = (tc != otc);
1364: cons->Print("%sSRP:%08x_%08x%s %sTT0:%08x%s(%c%c%c)",
1365: BOLDIF(p), (uint32)(srp >> 32), (uint32)srp, NORM,
1366: BOLDIF(t), tt0, NORM,
1367: (tt0 & m68030TT::E) ? 'E' : '-',
1368: (tt0 & m68030TT::CI) ? 'C' : '-',
1369: (tt0 & m68030TT::RWM) ? '-' : ((tt0 & m68030TT::RW) ? 'R' : 'W'));
1370: cons->Print(" %sTC:%08x%s(%c%c%c)\n",
1371: BOLDIF(c), tc, NORM,
1372: (tc & m68030TC::TC_E) ? 'E' : '-',
1373: (tc & m68030TC::TC_SRE) ? 'S' : '-',
1374: (tc & m68030TC::TC_FCL) ? 'F' : '-');
1375:
1376: // 2行目
1377: p = (crp != ocrp);
1378: t = (tt1 != ott1);
1379: c = (sr != osr);
1380: cons->Print("%sCRP:%08x_%08x%s %sTT1:%08x%s(%c%c%c)",
1381: BOLDIF(p), uint32(crp >> 32), (uint32)crp, NORM,
1382: BOLDIF(t), tt1, NORM,
1383: (tt1 & m68030TT::E) ? 'E' : '-',
1384: (tt1 & m68030TT::CI) ? 'C' : '-',
1385: (tt1 & m68030TT::RWM) ? '-' : ((tt1 & m68030TT::RW) ? 'R' : 'W'));
1386: cons->Print(" %sMMUSR: %04x%s(%c%c%c%c%c%c%c N=%d)\n",
1387: BOLDIF(c), sr, NORM,
1388: (sr & m68030MMUSR::B) ? 'B' : '-',
1389: (sr & m68030MMUSR::L) ? 'L' : '-',
1390: (sr & m68030MMUSR::S) ? 'S' : '-',
1391: (sr & m68030MMUSR::W) ? 'W' : '-',
1392: (sr & m68030MMUSR::I) ? 'I' : '-',
1393: (sr & m68030MMUSR::M) ? 'M' : '-',
1394: (sr & m68030MMUSR::T) ? 'T' : '-',
1395: (sr & m68030MMUSR::N));
1396: }
1397:
1398: // その他のレジスタを表示
1399: void
1400: Debugger::ShowRegOther()
1401: {
1402: TextScreen s(80, 2);
1403:
1404: // 0 1 2 3 4 5 6
1405: // 012345678901234567890123456789012345678901234567890123456789012345
1406: // CACR:01234567 VBR:01234567 USP:01234567
1407: // CAAR:01234567 SFC:0 DFC:0 MSP:01234567
1408:
1409: #define EM(name) ((cpu->reg.name != prev.name) ? TA::Em : TA::Normal)
1410: s.Print(0, 0, EM(cacr), "CACR:%08x", cpu->reg.cacr);
1411: s.Print(0, 1, EM(caar), "CAAR:%08x", cpu->reg.caar);
1412:
1413: s.Print(15, 0, EM(vbr), "VBR:%08x", cpu->reg.vbr);
1414: s.Print(15, 1, EM(sfc), "SFC:%d", cpu->reg.sfc);
1415: s.Print(22, 1, EM(dfc), "DFC:%d", cpu->reg.dfc);
1416:
1417: // スタック欄はモードによって表示を変える。
1418: // ユーザ 割り込み マスタ
1419: // 1行目 ISP USP USP
1420: // 2行目 MSP MSP ISP
1421: if (!cpu->reg.s) {
1422: s.Print(29, 0, EM(isp), "ISP:%08x", cpu->reg.isp);
1423: } else {
1424: s.Print(29, 0, EM(usp), "USP:%08x", cpu->reg.usp);
1425: }
1426: if (!cpu->reg.m) {
1427: s.Print(29, 1, EM(msp), "MSP:%08x", cpu->reg.msp);
1428: } else {
1429: s.Print(29, 1, EM(isp), "ISP:%08x", cpu->reg.isp);
1430: }
1431:
1432: ShowMonitor(s);
1433: }
1434:
1435: // op が 68030 の条件命令 Bcc, Scc, TRAPcc, DBcc なら true を返す。
1436: bool
1437: Debugger::IsOPcc(uint16 op)
1438: {
1439: uint16 cc;
1440:
1441: if ((op & 0xf000) == 0x6000) {
1442: cc = (op >> 8) & 0xf;
1443: if (cc == 0 || cc == 1) { // BRA, BSR
1444: return false;
1445: } else {
1446: return true; // Bcc
1447: }
1448: }
1449:
1450: if ((op & 0xf0c0) == 0x50c0) { // Scc, TRAPcc, DBcc
1451: return true;
1452: }
1453:
1454: return false;
1455: }
1456:
1457: // op が DBcc 命令なら true を返す。
1458: bool
1459: Debugger::IsDBcc(uint16 op)
1460: {
1461: if ((op & 0xf0f8) == 0x50c8) { // DBcc
1462: return true;
1463: }
1464: return false;
1465: }
1466:
1467: // op の cccc 条件が現在の CCR で成立するなら true を返す。
1468: bool
1469: Debugger::IsCond(uint16 op)
1470: {
1471: bool N = RegIsN;
1472: bool Z = RegIsZ;
1473: bool V = RegIsV;
1474: bool C = RegIsC;
1475:
1476: switch ((op >> 8) & 0x0f) {
1477: case 0: // T
1478: return true;
1479: case 1: // F
1480: return false;
1481: case 2: // HI
1482: return (!C) && (!Z);
1483: case 3: // LS
1484: return C || Z;
1485: case 4: // CC
1486: return !C;
1487: case 5: // CS
1488: return C;
1489: case 6: // NE
1490: return !Z;
1491: case 7: // EQ
1492: return Z;
1493: case 8: // VC
1494: return !V;
1495: case 9: // VS
1496: return V;
1497: case 10: // PL
1498: return !N;
1499: case 11: // MI
1500: return N;
1501: case 12: // GE
1502: return (N && V) || ((!N) && (!V));
1503: case 13: // LT
1504: return (N && (!V)) || ((!N) && V);
1505: case 14: // GT
1506: return (N && V && (!Z)) || ((!N) && (!V) && (!Z));
1507: case 15: // LE
1508: return Z || (N && (!V)) || ((!N) && V);
1509: default:
1510: __unreachable();
1511: }
1512: }
1513:
1514: // addr 位置の命令が条件命令なら、成立可否などの文字列を返す。
1515: // Bcc, Scc, TRAPcc 命令なら、条件が成立するかどうか。
1516: // DBcc 命令ならブランチするかどうか。
1517: const char *
1518: Debugger::OPccCondStr(uint32 addr)
1519: {
1520: uint16 op;
1521:
1522: // XXX logical peek のような気がする
1523: op = (((uint16)m68030_phys_peek_8(addr)) << 8)
1524: | m68030_phys_peek_8(addr + 1);
1525:
1526: // DBcc 命令なら、ブランチするかどうか
1527: // IsOPcc() は DBcc も含んでいるため、IsDBcc() の判定のほうが先。
1528: // DBcc は内部でカウンタレジスタを減算してから比較するため、
1529: // 命令実行前のカウンタが 0 の時点でループ終了となることに注意。
1530: if (IsDBcc(op)) {
1531: // 成立したら何もしない
1532: if (IsCond(op)) {
1533: return " (will fall)";
1534: }
1535: // カウンタが -1 なら何もしない
1536: uint rr = op & 7;
1537: if ((RegD(rr) & 0xffff) == 0) {
1538: return " (will expire)";
1539: }
1540: // それ以外はブランチ
1541: return " (will take)";
1542: }
1543:
1544: // Bcc, Scc, TRAPcc 命令なら条件が成立するかどうか
1545: if (IsOPcc(op)) {
1546: if (IsCond(op)) {
1547: return " (will take)";
1548: } else {
1549: return " (will not take)";
1550: }
1551: }
1552:
1553: // (ここで知ってる)条件命令ではない
1554: return "";
1555: }
1556:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.