MSXCPUInterface.hh

Go to the documentation of this file.

#ifndef MSXCPUINTERFACE_HH
#define MSXCPUINTERFACE_HH

#include "CacheLine.hh"
#include "MSXDevice.hh"
#include "WatchPoint.hh"
#include "openmsx.hh"
#include "noncopyable.hh"
#include "likely.hh"
#include <bitset>
#include <vector>
#include <map>
#include <memory>

namespace openmsx {

class VDPIODelay;
class DummyDevice;
class MSXMotherBoard;
class MSXCPU;
class CliComm;
class MemoryDebug;
class SlottedMemoryDebug;
class IODebug;
class SlotInfo;
class SubSlottedInfo;
class ExternalSlotInfo;
class IOInfo;
class BreakPoint;
class DebugCondition;

class MSXCPUInterface : private noncopyable
{
public:
        explicit MSXCPUInterface(MSXMotherBoard& motherBoard);
        ~MSXCPUInterface();

        void register_IO_In(byte port, MSXDevice* device);
        void unregister_IO_In(byte port, MSXDevice* device);

        void register_IO_Out(byte port, MSXDevice* device);
        void unregister_IO_Out(byte port, MSXDevice* device);

        void registerMemDevice(MSXDevice& device,
                               int primSl, int secSL, int base, int size);
        void unregisterMemDevice(MSXDevice& device,
                                 int primSl, int secSL, int base, int size);

        void   registerGlobalWrite(MSXDevice& device, word address);
        void unregisterGlobalWrite(MSXDevice& device, word address);

        void reset();

        inline byte readMem(word address, EmuTime::param time) {
                if (unlikely(disallowReadCache[address >> CacheLine::BITS])) {
                        return readMemSlow(address, time);
                }
                return visibleDevices[address >> 14]->readMem(address, time);
        }

        inline void writeMem(word address, byte value, EmuTime::param time) {
                if (unlikely(disallowWriteCache[address >> CacheLine::BITS])) {
                        writeMemSlow(address, value, time);
                }
                visibleDevices[address>>14]->writeMem(address, value, time);
        }

        inline byte readIO(word port, EmuTime::param time) {
                return IO_In[port & 0xFF]->readIO(port, time);
        }

        inline void writeIO(word port, byte value, EmuTime::param time) {
                IO_Out[port & 0xFF]->writeIO(port, value, time);
        }

        inline const byte* getReadCacheLine(word start) const {
                if (unlikely(disallowReadCache[start >> CacheLine::BITS])) {
                        return nullptr;
                }
                return visibleDevices[start >> 14]->getReadCacheLine(start);
        }

        inline byte* getWriteCacheLine(word start) const {
                if (unlikely(disallowWriteCache[start >> CacheLine::BITS])) {
                        return nullptr;
                }
                return visibleDevices[start >> 14]->getWriteCacheLine(start);
        }

        byte readIRQVector();

        /*
         * Should only be used by PPI
         *  TODO: make private / friend
         */
        void setPrimarySlots(byte value);

        byte peekMem(word address, EmuTime::param time) const;
        byte peekSlottedMem(unsigned address, EmuTime::param time) const;
        byte readSlottedMem(unsigned address, EmuTime::param time);
        void writeSlottedMem(unsigned address, byte value,
                             EmuTime::param time);

        void setExpanded(int ps);
        void unsetExpanded(int ps);
        void testUnsetExpanded(int ps, std::vector<MSXDevice*> allowed) const;
        inline bool isExpanded(int ps) const { return expanded[ps] != 0; }
        void changeExpanded(bool isExpanded);

        DummyDevice& getDummyDevice();

        static void insertBreakPoint(const std::shared_ptr<BreakPoint>& bp);
        static void removeBreakPoint(const BreakPoint& bp);
        // note: must be shared_ptr (not unique_ptr), see checkBreakPoints()
        // TODO use multi_set sorted on BreakPoint->getAddress()
        typedef std::multimap<word, std::shared_ptr<BreakPoint>> BreakPoints;
        static const BreakPoints& getBreakPoints();

        void setWatchPoint(const std::shared_ptr<WatchPoint>& watchPoint);
        void removeWatchPoint(std::shared_ptr<WatchPoint> watchPoint);
        // note: must be shared_ptr (not unique_ptr), see WatchIO::doReadCallback()
        typedef std::vector<std::shared_ptr<WatchPoint>> WatchPoints;
        const WatchPoints& getWatchPoints() const;

        static void setCondition(const std::shared_ptr<DebugCondition>& cond);
        static void removeCondition(const DebugCondition& cond);
        // note: must be shared_ptr (not unique_ptr), see checkBreakPoints()
        typedef std::vector<std::shared_ptr<DebugCondition>> Conditions;
        static const Conditions& getConditions();

        static bool isBreaked() { return breaked; }
        void doBreak();
        void doStep();
        void doContinue();

        // should only be used by CPUCore
        static bool isStep()            { return step; }
        static void setStep    (bool x) { step = x; }
        static bool isContinue()        { return continued; }
        static void setContinue(bool x) { continued = x; }

        // breakpoint methods used by CPUCore
        static bool anyBreakPoints()
        {
                return !breakPoints.empty() || !conditions.empty();
        }
        static bool checkBreakPoints(unsigned pc)
        {
                auto range = breakPoints.equal_range(pc);
                if (conditions.empty() && (range.first == range.second)) {
                        return false;
                }

                // slow path non-inlined
                checkBreakPoints(range);
                return isBreaked();
        }

        // cleanup global variables
        static void cleanup();

        // In fast-forward mode, breakpoints, watchpoints and conditions should
        // not trigger.
        void setFastForward(bool fastForward_) { fastForward = fastForward_; }
        bool isFastForward() const { return fastForward; }

        template<typename Archive>
        void serialize(Archive& ar, unsigned version);

private:
        byte readMemSlow(word address, EmuTime::param time);
        void writeMemSlow(word address, byte value, EmuTime::param time);

        MSXDevice*& getDevicePtr(byte port, bool isIn);

        void register_IO  (int port, bool isIn,
                           MSXDevice*& devicePtr, MSXDevice* device);
        void unregister_IO(MSXDevice*& devicePtr, MSXDevice* device);
        void testRegisterSlot(MSXDevice& device,
                              int ps, int ss, int base, int size);
        void registerSlot(MSXDevice& device,
                          int ps, int ss, int base, int size);
        void unregisterSlot(MSXDevice& device,
                            int ps, int ss, int base, int size);


        static void checkBreakPoints(std::pair<BreakPoints::const_iterator,
                                               BreakPoints::const_iterator> range);

        void removeAllWatchPoints();
        void registerIOWatch  (WatchPoint& watchPoint, MSXDevice** devices);
        void unregisterIOWatch(WatchPoint& watchPoint, MSXDevice** devices);
        void updateMemWatch(WatchPoint::Type type);
        void executeMemWatch(WatchPoint::Type type, unsigned address,
                             unsigned value = ~0u);

        void doContinue2();

        friend class SlotInfo;
        friend class IODebug;
        friend class IOInfo;
        const std::unique_ptr<MemoryDebug> memoryDebug;
        const std::unique_ptr<SlottedMemoryDebug> slottedMemoryDebug;
        const std::unique_ptr<IODebug> ioDebug;
        const std::unique_ptr<SlotInfo> slotInfo;
        const std::unique_ptr<SubSlottedInfo> subSlottedInfo;
        const std::unique_ptr<ExternalSlotInfo> externalSlotInfo;
        const std::unique_ptr<IOInfo> inputPortInfo;
        const std::unique_ptr<IOInfo> outputPortInfo;

        void updateVisible(int page);
        inline void updateVisible(int page, int ps, int ss);
        void setSubSlot(byte primSlot, byte value);

        std::unique_ptr<DummyDevice> dummyDevice;
        MSXCPU& msxcpu;
        CliComm& cliComm;
        MSXMotherBoard& motherBoard;

        std::unique_ptr<VDPIODelay> delayDevice;

        byte disallowReadCache [CacheLine::NUM];
        byte disallowWriteCache[CacheLine::NUM];
        std::bitset<CacheLine::SIZE> readWatchSet [CacheLine::NUM];
        std::bitset<CacheLine::SIZE> writeWatchSet[CacheLine::NUM];

        struct GlobalWriteInfo {
                MSXDevice* device;
                word addr;
                bool operator==(const GlobalWriteInfo& rhs) const {
                        return (device == rhs.device) &&
                               (addr   == rhs.addr);
                }
        };
        std::vector<GlobalWriteInfo> globalWrites;

        MSXDevice* IO_In [256];
        MSXDevice* IO_Out[256];
        MSXDevice* slotLayout[4][4][4];
        MSXDevice* visibleDevices[4];
        byte subSlotRegister[4];
        byte primarySlotState[4];
        byte secondarySlotState[4];
        unsigned expanded[4];

        bool fastForward; // no need to serialize

        //  All CPUs (Z80 and R800) of all MSX machines share this state.
        static BreakPoints breakPoints;
        WatchPoints watchPoints; // TODO must also be static
        static Conditions conditions;
        static bool breaked;
        static bool continued;
        static bool step;
};

} // namespace openmsx

#endif