Add support for breakpoint synchronization across emulator instances.

gulrak · gulrak · commit b66381b1fba0 · 2026-01-06T10:06:01.000+01:00
diff --git a/external/rlguipp/CMakeLists.txt b/external/rlguipp/CMakeLists.txt
@@ -1,7 +1,7 @@
 cmake_minimum_required(VERSION 3.16)
 project(RlGuiPp)
 
-add_library(rlguipp STATIC rlguipp.cpp rlguipp.hpp raygui4.h rlunicode.h dm_property_list.h syshelper.cpp syshelper.hpp)
+add_library(rlguipp STATIC rlguipp.cpp rlguipp.hpp raygui4.h rlunicode.h dm_property_list.h syshelper.cpp syshelper.hpp icons.h)
 target_include_directories(rlguipp PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/..)
 target_link_libraries(rlguipp PUBLIC raylib_static ghc_filesystem fmt::fmt)
 
diff --git a/external/rlguipp/icons.h b/external/rlguipp/icons.h
@@ -279,7 +279,7 @@ typedef enum {
     ICON_BURGER_MENU              = 248,
     ICON_HELP2                    = 249,
     ICON_FOLDER_DOWNLOADS         = 250,
-    ICON_251                      = 251,
+    ICON_ARROW_RIGHT_FILL_SMALL   = 251,
     ICON_252                      = 252,
     ICON_253                      = 253,
     ICON_254                      = 254,
@@ -542,7 +542,7 @@ unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS] = {
     0x00000000, 0x00000000, 0x1ff81ff8, 0x1ff80000, 0x00001ff8, 0x1ff81ff8, 0x00000000, 0x00000000,      // ICON_BURGER_MENU
     0x00000000, 0x07e003c0, 0x0c300c30, 0x06000c00, 0x01800300, 0x00000180, 0x01800180, 0x00000000,      // ICON_HELP2
     0x00000000, 0x0042007e, 0x40027fc2, 0x42a24082, 0x408241c2, 0x47f24412, 0x7ffe4002, 0x00000000,      // ICON_FOLDER_DOWNLOADS
-    0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,      // ICON_251
+    0x00000000, 0x00000000, 0x00400000, 0x01c000c0, 0x01c003c0, 0x004000c0, 0x00000000, 0x00000000,      // ICON_ARROW_RIGHT_FILL_SMALL
     0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,      // ICON_252
     0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,      // ICON_253
     0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,      // ICON_254
diff --git a/src/cadmium.cpp b/src/cadmium.cpp
@@ -1500,13 +1500,17 @@ void main()
                     _partialFrameTime -= 1000;
                     for(int i = 0; i < getFrameBoost(); ++i) {
                         _chipEmu->executeFrame();
+                        bool breakpoint = false;
                         for(auto& unit : *_chipEmu) {
                             if(unit.isBreakpointTriggered()) {
                                 _mainView = eDEBUGGER;
                                 _debugger.setBreakpointTriggered(true);
+                                breakpoint = true;
                                 break;
                             }
                         }
+                        if (!breakpoint)
+                            _debugger.setBreakpointTriggered(false);
                     }
                     _fps.add(GetTime()*1000);
                 }
diff --git a/src/debugger.cpp b/src/debugger.cpp
@@ -376,33 +376,40 @@ void Debugger::showBreakpoints(Font& font, const int lineSpacing)
     BeginTableView(area.height - (10 * 14.0f + 6), 3, &scroll);
     SetRowHeight(11);
     int count = -1;
+    bool foundTriggeredBP = false;
     for (const auto& [address, bpinfo] : _breakpointCache) {
         auto execUnit = _core->executionUnit(bpinfo->unit);
         auto isChip8 = dynamic_cast<emu::IChip8Emulator*>(execUnit) != nullptr;
         ++count;
-        if (bpinfo->isEnabled && _isBreakpointTriggered && execUnit->getPC() == address)
-            _selectedBreakpoint = count;
+        //if (bpinfo->isEnabled && _triggeredBreakpointAddress == address && execUnit->getPC() == address)
+        //    _selectedBreakpoint = count;
         TableNextRow(11.0f, count == _selectedBreakpoint ? StyleManager::getStyleColor(gui::Style::BORDER_COLOR_NORMAL): Color{0,0,0,0});
-        TableNextColumn(16, [&](Rectangle rect){
+        TableNextColumn(24, [&](Rectangle rect){
+            GuiDrawIcon(address == _triggeredBreakpointAddress ? ICON_ARROW_RIGHT_FILL_SMALL : ICON_NONE, rect.x - 2, rect.y - 3, 1, YELLOW);
+            if (address == _triggeredBreakpointAddress && execUnit->getPC() == address)
+                foundTriggeredBP = true;
             if (!GuiIsLocked() && IsMouseButtonPressed(0) && CheckCollisionPointRec(GetMousePosition(), rect)) {
                 bpinfo->isEnabled = !bpinfo->isEnabled;
-                _selectedBreakpoint = count;
+                selectBreakpoint(count);
             }
-            GuiDrawIcon(bpinfo->isEnabled ? ICON_BREAKPOINT : ICON_BREAKPOINT_OFF, rect.x, rect.y - 3, 1, RED);
+            GuiDrawIcon(bpinfo->isEnabled ? ICON_BREAKPOINT : ICON_BREAKPOINT_OFF, rect.x + 6, rect.y - 3, 1, RED);
         });
         TableNextColumn(32, [&](Rectangle rect){
             if (!GuiIsLocked() && IsMouseButtonPressed(0) && CheckCollisionPointRec(GetMousePosition(), rect)) {
-                _selectedBreakpoint = count;
+                selectBreakpoint(count);
             }
             DrawTextClipped(font, fmt::format("{:04x}", address).c_str(), {rect.x + 2, rect.y + 2}, WHITE);
         });
         TableNextColumn(area.width - 50, [&](Rectangle rect){
             if (!GuiIsLocked() && IsMouseButtonPressed(0) && CheckCollisionPointRec(GetMousePosition(), rect)) {
-                _selectedBreakpoint = count;
+                selectBreakpoint(count);
             }
             DrawTextClipped(font, fmt::format("{} breakpoint", isChip8 ? "CHIP-8" : execUnit->name()).c_str(), {rect.x + 2, rect.y + 2}, WHITE);
         });
     }
+    if (!foundTriggeredBP) {
+        setBreakpointTriggered(false);
+    }
     EndTableView();
     SetRowHeight(14);
     if (_selectedBreakpoint >= 0 && _selectedBreakpoint < _breakpointCache.size()) {
@@ -460,6 +467,17 @@ void Debugger::showBreakpoints(Font& font, const int lineSpacing)
     Space(GetContentAvailable().height);
 }
 
+void Debugger::selectBreakpoint(int idx)
+{
+    if (idx < 0 || idx >= _breakpointCache.size()) {
+        _selectedBreakpoint = -1;
+        _bpHitCount = "";
+        return;
+    }
+    _selectedBreakpoint = idx;
+    _bpHitCount = fmt::format("{}", _breakpointCache[idx].second->numHits);
+}
+
 void Debugger::showGenericRegs(emu::GenericCpu& cpu, const RegPack& regs, const RegPack& oldRegs, Font& font, const int lineSpacing, const Vector2& pos) const
 {
     using namespace gui;
@@ -512,7 +530,7 @@ void Debugger::refreshBreakpoints()
             return a.first < b.first;
         }
     );
-    _selectedBreakpoint = _breakpointCache.empty() ? -1 : 0;
+    selectBreakpoint(_breakpointCache.empty() ? -1 : 0);
 }
 
 const std::vector<std::pair<uint32_t,std::string>>& Debugger::disassembleNLinesBackwardsGeneric(emu::GenericCpu& cpu, uint32_t addr, int n)
@@ -544,6 +562,7 @@ void Debugger::toggleBreakpoint(emu::GenericCpu& cpu, uint32_t address)
     else {
         cpu.setBreakpoint(address, {.label = fmt::format("BP@{:x}", address), .type = emu::GenericCpu::BreakpointInfo::eTRANSIENT, .isEnabled = true, .unit = static_cast<uint8_t>(_activeInstructionsTab)});
     }
+    selectBreakpoint(-1);
     refreshBreakpoints();
 }
 
@@ -568,10 +587,31 @@ void Debugger::updateOctoBreakpoints(const emu::OctoCompiler& compiler)
             }
         }
     }
+    selectBreakpoint(-1);
     refreshBreakpoints();
 }
 
 bool Debugger::supportsStepOver() const
 {
     return _core->focussedExecutionUnit()->cpuID() != 1802;
 }
+
+void Debugger::setBreakpointTriggered(bool triggered)
+{
+    _isBreakpointTriggered = triggered;
+    if (triggered) {
+        int count = -1;
+        for (const auto& [address, bpinfo] : _breakpointCache) {
+            auto execUnit = _core->executionUnit(bpinfo->unit);
+            auto isChip8 = dynamic_cast<emu::IChip8Emulator*>(execUnit) != nullptr;
+            ++count;
+            if (bpinfo->isEnabled && execUnit->getPC() == address) {
+                _triggeredBreakpointAddress = address;
+                _selectedBreakpoint = count;
+            }
+        }
+    }
+    else {
+        _triggeredBreakpointAddress = ~0;
+    }
+}
diff --git a/src/debugger.hpp b/src/debugger.hpp
@@ -48,12 +48,13 @@ class Debugger : public Highlighter
     void updateOctoBreakpoints(const emu::OctoCompiler& compiler);
     bool supportsStepOver() const;
     bool isControllingChip8() const { return dynamic_cast<emu::IChip8Emulator*>(_core->focussedExecutionUnit()) != nullptr; }
-    void setBreakpointTriggered(bool triggered) { _isBreakpointTriggered = triggered; }
+    void setBreakpointTriggered(bool triggered);
     bool isBreakpointTriggered() const { return _isBreakpointTriggered; }
 private:
     emu::IChip8Emulator* chip8Core();
     void showInstructions(emu::GenericCpu& cpu, Font& font, const int lineSpacing);
     void showBreakpoints(Font& font, const int lineSpacing);
+    void selectBreakpoint(int idx);
     void showGenericRegs(emu::GenericCpu& cpu, const RegPack& regs, const RegPack& oldRegs, Font& font, const int lineSpacing, const Vector2& pos) const;
     void refreshBreakpoints();
     void toggleBreakpoint(emu::GenericCpu& cpu, uint32_t address);
@@ -72,6 +73,7 @@ class Debugger : public Highlighter
     std::vector<uint8_t> _memBackup;
     std::vector<std::pair<uint32_t, emu::GenericCpu::BreakpointInfo*>> _breakpointCache;
     int _selectedBreakpoint{-1};
+    uint32_t _triggeredBreakpointAddress{std::numeric_limits<uint32_t>::max()};
     bool _isBreakpointTriggered{false};
     std::string _bpCondition;
     std::string _bpLogFormat;
diff --git a/src/emuhostex.cpp b/src/emuhostex.cpp
@@ -108,7 +108,7 @@ void EmuHostEx::setPalette(const Palette& palette)
 
 std::unique_ptr<IEmulationCore> EmuHostEx::create(Properties& properties, IEmulationCore* iother)
 {
-    auto [variantName, emuCore] = CoreRegistry::create(*this, properties);
+    auto [variantName, emuCore] = CoreRegistry::create(*this, properties, iother);
     if (emuCore) {
         emuCore->reset();
         _variantName = variantName;
@@ -202,6 +202,13 @@ std::unique_ptr<IEmulationCore> EmuHostEx::create(Properties& properties, IEmula
 #endif
 }
 
+void EmuHostEx::resetAllBreakpoints()
+{
+    if(!_chipEmu) return;
+    for (auto& unit : *_chipEmu) {
+        unit.removeAllBreakpoints();
+    }
+}
 
 void EmuHostEx::updateEmulatorOptions(const Properties& properties)
 {
@@ -267,6 +274,7 @@ bool EmuHostEx::loadRom(std::string_view filename, LoadOptions loadOpt)
         _colorPalette = _defaultPalette;
         auto fileData = loadFile(filename, Librarian::MAX_ROM_SIZE);
         if (fileData) {
+            resetAllBreakpoints();
             return loadBinary(filename, *fileData, loadOpt);
         }
     }
diff --git a/src/emuhostex.hpp b/src/emuhostex.hpp
@@ -100,6 +100,7 @@ class EmuHostEx : public EmulatorHost
 
 protected:
     std::unique_ptr<IEmulationCore> create(Properties& properties, IEmulationCore* iother = nullptr);
+    void resetAllBreakpoints();
     virtual void whenRomLoaded(const std::string& filename, bool autoRun, emu::OctoCompiler* compiler, const std::string& source) {}
     virtual void whenEmuChanged(emu::IEmulationCore& emu) {}
     static int saturatedCast(double value) {
diff --git a/src/emulation/chip8generic.cpp b/src/emulation/chip8generic.cpp
@@ -361,13 +361,18 @@ static uint32_t rgb332To888(uint8_t c)
 }
 
 
-Chip8GenericEmulator::Chip8GenericEmulator(EmulatorHost& host, Properties& props, IChip8Emulator* other)
+Chip8GenericEmulator::Chip8GenericEmulator(EmulatorHost& host, Properties& props, IEmulationCore* other)
 : Chip8GenericBase(Chip8GenericOptions::fromProperties(props).variant(), {})
 , _host(host)
 , _options(Chip8GenericOptions::fromProperties(props))
 , _opcodeHandler(0x10000, &Chip8GenericEmulator::opInvalid)
 {
     (void)registeredHleC8;
+    if (other) {
+        if (auto otherC8 = other->chip8Core()) {
+            swapBreakpoints(*otherC8);
+        }
+    }
     ADDRESS_MASK = _options.ramSize - 1; //_options.behaviorBase == Chip8GenericOptions::eMEGACHIP ? 0xFFFFFF : _options.ramSize>4096 ? 0xFFFF : 0xFFF;
     SCREEN_WIDTH = _options.behaviorBase == Chip8GenericOptions::eMEGACHIP ? 256 : (_options.optAllowHires ? 128 : 64);
     SCREEN_HEIGHT = _options.behaviorBase == Chip8GenericOptions::eMEGACHIP ? 192 : (_options.optAllowHires ? 64 : (_options.optPalVideo ? 48 : 32));
diff --git a/src/emulation/chip8generic.hpp b/src/emulation/chip8generic.hpp
@@ -107,7 +107,7 @@ class Chip8GenericEmulator : public Chip8GenericBase
     int SCREEN_WIDTH;
     int SCREEN_HEIGHT;
     
-    Chip8GenericEmulator(EmulatorHost& host, Properties& props, IChip8Emulator* other = nullptr);
+    Chip8GenericEmulator(EmulatorHost& host, Properties& props, IEmulationCore* other = nullptr);
     ~Chip8GenericEmulator() override;
 
     std::string name() const override
diff --git a/src/emulation/chip8strict.hpp b/src/emulation/chip8strict.hpp
@@ -63,6 +63,11 @@ class Chip8StrictEmulator : public Chip8GenericBase
         , _host(host)
         , _options(Chip8StrictOptions::fromProperties(properties))
     {
+        if (other) {
+            if (auto otherC8 = other->chip8Core()) {
+                swapBreakpoints(*otherC8);
+            }
+        }
         _memory.resize(_options.ramSize, 0);
         _rV = _memory.data() + _options.ramSize - 0x110;
         _systemTime.setFrequency(CPU_CLOCK_FREQUENCY>>3);
diff --git a/src/emulation/coreregistry.hpp b/src/emulation/coreregistry.hpp
@@ -79,8 +79,8 @@ class CoreRegistry {
         void cacheVariantMappings() const;
         bool hasVariant(const std::string& variant) const;
         Properties variantProperties(const std::string& variant) const;
-        virtual std::pair<std::string, EmulatorInstance> createCore(const std::string& variant, EmulatorHost& host, Properties& props, PropertySelector propSel) const = 0;
-        virtual std::pair<std::string, EmulatorInstance> createCore(EmulatorHost& host, Properties& props) const = 0;
+        virtual std::pair<std::string, EmulatorInstance> createCore(const std::string& variant, EmulatorHost& host, Properties& props, PropertySelector propSel, IEmulationCore* other) const = 0;
+        virtual std::pair<std::string, EmulatorInstance> createCore(EmulatorHost& host, Properties& props, IEmulationCore* other) const = 0;
         std::string description;
         std::string variantsCombo{};
         int score{0};
@@ -118,7 +118,7 @@ class CoreRegistry {
         {
             return index < numberOfVariants() ? presets[index].supportedChip8Variants : presets[0].supportedChip8Variants;
         }
-        std::pair<std::string, EmulatorInstance> createCore(const std::string& variant, EmulatorHost& host, Properties& props, PropertySelector propSel) const override
+        std::pair<std::string, EmulatorInstance> createCore(const std::string& variant, EmulatorHost& host, Properties& props, PropertySelector propSel, IEmulationCore* other) const override
         {
             Properties defaultProps;
             auto newVariant = variant;
@@ -132,9 +132,9 @@ class CoreRegistry {
                 props = defaultProps ? defaultProps : presets[0].options.asProperties();
             }
             auto options = OptionsType::fromProperties(props);
-            return {newVariant, std::make_unique<CoreType>(host, props)};
+            return {newVariant, std::make_unique<CoreType>(host, props, other)};
         }
-        std::pair<std::string, EmulatorInstance> createCore(EmulatorHost& host, Properties& props) const override
+        std::pair<std::string, EmulatorInstance> createCore(EmulatorHost& host, Properties& props, IEmulationCore* other) const override
         {
             std::string variant;
             auto idx = variantIndex(props);
@@ -147,7 +147,7 @@ class CoreRegistry {
                 variant += "*";
             }
             auto options = OptionsType::fromProperties(props);
-            return {variant, std::make_unique<CoreType>(host, props)};
+            return {variant, std::make_unique<CoreType>(host, props, other)};
         }
     private:
         ghc::span<const PresetType> presets{nullptr};
@@ -182,22 +182,22 @@ class CoreRegistry {
         return false;
     }
 
-    static std::pair<std::string, EmulatorInstance> create(const std::string& name, const std::string& variant, EmulatorHost& host, Properties& properties, PropertySelector propSel)
+    static std::pair<std::string, EmulatorInstance> create(const std::string& name, const std::string& variant, EmulatorHost& host, Properties& properties, PropertySelector propSel, IEmulationCore* other)
     {
         if (auto iter = factoryMap().find(name); iter != factoryMap().end()) {
-            return iter->second->createCore(variant, host, properties, propSel);
+            return iter->second->createCore(variant, host, properties, propSel, other);
         }
         for(const auto& [coreName, info] : factoryMap()) {
             if(fuzzyCompare(info->prefix(), name) || fuzzyCompare(coreName, name))
-                return info->createCore(variant, host, properties, propSel);
+                return info->createCore(variant, host, properties, propSel, other);
         }
         return {};
     }
 
-    static std::pair<std::string, EmulatorInstance> create(EmulatorHost& host, Properties& properties)
+    static std::pair<std::string, EmulatorInstance> create(EmulatorHost& host, Properties& properties, IEmulationCore* other)
     {
         if (auto iter = factoryMap().find(properties.propertyClass()); iter != factoryMap().end()) {
-            return iter->second->createCore(host, properties);
+            return iter->second->createCore(host, properties, other);
         }
         return {};
     }
diff --git a/src/emulation/cosmacvip.cpp b/src/emulation/cosmacvip.cpp
@@ -653,6 +653,14 @@ CosmacVIP::CosmacVIP(EmulatorHost& host, Properties& properties, IEmulationCore*
     , _impl(new Private(host, *this, properties))
 {
     //options.optTraceLog = true;
+    if (other) {
+        if (auto otherVIP = dynamic_cast<CosmacVIP*>(other)) {
+            _impl->_cpu.swapBreakpoints(otherVIP->_impl->_cpu);
+        }
+        if (auto otherC8 = other->chip8Core()) {
+            swapBreakpoints(*otherC8);
+        }
+    }
     _execChip8 = _impl->_options.interpreter != VC8I_NONE;
     if(_impl->_options.interpreter == VC8I_NONE)
         _isHybridChipMode = false;
diff --git a/src/emulation/dream6800.cpp b/src/emulation/dream6800.cpp
@@ -285,10 +285,18 @@ static const uint8_t dream6800ChipOslo[] = {
     0x39, 0x7a, 0x00, 0x20, 0x7a, 0x00, 0x21, 0x7d, 0x80, 0x12, 0x3b, 0xde, 0x00, 0x6e, 0x00, 0x00, 0xc3, 0xf3, 0x00, 0x80, 0x00, 0x83, 0xc3, 0x60
 };
 
-Dream6800::Dream6800(EmulatorHost& host, Properties& props, IChip8Emulator* other)
+Dream6800::Dream6800(EmulatorHost& host, Properties& props, IEmulationCore* other)
     : Chip8RealCoreBase(host)
     , _impl(new Private(host, *this, props))
 {
+    if (other) {
+        if (auto otherVIP = dynamic_cast<Dream6800*>(other)) {
+            _impl->_cpu.swapBreakpoints(otherVIP->_impl->_cpu);
+        }
+        if (auto otherC8 = other->chip8Core()) {
+            swapBreakpoints(*otherC8);
+        }
+    }
     if(_impl->_options.romName == "CHIPOSLO") {
         std::memcpy(_impl->_rom.data(), dream6800ChipOslo, sizeof(dream6800ChipOslo));
         _impl->_properties[PROP_ROM_NAME].setAdditionalInfo(fmt::format("(sha1: {})", calculateSha1(dream6800ChipOslo).to_hex().substr(0,8)));
diff --git a/src/emulation/dream6800.hpp b/src/emulation/dream6800.hpp
@@ -39,7 +39,7 @@ class Dream6800 : public Chip8RealCoreBase, public M6800Bus<>
     //constexpr static uint32_t MAX_MEMORY_SIZE = 4096;
     //constexpr static uint32_t MAX_ADDRESS_MASK = MAX_MEMORY_SIZE-1;
 
-    Dream6800(EmulatorHost& host, Properties& properties, IChip8Emulator* other = nullptr);
+    Dream6800(EmulatorHost& host, Properties& properties, IEmulationCore* other = nullptr);
     ~Dream6800() override;
 
     bool updateProperties(Properties& props, Property& changed) override;
diff --git a/src/emulation/eti660.cpp b/src/emulation/eti660.cpp
@@ -257,6 +257,14 @@ Eti660::Eti660(EmulatorHost& host, Properties& properties, IEmulationCore* other
     , _impl(new Private(host, *this, properties))
 {
     //options.optTraceLog = true;
+    if (other) {
+        if (auto otherVIP = dynamic_cast<Eti660*>(other)) {
+            _impl->_cpu.swapBreakpoints(otherVIP->_impl->_cpu);
+        }
+        if (auto otherC8 = other->chip8Core()) {
+            swapBreakpoints(*otherC8);
+        }
+    }
     _execChip8 = false; //_impl->_options.interpreter != VC8I_NONE;
     //if(_impl->_options.interpreter == VC8I_NONE)
         _isHybridChipMode = false;
diff --git a/src/emulation/hardware/genericcpu.hpp b/src/emulation/hardware/genericcpu.hpp

Original file line number	Diff line number	Diff line change
`@@ -1500,13 +1500,17 @@ void main()`
`1500`	`1500`	`_partialFrameTime -= 1000;`
`1501`	`1501`	`for(int i = 0; i < getFrameBoost(); ++i) {`
`1502`	`1502`	`_chipEmu->executeFrame();`
	`1503`	`+ bool breakpoint = false;`
`1503`	`1504`	`for(auto& unit : *_chipEmu) {`
`1504`	`1505`	`if(unit.isBreakpointTriggered()) {`
`1505`	`1506`	`_mainView = eDEBUGGER;`
`1506`	`1507`	`_debugger.setBreakpointTriggered(true);`
	`1508`	`+ breakpoint = true;`
`1507`	`1509`	`break;`
`1508`	`1510`	`}`
`1509`	`1511`	`}`
	`1512`	`+ if (!breakpoint)`
	`1513`	`+ _debugger.setBreakpointTriggered(false);`
`1510`	`1514`	`}`
`1511`	`1515`	`_fps.add(GetTime()*1000);`
`1512`	`1516`	`}`
Original file line number	Diff line number	Diff line change
`@@ -108,7 +108,7 @@ void EmuHostEx::setPalette(const Palette& palette)`
`108`	`108`
`109`	`109`	`std::unique_ptr<IEmulationCore> EmuHostEx::create(Properties& properties, IEmulationCore* iother)`
`110`	`110`	`{`
`111`		`- auto [variantName, emuCore] = CoreRegistry::create(*this, properties);`
	`111`	`+ auto [variantName, emuCore] = CoreRegistry::create(*this, properties, iother);`
`112`	`112`	`if (emuCore) {`
`113`	`113`	`emuCore->reset();`
`114`	`114`	`_variantName = variantName;`
`@@ -202,6 +202,13 @@ std::unique_ptr<IEmulationCore> EmuHostEx::create(Properties& properties, IEmula`
`202`	`202`	`#endif`
`203`	`203`	`}`
`204`	`204`
	`205`	`+void EmuHostEx::resetAllBreakpoints()`
	`206`	`+{`
	`207`	`+ if(!_chipEmu) return;`
	`208`	`+ for (auto& unit : *_chipEmu) {`
	`209`	`+ unit.removeAllBreakpoints();`
	`210`	`+ }`
	`211`	`+}`
`205`	`212`
`206`	`213`	`void EmuHostEx::updateEmulatorOptions(const Properties& properties)`
`207`	`214`	`{`
`@@ -267,6 +274,7 @@ bool EmuHostEx::loadRom(std::string_view filename, LoadOptions loadOpt)`
`267`	`274`	`_colorPalette = _defaultPalette;`
`268`	`275`	`auto fileData = loadFile(filename, Librarian::MAX_ROM_SIZE);`
`269`	`276`	`if (fileData) {`
	`277`	`+ resetAllBreakpoints();`
`270`	`278`	`return loadBinary(filename, *fileData, loadOpt);`
`271`	`279`	`}`
`272`	`280`	`}`