Subversion Repositories s80186

// Copyright Jamie Iles, 2017

//

// This file is part of s80x86.

//

// s80x86 is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// s80x86 is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with s80x86.  If not, see <http://www.gnu.org/licenses/>.

#include "Emulate.h"

#include <cassert>

#include <cstdlib>

#include <iostream>

#include <functional>

#include <stdint.h>

#include "Memory.h"

#include "SoftwareCPU.h"

#include <config.h>

template <typename Out, typename In>

static inline Out sign_extend(In v)

{

    static_assert(sizeof(Out) > sizeof(In),

                  "May only sign extend to larger types");

    size_t bit_shift = (sizeof(Out) - sizeof(In)) * 8;

    Out o = static_cast<Out>(v);

    o <<= bit_shift;

    o >>= bit_shift;

    return o;

}

enum RepMode {

    REPNE, // Prefix 0xf2

    REPE,  // Prefix 0xf3

};

class EmulatorPimpl

{

public:

    EmulatorPimpl(RegisterFile *registers, SimCPU *sim_cpu);

    size_t step();

    size_t step_with_io(std::function<void(unsigned long)> io_callback,

                        unsigned long cur_cycle_count);

    void set_memory(Memory *mem)

    {

        this->mem = mem;

    }

    void set_io(std::map<uint16_t, IOPorts *> *io)

    {

        this->io = io;

    }

    bool has_trapped() const

    {

        auto int_cs = mem->read<uint16_t>(VEC_INT + 2);

        auto int_ip = mem->read<uint16_t>(VEC_INT + 0);

        return registers->get(CS) == int_cs && registers->get(IP) == int_ip;

    }

    void reset();

    void raise_nmi();

    void raise_irq(int irq_num);

private:

    size_t emulate_insn();

    void mov88();

    void mov89();

    void mov8a();

    void mov8b();

    void movc6();

    void movc7();

    void movb0_b7();

    void movb8_bf();

    void mova0();

    void mova1();

    void mova2();

    void mova3();

    void mov8e();

    void mov8c();

    void pusha60();

    void popa61();

    void pushff();

    void push50_57();

    void pushsr();

    void push68();

    void push6a();

    void pop8f();

    void pop58_5f();

    void popsr();

    void xchg86();

    void xchg87();

    void xchg90_97();

    void ine4();

    void ine5();

    void inec();

    void ined();

    void oute6();

    void oute7();

    void outee();

    void outef();

    void setalcd6();

    void xlatd7();

    void lea8d();

    void ldsc5();

    void lesc4();

    void lahf9f();

    void sahf9e();

    void pushf9c();

    void popf9d();

    void add_adc_sub_sbb_cmp_xor_or_and_80();

    void add_adc_sub_sbb_cmp_xor_or_and_81();

    void add_adc_sub_sbb_cmp_82();

    void add_adc_sub_sbb_cmp_83();

    void add00();

    void add01();

    void add02();

    void add03();

    void add04();

    void add05();

    void and20();

    void and21();

    void and22();

    void and23();

    void and24();

    void and25();

    void xor30();

    void xor31();

    void xor32();

    void xor33();

    void xor34();

    void xor35();

    void or08();

    void or09();

    void or0a();

    void or0b();

    void or0c();

    void or0d();

    void adc10();

    void adc11();

    void adc12();

    void adc13();

    void adc14();

    void adc15();

    void sub28();

    void sub29();

    void sub2a();

    void sub2b();

    void sub2c();

    void sub2d();

    void sbb18();

    void sbb19();

    void sbb1a();

    void sbb1b();

    void sbb1c();

    void sbb1d();

    void inc_dec_fe();

    void incff();

    void inc40_47();

    void decff();

    void dec48_4f();

    void aaa37();

    void daa27();

    void aas3f();

    void das2f();

    void aamd4();

    void negf6();

    void negf7();

    void notf6();

    void notf7();

    void cmp38();

    void cmp39();

    void cmp3a();

    void cmp3b();

    void cmp3c();

    void cmp3d();

    void mulf6();

    void mulf7();

    void imul6b();

    void imul69();

    void imulf6();

    void imulf7();

    void divf6();

    void divf7();

    void idivf6();

    void idivf7();

    void intcc();

    void intcd();

    void intoce();

    void cbw98();

    void cwd99();

    void jmpe9();

    void jmpeb();

    void jmpff_intra();

    void jmpff_inter();

    void jmpea();

    void je74();

    void jl7c();

    void jle7e();

    void jp7a();

    void jb72();

    void jbe76();

    void jo70();

    void js78();

    void jns79();

    void jne75();

    void jnl7d();

    void jnle7f();

    void jnb73();

    void jnbe77();

    void jnp7b();

    void jno71();

    void jcxze3();

    void calle8();

    void callff_intra();

    void callff_inter();

    void call9a();

    void retc3();

    void retc2();

    void retcb();

    void retca();

    void iretcf();

    void clcf8();

    void cmcf5();

    void stcf9();

    void cldfc();

    void stdfd();

    void clifa();

    void stifb();

    void loope2();

    void loopee1();

    void loopnze0();

    void scasbae();

    void scasbaf();

    void movsba4();

    void movswa5();

    void cmpsba6();

    void cmpswa7();

    void lodsbac();

    void lodswad();

    void stosbaa();

    void stoswab();

    void hltf4();

    void wait9b();

    void escd8();

    void aadd5();

    void shiftc0();

    void shiftc1();

    void shiftd0();

    void shiftd1();

    void shiftd2();

    void shiftd3();

    void shlc0();

    void shlc1();

    void shld0();

    void shld1();

    void shld2();

    void shld3();

    void shrc0();

    void shrc1();

    void shrd0();

    void shrd1();

    void shrd2();

    void shrd3();

    void sarc0();

    void sarc1();

    void sard0();

    void sard1();

    void sard2();

    void sard3();

    void rolc0();

    void rolc1();

    void rold0();

    void rold1();

    void rold2();

    void rold3();

    void rclc0();

    void rclc1();

    void rcld0();

    void rcld1();

    void rcld2();

    void rcld3();

    void rcrc0();

    void rcrc1();

    void rcrd0();

    void rcrd1();

    void rcrd2();

    void rcrd3();

    void rorc0();

    void rorc1();

    void rord0();

    void rord1();

    void rord2();

    void rord3();

    void test84();

    void test85();

    void testa8();

    void testa9();

    void testf6();

    void testf7();

    void bound62();

    void outsb6e();

    void outsw6f();

    void insb6c();

    void insw6d();

    void leavec9();

    void enterc8();

    void invalid_opcode();

    uint8_t fetch_byte();

    template <typename T>

    std::pair<uint16_t, T> do_mul(int32_t v1, int32_t v2);

    template <typename T>

    std::pair<uint16_t, T> do_add(uint16_t v1,

                                  uint16_t v2,

                                  uint16_t carry_in = 0);

    template <typename T>

    std::pair<uint16_t, T> do_sub(uint16_t v1,

                                  uint16_t v2,

                                  uint16_t carry_in = 0);

    template <typename T>

    std::pair<uint16_t, T> do_xor(uint16_t v1, uint16_t v2);

    template <typename T>

    std::pair<uint16_t, T> do_or(uint16_t v1, uint16_t v2);

    template <typename T>

    std::pair<uint16_t, T> do_and(uint16_t v1, uint16_t v2);

    void push_inc_jmp_call_ff();

    void neg_mul_not_test_div_f6();

    void neg_mul_not_test_div_f7();

    void push_word(uint16_t v);

    uint16_t pop_word();

    template <typename T>

    std::pair<uint16_t, T> do_alu(

        int32_t v1,

        int32_t v2,

        int32_t carry_in,

        std::function<uint32_t(uint32_t, uint32_t, uint32_t)> alu_op);

    template <typename T>

    void write_data(T val, bool stack = false);

    template <typename T>

    T read_data(bool stack = false);

    uint16_t fetch_16bit();

    GPR get_segment(bool is_stack_reference);

    void set_override_segment(GPR segment);

    void write_io8(uint32_t addr, uint8_t val)

    {

        if (!io->count(addr & ~1))

            return;

        auto p = (*io)[addr & ~1];

        p->write8((addr & ~1) - p->get_base(), addr & 1, val);

    }

    void write_io16(uint32_t addr, uint16_t val)

    {

        if (!io->count(addr & ~1))

            return;

        auto p = (*io)[addr & ~1];

        p->write16((addr & ~1) - p->get_base(), val);

    }

    uint8_t read_io8(uint32_t addr)

    {

        if (!io->count(addr & ~1))

            return 0;

        auto p = (*io)[addr & ~1];

        return p->read8((addr & ~1) - p->get_base(), addr & 1);

    }

    uint16_t read_io16(uint32_t addr)

    {

        if (!io->count(addr & ~1))

            return 0;

        auto p = (*io)[addr & ~1];

        return p->read16((addr & ~1) - p->get_base());

    }

    void do_rep(std::function<void()> primitive,

                std::function<bool()> should_terminate);

    bool string_rep_complete();

    void handle_nmi();

    void handle_irq();

    void single_step();

    Memory *mem;

    std::map<uint16_t, IOPorts *> *io;

    RegisterFile *registers;

    size_t instr_length = 0;

    std::unique_ptr<ModRMDecoder> modrm_decoder;

    uint8_t opcode;

    bool jump_taken;

    bool default_segment_overriden;

    GPR override_segment;

    RepMode rep_mode;

    bool has_rep_prefix;

    bool nmi_pending;

    bool ext_int_inhibit;

    uint8_t pending_irq;

    bool tf_was_set;

    SimCPU *sim_cpu;

};

void EmulatorPimpl::do_rep(std::function<void()> primitive,

                           std::function<bool()> should_terminate)

{

    if (!has_rep_prefix) {

        primitive();

        return;

    }

    while (registers->get(CX) != 0) {

        primitive();

        registers->set(CX, registers->get(CX) - 1);

        if (should_terminate())

            break;

    }

}

bool EmulatorPimpl::string_rep_complete()

{

    if (rep_mode == REPE && !registers->get_flag(ZF))

        return true;

    if (rep_mode == REPNE && registers->get_flag(ZF))

        return true;

    return false;

}

EmulatorPimpl::EmulatorPimpl(RegisterFile *registers, SimCPU *sim_cpu)

    : mem(NULL),

      io(NULL),

      registers(registers),

      jump_taken(false),

      default_segment_overriden(false),

      rep_mode(REPE),

      has_rep_prefix(false),

      tf_was_set(false),

      sim_cpu(sim_cpu)

{

    modrm_decoder = std::make_unique<ModRMDecoder>(

        [&] { return this->fetch_byte(); }, this->registers);

    reset();

}

void EmulatorPimpl::reset()

{

    registers->reset();

    opcode = 0;

    instr_length = 0;

    nmi_pending = false;

    ext_int_inhibit = false;

    pending_irq = 0;

}

void EmulatorPimpl::raise_nmi()

{

    nmi_pending = true;

}

void EmulatorPimpl::raise_irq(int irq_num)

{

    pending_irq = irq_num;

}

void EmulatorPimpl::handle_nmi()

{

    nmi_pending = false;

    auto flags = registers->get_flags();

    push_word(flags);

    push_word(registers->get(CS));

    push_word(registers->get(IP));

    flags &= ~(IF | TF);

    registers->set_flags(flags, IF | TF);

    auto new_cs = mem->read<uint16_t>(VEC_NMI + 2);

    auto new_ip = mem->read<uint16_t>(VEC_NMI + 0);

    registers->set(CS, new_cs);

    registers->set(IP, new_ip);

    jump_taken = true;

    single_step();

}

void EmulatorPimpl::handle_irq()

{

    assert(pending_irq);

    auto irq_num = pending_irq;

    pending_irq = 0;

    sim_cpu->ack_int(irq_num);

    auto flags = registers->get_flags();

    push_word(flags);

    push_word(registers->get(CS));

    push_word(registers->get(IP));

    flags &= ~(IF | TF);

    registers->set_flags(flags, IF | TF);

    auto new_cs = mem->read<uint16_t>(irq_num * 4 + 2);

    auto new_ip = mem->read<uint16_t>(irq_num * 4 + 0);

    registers->set(CS, new_cs);

    registers->set(IP, new_ip);

    jump_taken = true;

    single_step();

}

void EmulatorPimpl::single_step()

{

    if (!tf_was_set || ext_int_inhibit)

        return;

    auto flags = registers->get_flags();

    push_word(flags);

    push_word(registers->get(CS));

    push_word(registers->get(IP));

    flags &= ~(IF | TF);

    registers->set_flags(flags, IF | TF);

    auto new_cs = mem->read<uint16_t>(VEC_SINGLE_STEP + 2);

    auto new_ip = mem->read<uint16_t>(VEC_SINGLE_STEP + 0);

    registers->set(CS, new_cs);

    registers->set(IP, new_ip);

    jump_taken = true;

}

size_t EmulatorPimpl::step()

{

    tf_was_set = registers->get_flag(TF);

    if (nmi_pending && !ext_int_inhibit) {

        handle_nmi();

        return 0;

    } else if (pending_irq && !ext_int_inhibit && registers->get_flag(IF)) {

        handle_irq();

        return 0;

    }

    auto len = emulate_insn();

    // Hardware also processes interrupt entry at the tail of an instruction

    // rather than a conditional check at the start of each instruction.  So

    // when single stepping, stepping an instruction may retire that

    // instruction and then jump to the NMI/INT handler.

    if (nmi_pending && !ext_int_inhibit)

        handle_nmi();

    else if (pending_irq && !ext_int_inhibit && registers->get_flag(IF))

        handle_irq();

    else if (!ext_int_inhibit)

        single_step();

    return len;

}

size_t EmulatorPimpl::step_with_io(

    std::function<void(unsigned long)> io_callback,

    unsigned long cur_cycle_count)

{

    io_callback(cur_cycle_count);

    return this->step();

}

size_t EmulatorPimpl::emulate_insn()

{

    instr_length = 0;

    bool processing_prefixes;

    default_segment_overriden = false;

    has_rep_prefix = false;

    modrm_decoder->clear();

    jump_taken = false;

    ext_int_inhibit = false;

    do {

        processing_prefixes = false;

        opcode = fetch_byte();

        // clang-format off

        switch (opcode) {

        case 0x06: // fallthrough

        case 0x0e: // fallthrough

        case 0x16: // fallthrough

        case 0x1e: pushsr(); break;

        case 0x0f: invalid_opcode(); break;

        case 0x07: // fallthrough

        case 0x17: // fallthrough

        case 0x1f: popsr(); break;

        case 0x00: add00(); break;

        case 0x01: add01(); break;

        case 0x02: add02(); break;