Z80
v0.2-pre-2024-09-21
A biblioteca Z80 implementa um emulador rápido, pequeno e preciso do Zilog Z80. Emula tudo o que se sabe até hoje sobre esta CPU, incluindo os comportamentos sem documentos, memptr, q e a redefinição especial. Ele também tem a honra de ter sido o primeiro projeto de código aberto a fornecer emulação completa do modo de interrupção 0.
O código -fonte é escrito no ANSI C para máxima portabilidade e é comentado extensivamente. O objetivo tem sido escrever um software bem estruturado e fácil de entender; Algo sólido e elegante que pode resistir ao teste do tempo, sem necessidade de grandes mudanças.
Este emulador de CPU Z80 possui um design clássico com granularidade no nível de instrução que oferece o melhor desempenho, oferecendo uma flexibilidade razoável para obter precisão até o nível do estado T.
A granularidade no nível da instrução implica que, exceto em alguns casos bem definidos, a execução de uma determinada instrução não pode parar até que todos os seus ciclos m internos tenham sido processados (ou seja, as instruções não são divididas em micro-operações). Além disso, os registros são modificados apenas uma vez por instrução e o contador do estado t é normalmente atualizado após a execução de uma instrução completa.
Dito isto, instruções, bandeiras, acesso à memória, interrupções, ciclos de relógio etc. são emulados com precisão de acordo com a documentação técnica disponível, as descobertas feitas após décadas de pesquisa sobre o Z80 e simulações eletrônicas. E, é claro, o emulador passa os testes mais exaustivos escritos até o momento, incluindo as três principais suítes de teste:
Esse conjunto de programas tem como objetivo ajudar os autores do emulador a atingir o nível desejado da autenticidade da emulação da CPU. Cada um dos programas incluídos realiza uma computação exaustiva usando cada uma das instruções Z80 testadas, compara os resultados com os valores obtidos de um espectro Sinclair ZX real 48K com a CPU Zilog Z80 e relata quaisquer desvios detectados.
z80full.tap Testes todos os sinalizadores e registros. | z80doc.tap Testes todos os registros, mas apenas sinalizadores oficialmente documentados. |
z80flags.tap Testes todos os sinalizadores, ignora os registros. | z80docflags.tap Testes apenas sinalizadores documentados, ignora os registros. |
z80ccf.tap Testes todos os sinalizadores após a execução ccf após cada instrução testada. | z80memptr.tap Testes todos os sinalizadores após a execução bit N,(hl) após cada instrução testada. |
z80full.tap Testes todos os sinalizadores e registros. | z80doc.tap Testes todos os registros, mas apenas sinalizadores oficialmente documentados. |
z80flags.tap Testes todos os sinalizadores, ignora os registros. | z80docflags.tap Testes apenas sinalizadores documentados, ignora os registros. |
z80ccf.tap Testes todos os sinalizadores após a execução ccf após cada instrução testada. | z80memptr.tap Testes todos os sinalizadores após a execução bit N,(hl) após cada instrução testada. |
Este conjunto realiza uma série de testes para verificar os documentos do MEMPTR (inglês, russo) , que estão no local, bem como uma breve corrida por várias faixas de código de operação CBh/DDh/FDh . Os resultados do teste no programa são comparados com os de uma CPU NEC D780C-1, mas Simon Conway testou gentilmente vários outros clones Z80, confirmando os mesmos resultados.
z80tests.tap | |
O conjunto de instruções Z80 de Frank Cringle tenta executar cada código de operação Z80, colocando -os através de um ciclo de testes e comparando os resultados aos resultados reais da execução do código em um Z80 real. O exercício é fornecido com o Yaze de Frank (mais um emulador Z80). Muitas vezes, é difícil rastrear, então Jonathan Graham Harston juntou -o aqui, bem como algumas conversões. O último lançamento do Yaze está disponível no site de Andreas Gerlich.
zexdoc.tap Testes documentaram oficialmente os efeitos da bandeira. | zexall.tap Testes todas as mudanças de sinalizador. |
zexfix.tap Testes todas as mudanças de sinalizador. | zexbit.tap Testes todas as alterações do sinalizador das instruções bit . |
zexall2.tap |
Primeiro, adicione o repositório zxe e atualize o índice de pacotes:
sudo mkdir -pm700 /root/.gnupg
sudo mkdir -pm755 /etc/apt/keyrings
sudo gpg --no-default-keyring --keyring /etc/apt/keyrings/zxe-archive-keyring.gpg --keyserver hkp://keyserver.ubuntu.com:80 --recv-keys FE214A38D6A0C01D9AF514EE841EA3BD3A7E1487
echo " deb [arch= $( dpkg --print-architecture ) signed-by=/etc/apt/keyrings/zxe-archive-keyring.gpg] https://zxe.io/repos/apt stable main " | sudo tee /etc/apt/sources.list.d/zxe.list
sudo apt updateEm seguida, instale o pacote da biblioteca:
sudo apt install libz80Caso você precise criar software que exija a biblioteca Z80, instale o pacote de desenvolvimento também:
sudo apt install libz80-dev Primeiro, adicione e sincronize a sobreposição zxe :
eselect repository add zxe git https://github.com/redcode/zxe-gentoo-overlay.git
emaint sync --repo zxeEm seguida, instale a biblioteca:
emerge emulation-libs/z80brew install redcode/zxe/z80Os binários pré-criados para Windows estão disponíveis na página de download.
Você precisará de CMake v3.14 ou posterior para construir o pacote e, opcionalmente, versões recentes de doxygen, sphinx e respirar para compilar a documentação. Além disso, verifique se você possui um látex com suporte em PDF instalado no seu sistema, se desejar gerar a documentação no formato PDF.
O emulador requer alguns tipos e macros incluídos no Zeta, uma biblioteca somente para cabeçalho sem dependência usada para manter a compatibilidade com a maioria dos compiladores C. Instale a Zeta ou extraia seu Tarball de código -fonte para o diretório raiz do projeto Z80 ou seu diretório pai. Zeta é a única dependência; O emulador é uma implementação independente e, como tal, não depende da biblioteca padrão C.
Depois que os pré -requisitos forem atendidos, crie um diretório e execute cmake a partir daí para preparar o sistema de construção:
mkdir build
cd build
cmake [options] < Z80-project-directory > Os arquivos de construção resultantes podem ser configurados passando opções para cmake . Para mostrar uma lista completa dos disponíveis junto com suas configurações atuais, digite o seguinte:
cmake -LAH -N -B .Em caso de dúvida, leia a documentação do CMake para obter mais informações sobre as opções de configuração. A seguir, são apresentadas algumas das opções padrão mais relevantes do cmake:
Gerar bibliotecas compartilhadas em vez de bibliotecas estáticas.
O padrão é NO .
-DCMAKE_BUILD_TYPE=(Debug|Release|RelWithDebInfo|MinSizeRel)
Escolha o tipo de compilação (configuração) para gerar.
O padrão é Release .
-DCMAKE_INSTALL_NAME_DIR="<path>"
Especifique a parte do diretório do nome de instalação da Biblioteca Dinâmica nas plataformas Apple (para bibliotecas compartilhadas instaladas).
Não definido por padrão.
-DCMAKE_INSTALL_PREFIX="<path>"
Especifique o prefixo de instalação.
O padrão é "/usr/local" (nos sistemas operacionais do UNIX e UNIX).
As opções específicas do pacote são prefixadas com Z80_ e podem ser divididas em dois grupos. O primeiro controla aspectos não relacionados ao código -fonte da biblioteca:
-DZ80_DEPOT_LOCATION="<location>"
Especifique o diretório ou URL do depósito que contém os arquivos de teste (ou seja, o firmware e o software exigidos pela ferramenta de teste).
O padrão é "http://zxe.io/depot" .
-DZ80_FETCH_TEST_FILES=(YES|NO)
Copie ou faça o download dos arquivos de teste do depósito para o diretório Build.
O padrão é NO .
-DZ80_INSTALL_CMAKEDIR="<path>"
Especifique o diretório no qual instalar o pacote CMake Config-File.
O padrão é "${CMAKE_INSTALL_LIBDIR}/cmake/Z80" .
-DZ80_INSTALL_PKGCONFIGDIR="<path>"
Especifique o diretório para instalar o arquivo pkg-config.
O padrão é "${CMAKE_INSTALL_LIBDIR}/pkgconfig" .
-DZ80_NOSTDLIB_FLAGS=(Auto|"[<flag>[;<flag>...]]")
Especifique os sinalizadores do vinculador usados para evitar vincular as bibliotecas do sistema.
O padrão é Auto (sinalizadores automáticos). Se você receber erros de ligação, defina esta opção como "" .
-DZ80_OBJECT_LIBS=(YES|NO)
Construa o emulador como uma biblioteca de objetos.
Esta opção tem precedência sobre BUILD_SHARED_LIBS e Z80_SHARED_LIBS . Se ativado, o sistema de construção ignorará Z80_WITH_CMAKE_SUPPORT e Z80_WITH_PKGCONFIG_SUPPORT , pois nenhuma biblioteca ou arquivos de suporte será instalada.
O padrão é NO .
Construa o emulador como uma biblioteca compartilhada, em vez de estática.
Esta opção tem precedência sobre BUILD_SHARED_LIBS .
Não definido por padrão.
-DZ80_SPHINX_HTML_THEME="[<name>]"
Especifique o tema Sphinx para a documentação no formato HTML.
O padrão é "" (use o tema padrão).
-DZ80_WITH_CMAKE_SUPPORT=(YES|NO)
Gere e instale o pacote CMake Config-File.
O padrão é NO .
-DZ80_WITH_HTML_DOCUMENTATION=(YES|NO)
Crie e instale a documentação no formato HTML.
Requer doxygen, esfinge e respiração.
O padrão é NO .
-DZ80_WITH_PDF_DOCUMENTATION=(YES|NO)
Crie e instale a documentação no formato PDF.
Requer doxygen, esfinge, respiração e látex com suporte a PDF.
O padrão é NO .
-DZ80_WITH_PKGCONFIG_SUPPORT=(YES|NO)
Gere e instale o arquivo PKG-Config.
O padrão é NO .
-DZ80_WITH_STANDARD_DOCUMENTS=(YES|NO)
Instale os documentos de texto padrão distribuídos com o pacote: AUTHORS , COPYING , COPYING.LESSER , HISTORY , README e THANKS .
O padrão é NO .
-DZ80_WITH_TESTS=(YES|NO)
Crie a ferramenta de teste.
O padrão é NO .
O segundo grupo de opções específicas do pacote configura o código-fonte da biblioteca predefinando macros que permitem recursos opcionais:
-DZ80_WITH_EXECUTE=(YES|NO)
Crie a implementação da função z80_execute .
O padrão é NO .
-DZ80_WITH_FULL_IM0=(YES|NO)
Crie a implementação completa do modo de interrupção 0 em vez da reduzida.
O padrão é NO .
-DZ80_WITH_IM0_RETX_NOTIFICATIONS=(YES|NO)
Ativar notificações opcionais para qualquer instrução reti ou retn executada durante a resposta do modo de interrupção 0.
O padrão é NO .
-DZ80_WITH_Q=(YES|NO)
Construa a implementação de Q.
O padrão é NO .
-DZ80_WITH_SPECIAL_RESET=(YES|NO)
Construa a implementação da redefinição especial.
O padrão é NO .
-DZ80_WITH_UNOFFICIAL_RETI=(YES|NO)
Configure as instruções sem documentos ED5Dh , ED6Dh e ED7Dh como reti em vez de retn .
O padrão é NO .
-DZ80_WITH_ZILOG_NMOS_LD_A_IR_BUG=(YES|NO)
Crie a implementação do bug que afeta o Zilog Z80 NMOS, que faz com que o sinalizador P/V seja redefinido quando uma interrupção mascarável é aceita durante a execução das instruções ld a,{i|r} .
O padrão é NO .
Os mantenedores de pacotes são incentivados a usar pelo menos as seguintes opções para a biblioteca compartilhada:
-DZ80_WITH_EXECUTE=YES
-DZ80_WITH_FULL_IM0=YES
-DZ80_WITH_IM0_RETX_NOTIFICATIONS=YES
-DZ80_WITH_Q=YES
-DZ80_WITH_ZILOG_NMOS_LD_A_IR_BUG=YES
Finalmente, depois que o sistema de compilação estiver configurado de acordo com suas necessidades, construa e instale o pacote:
cmake --build . [--config (Debug | Release | RelWithDebInfo | MinSizeRel)]
cmake --install . [--config < configuration > ] [--strip] A opção --config é necessária apenas para os geradores de cmake que ignoram CMAKE_BUILD_TYPE (por exemplo, xcode e o Visual Studio). Use --strip para remover informações de depuração e símbolos não públicos ao instalar compilações semibug da biblioteca compartilhada.
Use o seguinte para construir o emulador como uma biblioteca compartilhada e instale -a junto com os arquivos de desenvolvimento em $HOME/.local :
mkdir work && cd work
git clone https://github.com/redcode/Zeta.git
git clone https://github.com/redcode/Z80.git
cd Zeta
mkdir build && cd build
cmake
-DCMAKE_BUILD_TYPE=Release
-DCMAKE_INSTALL_PREFIX= " $HOME /.local "
-DZeta_WITH_CMAKE_SUPPORT=YES
-DZeta_WITH_PKGCONFIG_SUPPORT=YES
..
cmake --install . --config Release
cd ../../Z80
mkdir build && cd build
cmake
-DBUILD_SHARED_LIBS=YES
-DCMAKE_BUILD_TYPE=Release
-DCMAKE_INSTALL_NAME_DIR= " $HOME /.local/lib "
-DCMAKE_INSTALL_PREFIX= " $HOME /.local "
-DZ80_WITH_CMAKE_SUPPORT=YES
-DZ80_WITH_PKGCONFIG_SUPPORT=YES
-DZ80_WITH_EXECUTE=YES
-DZ80_WITH_FULL_IM0=YES
-DZ80_WITH_IM0_RETX_NOTIFICATIONS=YES
-DZ80_WITH_Q=YES
-DZ80_WITH_ZILOG_NMOS_LD_A_IR_BUG=YES
..
cmake --build . --config Release
cmake --install . --config Release --stripBuild-and-Install-Z80.sh
O pacote inclui uma ferramenta chamada test-Z80 capaz de executar as versões de espectro CP/M e ZX mais relevantes das principais suítes de teste. Configure o sistema de construção com -DZ80_WITH_TESTS=YES para ativar sua compilação e -DZ80_FETCH_TEST_FILES=YES para baixar o firmware e o software necessários. Observe também que a biblioteca Z80 deve ser construída com -DZ80_WITH_Q=YES para poder passar nos testes de Patrik Rak.
Depois de criar o pacote, digite o seguinte para executar todos os testes:
./test-Z80 -p depot/firmware -p depot/software/POSIX -p " depot/software/ZX Spectrum " -a A ferramenta suporta opções e pode executar os testes individualmente (tipo ./test-Z80 -h para obter ajuda). Se você preferir executar todos os testes através do CTEST, use este comando:
ctest --verbose --build-config (Debug | Release | RelWithDebInfo | MinSizeRel) Os registros completos gerados pelo test-Z80 emulando diferentes variantes da CPU estão disponíveis aqui:
Observação
Os erros de CRC nos logs da variante NMOS NEC são normais e correspondem aos valores obtidos em hardware real. A variante St CMOS está atualmente sob investigação.
Use o seguinte para construir e testar o emulador:
mkdir work && cd work
git clone https://github.com/redcode/Zeta.git
git clone https://github.com/redcode/Z80.git
cd Z80
mkdir build && cd build
cmake
-DCMAKE_BUILD_TYPE=Release
-DZ80_FETCH_TEST_FILES=YES
-DZ80_WITH_TESTS=YES
-DZ80_WITH_EXECUTE=YES
-DZ80_WITH_FULL_IM0=YES
-DZ80_WITH_IM0_RETX_NOTIFICATIONS=YES
-DZ80_WITH_Q=YES
-DZ80_WITH_ZILOG_NMOS_LD_A_IR_BUG=YES
..
cmake --build . --config Release
ctest --verbose --build-config ReleaseBuild-and-Test-Z80.sh Build-and-Test-Z80.bat
A biblioteca Z80 inclui um pacote de arquivo de configuração para integração em projetos baseados em cmake que devem ser instalados para desenvolvimento. Use find_package para encontrar o pacote Z80 . Isso cria o destino da biblioteca importada Z80 , que carrega as dependências de link transitivo necessário. Opcionalmente, o método de vinculação pode ser selecionado especificando o componente Shared ou Static .
Exemplo:
find_package (Z80 REQUIRED Shared)
target_link_libraries (your- target Z80) Quando não especificado como um componente, o método de vinculação é selecionado de acordo com o Z80_SHARED_LIBS . Se essa opção não estiver definida, o arquivo de configuração usará o tipo de biblioteca instalada no sistema e, se encontrar as versões compartilhadas e estáticas, BUILD_SHARED_LIBS determinar qual se vincular.
Para incorporar a biblioteca Z80 como um subprojeto CMAKE, extraia as tarballs de código -fonte de Zeta e Z80 (ou clonam seus respectivos repositórios) em um subdiretório de outro projeto. Em seguida, use add_subdirectory no projeto pai para adicionar a árvore de código -fonte Z80 ao processo de construção (NB, o subproject Z80 encontrará automaticamente o Zeta e o importará como uma biblioteca de interface).
É aconselhável configurar a biblioteca Z80 nos CMakeLists.txt do projeto pai. Isso impedirá que o usuário precise especificar opções de configuração para o subprojeto Z80 através da linha de comando ao criar o projeto principal.
Exemplo:
set (Z80_SHARED_LIBS NO CACHE BOOL "" )
set (Z80_WITH_Q YES CACHE BOOL "" )
set (Z80_WITH_ZILOG_NMOS_LD_A_IR_BUG YES CACHE BOOL "" )
add_subdirectory (dependencies/Z80)
target_link_libraries (your- target Z80) É importante definir a opção Z80_SHARED_LIBS . Caso contrário, o CMake construirá o tipo de biblioteca indicado por BUILD_SHARED_LIBS , que pode não ser o desejado.
O código -fonte do emulador pode ser configurado no horário de compilação, predefinando uma série de macros. Z80.h e Z80.c Obedecem aos dois primeiros explicados abaixo. O restante das macros é relevante apenas ao compilar Z80.c :
#define Z80_EXTERNAL_HEADER "header-name.h"
Especifica o único cabeçalho externo para #include , substituindo todos os outros.
Predefine essa macro para fornecer um arquivo de cabeçalho que define os tipos externos e macros usados pelo emulador, impedindo que seu projeto dependa do Zeta. Você pode usar isso ao compilar Z80.c como parte do seu projeto ou (se seus tipos não quebrarem a compatibilidade binária) ao incluir <Z80.h> e vincular uma biblioteca Z80 pré-construída.
#define Z80_STATIC
Restringe a visibilidade dos símbolos públicos.
Essa macro é necessária se você estiver construindo Z80.c como uma biblioteca estática, compilando -a diretamente como parte do seu projeto ou vinculando seu programa contra a versão estática da biblioteca Z80. Em qualquer um desses casos, verifique se essa macro está definida antes de incluir "Z80.h" ou <Z80.h> .
#define Z80_WITH_LOCAL_HEADER
Diga Z80.c para #include "Z80.h" em vez de <Z80.h> .
Os recursos opcionais do emulador mencionados em "Instalação de fontes" são desativados por padrão. Se você compilar Z80.c como parte do seu projeto, ative os recursos necessários, predefinando as respectivas macros de ativação. Eles têm o mesmo nome que seus equivalentes de cmake:
#define Z80_WITH_EXECUTE#define Z80_WITH_FULL_IM0#define Z80_WITH_IM0_RETX_NOTIFICATIONS#define Z80_WITH_Q#define Z80_WITH_SPECIAL_RESET#define Z80_WITH_UNOFFICIAL_RETI#define Z80_WITH_ZILOG_NMOS_LD_A_IR_BUG Exceto para Z80_EXTERNAL_HEADER , as macros acima podem estar vazias; O código -fonte verifica apenas se eles são definidos.
Observação
A ativação de alguns dos recursos opcionais afeta a velocidade do emulador devido a vários fatores (leia a documentação para obter mais detalhes).
Este emulador foi usado pelos seguintes projetos (listados em ordem alfabética):
Muito obrigado aos seguintes indivíduos (em ordem alfabética):
ccf/scf .ccf/scf sobre hardware real. 2, 3ccf/scf . 5, 6ccf/scf . 12out (c),0 se comporta no Zilog Z80 CMOS. 16ccf/scf sobre hardware real. 12, 23ccf/scf .ccf/scf .ccf/scf . 15, 30ccf/scf .ccf/scf . 2, 3reti/retn adiam a aceitação da interrupção mascarável. 34ccf/scf . 36Copyright © 1999-2024 Manuel Sainz de Baranda y Goñi.
Esta biblioteca é um software livre: você pode redistribuí -lo e/ou modificá -lo nos termos da Licença Pública Geral GNU menor, conforme publicado pela Free Software Foundation, versão 3 da licença ou (por sua opção) qualquer versão posterior.
Esta biblioteca é distribuída na esperança de que seja útil, mas sem garantia; sem a garantia implícita de comercialização ou aptidão para uma finalidade específica . Veja a licença pública geral menor da GNU para obter mais detalhes.
Você deveria ter recebido uma cópia da licença pública geral da GNU, juntamente com esta biblioteca. Caso contrário, consulte https://www.gnu.org/license/.
Projetos em que os termos da Licença Pública Geral GNU menor impedem o uso desta biblioteca ou exigem publicação indesejada do código -fonte de produtos comerciais, podem solicitar uma licença especial.
