Imanol-Mikel Barba Sabariego / synacorvm · Files

//
// Created by imanol on 12/26/16.
//

#include <malloc.h>
#include <string.h>
#include "debug.h"

#include <signal.h>

//uint32_t cycle_count = 0;

uint8_t breakpoint = 1;
uint16_t breakpoints[0xFF];
uint16_t nbpoints = 0;
char lastchoice = 0;

uint8_t terminate = 0;

void to_debugger(int signal)
{
    if(signal == SIGINT)
    {
        breakpoint = 1;
        return;
    }
    core_dump();
}

void load_state(char *filename)

{

    FILE *state = fopen(filename,"r");
    uint16_t regsdump[NUM_REGISTERS+1];
    uint16_t memdump[MEMSIZE];
    uint16_t *stackdump;

    uint32_t stacksize;
    long stackpos;

    fread(regsdump,sizeof(uint16_t),NUM_REGISTERS+1,state);
    fread(memdump,sizeof(uint16_t),MEMSIZE,state);
    stackpos = ftell(state);
    fseek(state,0,SEEK_END);
    stacksize = (ftell(state) - stackpos)/sizeof(uint16_t);
    stackdump = calloc(stacksize,sizeof(uint16_t));
    fseek(state,stackpos,SEEK_SET);
    fread(stackdump,sizeof(uint16_t),stacksize,state);
    fclose(state);

    load_regs(regsdump);
    load_memory(memdump);
    stack_load(stackdump,stacksize);

    free(stackdump);

}

void save_state(char *filename)

{

    FILE *state = fopen(filename,"w");
    uint16_t regsdump[NUM_REGISTERS+1];
    uint16_t memdump[MEMSIZE];
    uint16_t *stackdump;
    uint32_t stacksize;

    dump_regs(regsdump);
    dump_memory(memdump);
    stacksize = stack_dump(&stackdump);

    fwrite(regsdump,sizeof(uint16_t),NUM_REGISTERS+1,state);
    fwrite(memdump,sizeof(uint16_t),MEMSIZE,state);
    fwrite(stackdump,sizeof(uint16_t),stacksize,state);
    fclose(state);
    free(stackdump);

}

void query()
{

    //TODO discard stdin

    uint8_t end = 0;

    uint16_t bpoint;
    uint16_t mempos;

    char input[100] = {0};
    char filename[32];

    uint8_t reg;
    uint16_t value;

    while(!end)
    {
        printf("\n> ");

        char command = 0;
        fgets(input,100,stdin);
        command = input[0];

        //FIXME: Input is not validated in any way. Crashes *will* occur on misuse. Have fun!

        if (command != '\n')
        {
            lastchoice = command;
        }
        else
        {
            command = lastchoice;
        }
        switch (command)
        {
            case 'b':

                sscanf(input,"b %hu\n",&bpoint);
                fprintf(stderr,"Set breakpoint %hu to %hu",nbpoints,bpoint);

                breakpoints[nbpoints] = bpoint;

                nbpoints = (uint16_t)(nbpoints + 1 % 0xFF);

                break;
            case 'd':

                sscanf(input,"d %hu\n",&bpoint);
                fprintf(stderr,"Deleted breakpoint %hu",bpoint);

                breakpoints[bpoint] = 0;

                break;
            case 'c':
                breakpoint = 0;
                end = 1;
                break;
            case 'n':
                end = 1;
                break;
            case 'r':
                print_regs();
                break;
            case 'm':

                sscanf(input,"m %hX\n",&mempos);

                fprintf(stderr,"%02X: %02x\n",mempos,mem[mempos]);

                break;

            case 's':
                sscanf(input,"s %s\n",filename);
                save_state(filename);
                fprintf(stderr,"Saved state as %s",filename);
                break;
            case 'l':
                sscanf(input,"l %s\n",filename);
                load_state(filename);
                fprintf(stderr,"Loaded state as %s",filename);
                break;
            case 'w':

                sscanf(input,"w r%hhu %hu\n",&reg,&value);
                fprintf(stderr,"Setting r%hhu = %02X",reg,value);

                regs[reg] = value;
                break;

            case 'q':
                terminate = 1;
                end = 1;
                break;

            default:
                break;
        }
    }
}

uint8_t in_breakpoint(uint16_t pc)
{
    uint8_t i;
    for(i = 0; i < nbpoints; i++)
    {
        if(breakpoints[i] == pc)
        {
            return 1;
        }
    }
    return 0;
}

uint16_t fetch_debug()
{
    uint16_t value = mem[pc++];
    /*if(breakpoint)
    {
        fprintf(stderr,"0x%2x (0x%2x): %d", pc, pc * sizeof(uint16_t),value);
        fprintf(stderr," cycle: %d\n", cycle_count++);
    }*/
    return value;
}

void translate_args(uint16_t a1, uint16_t a2, uint16_t a3, char *arg1, char *arg2, char *arg3)

{

    if(a1 > MAX_INT)
    {
        sprintf(arg1,"r%d",a1-(MAX_INT+1));
    }
    else
    {

        sprintf(arg1,"%02X",a1);

    }

    if(a2 > MAX_INT)
    {
        sprintf(arg2,"r%d",a2-(MAX_INT+1));
    }
    else
    {

        sprintf(arg2,"%02X",a2);

    }

    if(a3 > MAX_INT)
    {
        sprintf(arg3,"r%d",a3-(MAX_INT+1));
    }
    else
    {

        sprintf(arg3,"%02X",a3);

    }

}

void print_instruction(uint16_t opcode, uint16_t a1, uint16_t a2, uint16_t a3)
{
    char arg1[10];
    char arg2[10];
    char arg3[10];
    translate_args(a1,a2,a3,arg1,arg2,arg3);

    switch(opcode)
    {
        case HALT:

            fprintf(stderr, "HALT\n");

            break;
        case MOV:

            fprintf(stderr, "MOV %s %s\n", arg1, arg2);

            break;
        case PUSH:

            fprintf(stderr, "PUSH %s\n", arg1);

            break;
        case POP:

            fprintf(stderr, "POP %s\n", arg1);

            break;
        case TEQ:

            fprintf(stderr, "TEQ %s %s %s\n", arg1, arg2, arg3);

            break;
        case TGT:

            fprintf(stderr, "TGT %s %s %s\n", arg1, arg2, arg3);

            break;
        case JMP:

            fprintf(stderr, "JMP %s\n", arg1);

            break;
        case JNZ:

            fprintf(stderr, "JNZ %s %s\n", arg1, arg2);

            break;
        case JZ:

            fprintf(stderr, "JZ %s %s\n", arg1, arg2);

            break;
        case ADD:

            fprintf(stderr, "ADD %s %s %s\n", arg1, arg2, arg3);

            break;
        case MUL:

            fprintf(stderr, "MUL %s %s %s\n", arg1, arg2, arg3);

            break;
        case MOD:

            fprintf(stderr, "MOD %s %s %s\n", arg1, arg2, arg3);

            break;
        case AND:

            fprintf(stderr, "AND %s %s %s\n", arg1, arg2, arg3);

            break;
        case OR:

            fprintf(stderr, "OR %s %s %s\n", arg1, arg2, arg3);

            break;
        case NOT:

            fprintf(stderr, "NOT %s %s\n", arg1, arg2);

            break;
        case LOAD:

            fprintf(stderr, "LOAD %s %s\n", arg1, arg2);

            break;
        case STOR:

            fprintf(stderr, "STOR %s %s\n", arg1, arg2);

            break;
        case CALL:

            fprintf(stderr, "CALL %s\n", arg1);

            break;
        case RET:

            fprintf(stderr, "RET\n");

            break;
        case OUT:

            if (a1 <= MAX_INT)
            {
                fprintf(stderr, "OUT '%c'\n",a1);
            }
            else
            {
                fprintf(stderr, "OUT %s\n", arg1);
            }

            break;
        case IN:

            fprintf(stderr,"IN %s\n",arg1);

            break;
        case NOP:

            fprintf(stderr,"NOP\n");

            break;
        default:

            fprintf(stderr,"UNK %02X\n", opcode);

            break;
    }
}

void debug_program()
{

    signal(SIGINT, to_debugger);

    memset(breakpoints,0x00,0xFF);
    uint16_t arg1;
    uint16_t arg2;
    uint16_t arg3;
    for(;;)
    {

        if(in_breakpoint(pc))
        {
            breakpoint = 1;
            fprintf(stderr,"Breakpoint hit @ pc=%02X",pc);
        }

        if(breakpoint)

        {

            fprintf(stderr, "%02X: ", pc);

            print_instruction(mem[pc], mem[pc+1], mem[pc+2], mem[pc+3]);
            query();

            if(terminate)
            {
                return;
            }

        }
        uint16_t opcode = fetch_debug();

        decode_instruction(opcode, &arg1, &arg2, &arg3);
        if (execute_instruction(opcode, arg1, arg2, arg3))

        {

            return;

        }
    }
}