Return to m68030core.cpp CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0

Annotation of nono/m680x0/m68030core.cpp, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2017 [email protected]
        !             4: //
        !             5: 
        !             6: #include "header.h"
        !             7: #include "m68030core.h"
        !             8: #include "debugger.h"
        !             9: #include "cvprompt.h"
        !            10: #include "mpu.h"
        !            11: 
        !            12: #define OP_PROTO(name) static inline void __CONCAT(op_,name)(m68kcpu *cpu)
        !            13: #define OP_DEF(name)   static inline void __CONCAT(op_,name)(m68kcpu *cpu)
        !            14: #define OP_FUNC(name)  __CONCAT(op_,name)(cpu)
        !            15: 
        !            16: // (エミュレータ的)未実装命令
        !            17: // 今はまだマクロ
        !            18: #define op_unimpl(cpu) \
        !            19:        PANIC("unimplemented instruction! %s()", __FUNCTION__)
        !            20: 
        !            21: #include "m68030bus.h"
        !            22: #include "m68030bus.cpp"
        !            23: #include "m68030excep.h"
        !            24: #include "m68030ea.h"
        !            25: #include "m68030acc.h"
        !            26: #include "m68030ops.h"
        !            27: #include "m68030mmu.h"
        !            28: #include "m68030fpu.h"
        !            29: #include "m68030ops.cpp"
        !            30: 
        !            31: static void m68030_flush_interrupt(m68kcpu *cpu);
        !            32: 
        !            33: // request サイクル(を超えるところまで)実行する。
        !            34: uint32
        !            35: m68030_run(m68kcpu *cpu, uint64 request)
        !            36: {
        !            37:        uint64 goal_cycle = cpu->total_cycle + request;
        !            38: 
        !            39:        // メインループ
        !            40:        while (1) {
        !            41:                if (cpu->atomic_reqflag != 0) {
        !            42:                        // 何かが起きた
        !            43: 
        !            44:                        // デバッグ用
        !            45:                        if (0) {
        !            46:                                static int oldreq = -1;
        !            47:                                uint32 _req = cpu->atomic_reqflag;
        !            48:                                if ((_req & (CPU_REQ_TRACE | CPU_REQ_PROMPT)) != oldreq) {
        !            49:                                        oldreq = _req & (CPU_REQ_TRACE | CPU_REQ_PROMPT);
        !            50:                                        printf("reqflag=%c%c\n",
        !            51:                                                (_req & CPU_REQ_TRACE)  ? 'T' : '-',
        !            52:                                                (_req & CPU_REQ_PROMPT) ? 'P' : '-');
        !            53:                                }
        !            54:                        }
        !            55: 
        !            56:                        // XXX 発生頻度を観測すること。
        !            57:                        //     そして並び替えるとか、フラグの割り当てを考えるとか。
        !            58: 
        !            59:                        // このフラグ処理の優先度はたぶん次のような感じになるはず。
        !            60:                        // 1. スケジューラ依頼による処理の中断
        !            61:                        // 2. 命令途中で起きた例外の処理
        !            62:                        // 3. 割り込みチェック
        !            63:                        // 4. STOP、HALT 状態の対応
        !            64: 
        !            65:                        if ((cpu->atomic_reqflag & CPU_REQ_RELEASE)) {
        !            66:                                // ここで実行を中断してスケジューラに戻る
        !            67:                                cpu->atomic_reqflag &= ~CPU_REQ_RELEASE;
        !            68:                                return cpu->atomic_reqflag;
        !            69:                        }
        !            70: 
        !            71:                        if ((cpu->atomic_reqflag & CPU_REQ_INTR)) {
        !            72:                                // 割り込みチェック
        !            73:                                // 必要ならこの中で例外処理を起動する
        !            74:                                m68030_flush_interrupt(cpu);
        !            75:                        }
        !            76: 
        !            77:                        if ((cpu->atomic_reqflag & CPU_REQ_STOP)) {
        !            78:                                // STOP 状態は、残りサイクルを消費したことにして戻る
        !            79:                                cpu->reg.state = CPU_REQ_STOP;
        !            80:                                cpu->total_cycle = goal_cycle;
        !            81:                                return cpu->atomic_reqflag;
        !            82:                        }
        !            83: 
        !            84:                        if ((cpu->atomic_reqflag & CPU_REQ_HALT)) {
        !            85:                                cpu->reg.state = CPU_REQ_HALT;
        !            86:                                PANIC("未実装 HALT 状態");
        !            87:                        }
        !            88: 
        !            89:                        if ((cpu->atomic_reqflag & CPU_REQ_TRACE)) {
        !            90:                                // デバッガプロンプトを出すかどうかを判断する
        !            91:                                cpu->inst_count++;
        !            92:                                if (debugger_check()) {
        !            93:                                        cpu->atomic_reqflag |= CPU_REQ_PROMPT;
        !            94:                                }
        !            95:                        }
        !            96: 
        !            97:                        if ((cpu->atomic_reqflag & CPU_REQ_PROMPT)) {
        !            98:                                // デバッガプロンプトのための実行停止
        !            99: 
        !           100:                                // プロンプト獲得を通知
        !           101:                                gCVPrompt->NotifyAcquire();
        !           102: 
        !           103:                                // プロンプト解放を待機
        !           104:                                gCVPrompt->WaitRelease();
        !           105: 
        !           106:                                // プロンプトを抜けたのでここでフラグを落とす
        !           107:                                cpu->atomic_reqflag &= ~CPU_REQ_PROMPT;
        !           108:                        }
        !           109:                }
        !           110: 
        !           111:                try {
        !           112: #define USE_COMPUTED_GOTO
        !           113: #if defined(USE_COMPUTED_GOTO)
        !           114:                        // computed-goto を使う方法。
        !           115:                        // JUMP が1回目の分岐。CHECK_AND_JUMP が命令実行後の分岐。
        !           116:                        // outer は命令実行前にチェックしてはいけないので、2つに
        !           117:                        // 分かれている。1回目の分岐も goto.h の中で出力してある。
        !           118: #define JUMP   \
        !           119:                        RegPPC = RegPC; \
        !           120:                        cpu->flag_pi = 0; \
        !           121:                        cpu->flag_pd = 0; \
        !           122:                        RegIR = m68030_fetch_16(cpu);   \
        !           123:                        __assume((RegIR >> 6) < 1024);  \
        !           124:                        goto *jumptable[RegIR >> 6]
        !           125: 
        !           126: #define CHECK_AND_JUMP \
        !           127:                        cpu->total_cycle += cpu->cycle_cache;   \
        !           128:                        cpu->total_cycle += cpu->cycle_nocache; \
        !           129:                        cpu->cycle_cache = 0;   \
        !           130:                        cpu->cycle_nocache = 0; \
        !           131:                        if (cpu->total_cycle >= goal_cycle) return cpu->atomic_reqflag; \
        !           132:                        if (cpu->atomic_reqflag != 0) goto exit_inner_loop; \
        !           133:                        JUMP
        !           134: 
        !           135: #include "m68030goto.h"
        !           136:                        exit_inner_loop:;
        !           137: #else
        !           138:                        // switch-case を使う方法。
        !           139:                        do {
        !           140:                                RegPPC = RegPC;
        !           141:                                cpu->flag_pi = 0;
        !           142:                                cpu->flag_pd = 0;
        !           143:                                RegIR = m68030_fetch_16(cpu);
        !           144: 
        !           145:                                // uint16 を 6ビット右シフトしたら 1024 以上になるはずは
        !           146:                                // ないのだが、デフォルトでは gcc/clang どちらも律儀に
        !           147:                                // 1024 以上かどうか比較して分岐しようとする。
        !           148:                                // gcc は __assume() を入れることでこの比較・分岐を出力
        !           149:                                // しないようにすることが出来た(がパフォーマンスの差は
        !           150:                                // 見えない程度でしかなかった)。
        !           151:                                // clang ではどうやったら効くか不明。
        !           152:                                uint16 ir = RegIR >> 6;
        !           153:                                __assume(ir < 1024);
        !           154:                                switch (ir) {
        !           155: #include "m68030switch.h"
        !           156:                                }
        !           157: 
        !           158:                                cpu->total_cycle += cpu->cycle_cache;
        !           159:                                cpu->total_cycle += cpu->cycle_nocache;
        !           160:                                cpu->cycle_cache = 0;
        !           161:                                cpu->cycle_nocache = 0;
        !           162:                                if (cpu->total_cycle >= goal_cycle)
        !           163:                                        return cpu->atomic_reqflag;
        !           164: 
        !           165:                        } while (cpu->atomic_reqflag == 0);
        !           166: #endif
        !           167:                } catch (int vector) {
        !           168:                        // ここで(C++の)例外スローをキャッチするのは
        !           169:                        // - メモリ空間をアクセスした先でのバスエラー例外
        !           170:                        // - EA パース中の不当命令例外
        !           171:                        // のみ。それ以外の命令途中例外はその場で処理できる。
        !           172:                        cpulog(1, "%s", m68030_get_exception_name(vector));
        !           173:                        m68030_exception(cpu, vector);
        !           174:                }
        !           175:        }
        !           176:        __unreachable();
        !           177: }
        !           178: 
        !           179: // ペンディングの割り込みを確認
        !           180: static void
        !           181: m68030_flush_interrupt(m68kcpu *cpu)
        !           182: {
        !           183:        // 割り込みマスクをレベル(1-7)に変換するテーブル
        !           184:        // b はペンディングになってる割り込みのうち今回処理する最上位の1つ
        !           185:        // を示すビットが立った状態。不正入力がないとすると入力は 0 〜 64。
        !           186:        static uint8 mask2level[65] = {
        !           187:        //      0 1 2 3 4 5 6 7  8 9 A B C D E F
        !           188:                0,7,6,0,5,0,0,0, 4,0,0,0,0,0,0,0,       // $00
        !           189:                3,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,       // $10
        !           190:                2,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,       // $20
        !           191:                0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,       // $30
        !           192:                1,
        !           193:        };
        !           194:        int b;
        !           195: 
        !           196:        cpu->intrmtx.lock();
        !           197: 
        !           198:        b = cpu->intr_pending & cpu->intr_mask;
        !           199:        if (b != 0) {
        !           200:                // 立っている最下位ビットだけを残す
        !           201:                b &= -b;
        !           202: 
        !           203:                // 該当フラグは落としておく
        !           204:                cpu->intr_pending &= ~b;
        !           205: 
        !           206:                // ストップ状態を解除
        !           207:                cpu->atomic_reqflag &= ~CPU_REQ_STOP;
        !           208:                cpu->reg.state = 0;
        !           209: 
        !           210:                // b をレベルに変換
        !           211:                int level = mask2level[b];
        !           212:                int vector = cpu->intr_vector[level];
        !           213: 
        !           214:                // ロックここまで。例外処理時に intrmtx は外しておくこと
        !           215:                cpu->intrmtx.unlock();
        !           216: 
        !           217:                // 例外処理を起動
        !           218:                m68030_exception_interrupt(cpu, level, vector);
        !           219: 
        !           220:                // 次の命令境界でも割り込みチェックを行う
        !           221:                // 更に下のレベルの割り込みがペンディングになっている可能性のため
        !           222:        } else {
        !           223:                // ペンディングの割り込みはなくなったので、
        !           224:                // 次の命令境界では割り込みチェックは不要
        !           225:                cpu->atomic_reqflag &= ~CPU_REQ_INTR;
        !           226: 
        !           227:                // ロックここまで (atomic なのでその前で解放してもいいけど)
        !           228:                cpu->intrmtx.unlock();
        !           229:        }
        !           230: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.