Return to m68030ccr.h CVS log

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

Annotation of nono/m680x0/m68030ccr.h, revision 1.1.1.1

1.1       root        1: //
                      2: // nono
                      3: // Copyright (C) 2017 [email protected]
                      4: //
                      5: 
                      6: #pragma once
                      7: 
                      8: struct m68030ccr
                      9: {
                     10:        // X フラグは、x の X_BIT が立っていれば 1
                     11:        // N フラグは、n の N_BIT が立っていれば 1
                     12:        // Z フラグは、z == 0 なら 1
                     13:        // V フラグは、v の V_BIT が立っていれば 1
                     14:        // C フラグは、c の C_BIT が立っていれば 1
                     15:        static const uint32 X_BIT = 0x00000001;
                     16:        static const uint32 N_BIT = 0x80000000;
                     17:        static const uint32 V_BIT = 0x80000000;
                     18:        static const uint32 C_BIT = 0x00000001;
                     19: 
                     20:        uint32 x;
                     21:        uint32 v;
                     22:        uint32 n;
                     23:        union {
                     24:                uint64 cz;
                     25:                struct {
                     26: #if BYTE_ORDER == LITTLE_ENDIAN
                     27:                        uint32 z;
                     28:                        uint32 c;
                     29: #else
                     30:                        uint32 c;
                     31:                        uint32 z;
                     32: #endif
                     33:                } __packed;
                     34:        };
                     35: 
                     36:        // フラグを立てる
                     37:        void SetX() { x = X_BIT; }
                     38:        void SetN() { n = N_BIT; }
                     39:        void SetZ() { z = 0; }
                     40:        void SetV() { v = V_BIT; }
                     41:        void SetC() { c = C_BIT; }
                     42: 
                     43:        // フラグを降ろす
                     44:        void ClrX() { x = 0; }
                     45:        void ClrN() { n = 0; }
                     46:        void ClrZ() { z = 1; }
                     47:        void ClrV() { v = 0; }
                     48:        void ClrC() { c = 0; }
                     49: 
                     50:        // フラグを value (bool値) にセットする
                     51:        void PutX(bool value) { x = (value) ? X_BIT : 0; }
                     52:        void PutN(bool value) { n = (value) ? N_BIT : 0; }
                     53:        void PutZ(bool value) { z = (value) ? 0 : 1; }
                     54:        void PutV(bool value) { v = (value) ? V_BIT : 0; }
                     55:        void PutC(bool value) { c = (value) ? C_BIT : 0; }
                     56: 
                     57:        // フラグが立っていれば真を返す
                     58:        bool IsX() const { return ((x & X_BIT) != 0); }
                     59:        bool IsN() const { return ((n & N_BIT) != 0); }
                     60:        bool IsZ() const { return (z == 0); }
                     61:        bool IsV() const { return ((v & V_BIT) != 0); }
                     62:        bool IsC() const { return ((c & C_BIT) != 0); }
                     63: 
                     64:        // CCR レジスタの内容を作って返す
                     65:        uint8 Get() const {
                     66:                return (IsX() ? M68K_CCR_X : 0)
                     67:                     | (IsN() ? M68K_CCR_N : 0)
                     68:                     | (IsZ() ? M68K_CCR_Z : 0)
                     69:                     | (IsV() ? M68K_CCR_V : 0)
                     70:                     | (IsC() ? M68K_CCR_C : 0);
                     71:        }
                     72: 
                     73:        // CCR レジスタに val をセットする
                     74:        void Set(uint8 val) {
                     75:                PutX((val) & M68K_CCR_X);
                     76:                PutN((val) & M68K_CCR_N);
                     77:                PutZ((val) & M68K_CCR_Z);
                     78:                PutV((val) & M68K_CCR_V);
                     79:                PutC((val) & M68K_CCR_C);
                     80:        }
                     81: };
                     82: 
                     83: // フラグを立てる
                     84: #define RegSetX()              cpu->reg.ccr.SetX()
                     85: #define RegSetN()              cpu->reg.ccr.SetN()
                     86: #define RegSetZ()              cpu->reg.ccr.SetZ()
                     87: #define RegSetV()              cpu->reg.ccr.SetV()
                     88: #define RegSetC()              cpu->reg.ccr.SetC()
                     89: 
                     90: // フラグを降ろす
                     91: #define RegClrX()              cpu->reg.ccr.ClrX()
                     92: #define RegClrN()              cpu->reg.ccr.ClrN()
                     93: #define RegClrZ()              cpu->reg.ccr.ClrZ()
                     94: #define RegClrV()              cpu->reg.ccr.ClrV()
                     95: #define RegClrC()              cpu->reg.ccr.ClrC()
                     96: 
                     97: // フラグを value (bool値) にセットする
                     98: #define RegPutX(value)         cpu->reg.ccr.PutX(value)
                     99: #define RegPutN(value)         cpu->reg.ccr.PutN(value)
                    100: #define RegPutZ(value)         cpu->reg.ccr.PutZ(value)
                    101: #define RegPutV(value)         cpu->reg.ccr.PutV(value)
                    102: #define RegPutC(value)         cpu->reg.ccr.PutC(value)
                    103: 
                    104: // フラグが立っていれば真を返す
                    105: #define RegIsX                 (cpu->reg.ccr.IsX())
                    106: #define RegIsN                 (cpu->reg.ccr.IsN())
                    107: #define RegIsZ                 (cpu->reg.ccr.IsZ())
                    108: #define RegIsV                 (cpu->reg.ccr.IsV())
                    109: #define RegIsC                 (cpu->reg.ccr.IsC())
                    110: 
                    111: #define RegCondT       (true)
                    112: #define RegCondF       (false)
                    113: #define RegCondHI      (!RegIsC && !RegIsZ)
                    114: #define RegCondLS      (RegIsC || RegIsZ)
                    115: #define RegCondCC      (!RegIsC)
                    116: #define RegCondCS      (RegIsC)
                    117: #define RegCondNE      (!RegIsZ)
                    118: #define RegCondEQ      (RegIsZ)
                    119: #define RegCondVC      (!RegIsV)
                    120: #define RegCondVS      (RegIsV)
                    121: #define RegCondPL      (!RegIsN)
                    122: #define RegCondMI      (RegIsN)
                    123: #define RegCondGE      ((RegIsN && RegIsV) || (!RegIsN && !RegIsV))
                    124: #define RegCondLT      ((RegIsN && !RegIsV) || (!RegIsN && RegIsV))
                    125: #define RegCondGT      ((RegIsN && RegIsV && !RegIsZ) || \
                    126:                         (!RegIsN && !RegIsV && !RegIsZ))
                    127: #define RegCondLE      (RegIsZ || (RegIsN && !RegIsV) || (!RegIsN && RegIsV))

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