Annotation of nono/m680x0/m680x0ea.h, revision 1.1.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();

unix.superglobalmegacorp.com

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