#include "emulateinsn.h"
#include "insndecoder.h"
#include "ThreadContext.h"
#include "bkptmanager.h"
#include <stdio.h>

uint32_t basepc= 0x8C01EBE0;
uint8_t insnbytes[]= {
// 8C01EBE0
0xF0, 0x40, 0x2D, 0xE9,  // STMFD   SP!, {R4-R7,LR}
0x00, 0x50, 0xA0, 0xE1,  // MOV     R5, R0          ; src
0x02, 0x30, 0xA0, 0xE1,  // MOV     R3, R2          ; startvalue
0x00, 0x00, 0x51, 0xE3,  // CMP     R1, #0          ; size
0x17, 0x00, 0x00, 0x9A,  // BLS     loc_8C01EC54
0x01, 0x00, 0x41, 0xE2,  // SUB     R0, R1, #1
0x5C, 0x60, 0x9F, 0xE5,  // LDR     R6, =crc32table
0x20, 0x11, 0xA0, 0xE1,  // MOV     R1, R0,LSR#2
0x01, 0x70, 0x81, 0xE2,  // ADD     R7, R1, #1
//loc_8C01EC04
0x04, 0x40, 0x95, 0xE4,  // LDR     R4, [R5],#4
0x01, 0x70, 0x47, 0xE2,  // SUB     R7, R7, #1
0x00, 0x00, 0x57, 0xE3,  // CMP     R7, #0
0x03, 0x00, 0x24, 0xE0,  // EOR     R0, R4, R3
0xFF, 0x10, 0x00, 0xE2,  // AND     R1, R0, #0xFF
0x01, 0x21, 0x96, 0xE7,  // LDR     R2, [R6,R1,LSL#2]
0x23, 0x34, 0x22, 0xE0,  // EOR     R3, R2, R3,LSR#8
0x24, 0x04, 0x23, 0xE0,  // EOR     R0, R3, R4,LSR#8
0xFF, 0x10, 0x00, 0xE2,  // AND     R1, R0, #0xFF
0x01, 0x21, 0x96, 0xE7,  // LDR     R2, [R6,R1,LSL#2]
0x23, 0x34, 0x22, 0xE0,  // EOR     R3, R2, R3,LSR#8
0x24, 0x08, 0x23, 0xE0,  // EOR     R0, R3, R4,LSR#16
0xFF, 0x10, 0x00, 0xE2,  // AND     R1, R0, #0xFF
0x01, 0x21, 0x96, 0xE7,  // LDR     R2, [R6,R1,LSL#2]
0x23, 0x34, 0x22, 0xE0,  // EOR     R3, R2, R3,LSR#8
0x24, 0x0C, 0x23, 0xE0,  // EOR     R0, R3, R4,LSR#24
0xFF, 0x10, 0x00, 0xE2,  // AND     R1, R0, #0xFF
0x01, 0x21, 0x96, 0xE7,  // LDR     R2, [R6,R1,LSL#2]
0x23, 0x34, 0x22, 0xE0,  // EOR     R3, R2, R3,LSR#8
0xEB, 0xFF, 0xFF, 0x8A,  // BHI     loc_8C01EC04
// loc_8C01EC54
0x03, 0x00, 0xA0, 0xE1,  // MOV     R0, R3
0xF0, 0x80, 0xBD, 0xE8,  // LDMFD   SP!, {R4-R7,PC}
0x98, 0x94, 0x00, 0x8C
};

bool isvalidpc(uint32_t pc)
{
    return pc>=basepc && pc<basepc+sizeof(insnbytes);
}
class DummyProcessContext : public ProcessContext {
public:
    virtual uint32_t readdword(uint32_t offset)
    {
        return 0;
    }
    virtual void writedword(uint32_t offset, uint32_t value)
    {
    }

    virtual uint8_t readbyte(uint32_t offset)
    {
        return 0;
    }
    virtual void writebyte(uint32_t offset, uint8_t value)
    {
    }

    virtual uint32_t alloc(uint32_t size)
    {
        return 0;
    }
    virtual void free(uint32_t ptr)
    {
    }

    virtual uint32_t pid() const { return 0; }
    virtual uint32_t canonicaladdress(uint32_t a) { return a; }
};
int main(int, char**)
{
    try {
    DummyProcessContext proc;
    codesnip_manager code;
    breakpoint_manager bpm(code);

    InstructionEmulator emu(bpm);


    ThreadContext td;
    td.setreg(15, basepc);

    int cnt=0;
    while (true)
    {
        uint32_t pc= td.getreg(15);
        if (!isvalidpc(pc))
            break;
        instruction insn(insnbytes+pc-basepc, 4);
        printf("emulating %08lx: %08x\n", pc, insn.opcode());
        emu.emulate_insn(td, insn);
        printf("  -> resume @%08lx\n", td.getreg(15));
        td.setreg(15, td.getreg(15)+4);
        if (insn.isbranch() && insn.branchofs()<0 && cnt++<4)
            td.setreg(15, td.getreg(15)+4);
        bpm.handle_bpt(td);
        printf("  -> resume emu @%08lx\n", td.getreg(15));
    }
    }
    catch (const char*e)
    {
        printf("E: %s\n", e);
        return 1;
    }
    catch (...)
    {
        return 1;
    }
    return 0;
}