Return to m680x0ea.h CVS log

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

Annotation of nono/m680x0/m680x0ea.h, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2020 nono project
        !             4: // Licensed under nono-license.txt
        !             5: //
        !             6: 
        !             7: // EA
        !             8: 
        !             9: #pragma once
        !            10: 
        !            11:        // 命令ワードの下位6ビット mmmrrr のうち mmm の部分を取り出す
        !            12:        static inline int eamode(uint x)        { return (x >> 3) & 7; }
        !            13:        // 命令ワードの下位6ビット mmmrrr のうち rrr の部分を取り出す
        !            14:        static inline int eanum(uint x)         { return x & 7; }
        !            15: 
        !            16:        // internal_ea_*() は EA を計算だけする部分。CYCLE はここでは加算しない。
        !            17:        // MOVE の DST 側からも呼ばれる。
        !            18: 
        !            19:        // (An)
        !            20:        inline uint32 internal_ea_anin(uint n)
        !            21:        {
        !            22:                return reg.A[n];
        !            23:        }
        !            24: 
        !            25:        // (An)+ .B
        !            26:        inline uint32 internal_ea_anpi_1(uint n)
        !            27:        {
        !            28:                if (n == 7) {
        !            29:                        reg.A[n] += 2;
        !            30:                        return reg.A[n] - 2;
        !            31:                } else {
        !            32:                        reg.A[n] += 1;
        !            33:                        return reg.A[n] - 1;
        !            34:                }
        !            35:        }
        !            36: 
        !            37:        // (An)+ .W
        !            38:        inline uint32 internal_ea_anpi_2(uint n)
        !            39:        {
        !            40:                reg.A[n] += 2;
        !            41:                return reg.A[n] - 2;
        !            42:        }
        !            43: 
        !            44:        // (An)+ .L
        !            45:        inline uint32 internal_ea_anpi_4(uint n)
        !            46:        {
        !            47:                reg.A[n] += 4;
        !            48:                return reg.A[n] - 4;
        !            49:        }
        !            50: 
        !            51:        // -(An) .B
        !            52:        inline uint32 internal_ea_anpd_1(uint n)
        !            53:        {
        !            54:                if (n == 7) {
        !            55:                        reg.A[n] -= 2;
        !            56:                } else {
        !            57:                        reg.A[n] -= 1;
        !            58:                }
        !            59:                return reg.A[n];
        !            60:        }
        !            61: 
        !            62:        // -(An) .W
        !            63:        inline uint32 internal_ea_anpd_2(uint n)
        !            64:        {
        !            65:                reg.A[n] -= 2;
        !            66:                return reg.A[n];
        !            67:        }
        !            68: 
        !            69:        // -(An) .L
        !            70:        inline uint32 internal_ea_anpd_4(uint n)
        !            71:        {
        !            72:                reg.A[n] -= 4;
        !            73:                return reg.A[n];
        !            74:        }
        !            75: 
        !            76:        // d16(An)
        !            77:        inline uint32 internal_ea_andi(uint n)
        !            78:        {
        !            79:                int32 disp = (int32)(int16)fetch_2();
        !            80:                return reg.A[n] + disp;
        !            81:        }
        !            82: 
        !            83:        // (An,IX)
        !            84:        inline uint32 internal_ea_anix(uint n)
        !            85:        {
        !            86:                return internal_ea_ix(reg.A[n]);
        !            87:        }
        !            88: 
        !            89:        // Abs.W
        !            90:        inline uint32 internal_ea_absw()
        !            91:        {
        !            92:                return (int32)(int16)fetch_2();
        !            93:        }
        !            94: 
        !            95:        // Abs.L
        !            96:        inline uint32 internal_ea_absl()
        !            97:        {
        !            98:                return fetch_4();
        !            99:        }
        !           100: 
        !           101:        // d16(PC)
        !           102:        inline uint32 internal_ea_pcdi()
        !           103:        {
        !           104:                int32 origin = reg.pc;
        !           105:                int32 disp = (int32)(int16)fetch_2();
        !           106:                return origin + disp;
        !           107:        }
        !           108: 
        !           109:        // (PC,IX)
        !           110:        inline uint32 internal_ea_pcix()
        !           111:        {
        !           112:                return internal_ea_ix(reg.pc);
        !           113:        }
        !           114: 
        !           115:        uint32 internal_ea_ix(uint32);
        !           116: 
        !           117:        // CEA (個別)
        !           118:        uint32 cea_anin(uint n);
        !           119:        uint32 cea_anpi_1(uint n);
        !           120:        uint32 cea_anpi_2(uint n);
        !           121:        uint32 cea_anpi_4(uint n);
        !           122:        uint32 cea_anpd_1(uint n);
        !           123:        uint32 cea_anpd_2(uint n);
        !           124:        uint32 cea_anpd_4(uint n);
        !           125:        uint32 cea_andi(uint n);
        !           126:        uint32 cea_anix(uint n);
        !           127:        uint32 cea_absw();
        !           128:        uint32 cea_absl();
        !           129:        uint32 cea_pcdi();
        !           130:        uint32 cea_pcix();
        !           131: 
        !           132:        // FEA (個別)
        !           133:        uint32 fea_anin();
        !           134:        uint32 fea_anpi_1();
        !           135:        uint32 fea_anpi_2();
        !           136:        uint32 fea_anpi_4();
        !           137:        uint32 fea_anpd_1();
        !           138:        uint32 fea_anpd_2();
        !           139:        uint32 fea_anpd_4();
        !           140:        uint32 fea_andi();
        !           141:        uint32 fea_anix();
        !           142:        uint32 fea_absw();
        !           143:        uint32 fea_absl();
        !           144:        uint32 fea_pcdi();
        !           145:        uint32 fea_pcix();
        !           146:        void   fea_imm_2();
        !           147:        void   fea_imm_4();
        !           148: 
        !           149:        // CEA (グループ)
        !           150:        uint32 cea_ctrl();
        !           151:        uint32 cea_data_1();
        !           152:        uint32 cea_data_2();
        !           153:        uint32 cea_data_4();
        !           154:        uint32 cea_copro();
        !           155: 
        !           156:        // FEA (グループ)
        !           157:        uint32 fea_data_1();
        !           158:        uint32 fea_data_2();
        !           159:        uint32 fea_data_4();
        !           160:        uint32 fea_all_1();
        !           161:        uint32 fea_all_2();
        !           162:        uint32 fea_all_4();

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