MSXCPU.hh

Go to the documentation of this file.

#ifndef MSXCPU_HH
#define MSXCPU_HH
 
#include "InfoTopic.hh"
#include "SimpleDebuggable.hh"
#include "Observer.hh"
#include "BooleanSetting.hh"
#include "CacheLine.hh"
#include "EmuTime.hh"
#include "TclCallback.hh"
#include "serialize_meta.hh"
#include "openmsx.hh"
 
#include <array>
#include <memory>
#include <span>
 
namespace openmsx {
 
class MSXMotherBoard;
class MSXCPUInterface;
class CPUClock;
class CPURegs;
class Z80TYPE;
class R800TYPE;
template<typename T> class CPUCore;
class TclObject;
class Interpreter;
 
class MSXCPU final : private Observer<Setting>
{
public:
        enum class Type { Z80, R800 };
 
        explicit MSXCPU(MSXMotherBoard& motherboard);
        ~MSXCPU();
 
        void doReset(EmuTime::param time);
 
        void setActiveCPU(Type cpu);
 
        void setDRAMmode(bool dram);
 
        void updateVisiblePage(byte page, byte primarySlot, byte secondarySlot);
 
        void invalidateAllSlotsRWCache(word start, unsigned size);
 
        void invalidateRWCache(unsigned start, unsigned size, int ps, int ss,
                               std::span<const byte, 256> disallowRead,
                               std::span<const byte, 256> disallowWrite);
        void invalidateRCache (unsigned start, unsigned size, int ps, int ss,
                               std::span<const byte, 256> disallowRead,
                               std::span<const byte, 256> disallowWrite);
        void invalidateWCache (unsigned start, unsigned size, int ps, int ss,
                               std::span<const byte, 256> disallowRead,
                               std::span<const byte, 256> disallowWrite);
 
        void fillRWCache(unsigned start, unsigned size, const byte* rData, byte* wData, int ps, int ss,
                         std::span<const byte, 256> disallowRead,
                         std::span<const byte, 256> disallowWrite);
        void fillRCache (unsigned start, unsigned size, const byte* rData, int ps, int ss,
                         std::span<const byte, 256> disallowRead,
                         std::span<const byte, 256> disallowWrite);
        void fillWCache (unsigned start, unsigned size, byte* wData, int ps, int ss,
                         std::span<const byte, 256> disallowRead,
                         std::span<const byte, 256> disallowWrite);
 
        void raiseIRQ();
 
        void lowerIRQ();
 
        void raiseNMI();
 
        void lowerNMI();
 
        [[nodiscard]] bool isM1Cycle(unsigned address) const;
 
        void exitCPULoopSync();
        void exitCPULoopAsync();
 
        [[nodiscard]] bool isR800Active() const { return !z80Active; }
 
        void setZ80Freq(unsigned freq);
 
        void setInterface(MSXCPUInterface* interface);
 
        void setPaused(bool paused);
 
        void setNextSyncPoint(EmuTime::param time);
 
        void wait(EmuTime::param time);
        EmuTime waitCyclesZ80(EmuTime::param time, unsigned cycles);
        EmuTime waitCyclesR800(EmuTime::param time, unsigned cycles);
 
        [[nodiscard]] CPURegs& getRegisters();
 
        [[nodiscard]] auto* getZ80() { return z80.get(); }
        [[nodiscard]] auto* getR800() { return r800.get(); }
 
        template<typename Archive>
        void serialize(Archive& ar, unsigned version);
 
private:
        void invalidateMemCacheSlot();
 
        // only for MSXMotherBoard
        void execute(bool fastForward);
        friend class MSXMotherBoard;
 
        EmuTime::param getCurrentTime() const;
 
        // Observer<Setting>
        void update(const Setting& setting) noexcept override;
 
        template<bool READ, bool WRITE, bool SUB_START>
        void setRWCache(unsigned start, unsigned size, const byte* rData, byte* wData, int ps, int ss,
                        std::span<const byte, 256> disallowRead, std::span<const byte, 256> disallowWrite);
 
private:
        MSXMotherBoard& motherboard;
        BooleanSetting traceSetting;
        TclCallback diHaltCallback;
        const std::unique_ptr<CPUCore<Z80TYPE>> z80;
        const std::unique_ptr<CPUCore<R800TYPE>> r800; // can be nullptr
 
        std::array<std::array<const byte*, CacheLine::NUM>, 16> slotReadLines;
        std::array<std::array<      byte*, CacheLine::NUM>, 16> slotWriteLines;
        std::array<byte, 4> slots; // active slot for page (= 4 * primSlot + secSlot)
 
        struct TimeInfoTopic final : InfoTopic {
                explicit TimeInfoTopic(InfoCommand& machineInfoCommand);
                void execute(std::span<const TclObject> tokens,
                             TclObject& result) const override;
                [[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;
        } timeInfo;
 
        class CPUFreqInfoTopic final : public InfoTopic {
        public:
                CPUFreqInfoTopic(InfoCommand& machineInfoCommand,
                                 const std::string& name, CPUClock& clock);
                void execute(std::span<const TclObject> tokens,
                             TclObject& result) const override;
                [[nodiscard]] std::string help(std::span<const TclObject> tokens) const override;
        private:
                CPUClock& clock;
        };
        CPUFreqInfoTopic                        z80FreqInfo;  // always present
        const std::unique_ptr<CPUFreqInfoTopic> r800FreqInfo; // can be nullptr
 
        struct Debuggable final : SimpleDebuggable {
                explicit Debuggable(MSXMotherBoard& motherboard);
                [[nodiscard]] byte read(unsigned address) override;
                void write(unsigned address, byte value) override;
        } debuggable;
 
        EmuTime reference{EmuTime::zero()};
        bool z80Active{true};
        bool newZ80Active{true};
 
        MSXCPUInterface* interface{nullptr}; // only used for debug
};
SERIALIZE_CLASS_VERSION(MSXCPU, 2);
 
} // namespace openmsx
 
#endif