OpenCores
URL https://opencores.org/ocsvn/zipcpu/zipcpu/trunk

Subversion Repositories zipcpu

[/] [zipcpu/] [trunk/] [bench/] [cpp/] [zippy_tb.cpp] - Diff between revs 148 and 155

Go to most recent revision | Show entire file | Details | Blame | View Log

Rev 148 Rev 155
Line 36... Line 36...
//
//
#include <signal.h>
#include <signal.h>
#include <time.h>
#include <time.h>
#include <unistd.h>
#include <unistd.h>
#include <poll.h>
#include <poll.h>
 
#include <sys/types.h>
 
#include <sys/stat.h>
 
#include <fcntl.h>
 
 
#include <ctype.h>
#include <ctype.h>
#include <ncurses.h>
#include <ncurses.h>
 
 
#include "verilated.h"
#include "verilated.h"
Line 53... Line 56...
#include "zopcodes.h"
#include "zopcodes.h"
#include "zparser.h"
#include "zparser.h"
 
 
#define CMD_REG         0
#define CMD_REG         0
#define CMD_DATA        1
#define CMD_DATA        1
 
#define CMD_GIE         (1<<13)
 
#define CMD_SLEEP       (1<<12)
 
#define CMD_CLEAR_CACHE (1<<11)
#define CMD_HALT        (1<<10)
#define CMD_HALT        (1<<10)
#define CMD_STALL       (1<<9)
#define CMD_STALL       (1<<9)
#define CMD_INT         (1<<7)
#define CMD_INT         (1<<7)
#define CMD_RESET       (1<<6)
#define CMD_RESET       (1<<6)
#define CMD_STEP        ((1<<8)|CMD_HALT)
#define CMD_STEP        ((1<<8)|CMD_HALT)
Line 65... Line 71...
#define KEY_RETURN      10
#define KEY_RETURN      10
#define CTRL(X)         ((X)&0x01f)
#define CTRL(X)         ((X)&0x01f)
 
 
#define MAXERR          10000
#define MAXERR          10000
 
 
 
#define LGRAMLEN        20
 
#define RAMBASE         0x100000
 
#define MEMWORDS        (1<<LGRAMLEN)
 
 
class   SPARSEMEM {
class   SPARSEMEM {
public:
public:
        bool    m_valid;
        bool    m_valid;
        unsigned int    m_a, m_d;
        unsigned int    m_a, m_d;
Line 95... Line 104...
class   ZIPPY_TB : public TESTB<Vzipsystem> {
class   ZIPPY_TB : public TESTB<Vzipsystem> {
public:
public:
        unsigned long   m_mem_size;
        unsigned long   m_mem_size;
        MEMSIM          m_mem;
        MEMSIM          m_mem;
        // QSPIFLASHSIM m_flash;
        // QSPIFLASHSIM m_flash;
        FILE            *dbg_fp, *m_profile_fp;
        FILE            *m_dbgfp, *m_profile_fp;
        bool            dbg_flag, bomb, m_show_user_timers;
        bool            dbg_flag, bomb, m_show_user_timers;
        int             m_cursor;
        int             m_cursor;
        unsigned long   m_last_instruction_tickcount;
        unsigned long   m_last_instruction_tickcount;
        ZIPSTATE        m_state;
        ZIPSTATE        m_state;
 
 
        ZIPPY_TB(void) : m_mem_size(1<<20), m_mem(m_mem_size) {
        ZIPPY_TB(void) : m_mem_size(MEMWORDS), m_mem(m_mem_size) {
                if (false) {
                if (false) {
                        dbg_fp = fopen("dbg.txt", "w");
                        m_dbgfp = fopen("dbg.txt", "w");
                        dbg_flag = true;
                        dbg_flag = true;
                } else {
                } else {
                        dbg_fp = NULL;
                        m_dbgfp = NULL;
                        dbg_flag = false;
                        dbg_flag = false;
                }
                }
                bomb = false;
                bomb = false;
                m_cursor = 0;
                m_cursor = 0;
                m_show_user_timers = false;
                m_show_user_timers = false;
Line 122... Line 131...
                        m_profile_fp = NULL;
                        m_profile_fp = NULL;
                }
                }
        }
        }
 
 
        ~ZIPPY_TB(void) {
        ~ZIPPY_TB(void) {
                if (dbg_fp)
                if (m_dbgfp)
                        fclose(dbg_fp);
                        fclose(m_dbgfp);
                if (m_profile_fp)
                if (m_profile_fp)
                        fclose(m_profile_fp);
                        fclose(m_profile_fp);
        }
        }
 
 
        void    reset(void) {
        void    reset(void) {
Line 152... Line 161...
                for(int i=0; i<16; i++)
                for(int i=0; i<16; i++)
                        m_state.m_uR[i] = cmd_read(i+16);
                        m_state.m_uR[i] = cmd_read(i+16);
                for(int i=0; i<20; i++)
                for(int i=0; i<20; i++)
                        m_state.m_p[i]  = cmd_read(i+32);
                        m_state.m_p[i]  = cmd_read(i+32);
 
 
                m_state.m_gie = (m_state.m_sR[14] & 0x020);
                m_state.m_gie = wb_read(CMD_REG) & CMD_GIE;
                m_state.m_pc  = (m_state.m_gie) ? (m_state.m_uR[15]):(m_state.m_sR[15]);
                m_state.m_pc  = (m_state.m_gie) ? (m_state.m_uR[15]):(m_state.m_sR[15]);
                m_state.m_sp  = (m_state.m_gie) ? (m_state.m_uR[13]):(m_state.m_sR[13]);
                m_state.m_sp  = (m_state.m_gie) ? (m_state.m_uR[13]):(m_state.m_sR[13]);
 
 
                if (m_state.m_last_pc_valid)
                if (m_state.m_last_pc_valid)
                        m_state.m_imem[0].m_a = m_state.m_last_pc;
                        m_state.m_imem[0].m_a = m_state.m_last_pc;
Line 201... Line 210...
                for(int i=0; i<16; i++)
                for(int i=0; i<16; i++)
                        m_state.m_uR[i] = m_core->v__DOT__thecpu__DOT__regset[i+16];
                        m_state.m_uR[i] = m_core->v__DOT__thecpu__DOT__regset[i+16];
                m_state.m_uR[14] = (m_state.m_uR[14]&0xffffe000)|m_core->v__DOT__thecpu__DOT__w_uflags;
                m_state.m_uR[14] = (m_state.m_uR[14]&0xffffe000)|m_core->v__DOT__thecpu__DOT__w_uflags;
                m_state.m_uR[15] = m_core->v__DOT__thecpu__DOT__upc;
                m_state.m_uR[15] = m_core->v__DOT__thecpu__DOT__upc;
 
 
                m_state.m_gie = (m_state.m_sR[14] & 0x020);
                m_state.m_gie = m_core->v__DOT__thecpu__DOT__gie;
                m_state.m_pc  = (m_state.m_gie) ? (m_state.m_uR[15]):(m_state.m_sR[15]);
                m_state.m_pc  = (m_state.m_gie) ? (m_state.m_uR[15]):(m_state.m_sR[15]);
                m_state.m_sp  = (m_state.m_gie) ? (m_state.m_uR[13]):(m_state.m_sR[13]);
                m_state.m_sp  = (m_state.m_gie) ? (m_state.m_uR[13]):(m_state.m_sR[13]);
 
 
                m_state.m_p[0] = m_core->v__DOT__pic_data;
                m_state.m_p[0] = m_core->v__DOT__pic_data;
                m_state.m_p[1] = m_core->v__DOT__watchdog__DOT__r_value;
                m_state.m_p[1] = m_core->v__DOT__watchdog__DOT__r_value;
Line 246... Line 255...
                        mvprintw(y, x, ">%s> 0x%08x<", n, v);
                        mvprintw(y, x, ">%s> 0x%08x<", n, v);
                else
                else
                        mvprintw(y, x, " %s: 0x%08x ", n, v);
                        mvprintw(y, x, " %s: 0x%08x ", n, v);
        }
        }
 
 
 
        void    dbgreg(FILE *fp, int id, const char *n, unsigned int v) {
 
                /*
 
                if ((id == 14)||(id == 14+16)) {
 
                        //char  buf[64];
 
                        //fprintf(fp, " %s:",
 
                        fprintf(fp, " %s: 0x%08x ", n, v);
 
                } else
 
                */
 
                        fprintf(fp, " %s: 0x%08x ", n, v);
 
        }
 
 
        void    showreg(int y, int x, const char *n, int r, bool c) {
        void    showreg(int y, int x, const char *n, int r, bool c) {
                if (r < 16)
                if (r < 16)
                        dispreg(y, x, n, m_state.m_sR[r], c);
                        dispreg(y, x, n, m_state.m_sR[r], c);
                else
                else
                        dispreg(y, x, n, m_state.m_uR[r-16], c);
                        dispreg(y, x, n, m_state.m_uR[r-16], c);
Line 305... Line 325...
        void    dbgins(const char *lbl, const int ce, const int valid,
        void    dbgins(const char *lbl, const int ce, const int valid,
                        const int gie, const int stall, const unsigned int pc,
                        const int gie, const int stall, const unsigned int pc,
                        const bool phase, const bool illegal) {
                        const bool phase, const bool illegal) {
                char    la[80], lb[80];
                char    la[80], lb[80];
 
 
                if (!dbg_fp)
                if (!m_dbgfp)
                        return;
                        return;
 
 
                if (ce)
                if (ce)
                        fprintf(dbg_fp, "%s Ck ", lbl);
                        fprintf(m_dbgfp, "%s Ck ", lbl);
                else
                else
                        fprintf(dbg_fp, "%s    ", lbl);
                        fprintf(m_dbgfp, "%s    ", lbl);
                if (stall)
                if (stall)
                        fprintf(dbg_fp, "Stl ");
                        fprintf(m_dbgfp, "Stl ");
                else
                else
                        fprintf(dbg_fp, "    ");
                        fprintf(m_dbgfp, "    ");
                fprintf(dbg_fp, "0x%08x:  ", pc);
                fprintf(m_dbgfp, "0x%08x:  ", pc);
 
 
                if (valid) {
                if (valid) {
                        zipi_to_string(m_mem[pc], la, lb);
                        zipi_to_string(m_mem[pc], la, lb);
                        if ((phase)||((m_mem[pc]&0x80000000)==0))
                        if ((phase)||((m_mem[pc]&0x80000000)==0))
                                fprintf(dbg_fp, "  %-24s", la);
                                fprintf(m_dbgfp, "  %-24s", la);
                        else
                        else
                                fprintf(dbg_fp, "  %-24s", lb);
                                fprintf(m_dbgfp, "  %-24s", lb);
                } else {
                } else {
                        fprintf(dbg_fp, "  (0x%08x)", m_mem[pc]);
                        fprintf(m_dbgfp, "  (0x%08x)", m_mem[pc]);
                } if (illegal)
                } if (illegal)
                        fprintf(dbg_fp, " (Illegal)");
                        fprintf(m_dbgfp, " (Illegal)");
                fprintf(dbg_fp, "\n");
                fprintf(m_dbgfp, "\n");
        }
        }
 
 
        void    show_state(void) {
        void    show_state(void) {
                int     ln= 0;
                int     ln= 0;
 
 
Line 783... Line 803...
                m_show_user_timers = v;
                m_show_user_timers = v;
        }
        }
 
 
        unsigned int    cmd_read(unsigned int a) {
        unsigned int    cmd_read(unsigned int a) {
                int     errcount = 0;
                int     errcount = 0;
                if (dbg_fp) {
                if (m_dbgfp) {
                        dbg_flag= true;
                        dbg_flag= true;
                        fprintf(dbg_fp, "CMD-READ(%d)\n", a);
                        fprintf(m_dbgfp, "CMD-READ(%d)\n", a);
                }
                }
                wb_write(CMD_REG, CMD_HALT|(a&0x3f));
                wb_write(CMD_REG, CMD_HALT|(a&0x3f));
                while(((wb_read(CMD_REG) & CMD_STALL) == 0)&&(errcount<MAXERR))
                while(((wb_read(CMD_REG) & CMD_STALL) == 0)&&(errcount<MAXERR))
                        errcount++;
                        errcount++;
                if (errcount >= MAXERR) {
                if (errcount >= MAXERR) {
Line 817... Line 837...
 
 
                assert(errcount < MAXERR);
                assert(errcount < MAXERR);
                unsigned int v = wb_read(CMD_DATA);
                unsigned int v = wb_read(CMD_DATA);
 
 
                if (dbg_flag)
                if (dbg_flag)
                        fprintf(dbg_fp, "CMD-READ(%d) = 0x%08x\n", a, v);
                        fprintf(m_dbgfp, "CMD-READ(%d) = 0x%08x\n", a, v);
                dbg_flag = false;
                dbg_flag = false;
                return v;
                return v;
        }
        }
 
 
        void    cmd_write(unsigned int a, int v) {
        void    cmd_write(unsigned int a, int v) {
Line 831... Line 851...
                wb_write(CMD_REG, CMD_HALT|(a&0x3f));
                wb_write(CMD_REG, CMD_HALT|(a&0x3f));
                while(((wb_read(CMD_REG) & CMD_STALL) == 0)&&(errcount < MAXERR))
                while(((wb_read(CMD_REG) & CMD_STALL) == 0)&&(errcount < MAXERR))
                        errcount++;
                        errcount++;
                assert(errcount < MAXERR);
                assert(errcount < MAXERR);
                if (dbg_flag)
                if (dbg_flag)
                        fprintf(dbg_fp, "CMD-WRITE(%d) <= 0x%08x\n", a, v);
                        fprintf(m_dbgfp, "CMD-WRITE(%d) <= 0x%08x\n", a, v);
                wb_write(CMD_DATA, v);
                wb_write(CMD_DATA, v);
        }
        }
 
 
        bool    halted(void) {
        bool    halted(void) {
                return (m_core->v__DOT__cmd_halt != 0);
                return (m_core->v__DOT__cmd_halt != 0);
Line 893... Line 913...
                }
                }
 
 
                ln++;
                ln++;
                ln++;
                ln++;
                unsigned int cc = m_state.m_sR[14];
                unsigned int cc = m_state.m_sR[14];
                if (dbg_fp) fprintf(dbg_fp, "CC = %08x, gie = %d\n", cc,
                if (m_dbgfp) fprintf(m_dbgfp, "CC = %08x, gie = %d\n", cc,
                        m_core->v__DOT__thecpu__DOT__gie);
                        m_core->v__DOT__thecpu__DOT__gie);
                gie = (cc & 0x020);
                gie = (cc & 0x020);
                if (gie)
                if (gie)
                        attroff(A_BOLD);
                        attroff(A_BOLD);
                else
                else
Line 1092... Line 1112...
                if ((m_core->o_wb_addr & (-1<<20))!=1)
                if ((m_core->o_wb_addr & (-1<<20))!=1)
                        stb = 0;
                        stb = 0;
                if ((m_core->o_wb_cyc)&&(m_core->o_wb_stb)&&(!stb))
                if ((m_core->o_wb_cyc)&&(m_core->o_wb_stb)&&(!stb))
                        m_core->i_wb_ack = 1;
                        m_core->i_wb_ack = 1;
 
 
                if ((dbg_flag)&&(dbg_fp)) {
                if ((dbg_flag)&&(m_dbgfp)) {
                        fprintf(dbg_fp, "DBG  %s %s %s @0x%08x/%d[0x%08x] %s %s [0x%08x] %s %s %s%s%s%s%s%s%s%s%s\n",
                        fprintf(m_dbgfp, "DBG  %s %s %s @0x%08x/%d[0x%08x] %s %s [0x%08x] %s %s %s%s%s%s%s%s%s%s%s\n",
                                (m_core->i_dbg_cyc)?"CYC":"   ",
                                (m_core->i_dbg_cyc)?"CYC":"   ",
                                (m_core->i_dbg_stb)?"STB":
                                (m_core->i_dbg_stb)?"STB":
                                        ((m_core->v__DOT__dbg_stb)?"DBG":"   "),
                                        ((m_core->v__DOT__dbg_stb)?"DBG":"   "),
                                ((m_core->i_dbg_we)?"WE":"  "),
                                ((m_core->i_dbg_we)?"WE":"  "),
                                (m_core->i_dbg_addr),0,
                                (m_core->i_dbg_addr),0,
Line 1114... Line 1134...
                                (m_core->v__DOT__thecpu__DOT__mem_cyc_lcl)?"LC":"  ",
                                (m_core->v__DOT__thecpu__DOT__mem_cyc_lcl)?"LC":"  ",
                                (m_core->v__DOT__thecpu__DOT__alu_wr)?"ALUW ":"",
                                (m_core->v__DOT__thecpu__DOT__alu_wr)?"ALUW ":"",
                                (m_core->v__DOT__thecpu__DOT__alu_ce)?"ALCE ":"",
                                (m_core->v__DOT__thecpu__DOT__alu_ce)?"ALCE ":"",
                                (m_core->v__DOT__thecpu__DOT__alu_valid)?"ALUV ":"",
                                (m_core->v__DOT__thecpu__DOT__alu_valid)?"ALUV ":"",
                                (m_core->v__DOT__thecpu__DOT__mem_valid)?"MEMV ":"");
                                (m_core->v__DOT__thecpu__DOT__mem_valid)?"MEMV ":"");
                        fprintf(dbg_fp, " SYS %s %s %s @0x%08x/%d[0x%08x] %s [0x%08x]\n",
                        fprintf(m_dbgfp, " SYS %s %s %s @0x%08x/%d[0x%08x] %s [0x%08x]\n",
                                (m_core->v__DOT__sys_cyc)?"CYC":"   ",
                                (m_core->v__DOT__sys_cyc)?"CYC":"   ",
                                (m_core->v__DOT__sys_stb)?"STB":"   ",
                                (m_core->v__DOT__sys_stb)?"STB":"   ",
                                (m_core->v__DOT__sys_we)?"WE":"  ",
                                (m_core->v__DOT__sys_we)?"WE":"  ",
                                (m_core->v__DOT__sys_addr),
                                (m_core->v__DOT__sys_addr),
                                (m_core->v__DOT__dbg_addr),
                                (m_core->v__DOT__dbg_addr),
                                (m_core->v__DOT__sys_data),
                                (m_core->v__DOT__sys_data),
                                (m_core->v__DOT__dbg_ack)?"ACK":"   ",
                                (m_core->v__DOT__dbg_ack)?"ACK":"   ",
                                (m_core->v__DOT__wb_data));
                                (m_core->v__DOT__wb_data));
                }
                }
 
 
                if (dbg_fp)
                if (m_dbgfp)
                        fprintf(dbg_fp, "CEs %d/0x%08x,%d/0x%08x DCD: ->%02x, OP: ->%02x, ALU: halt=%d,%d ce=%d, valid=%d, wr=%d  Reg=%02x, IPC=%08x, UPC=%08x\n",
                        fprintf(m_dbgfp, "CEs %d/0x%08x,%d/0x%08x DCD: ->%02x, OP: ->%02x, ALU: halt=%d,%d ce=%d, valid=%d, wr=%d  Reg=%02x, IPC=%08x, UPC=%08x\n",
                                dcd_ce(),
                                dcd_ce(),
                                m_core->v__DOT__thecpu__DOT__dcd_pc,
                                m_core->v__DOT__thecpu__DOT__dcd_pc,
                                op_ce(),
                                op_ce(),
                                op_pc(),
                                op_pc(),
                                dcdA()&0x01f,
                                dcdA()&0x01f,
Line 1142... Line 1162...
                                m_core->v__DOT__thecpu__DOT__alu_wr,
                                m_core->v__DOT__thecpu__DOT__alu_wr,
                                m_core->v__DOT__thecpu__DOT__alu_reg,
                                m_core->v__DOT__thecpu__DOT__alu_reg,
                                m_core->v__DOT__thecpu__DOT__ipc,
                                m_core->v__DOT__thecpu__DOT__ipc,
                                m_core->v__DOT__thecpu__DOT__upc);
                                m_core->v__DOT__thecpu__DOT__upc);
 
 
                if ((dbg_fp)&&(!gie)&&(m_core->v__DOT__thecpu__DOT__w_release_from_interrupt)) {
                if ((m_dbgfp)&&(!gie)&&(m_core->v__DOT__thecpu__DOT__w_release_from_interrupt)) {
                        fprintf(dbg_fp, "RELEASE: int=%d, %d/%02x[%08x] ?/%02x[0x%08x], ce=%d %d,%d,%d\n",
                        fprintf(m_dbgfp, "RELEASE: int=%d, %d/%02x[%08x] ?/%02x[0x%08x], ce=%d %d,%d,%d\n",
                                m_core->v__DOT__genblk9__DOT__pic__DOT__r_interrupt,
                                m_core->v__DOT__genblk9__DOT__pic__DOT__r_interrupt,
                                m_core->v__DOT__thecpu__DOT__wr_reg_ce,
                                m_core->v__DOT__thecpu__DOT__wr_reg_ce,
                                m_core->v__DOT__thecpu__DOT__wr_reg_id,
                                m_core->v__DOT__thecpu__DOT__wr_reg_id,
                                m_core->v__DOT__thecpu__DOT__wr_reg_vl,
                                m_core->v__DOT__thecpu__DOT__wr_spreg_vl,
                                m_core->v__DOT__cmd_addr,
                                m_core->v__DOT__cmd_addr,
                                m_core->v__DOT__dbg_idata,
                                m_core->v__DOT__dbg_idata,
                                m_core->v__DOT__thecpu__DOT__master_ce,
                                m_core->v__DOT__thecpu__DOT__master_ce,
                                m_core->v__DOT__thecpu__DOT__alu_wr,
                                m_core->v__DOT__thecpu__DOT__alu_wr,
                                m_core->v__DOT__thecpu__DOT__alu_valid,
                                m_core->v__DOT__thecpu__DOT__alu_valid,
                                m_core->v__DOT__thecpu__DOT__mem_valid);
                                m_core->v__DOT__thecpu__DOT__mem_valid);
                } else if ((dbg_fp)&&(gie)&&(m_core->v__DOT__thecpu__DOT__w_switch_to_interrupt)) {
                } else if ((m_dbgfp)&&(gie)&&(m_core->v__DOT__thecpu__DOT__w_switch_to_interrupt)) {
                        fprintf(dbg_fp, "SWITCH: %d/%02x[%08x] ?/%02x[0x%08x], ce=%d %d,%d,%d, F%02x,%02x\n",
                        fprintf(m_dbgfp, "SWITCH: %d/%02x[%08x] ?/%02x[0x%08x], ce=%d %d,%d,%d, F%02x,%02x\n",
                                m_core->v__DOT__thecpu__DOT__wr_reg_ce,
                                m_core->v__DOT__thecpu__DOT__wr_reg_ce,
                                m_core->v__DOT__thecpu__DOT__wr_reg_id,
                                m_core->v__DOT__thecpu__DOT__wr_reg_id,
                                m_core->v__DOT__thecpu__DOT__wr_reg_vl,
                                m_core->v__DOT__thecpu__DOT__wr_spreg_vl,
                                m_core->v__DOT__cmd_addr,
                                m_core->v__DOT__cmd_addr,
                                m_core->v__DOT__dbg_idata,
                                m_core->v__DOT__dbg_idata,
                                m_core->v__DOT__thecpu__DOT__master_ce,
                                m_core->v__DOT__thecpu__DOT__master_ce,
                                m_core->v__DOT__thecpu__DOT__alu_wr,
                                m_core->v__DOT__thecpu__DOT__alu_wr,
                                m_core->v__DOT__thecpu__DOT__alu_valid,
                                m_core->v__DOT__thecpu__DOT__alu_valid,
                                m_core->v__DOT__thecpu__DOT__mem_valid,
                                m_core->v__DOT__thecpu__DOT__mem_valid,
                                m_core->v__DOT__thecpu__DOT__w_iflags,
                                m_core->v__DOT__thecpu__DOT__w_iflags,
                                m_core->v__DOT__thecpu__DOT__w_uflags);
                                m_core->v__DOT__thecpu__DOT__w_uflags);
                        fprintf(dbg_fp, "\tbrk=%s %d,%d\n",
                        fprintf(m_dbgfp, "\tbrk=%s %d,%d\n",
                                (m_core->v__DOT__thecpu__DOT__master_ce)?"CE":"  ",
                                (m_core->v__DOT__thecpu__DOT__master_ce)?"CE":"  ",
                                m_core->v__DOT__thecpu__DOT__break_en,
                                m_core->v__DOT__thecpu__DOT__break_en,
                                m_core->v__DOT__thecpu__DOT__op_break);
                                m_core->v__DOT__thecpu__DOT__op_break);
                } else if ((dbg_fp)&&
                } else if ((m_dbgfp)&&
                                ((m_core->v__DOT__thecpu__DOT__op_break)
                                ((m_core->v__DOT__thecpu__DOT__op_break)
                                ||(m_core->v__DOT__thecpu__DOT__r_alu_illegal)
                                ||(m_core->v__DOT__thecpu__DOT__r_alu_illegal)
                                ||(m_core->v__DOT__thecpu__DOT__dcd_break))) {
                                ||(m_core->v__DOT__thecpu__DOT__dcd_break))) {
                        fprintf(dbg_fp, "NOT SWITCHING TO GIE (gie = %d)\n", gie);
                        fprintf(m_dbgfp, "NOT SWITCHING TO GIE (gie = %d)\n", gie);
                        fprintf(dbg_fp, "\tbrk=%s breaken=%d,dcdbreak=%d,opbreak=%d,alu_illegal=%d\n",
                        fprintf(m_dbgfp, "\tbrk=%s breaken=%d,dcdbreak=%d,opbreak=%d,alu_illegal=%d\n",
                                (m_core->v__DOT__thecpu__DOT__master_ce)?"CE":"  ",
                                (m_core->v__DOT__thecpu__DOT__master_ce)?"CE":"  ",
                                m_core->v__DOT__thecpu__DOT__break_en,
                                m_core->v__DOT__thecpu__DOT__break_en,
                                m_core->v__DOT__thecpu__DOT__dcd_break,
                                m_core->v__DOT__thecpu__DOT__dcd_break,
                                m_core->v__DOT__thecpu__DOT__op_break,
                                m_core->v__DOT__thecpu__DOT__op_break,
                                m_core->v__DOT__thecpu__DOT__r_alu_illegal);
                                m_core->v__DOT__thecpu__DOT__r_alu_illegal);
                }
                }
 
 
                if (dbg_fp) {
                if (m_dbgfp) {
                        if(m_core->v__DOT__thecpu__DOT__clear_pipeline)
                        if(m_core->v__DOT__thecpu__DOT__clear_pipeline)
                                fprintf(dbg_fp, "\tClear Pipeline\n");
                                fprintf(m_dbgfp, "\tClear Pipeline\n");
                        if(m_core->v__DOT__thecpu__DOT__new_pc)
                        if(m_core->v__DOT__thecpu__DOT__new_pc)
                                fprintf(dbg_fp, "\tNew PC\n");
                                fprintf(m_dbgfp, "\tNew PC\n");
                }
                }
 
 
                if (dbg_fp)
                if (m_dbgfp)
                        fprintf(dbg_fp, "-----------  TICK ----------\n");
                        fprintf(m_dbgfp, "-----------  TICK ----------\n");
                if (false) {
                if (false) {
                        m_core->i_clk = 1;
                        m_core->i_clk = 1;
                        m_mem(m_core->i_clk, m_core->o_wb_cyc, m_core->o_wb_stb, m_core->o_wb_we,
                        m_mem(m_core->i_clk, m_core->o_wb_cyc, m_core->o_wb_stb, m_core->o_wb_we,
                                m_core->o_wb_addr & ((1<<20)-1), m_core->o_wb_data,
                                m_core->o_wb_addr & ((1<<20)-1), m_core->o_wb_data,
                                m_core->i_wb_ack, m_core->i_wb_stall,m_core->i_wb_data);
                                m_core->i_wb_ack, m_core->i_wb_stall,m_core->i_wb_data);
Line 1216... Line 1236...
                                m_core->i_wb_err = 1;
                                m_core->i_wb_err = 1;
                        else
                        else
                                m_core->i_wb_err = 0;
                                m_core->i_wb_err = 0;
                        TESTB<Vzipsystem>::tick();
                        TESTB<Vzipsystem>::tick();
                }
                }
                if ((dbg_fp)&&(gie != m_core->v__DOT__thecpu__DOT__gie)) {
                if ((m_dbgfp)&&(gie != m_core->v__DOT__thecpu__DOT__gie)) {
                        fprintf(dbg_fp, "SWITCH FROM %s to %s: sPC = 0x%08x uPC = 0x%08x pf_pc = 0x%08x\n",
                        fprintf(m_dbgfp, "SWITCH FROM %s to %s: sPC = 0x%08x uPC = 0x%08x pf_pc = 0x%08x\n",
                                (gie)?"User":"Supervisor",
                                (gie)?"User":"Supervisor",
                                (gie)?"Supervisor":"User",
                                (gie)?"Supervisor":"User",
                                m_core->v__DOT__thecpu__DOT__ipc,
                                m_core->v__DOT__thecpu__DOT__ipc,
                                m_core->v__DOT__thecpu__DOT__upc,
                                m_core->v__DOT__thecpu__DOT__upc,
                                m_core->v__DOT__thecpu__DOT__pf_pc);
                                m_core->v__DOT__thecpu__DOT__pf_pc);
                } if (dbg_fp) {
                } if (m_dbgfp) {
#ifdef  OPT_TRADITIONAL_PFCACHE
#ifdef  OPT_TRADITIONAL_PFCACHE
                        fprintf(dbg_fp, "PFCACHE %s(%08x,%08x%s),%08x - %08x %s%s%s\n",
                        fprintf(m_dbgfp, "PFCACHE %s(%08x,%08x%s),%08x - %08x %s%s%s\n",
                                (m_core->v__DOT__thecpu__DOT__new_pc)?"N":" ",
                                (m_core->v__DOT__thecpu__DOT__new_pc)?"N":" ",
                                m_core->v__DOT__thecpu__DOT__pf_pc,
                                m_core->v__DOT__thecpu__DOT__pf_pc,
                                m_core->v__DOT__thecpu__DOT__instruction_decoder__DOT__genblk3__DOT__r_branch_pc,
                                m_core->v__DOT__thecpu__DOT__instruction_decoder__DOT__genblk3__DOT__r_branch_pc,
                                ((m_core->v__DOT__thecpu__DOT__instruction_decoder__DOT__genblk3__DOT__r_early_branch)
                                ((m_core->v__DOT__thecpu__DOT__instruction_decoder__DOT__genblk3__DOT__r_early_branch)
                                &&(dcdvalid())
                                &&(dcdvalid())
Line 1299... Line 1319...
#endif
#endif
                                );
                                );
 
 
                }
                }
 
 
 
                if ((m_dbgfp)&&((m_core->v__DOT__thecpu__DOT__div_valid)
 
                        ||(m_core->v__DOT__thecpu__DOT__div_ce)
 
                        ||(m_core->v__DOT__thecpu__DOT__div_busy)
 
                        )) {
 
                        fprintf(m_dbgfp, "DIV: %s %s %s %s[%2x] GP:%08x/SP:%08x %s:0x%08x\n",
 
                                (m_core->v__DOT__thecpu__DOT__div_ce)?"CE":"  ",
 
                                (m_core->v__DOT__thecpu__DOT__div_busy)?"BUSY":"    ",
 
                                (m_core->v__DOT__thecpu__DOT__div_valid)?"VALID":"     ",
 
                                (m_core->v__DOT__thecpu__DOT__wr_reg_ce)?"REG-CE":"      ",
 
                                m_core->v__DOT__thecpu__DOT__wr_reg_id,
 
                                m_core->v__DOT__thecpu__DOT__wr_gpreg_vl,
 
                                m_core->v__DOT__thecpu__DOT__wr_spreg_vl,
 
                                (m_core->v__DOT__thecpu__DOT__alu_pc_valid)?"PCV":"   ",
 
                                m_core->v__DOT__thecpu__DOT__alu_pc);
 
 
 
                        fprintf(m_dbgfp, "ALU-PC: %08x %s %s\n",
 
                                m_core->v__DOT__thecpu__DOT__alu_pc,
 
                                (m_core->v__DOT__thecpu__DOT__r_alu_pc_valid)?"VALID":"",
 
                                (m_core->v__DOT__thecpu__DOT__alu_gie)?"ALU-GIE":"");
 
                }
 
 
                if ((m_core->v__DOT__thecpu__DOT__alu_pc_valid)
                if ((m_core->v__DOT__thecpu__DOT__alu_pc_valid)
                        &&(!m_core->v__DOT__thecpu__DOT__clear_pipeline)) {
                        &&(!m_core->v__DOT__thecpu__DOT__clear_pipeline)) {
                        unsigned long iticks = m_tickcount - m_last_instruction_tickcount;
                        unsigned long iticks = m_tickcount - m_last_instruction_tickcount;
                        if (m_profile_fp) {
                        if (m_profile_fp) {
                                unsigned buf[2];
                                unsigned buf[2];
Line 1513... Line 1554...
                        m_cursor++;
                        m_cursor++;
                else    m_cursor = 0;
                else    m_cursor = 0;
        }
        }
 
 
        int     cursor(void) { return m_cursor; }
        int     cursor(void) { return m_cursor; }
 
 
 
        void    jump_to(ZIPI address) {
 
                m_core->v__DOT__thecpu__DOT__pf_pc = address;
 
                m_core->v__DOT__thecpu__DOT__clear_pipeline = 1;
 
                m_core->v__DOT__thecpu__DOT__new_pc = 1;
 
        }
 
 
 
        void    dump_state(void) {
 
                if (m_dbgfp)
 
                        dump_state(m_dbgfp);
 
        }
 
 
 
        void    dump_state(FILE *fp) {
 
                if (!fp)
 
                        return;
 
                fprintf(fp, "FINAL STATE: %s\n",
 
                        (m_state.m_gie)?"GIE(User-Mode)":"Supervisor-mode");
 
                fprintf(fp, "Supervisor Registers\n");
 
                for(int i=0; i<16; i++) {
 
                        char str[16];
 
                        if (i==13)
 
                                sprintf(str, "sSP");
 
                        else if (i==14)
 
                                sprintf(str, "sCC");
 
                        else if (i==15)
 
                                sprintf(str, "sPC");
 
                        else // if (i<=12)
 
                                sprintf(str, "s-%2d", i);
 
                        dbgreg(fp, i, str, m_state.m_sR[i]);
 
                        if ((i&3)==3)
 
                                fprintf(fp, "\n");
 
                }
 
                fprintf(fp, "User Registers\n");
 
                for(int i=0; i<16; i++) {
 
                        char str[16];
 
                        if (i==13)
 
                                sprintf(str, "uSP");
 
                        else if (i==14)
 
                                sprintf(str, "uCC");
 
                        else if (i==15)
 
                                sprintf(str, "uPC");
 
                        else // if (i<=12)
 
                                sprintf(str, "u-%2d", i);
 
                        dbgreg(fp, i, str, m_state.m_uR[i]);
 
                        if ((i&3)==3)
 
                                fprintf(fp, "\n");
 
                }
 
        }
};
};
 
 
void    get_value(ZIPPY_TB *tb) {
void    get_value(ZIPPY_TB *tb) {
        int     wy, wx, ra;
        int     wy, wx, ra;
        int     c = tb->cursor();
        int     c = tb->cursor();
Line 1636... Line 1725...
                } else
                } else
                        tb->cmd_write(ra, v);
                        tb->cmd_write(ra, v);
        }
        }
}
}
 
 
 
 
 
bool    iself(const char *fname) {
 
        FILE    *fp;
 
        bool    ret = true;
 
        fp = fopen(fname, "rb");
 
 
 
        if (!fp)        return false;
 
        if (0x7f != fgetc(fp))  ret = false;
 
        if ('E'  != fgetc(fp))  ret = false;
 
        if ('L'  != fgetc(fp))  ret = false;
 
        if ('F'  != fgetc(fp))  ret = false;
 
        fclose(fp);
 
        return  ret;
 
}
 
 
 
long    fgetwords(FILE *fp) {
 
        // Return the number of words in the current file, and return the 
 
        // file as though it had never been adjusted
 
        long    fpos, flen;
 
        fpos = ftell(fp);
 
        if (0 != fseek(fp, 0l, SEEK_END)) {
 
                fprintf(stderr, "ERR: Could not determine file size\n");
 
                perror("O/S Err:");
 
                exit(-2);
 
        } flen = ftell(fp);
 
        if (0 != fseek(fp, fpos, SEEK_SET)) {
 
                fprintf(stderr, "ERR: Could not seek on file\n");
 
                perror("O/S Err:");
 
                exit(-2);
 
        } flen /= sizeof(ZIPI);
 
        return flen;
 
}
 
 
 
class   SECTION {
 
public:
 
        unsigned        m_start, m_len;
 
        ZIPI            m_data[1];
 
};
 
 
 
SECTION **singlesection(int nwords) {
 
        fprintf(stderr, "NWORDS = %d\n", nwords);
 
        size_t  sz = (2*(sizeof(SECTION)+sizeof(SECTION *))
 
                +(nwords-1)*(sizeof(ZIPI)));
 
        char    *d = (char *)malloc(sz);
 
        SECTION **r = (SECTION **)d;
 
        memset(r, 0, sz);
 
        r[0] = (SECTION *)(&d[2*sizeof(SECTION *)]);
 
        r[0]->m_len   = nwords;
 
        r[1] = (SECTION *)(&r[0]->m_data[r[0]->m_len]);
 
        r[0]->m_start = 0;
 
        r[1]->m_start = 0;
 
        r[1]->m_len   = 0;
 
 
 
        return r;
 
}
 
 
 
SECTION **rawsection(const char *fname) {
 
        SECTION         **secpp, *secp;
 
        unsigned        num_words;
 
        FILE            *fp;
 
        int             nr;
 
 
 
        fp = fopen(fname, "r");
 
        if (fp == NULL) {
 
                fprintf(stderr, "Could not open: %s\n", fname);
 
                exit(-1);
 
        }
 
 
 
        if ((num_words=fgetwords(fp)) > MEMWORDS) {
 
                fprintf(stderr, "File overruns Block RAM\n");
 
                exit(-1);
 
        }
 
        secpp = singlesection(num_words);
 
        secp = secpp[0];
 
        secp->m_start = RAMBASE;
 
        secp->m_len = num_words;
 
        nr= fread(secp->m_data, sizeof(ZIPI), num_words, fp);
 
        if (nr != (int)num_words) {
 
                fprintf(stderr, "Could not read entire file\n");
 
                perror("O/S Err:");
 
                exit(-2);
 
        } assert(secpp[1]->m_len == 0);
 
 
 
        return secpp;
 
}
 
 
 
unsigned        byteswap(unsigned n) {
 
        unsigned        r;
 
 
 
        r = (n&0x0ff); n>>= 8;
 
        r = (r<<8) | (n&0x0ff); n>>= 8;
 
        r = (r<<8) | (n&0x0ff); n>>= 8;
 
        r = (r<<8) | (n&0x0ff); n>>= 8;
 
 
 
        return r;
 
}
 
 
 
#include <libelf.h>
 
#include <gelf.h>
 
 
 
void    elfread(const char *fname, unsigned &entry, SECTION **&sections) {
 
        Elf     *e;
 
        int     fd, i;
 
        size_t  n;
 
        char    *id;
 
        Elf_Kind        ek;
 
        GElf_Ehdr       ehdr;
 
        GElf_Phdr       phdr;
 
        const   bool    dbg = false;
 
 
 
        if (elf_version(EV_CURRENT) == EV_NONE) {
 
                fprintf(stderr, "ELF library initialization err, %s\n", elf_errmsg(-1));
 
                perror("O/S Err:");
 
                exit(EXIT_FAILURE);
 
        } if ((fd = open(fname, O_RDONLY, 0)) < 0) {
 
                fprintf(stderr, "Could not open %s\n", fname);
 
                perror("O/S Err:");
 
                exit(EXIT_FAILURE);
 
        } if ((e = elf_begin(fd, ELF_C_READ, NULL))==NULL) {
 
                fprintf(stderr, "Could not run elf_begin, %s\n", elf_errmsg(-1));
 
                exit(EXIT_FAILURE);
 
        }
 
 
 
        ek = elf_kind(e);
 
        if (ek == ELF_K_ELF) {
 
                ; // This is the kind of file we should expect
 
        } else if (ek == ELF_K_AR) {
 
                fprintf(stderr, "Cannot run an archive!\n");
 
                exit(EXIT_FAILURE);
 
        } else if (ek == ELF_K_NONE) {
 
                ;
 
        } else {
 
                fprintf(stderr, "Unexpected ELF file kind!\n");
 
                exit(EXIT_FAILURE);
 
        }
 
 
 
        if (gelf_getehdr(e, &ehdr) == NULL) {
 
                fprintf(stderr, "getehdr() failed: %s\n", elf_errmsg(-1));
 
                exit(EXIT_FAILURE);
 
        } if ((i=gelf_getclass(e)) == ELFCLASSNONE) {
 
                fprintf(stderr, "getclass() failed: %s\n", elf_errmsg(-1));
 
                exit(EXIT_FAILURE);
 
        } if ((id = elf_getident(e, NULL)) == NULL) {
 
                fprintf(stderr, "getident() failed: %s\n", elf_errmsg(-1));
 
                exit(EXIT_FAILURE);
 
        } if (i != ELFCLASS32) {
 
                fprintf(stderr, "This is a 64-bit ELF file, ZipCPU ELF files are all 32-bit\n");
 
                exit(EXIT_FAILURE);
 
        }
 
 
 
        if (dbg) {
 
        printf("    %-20s 0x%jx\n", "e_type", (uintmax_t)ehdr.e_type);
 
        printf("    %-20s 0x%jx\n", "e_machine", (uintmax_t)ehdr.e_machine);
 
        printf("    %-20s 0x%jx\n", "e_version", (uintmax_t)ehdr.e_version);
 
        printf("    %-20s 0x%jx\n", "e_entry", (uintmax_t)ehdr.e_entry);
 
        printf("    %-20s 0x%jx\n", "e_phoff", (uintmax_t)ehdr.e_phoff);
 
        printf("    %-20s 0x%jx\n", "e_shoff", (uintmax_t)ehdr.e_shoff);
 
        printf("    %-20s 0x%jx\n", "e_flags", (uintmax_t)ehdr.e_flags);
 
        printf("    %-20s 0x%jx\n", "e_ehsize", (uintmax_t)ehdr.e_ehsize);
 
        printf("    %-20s 0x%jx\n", "e_phentsize", (uintmax_t)ehdr.e_phentsize);
 
        printf("    %-20s 0x%jx\n", "e_shentsize", (uintmax_t)ehdr.e_shentsize);
 
        printf("\n");
 
        }
 
 
 
 
 
        // Check whether or not this is an ELF file for the ZipCPU ...
 
        if (ehdr.e_machine != 0x0dadd) {
 
                fprintf(stderr, "This is not a ZipCPU ELF file\n");
 
                exit(EXIT_FAILURE);
 
        }
 
 
 
        // Get our entry address
 
        entry = ehdr.e_entry;
 
 
 
 
 
        // Now, let's go look at the program header
 
        if (elf_getphdrnum(e, &n) != 0) {
 
                fprintf(stderr, "elf_getphdrnum() failed: %s\n", elf_errmsg(-1));
 
                exit(EXIT_FAILURE);
 
        }
 
 
 
        unsigned total_octets = 0, current_offset=0, current_section=0;
 
        for(i=0; i<(int)n; i++) {
 
                total_octets += sizeof(SECTION *)+sizeof(SECTION);
 
 
 
                if (gelf_getphdr(e, i, &phdr) != &phdr) {
 
                        fprintf(stderr, "getphdr() failed: %s\n", elf_errmsg(-1));
 
                        exit(EXIT_FAILURE);
 
                }
 
 
 
                if (dbg) {
 
                printf("    %-20s 0x%x\n", "p_type",   phdr.p_type);
 
                printf("    %-20s 0x%jx\n", "p_offset", phdr.p_offset);
 
                printf("    %-20s 0x%jx\n", "p_vaddr",  phdr.p_vaddr);
 
                printf("    %-20s 0x%jx\n", "p_paddr",  phdr.p_paddr);
 
                printf("    %-20s 0x%jx\n", "p_filesz", phdr.p_filesz);
 
                printf("    %-20s 0x%jx\n", "p_memsz",  phdr.p_memsz);
 
                printf("    %-20s 0x%x [", "p_flags",  phdr.p_flags);
 
 
 
                if (phdr.p_flags & PF_X)        printf(" Execute");
 
                if (phdr.p_flags & PF_R)        printf(" Read");
 
                if (phdr.p_flags & PF_W)        printf(" Write");
 
                printf("]\n");
 
                printf("    %-20s 0x%jx\n", "p_align", phdr.p_align);
 
                }
 
 
 
                total_octets += phdr.p_memsz;
 
        }
 
 
 
        char    *d = (char *)malloc(total_octets + sizeof(SECTION)+sizeof(SECTION *));
 
        memset(d, 0, total_octets);
 
 
 
        SECTION **r = sections = (SECTION **)d;
 
        current_offset = (n+1)*sizeof(SECTION *);
 
        current_section = 0;
 
 
 
        for(i=0; i<(int)n; i++) {
 
                r[i] = (SECTION *)(&d[current_offset]);
 
 
 
                if (gelf_getphdr(e, i, &phdr) != &phdr) {
 
                        fprintf(stderr, "getphdr() failed: %s\n", elf_errmsg(-1));
 
                        exit(EXIT_FAILURE);
 
                }
 
 
 
                if (dbg) {
 
                printf("    %-20s 0x%jx\n", "p_offset", phdr.p_offset);
 
                printf("    %-20s 0x%jx\n", "p_vaddr",  phdr.p_vaddr);
 
                printf("    %-20s 0x%jx\n", "p_paddr",  phdr.p_paddr);
 
                printf("    %-20s 0x%jx\n", "p_filesz", phdr.p_filesz);
 
                printf("    %-20s 0x%jx\n", "p_memsz",  phdr.p_memsz);
 
                printf("    %-20s 0x%x [", "p_flags",  phdr.p_flags);
 
 
 
                if (phdr.p_flags & PF_X)        printf(" Execute");
 
                if (phdr.p_flags & PF_R)        printf(" Read");
 
                if (phdr.p_flags & PF_W)        printf(" Write");
 
                printf("]\n");
 
 
 
                printf("    %-20s 0x%jx\n", "p_align", phdr.p_align);
 
                }
 
 
 
                current_section++;
 
 
 
                r[i]->m_start = phdr.p_vaddr;
 
                r[i]->m_len   = phdr.p_filesz/ sizeof(ZIPI);
 
 
 
                current_offset += phdr.p_memsz + sizeof(SECTION);
 
 
 
                // Now, let's read in our section ...
 
                if (lseek(fd, phdr.p_offset, SEEK_SET) < 0) {
 
                        fprintf(stderr, "Could not seek to file position %08lx\n", phdr.p_offset);
 
                        perror("O/S Err:");
 
                        exit(EXIT_FAILURE);
 
                } if (phdr.p_filesz > phdr.p_memsz)
 
                        phdr.p_filesz = 0;
 
                if (read(fd, r[i]->m_data, phdr.p_filesz) != (int)phdr.p_filesz) {
 
                        fprintf(stderr, "Didnt read entire section\n");
 
                        perror("O/S Err:");
 
                        exit(EXIT_FAILURE);
 
                }
 
 
 
                // Next, we need to byte swap it from big to little endian
 
                for(unsigned j=0; j<r[i]->m_len; j++)
 
                        r[i]->m_data[j] = byteswap(r[i]->m_data[j]);
 
 
 
                if (dbg) for(unsigned j=0; j<r[i]->m_len; j++)
 
                        fprintf(stderr, "ADR[%04x] = %08x\n", r[i]->m_start+j,
 
                        r[i]->m_data[j]);
 
        }
 
 
 
        r[i] = (SECTION *)(&d[current_offset]);
 
        r[current_section]->m_start = 0;
 
        r[current_section]->m_len   = 0;
 
 
 
        elf_end(e);
 
        close(fd);
 
}
 
 
void    usage(void) {
void    usage(void) {
        printf("USAGE: zippy_tb [-a] <testfile.out>\n");
        printf("USAGE: zippy_tb [-a] <testfile.out>\n");
        printf("\n");
        printf("\n");
        printf("\tWhere testfile.out is an output file from the assembler.\n");
        printf("\tWhere testfile.out is an output file from the assembler.\n");
        printf("\tThis file needs to be in a raw format and not an ELF\n");
        printf("\tThis file needs to be in a raw format and not an ELF\n");
Line 1672... Line 2038...
 
 
int     main(int argc, char **argv) {
int     main(int argc, char **argv) {
        Verilated::commandArgs(argc, argv);
        Verilated::commandArgs(argc, argv);
        ZIPPY_TB        *tb = new ZIPPY_TB();
        ZIPPY_TB        *tb = new ZIPPY_TB();
        bool            autorun = false, exit_on_done = false, autostep=false;
        bool            autorun = false, exit_on_done = false, autostep=false;
 
        ZIPI            entry = RAMBASE;
 
 
        // mem[0x00000] = 0xbe000010; // Halt instruction
        // mem[0x00000] = 0xbe000010; // Halt instruction
        unsigned int mptr = 0;
        unsigned int mptr = 0;
 
 
        signal(SIGINT, sigint);
        signal(SIGINT, sigint);
Line 1704... Line 2071...
                                        usage();
                                        usage();
                                        exit(-1);
                                        exit(-1);
                                        break;
                                        break;
                                }
                                }
                        } else if (access(argv[argn], R_OK)==0) {
                        } else if (access(argv[argn], R_OK)==0) {
 
                                if (iself(argv[argn])) {
 
                                        SECTION **secpp = NULL, *secp;
 
                                        elfread(argv[argn], entry, secpp);
 
                                        for(int i=0; secpp[i]->m_len; i++) {
 
                                                secp = secpp[i];
 
                                                assert(secp->m_start >= RAMBASE);
 
                                                assert(secp->m_start+secp->m_len <= RAMBASE+MEMWORDS);
 
                                                memcpy(&tb->m_mem[secp->m_start-RAMBASE],
 
                                                        &secp->m_data,
 
                                                        secp->m_len*sizeof(ZIPI));
 
                                                mptr = secp->m_start+secp->m_len;
 
                                        }
 
                                } else {
                                FILE *fp = fopen(argv[argn], "r");
                                FILE *fp = fopen(argv[argn], "r");
                                int     nr, nv = 0;
                                int     nr, nv = 0;
                                if (fp == NULL) {
                                if (fp == NULL) {
                                        printf("Cannot open %s\n", argv[argn]);
                                        printf("Cannot open %s\n", argv[argn]);
                                        perror("O/S Err: ");
                                        perror("O/S Err: ");
Line 1725... Line 2105...
                                } if (nv == 0) {
                                } if (nv == 0) {
                                        printf("Read nothing but zeros from %s\n", argv[argn]);
                                        printf("Read nothing but zeros from %s\n", argv[argn]);
                                        perror("O/S  Err?:");
                                        perror("O/S  Err?:");
                                        exit(-2);
                                        exit(-2);
                                }
                                }
 
                                }
                        } else {
                        } else {
                                fprintf(stderr, "No access to %s, or unknown arg\n", argv[argn]);
                                fprintf(stderr, "No access to %s, or unknown arg\n", argv[argn]);
                                exit(-2);
                                exit(-2);
                        }
                        }
                }
                }
Line 1743... Line 2124...
                printf("Running in non-interactive mode\n");
                printf("Running in non-interactive mode\n");
                tb->reset();
                tb->reset();
                for(int i=0; i<2; i++)
                for(int i=0; i<2; i++)
                        tb->tick();
                        tb->tick();
                tb->m_core->v__DOT__cmd_halt = 0;
                tb->m_core->v__DOT__cmd_halt = 0;
 
                tb->wb_write(CMD_REG, CMD_HALT|CMD_RESET|15);
 
                tb->wb_write(CMD_DATA, entry);
 
                tb->wb_write(CMD_REG, 15);
                while(!done) {
                while(!done) {
                        tb->tick();
                        tb->tick();
 
 
                                // tb->m_core->v__DOT__thecpu__DOT__step = 0;
                                // tb->m_core->v__DOT__thecpu__DOT__step = 0;
                                // tb->m_core->v__DOT__cmd_halt = 0;
                                // tb->m_core->v__DOT__cmd_halt = 0;
Line 1764... Line 2148...
                }
                }
        } else if (autostep) {
        } else if (autostep) {
                bool    done = false;
                bool    done = false;
 
 
                printf("Running in non-interactive mode, via step commands\n");
                printf("Running in non-interactive mode, via step commands\n");
                tb->wb_write(CMD_REG, CMD_HALT|CMD_RESET);
                tb->wb_write(CMD_REG, CMD_HALT|CMD_RESET|15);
 
                tb->wb_write(CMD_DATA, entry);
 
                tb->wb_write(CMD_REG, 15);
                while(!done) {
                while(!done) {
                        tb->wb_write(CMD_REG, CMD_STEP);
                        tb->wb_write(CMD_REG, CMD_STEP);
                        done = (tb->test_success())||(tb->test_failure());
                        done = (tb->test_success())||(tb->test_failure());
                        done = done || signalled;
                        done = done || signalled;
                }
                }
Line 1782... Line 2168...
                // for(int i=0; i<2; i++)
                // for(int i=0; i<2; i++)
                        // tb->tick();
                        // tb->tick();
                tb->m_core->v__DOT__cmd_reset = 1;
                tb->m_core->v__DOT__cmd_reset = 1;
                tb->m_core->v__DOT__cmd_halt = 0;
                tb->m_core->v__DOT__cmd_halt = 0;
 
 
                /*
                tb->jump_to(entry);
                // For debugging purposes: do we wish to skip some number of
 
                // instructions to fast forward to a time of interest??
                // For debugging purposes: do we wish to skip some number of
                for(int i=0; i<0x4d0; i++) {
                // instructions to fast forward to a time of interest??
                        tb->m_core->v__DOT__cmd_halt = 0;
                for(int i=0; i<0x3f80; i++) {
                        tb->tick();
                        tb->m_core->v__DOT__cmd_halt = 0;
                }
                        tb->tick();
                */
                }
 
 
                int     chv = 'q';
                int     chv = 'q';
 
 
                bool    done = false, halted = true, manual = true,
                bool    done = false, halted = true, manual = true,
                        high_speed = false;
                        high_speed = false;
Line 1917... Line 2303...
                        }
                        }
 
 
                        if (manual) {
                        if (manual) {
                                tb->show_state();
                                tb->show_state();
                        } else if (halted) {
                        } else if (halted) {
                                if (tb->dbg_fp)
                                if (tb->m_dbgfp)
                                        fprintf(tb->dbg_fp, "\n\nREAD-STATE ******\n");
                                        fprintf(tb->m_dbgfp, "\n\nREAD-STATE ******\n");
                                tb->read_state();
                                tb->read_state();
                        } else
                        } else
                                tb->show_state();
                                tb->show_state();
 
 
                        if (tb->m_core->i_rst)
                        if (tb->m_core->i_rst)
Line 1956... Line 2342...
                }
                }
        }
        }
#endif
#endif
 
 
        printf("\n");
        printf("\n");
 
        if (tb->test_failure()) {
 
                tb->dump_state();
 
        }
 
 
        printf("Clocks used         : %08x\n", tb->m_core->v__DOT__mtc_data);
        printf("Clocks used         : %08x\n", tb->m_core->v__DOT__mtc_data);
        printf("Instructions Issued : %08x\n", tb->m_core->v__DOT__mic_data);
        printf("Instructions Issued : %08x\n", tb->m_core->v__DOT__mic_data);
        printf("Tick Count          : %08lx\n", tb->m_tickcount);
        printf("Tick Count          : %08lx\n", tb->m_tickcount);
        if (tb->m_core->v__DOT__mtc_data != 0)
        if (tb->m_core->v__DOT__mtc_data != 0)
                printf("Instructions / Clock: %.2f\n",
                printf("Instructions / Clock: %.2f\n",

powered by: WebSVN 2.1.0

© copyright 1999-2022 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.