ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

simplify floooh z80 usage

This commit is contained in:
CasualPokePlayer 2024-10-07 01:09:17 -07:00
parent 682dd761c3
commit 187674338b
7 changed files with 321 additions and 883 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Assets/dll/FlooohZ80.dll
View File

Binary file not shown.

33
ExternalProjects/FlooohZ80/FlooohZ80.c Normal file
View File

@ -0,0 +1,33 @@
#define CHIPS_IMPL
#include "z80.h"
#ifdef _WIN32
#define FZ80_EXPORT __declspec(dllexport)
#else
#define FZ80_EXPORT __attribute__((visibility("default")))
#endif
FZ80_EXPORT uint64_t LibFz80_Initialize(z80_t* z80)
{
return z80_init(z80);
}
FZ80_EXPORT uint64_t LibFz80_Reset(z80_t* z80)
{
return z80_reset(z80);
}
FZ80_EXPORT uint64_t LibFz80_Tick(z80_t* z80, uint64_t pins)
{
return z80_tick(z80, pins);
}
FZ80_EXPORT uint64_t LibFz80_Prefetch(z80_t* z80, uint16_t new_pc)
{
return z80_prefetch(z80, new_pc);
}
FZ80_EXPORT bool LibFz80_InstructionDone(z80_t* z80)
{
return z80_opdone(z80);
}

179
ExternalProjects/FlooohZ80/FlooohZ80.cpp
View File

@ -1,179 +0,0 @@
#define CHIPS_IMPL
#include "FlooohZ80.h"
#include <stdlib.h> // Include for malloc and free
LibFz80::LibFz80() {
z80Instance = new z80_t();
z80_init(z80Instance);
}
LibFz80::~LibFz80() {
delete z80Instance;
}
uint64_t LibFz80::Initialize() {
return z80_init(z80Instance);
}
uint64_t LibFz80::Reset() {
return z80_reset(z80Instance);
}
uint64_t LibFz80::Tick(uint64_t pins) {
return z80_tick(z80Instance, pins);
}
uint64_t LibFz80::Prefetch(uint16_t new_pc) {
return z80_prefetch(z80Instance, new_pc);
}
bool LibFz80::InstructionDone() {
return z80_opdone(z80Instance);
}
// Getter methods for z80_t members
uint16_t LibFz80::GET_step() { return z80Instance->step; }
uint16_t LibFz80::GET_addr() { return z80Instance->addr; }
uint8_t LibFz80::GET_dlatch() { return z80Instance->dlatch; }
uint8_t LibFz80::GET_opcode() { return z80Instance->opcode; }
uint8_t LibFz80::GET_hlx_idx() { return z80Instance->hlx_idx; }
bool LibFz80::GET_prefix_active() { return z80Instance->prefix_active; }
uint64_t LibFz80::GET_pins() { return z80Instance->pins; }
uint64_t LibFz80::GET_int_bits() { return z80Instance->int_bits; }
uint16_t LibFz80::GET_pc() { return z80Instance->pc; }
uint16_t LibFz80::GET_af() { return z80Instance->af; }
uint16_t LibFz80::GET_bc() { return z80Instance->bc; }
uint16_t LibFz80::GET_de() { return z80Instance->de; }
uint16_t LibFz80::GET_hl() { return z80Instance->hl; }
uint16_t LibFz80::GET_ix() { return z80Instance->ix; }
uint16_t LibFz80::GET_iy() { return z80Instance->iy; }
uint16_t LibFz80::GET_wz() { return z80Instance->wz; }
uint16_t LibFz80::GET_sp() { return z80Instance->sp; }
uint16_t LibFz80::GET_ir() { return z80Instance->ir; }
uint16_t LibFz80::GET_af2() { return z80Instance->af2; }
uint16_t LibFz80::GET_bc2() { return z80Instance->bc2; }
uint16_t LibFz80::GET_de2() { return z80Instance->de2; }
uint16_t LibFz80::GET_hl2() { return z80Instance->hl2; }
uint8_t LibFz80::GET_im() { return z80Instance->im; }
bool LibFz80::GET_iff1() { return z80Instance->iff1; }
bool LibFz80::GET_iff2() { return z80Instance->iff2; }
// Setter methods for z80_t members
void LibFz80::SET_step(uint16_t value) { z80Instance->step = value; }
void LibFz80::SET_addr(uint16_t value) { z80Instance->addr = value; }
void LibFz80::SET_dlatch(uint8_t value) { z80Instance->dlatch = value; }
void LibFz80::SET_opcode(uint8_t value) { z80Instance->opcode = value; }
void LibFz80::SET_hlx_idx(uint8_t value) { z80Instance->hlx_idx = value; }
void LibFz80::SET_prefix_active(bool value) { z80Instance->prefix_active = value; }
void LibFz80::SET_pins(uint64_t value) { z80Instance->pins = value; }
void LibFz80::SET_int_bits(uint64_t value) { z80Instance->int_bits = value; }
void LibFz80::SET_pc(uint16_t value) { z80Instance->pc = value; }
void LibFz80::SET_af(uint16_t value) { z80Instance->af = value; }
void LibFz80::SET_bc(uint16_t value) { z80Instance->bc = value; }
void LibFz80::SET_de(uint16_t value) { z80Instance->de = value; }
void LibFz80::SET_hl(uint16_t value) { z80Instance->hl = value; }
void LibFz80::SET_ix(uint16_t value) { z80Instance->ix = value; }
void LibFz80::SET_iy(uint16_t value) { z80Instance->iy = value; }
void LibFz80::SET_wz(uint16_t value) { z80Instance->wz = value; }
void LibFz80::SET_sp(uint16_t value) { z80Instance->sp = value; }
void LibFz80::SET_ir(uint16_t value) { z80Instance->ir = value; }
void LibFz80::SET_af2(uint16_t value) { z80Instance->af2 = value; }
void LibFz80::SET_bc2(uint16_t value) { z80Instance->bc2 = value; }
void LibFz80::SET_de2(uint16_t value) { z80Instance->de2 = value; }
void LibFz80::SET_hl2(uint16_t value) { z80Instance->hl2 = value; }
void LibFz80::SET_im(uint8_t value) { z80Instance->im = value; }
void LibFz80::SET_iff1(bool value) { z80Instance->iff1 = value; }
void LibFz80::SET_iff2(bool value) { z80Instance->iff2 = value; }
// Expose the functions for C# interoperability
extern "C" {
#ifdef _WIN32
#define FZ80_EXPORT __declspec(dllexport)
#else
#define FZ80_EXPORT __attribute__((visibility("default")))
#endif
FZ80_EXPORT LibFz80* CreateLibFz80() {
return new LibFz80();
}
FZ80_EXPORT void DestroyLibFz80(LibFz80* instance) {
delete instance;
}
FZ80_EXPORT uint64_t LibFz80_Initialize(LibFz80* instance) {
return instance->Initialize();
}
FZ80_EXPORT uint64_t LibFz80_Reset(LibFz80* instance) {
return instance->Reset();
}
FZ80_EXPORT uint64_t LibFz80_Tick(LibFz80* instance, uint64_t pins) {
return instance->Tick(pins);
}
FZ80_EXPORT uint64_t LibFz80_Prefetch(LibFz80* instance, uint16_t new_pc) {
return instance->Prefetch(new_pc);
}
FZ80_EXPORT bool LibFz80_InstructionDone(LibFz80* instance) {
return instance->InstructionDone();
}
// Getter functions
FZ80_EXPORT uint16_t LibFz80_GET_step(LibFz80* instance) { return instance->GET_step(); }
FZ80_EXPORT uint16_t LibFz80_GET_addr(LibFz80* instance) { return instance->GET_addr(); }
FZ80_EXPORT uint8_t LibFz80_GET_dlatch(LibFz80* instance) { return instance->GET_dlatch(); }
FZ80_EXPORT uint8_t LibFz80_GET_opcode(LibFz80* instance) { return instance->GET_opcode(); }
FZ80_EXPORT uint8_t LibFz80_GET_hlx_idx(LibFz80* instance) { return instance->GET_hlx_idx(); }
FZ80_EXPORT bool LibFz80_GET_prefix_active(LibFz80* instance) { return instance->GET_prefix_active(); }
FZ80_EXPORT uint64_t LibFz80_GET_pins(LibFz80* instance) { return instance->GET_pins(); }
FZ80_EXPORT uint64_t LibFz80_GET_int_bits(LibFz80* instance) { return instance->GET_int_bits(); }
FZ80_EXPORT uint16_t LibFz80_GET_pc(LibFz80* instance) { return instance->GET_pc(); }
FZ80_EXPORT uint16_t LibFz80_GET_af(LibFz80* instance) { return instance->GET_af(); }
FZ80_EXPORT uint16_t LibFz80_GET_bc(LibFz80* instance) { return instance->GET_bc(); }
FZ80_EXPORT uint16_t LibFz80_GET_de(LibFz80* instance) { return instance->GET_de(); }
FZ80_EXPORT uint16_t LibFz80_GET_hl(LibFz80* instance) { return instance->GET_hl(); }
FZ80_EXPORT uint16_t LibFz80_GET_ix(LibFz80* instance) { return instance->GET_ix(); }
FZ80_EXPORT uint16_t LibFz80_GET_iy(LibFz80* instance) { return instance->GET_iy(); }
FZ80_EXPORT uint16_t LibFz80_GET_wz(LibFz80* instance) { return instance->GET_wz(); }
FZ80_EXPORT uint16_t LibFz80_GET_sp(LibFz80* instance) { return instance->GET_sp(); }
FZ80_EXPORT uint16_t LibFz80_GET_ir(LibFz80* instance) { return instance->GET_ir(); }
FZ80_EXPORT uint16_t LibFz80_GET_af2(LibFz80* instance) { return instance->GET_af2(); }
FZ80_EXPORT uint16_t LibFz80_GET_bc2(LibFz80* instance) { return instance->GET_bc2(); }
FZ80_EXPORT uint16_t LibFz80_GET_de2(LibFz80* instance) { return instance->GET_de2(); }
FZ80_EXPORT uint16_t LibFz80_GET_hl2(LibFz80* instance) { return instance->GET_hl2(); }
FZ80_EXPORT uint8_t LibFz80_GET_im(LibFz80* instance) { return instance->GET_im(); }
FZ80_EXPORT bool LibFz80_GET_iff1(LibFz80* instance) { return instance->GET_iff1(); }
FZ80_EXPORT bool LibFz80_GET_iff2(LibFz80* instance) { return instance->GET_iff2(); }
// Setter functions
FZ80_EXPORT void LibFz80_SET_step(LibFz80* instance, uint16_t value) { instance->SET_step(value); }
FZ80_EXPORT void LibFz80_SET_addr(LibFz80* instance, uint16_t value) { instance->SET_addr(value); }
FZ80_EXPORT void LibFz80_SET_dlatch(LibFz80* instance, uint8_t value) { instance->SET_dlatch(value); }
FZ80_EXPORT void LibFz80_SET_opcode(LibFz80* instance, uint8_t value) { instance->SET_opcode(value); }
FZ80_EXPORT void LibFz80_SET_hlx_idx(LibFz80* instance, uint8_t value) { instance->SET_hlx_idx(value); }
FZ80_EXPORT void LibFz80_SET_prefix_active(LibFz80* instance, bool value) { instance->SET_prefix_active(value); }
FZ80_EXPORT void LibFz80_SET_pins(LibFz80* instance, uint64_t value) { instance->SET_pins(value); }
FZ80_EXPORT void LibFz80_SET_int_bits(LibFz80* instance, uint64_t value) { instance->SET_int_bits(value); }
FZ80_EXPORT void LibFz80_SET_pc(LibFz80* instance, uint16_t value) { instance->SET_pc(value); }
FZ80_EXPORT void LibFz80_SET_af(LibFz80* instance, uint16_t value) { instance->SET_af(value); }
FZ80_EXPORT void LibFz80_SET_bc(LibFz80* instance, uint16_t value) { instance->SET_bc(value); }
FZ80_EXPORT void LibFz80_SET_de(LibFz80* instance, uint16_t value) { instance->SET_de(value); }
FZ80_EXPORT void LibFz80_SET_hl(LibFz80* instance, uint16_t value) { instance->SET_hl(value); }
FZ80_EXPORT void LibFz80_SET_ix(LibFz80* instance, uint16_t value) { instance->SET_ix(value); }
FZ80_EXPORT void LibFz80_SET_iy(LibFz80* instance, uint16_t value) { instance->SET_iy(value); }
FZ80_EXPORT void LibFz80_SET_wz(LibFz80* instance, uint16_t value) { instance->SET_wz(value); }
FZ80_EXPORT void LibFz80_SET_sp(LibFz80* instance, uint16_t value) { instance->SET_sp(value); }
FZ80_EXPORT void LibFz80_SET_ir(LibFz80* instance, uint16_t value) { instance->SET_ir(value); }
FZ80_EXPORT void LibFz80_SET_af2(LibFz80* instance, uint16_t value) { instance->SET_af2(value); }
FZ80_EXPORT void LibFz80_SET_bc2(LibFz80* instance, uint16_t value) { instance->SET_bc2(value); }
FZ80_EXPORT void LibFz80_SET_de2(LibFz80* instance, uint16_t value) { instance->SET_de2(value); }
FZ80_EXPORT void LibFz80_SET_hl2(LibFz80* instance, uint16_t value) { instance->SET_hl2(value); }
FZ80_EXPORT void LibFz80_SET_im(LibFz80* instance, uint8_t value) { instance->SET_im(value); }
FZ80_EXPORT void LibFz80_SET_iff1(LibFz80* instance, bool value) { instance->SET_iff1(value); }
FZ80_EXPORT void LibFz80_SET_iff2(LibFz80* instance, bool value) { instance->SET_iff2(value); }
}

77
ExternalProjects/FlooohZ80/FlooohZ80.h
View File

@ -1,77 +0,0 @@
#ifndef FLOOOHZ80_H
#define FLOOOHZ80_H
#include <stdint.h>
#include <stdbool.h>
#include "z80.h"
class LibFz80 {
public:
LibFz80();
~LibFz80();
uint64_t Initialize();
uint64_t Reset();
uint64_t Tick(uint64_t pins);
uint64_t Prefetch(uint16_t new_pc);
bool InstructionDone();
// getter methods for the z80_t struct members
uint16_t GET_step();
uint16_t GET_addr();
uint8_t GET_dlatch();
uint8_t GET_opcode();
uint8_t GET_hlx_idx();
bool GET_prefix_active();
uint64_t GET_pins();
uint64_t GET_int_bits();
uint16_t GET_pc();
uint16_t GET_af();
uint16_t GET_bc();
uint16_t GET_de();
uint16_t GET_hl();
uint16_t GET_ix();
uint16_t GET_iy();
uint16_t GET_wz();
uint16_t GET_sp();
uint16_t GET_ir();
uint16_t GET_af2();
uint16_t GET_bc2();
uint16_t GET_de2();
uint16_t GET_hl2();
uint8_t GET_im();
bool GET_iff1();
bool GET_iff2();
// setter methods for the z80_t struct members
void SET_step(uint16_t value);
void SET_addr(uint16_t value);
void SET_dlatch(uint8_t value);
void SET_opcode(uint8_t value);
void SET_hlx_idx(uint8_t value);
void SET_prefix_active(bool value);
void SET_pins(uint64_t value);
void SET_int_bits(uint64_t value);
void SET_pc(uint16_t value);
void SET_af(uint16_t value);
void SET_bc(uint16_t value);
void SET_de(uint16_t value);
void SET_hl(uint16_t value);
void SET_ix(uint16_t value);
void SET_iy(uint16_t value);
void SET_wz(uint16_t value);
void SET_sp(uint16_t value);
void SET_ir(uint16_t value);
void SET_af2(uint16_t value);
void SET_bc2(uint16_t value);
void SET_de2(uint16_t value);
void SET_hl2(uint16_t value);
void SET_im(uint8_t value);
void SET_iff1(bool value);
void SET_iff2(bool value);
private:
z80_t* z80Instance;
};
#endif // FLOOOHZ80_H

6
ExternalProjects/FlooohZ80/FlooohZ80.sln
View File

@ -8,19 +8,13 @@ EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|x64 = Debug|x64
Debug|x86 = Debug|x86
Release|x64 = Release|x64
Release|x86 = Release|x86
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{E1CCFFD1-D23B-4507-88EA-0184A6CE99BF}.Debug|x64.ActiveCfg = Debug|x64
{E1CCFFD1-D23B-4507-88EA-0184A6CE99BF}.Debug|x64.Build.0 = Debug|x64
{E1CCFFD1-D23B-4507-88EA-0184A6CE99BF}.Debug|x86.ActiveCfg = Debug|Win32
{E1CCFFD1-D23B-4507-88EA-0184A6CE99BF}.Debug|x86.Build.0 = Debug|Win32
{E1CCFFD1-D23B-4507-88EA-0184A6CE99BF}.Release|x64.ActiveCfg = Release|x64
{E1CCFFD1-D23B-4507-88EA-0184A6CE99BF}.Release|x64.Build.0 = Release|x64
{E1CCFFD1-D23B-4507-88EA-0184A6CE99BF}.Release|x86.ActiveCfg = Release|Win32
{E1CCFFD1-D23B-4507-88EA-0184A6CE99BF}.Release|x86.Build.0 = Release|Win32
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE

276
ExternalProjects/FlooohZ80/FlooohZ80.vcxproj
View File

@ -1,164 +1,116 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|Win32">
<Configuration>Debug</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>17.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{e1ccffd1-d23b-4507-88ea-0184a6ce99bf}</ProjectGuid>
<RootNamespace>FlooohZ80</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<OutDir>..\..\Assets\dll</OutDir>
<IntDir>$(Platform)\$(Configuration)\</IntDir>
<TargetName>FlooohZ80</TargetName>
<TargetExt>.dll</TargetExt>
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>..\..\Assets\dll</OutDir>
<IntDir>$(Platform)\$(Configuration)\</IntDir>
<TargetName>FlooohZ80</TargetName>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
</Link>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>NDEBUG;CHIPS_IMPL;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<CompileAs>CompileAsCpp</CompileAs>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
<ShowProgress>LinkVerbose</ShowProgress>
</Link>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="FlooohZ80.h" />
<ClInclude Include="z80.h">
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="FlooohZ80.cpp">
<PrecompiledHeaderFile Condition="'$(Configuration)|$(Platform)'=='Release|x64'">pch.h</PrecompiledHeaderFile>
<CompileAs Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Default</CompileAs>
<ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
</ClCompile>
</ItemGroup>
<ItemGroup>
<Text Include="LICENSE.txt" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Debug|x64">
<Configuration>Debug</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<VCProjectVersion>17.0</VCProjectVersion>
<Keyword>Win32Proj</Keyword>
<ProjectGuid>{e1ccffd1-d23b-4507-88ea-0184a6ce99bf}</ProjectGuid>
<RootNamespace>FlooohZ80</RootNamespace>
<WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>true</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="Shared">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<OutDir>$(Platform)\$(Configuration)\</OutDir>
<IntDir>$(Platform)\$(Configuration)\</IntDir>
<TargetName>FlooohZ80</TargetName>
<TargetExt>.dll</TargetExt>
<LinkIncremental>false</LinkIncremental>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<OutDir>$(Platform)\$(Configuration)\</OutDir>
<IntDir>$(Platform)\$(Configuration)\</IntDir>
<TargetName>FlooohZ80</TargetName>
<TargetExt>.dll</TargetExt>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>true</SDLCheck>
<PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
<ShowProgress>LinkVerbose</ShowProgress>
</Link>
<PostBuildEvent>
<Command>
copy /Y "$(TargetDir)$(TargetName)$(TargetExt)" "$(SolutionDir)..\..\Assets\dll\$(TargetName)$(TargetExt)"
copy /Y "$(TargetDir)$(TargetName)$(TargetExt)" "$(SolutionDir)..\..\output\dll\$(TargetName)$(TargetExt)"
</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<WarningLevel>Level3</WarningLevel>
<SDLCheck>false</SDLCheck>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>NDEBUG;CHIPS_IMPL;_WINDOWS;_USRDLL;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
</ClCompile>
<Link>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableUAC>false</EnableUAC>
<ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
</Link>
<PostBuildEvent>
<Command>
copy /Y "$(TargetDir)$(TargetName)$(TargetExt)" "$(SolutionDir)..\..\Assets\dll\$(TargetName)$(TargetExt)"
copy /Y "$(TargetDir)$(TargetName)$(TargetExt)" "$(SolutionDir)..\..\output\dll\$(TargetName)$(TargetExt)"
</Command>
</PostBuildEvent>
</ItemDefinitionGroup>
<ItemGroup>
<ClInclude Include="z80.h">
</ClInclude>
</ItemGroup>
<ItemGroup>
<ClCompile Include="FlooohZ80.c">
</ClCompile>
</ItemGroup>
<ItemGroup>
<Text Include="LICENSE.txt" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

633
src/BizHawk.Emulation.Cores/Computers/AmstradCPC/Hardware/LibFz80.cs
View File

@ -7,7 +7,7 @@ using BizHawk.Emulation.Common;
namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
{
public class LibFz80Wrapper : IDisposable
public class LibFz80Wrapper
{
public const int Z80_PIN_M1 = 24; // machine cycle 1
public const int Z80_PIN_MREQ = 25; // memory request
@ -27,9 +27,10 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
/// </summary>
public ulong Pins
{
get { return _pins; }
set { _pins = value; }
get => _pins;
set => _pins = value;
}
private ulong _pins;
// read only pins
@ -48,16 +49,23 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
get => GetPin(Z80_PIN_INT);
set => ChangePin(30, value);
}
public int RES
{
get => GetPin(Z80_PIN_RES);
set => Reset(); // the z80 implementation doesn't implement the RES pin properly
set
{
_ = value;
Reset(); // the z80 implementation doesn't implement the RES pin properly
}
}
public int NMI
{
get => GetPin(Z80_PIN_NMI);
set => ChangePin(Z80_PIN_NMI, value);
}
public int WAIT
{
get => GetPin(Z80_PIN_WAIT);
@ -73,11 +81,8 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public long TotalExecutedCycles;
private int GetPin(int pin)
{
return (_pins & (1UL << pin)) != 0 ? 1 : 0;
}
=> (_pins & (1UL << pin)) != 0 ? 1 : 0;
private void ChangePin(int pin, int value)
{
@ -91,195 +96,58 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
}
}
private IntPtr instance;
private Z80State Z80;
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern IntPtr CreateLibFz80();
[StructLayout(LayoutKind.Sequential)]
public struct Z80State
{
public ushort step;
public ushort addr;
public byte dlatch;
public byte opcode;
public byte hlx_idx;
public byte prefix_active;
public ulong pins;
public ulong int_bits;
public ushort pc;
public ushort af;
public ushort bc;
public ushort de;
public ushort hl;
public ushort ix;
public ushort iy;
public ushort wz;
public ushort sp;
public ushort ir;
public ushort af2, bc2, de2, hl2;
public byte im;
public byte iff1, iff2;
}
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern void DestroyLibFz80(IntPtr instance);
[DllImport("FlooohZ80", CallingConvention = CallingConvention.Cdecl)]
private static extern ulong LibFz80_Initialize(ref Z80State z80);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern ulong LibFz80_Initialize(IntPtr instance);
[DllImport("FlooohZ80", CallingConvention = CallingConvention.Cdecl)]
private static extern ulong LibFz80_Reset(ref Z80State z80);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern ulong LibFz80_Reset(IntPtr instance);
[DllImport("FlooohZ80", CallingConvention = CallingConvention.Cdecl)]
private static extern ulong LibFz80_Tick(ref Z80State z80, ulong pins);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern ulong LibFz80_Tick(IntPtr instance, ulong pins);
#if false
[DllImport("FlooohZ80", CallingConvention = CallingConvention.Cdecl)]
private static extern ulong LibFz80_Prefetch(ref Z80State z80, ushort new_pc);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern ulong LibFz80_Prefetch(IntPtr instance, ushort new_pc);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
private static extern bool LibFz80_InstructionDone(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_step(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_addr(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern byte LibFz80_GET_dlatch(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern byte LibFz80_GET_opcode(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern byte LibFz80_GET_hlx_idx(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LibFz80_GET_prefix_active(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ulong LibFz80_GET_pins(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ulong LibFz80_GET_int_bits(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_pc(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_af(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_bc(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_de(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_hl(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_ix(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_iy(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_wz(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_sp(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_ir(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_af2(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_bc2(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_de2(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern ushort LibFz80_GET_hl2(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern byte LibFz80_GET_im(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LibFz80_GET_iff1(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern bool LibFz80_GET_iff2(IntPtr instance);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_step(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_addr(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_dlatch(IntPtr instance, byte value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_opcode(IntPtr instance, byte value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_hlx_idx(IntPtr instance, byte value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_prefix_active(IntPtr instance, bool value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_pins(IntPtr instance, ulong value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_addr(IntPtr instance, ulong value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_int_bits(IntPtr instance, ulong value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_pc(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_af(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_bc(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_de(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_hl(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_ix(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_iy(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_wz(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_sp(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_ir(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_af2(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_bc2(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_de2(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_hl2(IntPtr instance, ushort value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_im(IntPtr instance, byte value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_iff1(IntPtr instance, bool value);
[DllImport("FlooohZ80.dll", CallingConvention = CallingConvention.Cdecl)]
public static extern void LibFz80_SET_iff2(IntPtr instance, bool value);
/// <summary>
/// Public Delegate
/// </summary>
public delegate void CallBack();
[DllImport("FlooohZ80", CallingConvention = CallingConvention.Cdecl)]
private static extern bool LibFz80_InstructionDone(ref Z80State z80);
#endif
/// <summary>
/// Fired when the CPU acknowledges an interrupt
/// </summary>
private CallBack IRQACK_Callbacks;
private Action IRQACK_Callbacks;
public void AttachIRQACKOnCallback(CallBack irqackCall) => IRQACK_Callbacks += irqackCall;
public void AttachIRQACKOnCallback(Action irqackCall)
=> IRQACK_Callbacks += irqackCall;
public Func<ushort, byte> ReadMemory;
public Action<ushort, byte> WriteMemory;
@ -295,14 +163,12 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
public LibFz80Wrapper()
{
instance = CreateLibFz80();
_pins = Initialize();
//Z80State = new Z80();
_pins = LibFz80_Initialize(ref Z80);
}
public void ExecuteOne()
{
ushort step = GetStep();
//ushort step = Z80.step;
if (MREQ == 1 && RD == 1)
{
@ -331,174 +197,54 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
TotalExecutedCycles++;
_pins = Tick(_pins);
_pins = LibFz80_Tick(ref Z80, _pins);
}
public ulong Reset()
{
return LibFz80_Reset(instance);
}
public void Dispose()
{
if (instance != IntPtr.Zero)
{
DestroyLibFz80(instance);
instance = IntPtr.Zero;
}
}
=> LibFz80_Reset(ref Z80);
#if false
public bool InstructionDone()
{
return LibFz80_InstructionDone(instance);
}
private ulong Initialize()
{
return LibFz80_Initialize(instance);
}
private ulong Tick(ulong pins)
{
return LibFz80_Tick(instance, pins);
}
=> LibFz80_InstructionDone(ref Z80);
private ulong Prefetch(ushort new_pc)
{
return LibFz80_Prefetch(instance, new_pc);
}
private ushort GetStep()
{
return LibFz80_GET_step(instance);
}
private void SetStep(ushort value)
{
LibFz80_SET_step(instance, value);
}
ushort step;
ushort addr;
byte dlatch;
byte opcode;
byte hlx_idx;
bool prefix_active;
ulong pins;
ulong int_bits;
ushort pc;
ushort af;
ushort bc;
ushort de;
ushort hl;
ushort ix;
ushort iy;
ushort wz;
ushort sp;
ushort ir;
ushort af2;
ushort bc2;
ushort de2;
ushort hl2;
byte im;
bool iff1;
bool iff2;
private void GetStateFromCpu()
{
step = LibFz80_GET_step(instance);
addr = LibFz80_GET_addr(instance);
dlatch = LibFz80_GET_dlatch(instance);
opcode = LibFz80_GET_opcode(instance);
hlx_idx = LibFz80_GET_hlx_idx(instance);
prefix_active = LibFz80_GET_prefix_active(instance);
pins = LibFz80_GET_pins(instance);
int_bits = LibFz80_GET_int_bits(instance);
pc = LibFz80_GET_pc(instance);
af = LibFz80_GET_af(instance);
bc = LibFz80_GET_bc(instance);
de = LibFz80_GET_de(instance);
hl = LibFz80_GET_hl(instance);
ix = LibFz80_GET_ix(instance);
iy = LibFz80_GET_iy(instance);
wz = LibFz80_GET_wz(instance);
sp = LibFz80_GET_sp(instance);
ir = LibFz80_GET_ir(instance);
af2 = LibFz80_GET_af2(instance);
bc2 = LibFz80_GET_bc2(instance);
de2 = LibFz80_GET_de2(instance);
hl2 = LibFz80_GET_hl2(instance);
im = LibFz80_GET_im(instance);
iff1 = LibFz80_GET_iff1(instance);
iff2 = LibFz80_GET_iff2(instance);
}
private void PutStateToCpu()
{
LibFz80_SET_step(instance, step);
LibFz80_SET_addr(instance, addr);
LibFz80_SET_dlatch(instance, dlatch);
LibFz80_SET_opcode(instance, opcode);
LibFz80_SET_hlx_idx(instance, hlx_idx);
LibFz80_SET_prefix_active(instance, prefix_active);
LibFz80_SET_pins(instance, pins);
LibFz80_SET_int_bits(instance, int_bits);
LibFz80_SET_pc(instance, pc);
LibFz80_SET_af(instance, af);
LibFz80_SET_bc(instance, bc);
LibFz80_SET_de(instance, de);
LibFz80_SET_hl(instance, hl);
LibFz80_SET_ix(instance, ix);
LibFz80_SET_iy(instance, iy);
LibFz80_SET_wz(instance, wz);
LibFz80_SET_sp(instance, sp);
LibFz80_SET_ir(instance, ir);
LibFz80_SET_af2(instance, af2);
LibFz80_SET_bc2(instance, bc2);
LibFz80_SET_de2(instance, de2);
LibFz80_SET_hl2(instance, hl2);
LibFz80_SET_im(instance, im);
LibFz80_SET_iff1(instance, iff1);
LibFz80_SET_iff2(instance, iff2);
}
=> LibFz80_Prefetch(ref Z80, new_pc);
#endif
public IDictionary<string, RegisterValue> GetCpuFlagsAndRegisters()
{
GetStateFromCpu();
return new Dictionary<string, RegisterValue>
{
["A"] = af >> 8,
["AF"] = af,
["B"] = bc >> 8,
["BC"] = bc,
["C"] = bc & 0xff,
["D"] = de >> 8,
["DE"] = de,
["E"] = de & 0xff,
["F"] = af * 0xff,
["H"] = hl >> 8,
["HL"] = hl,
["I"] = ir >> 8,
["IX"] = ix,
["IY"] = iy,
["L"] = hl & 0xff,
["PC"] = pc,
["R"] = ir & 0xff,
["Shadow AF"] = af2,
["Shadow BC"] = bc2,
["Shadow DE"] = de2,
["Shadow HL"] = hl2,
["SP"] = sp,
["Flag C"] = af.Bit(0),
["Flag N"] = af.Bit(1),
["Flag P/V"] = af.Bit(2),
["Flag 3rd"] = af.Bit(3),
["Flag H"] = af.Bit(4),
["Flag 5th"] = af.Bit(5),
["Flag Z"] = af.Bit(6),
["Flag S"] = af.Bit(7)
["A"] = Z80.af >> 8,
["F"] = Z80.af & 0xFF,
["AF"] = Z80.af,
["B"] = Z80.bc >> 8,
["C"] = Z80.bc & 0xFF,
["BC"] = Z80.bc,
["D"] = Z80.de >> 8,
["E"] = Z80.de & 0xFF,
["DE"] = Z80.de,
["H"] = Z80.hl >> 8,
["L"] = Z80.hl & 0xFF,
["HL"] = Z80.hl,
["I"] = Z80.ir >> 8,
["R"] = Z80.ir & 0xFF,
["IX"] = Z80.ix,
["IY"] = Z80.iy,
["PC"] = Z80.pc,
["Shadow AF"] = Z80.af2,
["Shadow BC"] = Z80.bc2,
["Shadow DE"] = Z80.de2,
["Shadow HL"] = Z80.hl2,
["SP"] = Z80.sp,
["Flag C"] = Z80.af.Bit(0),
["Flag N"] = Z80.af.Bit(1),
["Flag P/V"] = Z80.af.Bit(2),
["Flag 3rd"] = Z80.af.Bit(3),
["Flag H"] = Z80.af.Bit(4),
["Flag 5th"] = Z80.af.Bit(5),
["Flag Z"] = Z80.af.Bit(6),
["Flag S"] = Z80.af.Bit(7)
};
}
@ -509,102 +255,80 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
default:
throw new InvalidOperationException();
case "A":
af = LibFz80_GET_af(instance);
af |= (ushort)(value << 8);
LibFz80_SET_af(instance, af);
break;
case "AF":
af = (ushort)value;
LibFz80_SET_af(instance, af);
break;
case "B":
bc = LibFz80_GET_bc(instance);
bc |= (ushort)(value << 8);
LibFz80_SET_bc(instance, bc);
break;
case "BC":
bc = (ushort)value;
LibFz80_SET_bc(instance, bc);
break;
case "C":
bc = LibFz80_GET_bc(instance);
bc |= (ushort)(value & 0xff);
LibFz80_SET_bc(instance, bc);
break;
case "D":
de = LibFz80_GET_de(instance);
de |= (ushort)(value << 8);
LibFz80_SET_de(instance, de);
break;
case "DE":
de = (ushort)value;
LibFz80_SET_de(instance, de);
break;
case "E":
de = LibFz80_GET_de(instance);
de |= (ushort)(value & 0xff);
LibFz80_SET_de(instance, de);
Z80.af &= 0x00FF;
Z80.af |= (ushort)(value << 8);
break;
case "F":
af = LibFz80_GET_af(instance);
af |= (ushort)(value & 0xff);
LibFz80_SET_af(instance, af);
Z80.af &= 0xFF00;
Z80.af |= (ushort)(value & 0xFF);
break;
case "AF":
Z80.af = (ushort)value;
break;
case "B":
Z80.bc &= 0x00FF;
Z80.bc |= (ushort)(value << 8);
break;
case "C":
Z80.bc &= 0xFF00;
Z80.bc |= (ushort)(value & 0xFF);
break;
case "BC":
Z80.bc = (ushort)value;
break;
case "D":
Z80.de &= 0x00FF;
Z80.de |= (ushort)(value << 8);
break;
case "E":
Z80.de &= 0xFF00;
Z80.de |= (ushort)(value & 0xFF);
break;
case "DE":
Z80.de = (ushort)value;
break;
case "H":
hl = LibFz80_GET_hl(instance);
hl |= (ushort)(value << 8);
LibFz80_SET_hl(instance, hl);
break;
case "HL":
hl = (ushort)value;
LibFz80_SET_hl(instance, hl);
break;
case "I":
ir = LibFz80_GET_ir(instance);
ir |= (ushort)(value << 8);
LibFz80_SET_ir(instance, ir);
break;
case "IX":
ix = (ushort)value;
LibFz80_SET_ix(instance, ix);
break;
case "IY":
iy = (ushort)value;
LibFz80_SET_iy(instance, iy);
Z80.hl &= 0xFF00;
Z80.hl |= (ushort)(value << 8);
break;
case "L":
hl = LibFz80_GET_hl(instance);
hl |= (ushort)(value & 0xff);
LibFz80_SET_hl(instance, hl);
Z80.hl &= 0x00FF;
Z80.hl |= (ushort)(value & 0xFF);
break;
case "PC":
pc = (ushort)value;
LibFz80_SET_pc(instance, pc);
case "HL":
Z80.hl = (ushort)value;
break;
case "I":
Z80.ir &= 0x00FF;
Z80.ir |= (ushort)(value << 8);
break;
case "R":
ir = LibFz80_GET_ir(instance);
ir |= (ushort)(value & 0xff);
LibFz80_SET_ir(instance, ir);
Z80.ir &= 0xFF00;
Z80.ir |= (ushort)(value & 0xFF);
break;
case "IX":
Z80.ix = (ushort)value;
break;
case "IY":
Z80.iy = (ushort)value;
break;
case "PC":
Z80.pc = (ushort)value;
break;
case "Shadow AF":
af2 = (ushort)value;
LibFz80_SET_af2(instance, af2);
Z80.af2 = (ushort)value;
break;
case "Shadow BC":
bc2 = (ushort)value;
LibFz80_SET_bc2(instance, bc2);
Z80.bc2 = (ushort)value;
break;
case "Shadow DE":
de2 = (ushort)value;
LibFz80_SET_de2(instance, de2);
Z80.de2 = (ushort)value;
break;
case "Shadow HL":
hl2 = (ushort)value;
LibFz80_SET_hl2(instance, hl2);
Z80.hl2 = (ushort)value;
break;
case "SP":
sp = (ushort)value;
LibFz80_SET_sp(instance, sp);
Z80.sp = (ushort)value;
break;
}
}
@ -613,44 +337,35 @@ namespace BizHawk.Emulation.Cores.Computers.AmstradCPC
{
ser.BeginSection("FlooohZ80");
if (ser.IsWriter)
{
GetStateFromCpu();
}
ser.Sync(nameof(step), ref step);
ser.Sync(nameof(addr), ref addr);
ser.Sync(nameof(dlatch), ref dlatch);
ser.Sync(nameof(opcode), ref opcode);
ser.Sync(nameof(hlx_idx), ref hlx_idx);
ser.Sync(nameof(prefix_active), ref prefix_active);
ser.Sync(nameof(pins), ref pins);
ser.Sync(nameof(int_bits), ref int_bits);
ser.Sync(nameof(pc), ref pc);
ser.Sync(nameof(af), ref af);
ser.Sync(nameof(bc), ref bc);
ser.Sync(nameof(de), ref de);
ser.Sync(nameof(hl), ref hl);
ser.Sync(nameof(ix), ref ix);
ser.Sync(nameof(iy), ref iy);
ser.Sync(nameof(wz), ref wz);
ser.Sync(nameof(sp), ref sp);
ser.Sync(nameof(ir), ref ir);
ser.Sync(nameof(af2), ref af2);
ser.Sync(nameof(bc2), ref bc2);
ser.Sync(nameof(de2), ref de2);
ser.Sync(nameof(hl2), ref hl2);
ser.Sync(nameof(im), ref im);
ser.Sync(nameof(iff1), ref iff1);
ser.Sync(nameof(iff2), ref iff2);
if (ser.IsReader)
{
PutStateToCpu();
}
ser.Sync(nameof(Z80.step), ref Z80.step);
ser.Sync(nameof(Z80.addr), ref Z80.addr);
ser.Sync(nameof(Z80.dlatch), ref Z80.dlatch);
ser.Sync(nameof(Z80.opcode), ref Z80.opcode);
ser.Sync(nameof(Z80.hlx_idx), ref Z80.hlx_idx);
ser.Sync(nameof(Z80.prefix_active), ref Z80.prefix_active);
ser.Sync(nameof(Z80.pins), ref Z80.pins);
ser.Sync(nameof(Z80.int_bits), ref Z80.int_bits);
ser.Sync(nameof(Z80.pc), ref Z80.pc);
ser.Sync(nameof(Z80.af), ref Z80.af);
ser.Sync(nameof(Z80.bc), ref Z80.bc);
ser.Sync(nameof(Z80.de), ref Z80.de);
ser.Sync(nameof(Z80.hl), ref Z80.hl);
ser.Sync(nameof(Z80.ix), ref Z80.ix);
ser.Sync(nameof(Z80.iy), ref Z80.iy);
ser.Sync(nameof(Z80.wz), ref Z80.wz);
ser.Sync(nameof(Z80.sp), ref Z80.sp);
ser.Sync(nameof(Z80.ir), ref Z80.ir);
ser.Sync(nameof(Z80.af2), ref Z80.af2);
ser.Sync(nameof(Z80.bc2), ref Z80.bc2);
ser.Sync(nameof(Z80.de2), ref Z80.de2);
ser.Sync(nameof(Z80.hl2), ref Z80.hl2);
ser.Sync(nameof(Z80.im), ref Z80.im);
ser.Sync(nameof(Z80.iff1), ref Z80.iff1);
ser.Sync(nameof(Z80.iff2), ref Z80.iff2);
ser.Sync(nameof(_pins), ref _pins);
ser.Sync(nameof(TotalExecutedCycles), ref TotalExecutedCycles);
ser.EndSection();
}
}