Return to m680x0bitfield.cpp CVS log

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

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

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2022 nono project
        !             4: // Licensed under nono-license.txt
        !             5: //
        !             6: 
        !             7: #include "m680x0bitfield.h"
        !             8: #include "bitops.h"
        !             9: 
        !            10: // コンストラクタ
        !            11: // 呼び出し側でここまでに ir2 へのフェッチはしておくこと。
        !            12: acc_bf::acc_bf(MPU680x0Device *cpu_)
        !            13: {
        !            14:        cpu = cpu_;
        !            15: 
        !            16:        //  F  E  D  C  B  A  9  8  7  6  5  4  3  2  1  0
        !            17:        //  0  0  0  0 DO <-- offset --> DW <-- width --->
        !            18: 
        !            19:        offset = (cpu->GetIR2() >> 6) & 0x1f;
        !            20:        if ((cpu->GetIR2() & 0x0800)) {
        !            21:                offset = (int32)cpu->reg.D[offset & 7];
        !            22:                local_offset = offset & 0x1f;
        !            23:        } else {
        !            24:                local_offset = offset;
        !            25:        }
        !            26: 
        !            27:        width = cpu->GetIR2();
        !            28:        if ((cpu->GetIR2() & 0x0020)) {
        !            29:                width = cpu->reg.D[width & 7];
        !            30:        }
        !            31:        // モジュロ 32 を取り、0 なら 32 を表す
        !            32:        width = ((width - 1) & 31) + 1;
        !            33:        // mask は32ビットの上位から width ビット 1 が並んだもの
        !            34:        mask = 0xffffffff << (32 - width);
        !            35: }
        !            36: 
        !            37: // データレジスタから値を読み込む。n はデータレジスタの番号。
        !            38: void
        !            39: acc_bf::LoadReg(uint n)
        !            40: {
        !            41:        data = cpu->reg.D[n];
        !            42:        data = ROL32(data, local_offset);
        !            43:        data &= mask;
        !            44: }
        !            45: 
        !            46: // メモリから値を読み込む。
        !            47: void
        !            48: acc_bf::LoadMem(uint32 addr)
        !            49: {
        !            50:        // EA の計算
        !            51:        ea = addr + offset / 8;
        !            52:        local_offset = offset % 8;
        !            53:        if (local_offset < 0) {
        !            54:                local_offset += 8;
        !            55:                ea--;
        !            56:        }
        !            57: 
        !            58:        // アクセスするバイト数
        !            59:        bytes = (local_offset + width + 7) / 8;
        !            60: 
        !            61:        // 40ビットバッファに読み込む
        !            62:        if (bytes <= 4) {
        !            63:                buf = ((uint64)cpu->read_n(ea, bytes)) << ((5 - bytes) * 8);
        !            64:        } else {
        !            65:                // 実際どういうアクセスになるのか分からないが。
        !            66:                if ((ea & 1) == 0) {
        !            67:                        // 偶数アドレスから5バイト
        !            68:                        buf = ((uint64)cpu->read_4(ea)) << 8;
        !            69:                        buf |= ((uint64)cpu->read_1(ea + 4));
        !            70:                } else {
        !            71:                        // 奇数アドレスから5バイト
        !            72:                        buf = ((uint64)cpu->read_1(ea)) << 32;
        !            73:                        buf |= ((uint64)cpu->read_4(ea + 1));
        !            74:                }
        !            75:        }
        !            76: 
        !            77:        // 32ビット左詰めにする
        !            78:        data = (buf >> (8 - local_offset)) & mask;
        !            79: }
        !            80: 
        !            81: // データレジスタに値を書き出す。
        !            82: void
        !            83: acc_bf::StoreReg(uint n)
        !            84: {
        !            85:        uint32 m = ROR32(mask, local_offset);
        !            86:        uint32 d = ROR32(data, local_offset);
        !            87: 
        !            88:        cpu->reg.D[n] = (cpu->reg.D[n] & ~m) | (d & m);
        !            89: }
        !            90: 
        !            91: // メモリに値を書き出す
        !            92: void
        !            93: acc_bf::StoreMem()
        !            94: {
        !            95:        // 32ビット左詰めデータを 40ビットバッファにマージ
        !            96:        uint64 m = (uint64)mask << (8 - local_offset);
        !            97:        uint64 d = (uint64)data << (8 - local_offset);
        !            98:        buf = (buf & ~m) | (d & m);
        !            99: 
        !           100:        // 40ビットバッファを書き戻す
        !           101:        if (bytes <= 4) {
        !           102:                cpu->write_n(ea, bytes, buf >> ((5 - bytes) * 8));
        !           103:        } else {
        !           104:                // 実際どういうアクセスになるのか分からないが。
        !           105:                if ((ea & 1) == 0) {
        !           106:                        // 偶数アドレスから5バイト
        !           107:                        cpu->write_4(ea, buf >> 8);
        !           108:                        cpu->write_1(ea + 4, buf & 0xff);
        !           109:                } else {
        !           110:                        // 奇数アドレスから5バイト
        !           111:                        cpu->write_1(ea, buf >> 32);
        !           112:                        cpu->write_4(ea + 1, buf);
        !           113:                }
        !           114:        }
        !           115: }

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