URL https://opencores.org/ocsvn/eco32/eco32/trunk

Subversion Repositories eco32

[/] [eco32/] [trunk/] [sim/] [command.c] - Blame information for rev 296

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * command.c -- command interpreter
 */
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>
 
#include "common.h"
#include "console.h"
#include "error.h"
#include "except.h"
#include "command.h"
#include "asm.h"
#include "disasm.h"
#include "cpu.h"
#include "trace.h"
#include "mmu.h"
#include "memory.h"
#include "timer.h"
#include "dspkbd.h"
#include "serial.h"
#include "disk.h"
#include "output.h"
#include "shutdown.h"
#include "graph.h"
 
 
#define MAX_TOKENS      10
 
 
static Bool quit;
 
 
typedef struct {
  char *name;
  void (*hlpProc)(void);
  void (*cmdProc)(char *tokens[], int n);
} Command;
 
extern Command commands[];
extern int numCommands;
 
 
static void help(void) {
  cPrintf("valid commands are:\n");
  cPrintf("  help    get help\n");
  cPrintf("  +       add and subtract\n");
  cPrintf("  a       assemble\n");
  cPrintf("  u       unassemble\n");
  cPrintf("  b       set/reset breakpoint\n");
  cPrintf("  c       continue from breakpoint\n");
  cPrintf("  s       single-step\n");
  cPrintf("  #       show/set PC\n");
  cPrintf("  p       show/set PSW\n");
  cPrintf("  r       show/set register\n");
  cPrintf("  d       dump memory\n");
  cPrintf("  mw      show/set memory word\n");
  cPrintf("  mh      show/set memory halfword\n");
  cPrintf("  mb      show/set memory byte\n");
  cPrintf("  t       show/set TLB contents\n");
  cPrintf("  l       list trace buffer\n");
  cPrintf("  i       initialize hardware\n");
  cPrintf("  q       quit simulator\n");
  cPrintf("type 'help <cmd>' to get help for <cmd>\n");
}
 
 
static void help00(void) {
  cPrintf("  help              show a list of commands\n");
  cPrintf("  help <cmd>        show help for <cmd>\n");
}
 
 
static void help01(void) {
  cPrintf("  +  <num1> <num2>  add and subtract <num1> and <num2>\n");
}
 
 
static void help02(void) {
  cPrintf("  a                 assemble starting at PC\n");
  cPrintf("  a  <addr>         assemble starting at <addr>\n");
}
 
 
static void help03(void) {
  cPrintf("  u                 unassemble 16 instrs starting at PC\n");
  cPrintf("  u  <addr>         unassemble 16 instrs starting at <addr>\n");
  cPrintf("  u  <addr> <cnt>   unassemble <cnt> instrs starting at <addr>\n");
}
 
 
static void help04(void) {
  cPrintf("  b                 reset break\n");
  cPrintf("  b  <addr>         set break at <addr>\n");
}
 
 
static void help05(void) {
  cPrintf("  c                 continue execution\n");
  cPrintf("  c  <cnt>          continue execution <cnt> times\n");
}
 
 
static void help06(void) {
  cPrintf("  s                 single-step one instruction\n");
  cPrintf("  s  <cnt>          single-step <cnt> instructions\n");
}
 
 
static void help07(void) {
  cPrintf("  #                 show PC\n");
  cPrintf("  #  <addr>         set PC to <addr>\n");
}
 
 
static void help08(void) {
  cPrintf("  p                 show PSW\n");
  cPrintf("  p  <data>         set PSW to <data>\n");
}
 
 
static void help09(void) {
  cPrintf("  r                 show all registers\n");
  cPrintf("  r  <reg>          show register <reg>\n");
  cPrintf("  r  <reg> <data>   set register <reg> to <data>\n");
}
 
 
static void help10(void) {
  cPrintf("  d                 dump 256 bytes starting at PC\n");
  cPrintf("  d  <addr>         dump 256 bytes starting at <addr>\n");
  cPrintf("  d  <addr> <cnt>   dump <cnt> bytes starting at <addr>\n");
}
 
 
static void help11(void) {
  cPrintf("  mw                show memory word at PC\n");
  cPrintf("  mw <addr>         show memory word at <addr>\n");
  cPrintf("  mw <addr> <data>  set memory word at <addr> to <data>\n");
}
 
 
static void help12(void) {
  cPrintf("  mh                show memory halfword at PC\n");
  cPrintf("  mh <addr>         show memory halfword at <addr>\n");
  cPrintf("  mh <addr> <data>  set memory halfword at <addr> to <data>\n");
}
 
 
static void help13(void) {
  cPrintf("  mb                show memory byte at PC\n");
  cPrintf("  mb <addr>         show memory byte at <addr>\n");
  cPrintf("  mb <addr> <data>  set memory byte at <addr> to <data>\n");
}
 
 
static void help14(void) {
  cPrintf("  t                 show TLB contents\n");
  cPrintf("  t  <i>            show TLB contents at <i>\n");
  cPrintf("  t  <i> p <data>   set TLB contents at <i> to page <data>\n");
  cPrintf("  t  <i> f <data>   set TLB contents at <i> to frame <data>\n");
}
 
 
static void help15(void) {
  cPrintf("  l                 list 16 trace entries starting at -16\n");
  cPrintf("  l <i>             list 16 trace entries starting at <i>\n");
  cPrintf("  l <i> <cnt>       list <cnt> trace entries starting at <i>\n");
}
 
 
static void help16(void) {
  cPrintf("  i                 initialize hardware\n");
}
 
 
static void help17(void) {
  cPrintf("  q                 quit simulator\n");
}
 
 
static Bool getHexNumber(char *str, Word *valptr) {
  char *end;
 
  *valptr = strtoul(str, &end, 16);
  return *end == '\0';
}
 
 
static Bool getDecNumber(char *str, int *valptr) {
  char *end;
 
  *valptr = strtoul(str, &end, 10);
  return *end == '\0';
}
 
 
static void showPC(void) {
  Word pc, psw;
  Word instr;
 
  pc = cpuGetPC();
  psw = cpuGetPSW();
  instr = mmuReadWord(pc, psw & PSW_UM);
  cPrintf("PC   %08X     [PC]   %08X   %s\n",
          pc, instr, disasm(instr, pc));
}
 
 
static void showBreakAndTotal(void) {
  Word brk;
  Word tot;
 
  brk = cpuGetBreak();
  tot = cpuGetTotal();
  cPrintf("Brk  ");
  if (cpuTestBreak()) {
    cPrintf("%08X", brk);
  } else {
    cPrintf("--------");
  }
  cPrintf("     Total  %08X   instructions\n", tot);
}
 
 
static void showIRQ(void) {
  Word irq;
  int i;
 
  irq = cpuGetIRQ();
  cPrintf("IRQ                            ");
  for (i = 15; i >= 0; i--) {
    cPrintf("%c", irq & (1 << i) ? '1' : '0');
  }
  cPrintf("\n");
}
 
 
static void showPSW(void) {
  Word psw;
  int i;
 
  psw = cpuGetPSW();
  cPrintf("     xxxx  V  UPO  IPO  IACK   MASK\n");
  cPrintf("PSW  ");
  for (i = 31; i >= 0; i--) {
    if (i == 27 || i == 26 || i == 23 || i == 20 || i == 15) {
      cPrintf("  ");
    }
    cPrintf("%c", psw & (1 << i) ? '1' : '0');
  }
  cPrintf("\n");
}
 
 
static void doHelp(char *tokens[], int n) {
  int i;
 
  if (n == 1) {
    help();
  } else if (n == 2) {
    for (i = 0; i < numCommands; i++) {
      if (strcmp(commands[i].name, tokens[1]) == 0) {
        (*commands[i].hlpProc)();
        return;
      }
    }
    cPrintf("no help available for '%s', sorry\n", tokens[1]);
  } else {
    help00();
  }
}
 
 
static void doArith(char *tokens[], int n) {
  Word num1, num2, num3, num4;
 
  if (n == 3) {
    if (!getHexNumber(tokens[1], &num1)) {
      cPrintf("illegal first number\n");
      return;
    }
    if (!getHexNumber(tokens[2], &num2)) {
      cPrintf("illegal second number\n");
      return;
    }
    num3 = num1 + num2;
    num4 = num1 - num2;
    cPrintf("add = %08X, sub = %08X\n", num3, num4);
  } else {
    help01();
  }
}
 
 
static void doAssemble(char *tokens[], int n) {
  Word addr;
  Word psw;
  char prompt[30];
  char *line;
  char *msg;
  Word instr;
 
  if (n == 1) {
    addr = cpuGetPC();
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
  } else {
    help02();
    return;
  }
  addr &= ~0x00000003;
  psw = cpuGetPSW();
  while (1) {
    sprintf(prompt, "ASM # %08X: ", addr);
    line = cGetLine(prompt);
    if (*line == '\0' || *line == '\n') {
      break;
    }
    cAddHist(line);
    msg = asmInstr(line, addr, &instr);
    if (msg != NULL) {
      cPrintf("%s\n", msg);
    } else {
      mmuWriteWord(addr, instr, psw & PSW_UM);
      addr += 4;
    }
  }
}
 
 
static void doUnassemble(char *tokens[], int n) {
  Word addr, count;
  Word psw;
  int i;
  Word instr;
 
  if (n == 1) {
    addr = cpuGetPC();
    count = 16;
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    count = 16;
  } else if (n == 3) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    if (!getHexNumber(tokens[2], &count)) {
      cPrintf("illegal count\n");
      return;
    }
    if (count == 0) {
      return;
    }
  } else {
    help03();
    return;
  }
  addr &= ~0x00000003;
  psw = cpuGetPSW();
  for (i = 0; i < count; i++) {
    instr = mmuReadWord(addr, psw & PSW_UM);
    cPrintf("%08X:  %08X    %s\n",
            addr, instr, disasm(instr, addr));
    if (addr + 4 < addr) {
      /* wrap-around */
      break;
    }
    addr += 4;
  }
}
 
 
static void doBreak(char *tokens[], int n) {
  Word addr;
 
  if (n == 1) {
    cpuResetBreak();
    showBreakAndTotal();
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    addr &= ~0x00000003;
    cpuSetBreak(addr);
    showBreakAndTotal();
  } else {
    help04();
  }
}
 
 
static void doContinue(char *tokens[], int n) {
  Word count, i;
  Word addr;
 
  if (n == 1) {
    count = 1;
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &count) || count == 0) {
      cPrintf("illegal count\n");
      return;
    }
  } else {
    help05();
    return;
  }
  cPrintf("CPU is running, press ^C to interrupt...\n");
  for (i = 0; i < count; i++) {
    cpuRun();
  }
  addr = cpuGetPC();
  cPrintf("Break at %08X\n", addr);
  showPC();
}
 
 
static void doStep(char *tokens[], int n) {
  Word count, i;
 
  if (n == 1) {
    count = 1;
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &count) || count == 0) {
      cPrintf("illegal count\n");
      return;
    }
  } else {
    help06();
    return;
  }
  for (i = 0; i < count; i++) {
    cpuStep();
  }
  showPC();
}
 
 
static void doPC(char *tokens[], int n) {
  Word addr;
 
  if (n == 1) {
    showPC();
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    addr &= ~0x00000003;
    cpuSetPC(addr);
    showPC();
  } else {
    help07();
  }
}
 
 
static void explainPSW(Word data) {
  int i;
 
  cPrintf("interrupt vector                   : %s (%s)\n",
          data & PSW_V ? "on " : "off",
          data & PSW_V ? "RAM" : "ROM");
  cPrintf("current user mode                  : %s (%s)\n",
          data & PSW_UM ? "on " : "off",
          data & PSW_UM ? "user" : "kernel");
  cPrintf("previous user mode                 : %s (%s)\n",
          data & PSW_PUM ? "on " : "off",
          data & PSW_PUM ? "user" : "kernel");
  cPrintf("old user mode                      : %s (%s)\n",
          data & PSW_OUM ? "on " : "off",
          data & PSW_OUM ? "user" : "kernel");
  cPrintf("current interrupt enable           : %s (%s)\n",
          data & PSW_IE ? "on " : "off",
          data & PSW_IE ? "enabled" : "disabled");
  cPrintf("previous interrupt enable          : %s (%s)\n",
          data & PSW_PIE ? "on " : "off",
          data & PSW_PIE ? "enabled" : "disabled");
  cPrintf("old interrupt enable               : %s (%s)\n",
          data & PSW_OIE ? "on " : "off",
          data & PSW_OIE ? "enabled" : "disabled");
  cPrintf("last interrupt acknowledged        : %02d  (%s)\n",
          (data & PSW_PRIO_MASK) >> 16,
          exceptionToString((data & PSW_PRIO_MASK) >> 16));
  for (i = 15; i >= 0; i--) {
    cPrintf("%-35s: %s (%s)\n",
            exceptionToString(i),
            data & (1 << i) ? "on " : "off",
            data & (1 << i) ? "enabled" : "disabled");
  }
}
 
 
static void doPSW(char *tokens[], int n) {
  Word data;
 
  if (n == 1) {
    data = cpuGetPSW();
    showPSW();
    showIRQ();
    explainPSW(data);
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &data)) {
      cPrintf("illegal data\n");
      return;
    }
    data &= 0x0FFFFFFF;
    cpuSetPSW(data);
    showPSW();
    showIRQ();
    explainPSW(data);
  } else {
    help08();
  }
}
 
 
static void doRegister(char *tokens[], int n) {
  int i, j;
  int reg;
  Word data;
 
  if (n == 1) {
    for (i = 0; i < 8; i++) {
      for (j = 0; j < 4; j++) {
        reg = 8 * j + i;
        data = cpuGetReg(reg);
        cPrintf("$%-2d  %08X     ", reg, data);
      }
      cPrintf("\n");
    }
    showPSW();
    showIRQ();
    showBreakAndTotal();
    showPC();
  } else if (n == 2) {
    if (!getDecNumber(tokens[1], &reg) || reg < 0 || reg >= 32) {
      cPrintf("illegal register number\n");
      return;
    }
    data = cpuGetReg(reg);
    cPrintf("$%-2d  %08X\n", reg, data);
  } else if (n == 3) {
    if (!getDecNumber(tokens[1], &reg) || reg < 0 || reg >= 32) {
      cPrintf("illegal register number\n");
      return;
    }
    if (!getHexNumber(tokens[2], &data)) {
      cPrintf("illegal data\n");
      return;
    }
    cpuSetReg(reg, data);
  } else {
    help09();
  }
}
 
 
static void doDump(char *tokens[], int n) {
  Word addr, count;
  Word psw;
  Word lo, hi, curr;
  int lines, i, j;
  Word tmp;
  Byte c;
 
  if (n == 1) {
    addr = cpuGetPC();
    count = 16 * 16;
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    count = 16 * 16;
  } else if (n == 3) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    if (!getHexNumber(tokens[2], &count)) {
      cPrintf("illegal count\n");
      return;
    }
    if (count == 0) {
      return;
    }
  } else {
    help10();
    return;
  }
  psw = cpuGetPSW();
  lo = addr & ~0x0000000F;
  hi = addr + count - 1;
  if (hi < lo) {
    /* wrap-around */
    hi = 0xFFFFFFFF;
  }
  lines = (hi - lo + 16) >> 4;
  curr = lo;
  for (i = 0; i < lines; i++) {
    cPrintf("%08X:  ", curr);
    for (j = 0; j < 16; j++) {
      tmp = curr + j;
      if (tmp < addr || tmp > hi) {
        cPrintf("  ");
      } else {
        c = mmuReadByte(tmp, psw & PSW_UM);
        cPrintf("%02X", c);
      }
      cPrintf(" ");
    }
    cPrintf("  ");
    for (j = 0; j < 16; j++) {
      tmp = curr + j;
      if (tmp < addr || tmp > hi) {
        cPrintf(" ");
      } else {
        c = mmuReadByte(tmp, psw & PSW_UM);
        if (c >= 32 && c <= 126) {
          cPrintf("%c", c);
        } else {
          cPrintf(".");
        }
      }
    }
    cPrintf("\n");
    curr += 16;
  }
}
 
 
static void doMemoryWord(char *tokens[], int n) {
  Word psw;
  Word addr;
  Word data;
  Word tmpData;
 
  psw = cpuGetPSW();
  if (n == 1) {
    addr = cpuGetPC();
    data = mmuReadWord(addr, psw & PSW_UM);
    cPrintf("%08X:  %08X\n", addr, data);
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    data = mmuReadWord(addr, psw & PSW_UM);
    cPrintf("%08X:  %08X\n", addr, data);
  } else if (n == 3) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    if (!getHexNumber(tokens[2], &tmpData)) {
      cPrintf("illegal data\n");
      return;
    }
    data = tmpData;
    mmuWriteWord(addr, data, psw & PSW_UM);
  } else {
    help11();
  }
}
 
 
static void doMemoryHalf(char *tokens[], int n) {
  Word psw;
  Word addr;
  Half data;
  Word tmpData;
 
  psw = cpuGetPSW();
  if (n == 1) {
    addr = cpuGetPC();
    data = mmuReadHalf(addr, psw & PSW_UM);
    cPrintf("%08X:  %04X\n", addr, data);
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    data = mmuReadHalf(addr, psw & PSW_UM);
    cPrintf("%08X:  %04X\n", addr, data);
  } else if (n == 3) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    if (!getHexNumber(tokens[2], &tmpData)) {
      cPrintf("illegal data\n");
      return;
    }
    data = (Half) tmpData;
    mmuWriteHalf(addr, data, psw & PSW_UM);
  } else {
    help12();
  }
}
 
 
static void doMemoryByte(char *tokens[], int n) {
  Word psw;
  Word addr;
  Byte data;
  Word tmpData;
 
  psw = cpuGetPSW();
  if (n == 1) {
    addr = cpuGetPC();
    data = mmuReadByte(addr, psw & PSW_UM);
    cPrintf("%08X:  %02X\n", addr, data);
  } else if (n == 2) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    data = mmuReadByte(addr, psw & PSW_UM);
    cPrintf("%08X:  %02X\n", addr, data);
  } else if (n == 3) {
    if (!getHexNumber(tokens[1], &addr)) {
      cPrintf("illegal address\n");
      return;
    }
    if (!getHexNumber(tokens[2], &tmpData)) {
      cPrintf("illegal data\n");
      return;
    }
    data = (Byte) tmpData;
    mmuWriteByte(addr, data, psw & PSW_UM);
  } else {
    help13();
  }
}
 
 
static void doTLB(char *tokens[], int n) {
  static char *mmuAccsWidth[4] = { "byte", "half", "word", "????" };
  int index;
  TLB_Entry tlbEntry;
  Word mmuAccs;
  Word data;
 
  if (n == 1) {
    for (index = 0; index < TLB_SIZE; index++) {
      tlbEntry = mmuGetTLB(index);
      cPrintf("TLB[%02d]    page  %08X    frame  %08X  %c  %c\n",
              index, tlbEntry.page, tlbEntry.frame,
              tlbEntry.write ? 'w' : '-',
              tlbEntry.valid ? 'v' : '-');
    }
    cPrintf("Index   (1)  %08X\n", mmuGetIndex());
    cPrintf("EntryHi (2)  %08X\n", mmuGetEntryHi());
    cPrintf("EntryLo (3)  %08X\n", mmuGetEntryLo());
    cPrintf("BadAddr (4)  %08X\n", mmuGetBadAddr());
    mmuAccs = mmuGetBadAccs();
    cPrintf("BadAccs (5)  %08X (%s %s)\n",
            mmuAccs,
            (mmuAccs & MMU_ACCS_WRITE) ? "write" : "read",
            mmuAccsWidth[mmuAccs & 0x03]);
  } else if (n == 2) {
    if (!getDecNumber(tokens[1], &index) || index < 0 || index >= TLB_SIZE) {
      cPrintf("illegal TLB index\n");
      return;
    }
    tlbEntry = mmuGetTLB(index);
    cPrintf("TLB[%02d]    page  %08X    frame  %08X  %c  %c\n",
            index, tlbEntry.page, tlbEntry.frame,
            tlbEntry.write ? 'w' : '-',
            tlbEntry.valid ? 'v' : '-');
  } else if (n == 3) {
    help14();
  } else if (n == 4) {
    if (!getDecNumber(tokens[1], &index) || index < 0 || index >= TLB_SIZE) {
      cPrintf("illegal TLB index\n");
      return;
    }
    if (!getHexNumber(tokens[3], &data)) {
      cPrintf("illegal data\n");
      return;
    }
    tlbEntry = mmuGetTLB(index);
    if (strcmp(tokens[2], "p") == 0) {
      tlbEntry.page = data & PAGE_MASK;
    } else
    if (strcmp(tokens[2], "f") == 0) {
      tlbEntry.frame = data & FRAME_MASK;
      tlbEntry.write = data & TLB_WRITE ? true : false;
      tlbEntry.valid = data & TLB_VALID ? true : false;
    } else {
      cPrintf("TLB selector is not one of 'p' or 'f'\n");
      return;
    }
    mmuSetTLB(index, tlbEntry);
    cPrintf("TLB[%02d]    page  %08X    frame  %08X  %c  %c\n",
            index, tlbEntry.page, tlbEntry.frame,
            tlbEntry.write ? 'w' : '-',
            tlbEntry.valid ? 'v' : '-');
  } else {
    help14();
  }
}
 
 
static void doList(char *tokens[], int n) {
  int start, count, stop;
  int back;
 
  if (n == 1) {
    start = 16;
    count = 16;
  } else if (n == 2) {
    if (!getDecNumber(tokens[1], &start) || start >= 0) {
      cPrintf("illegal trace buffer index (must be < 0)\n");
      return;
    }
    start = -start;
    count = 16;
  } else if (n == 3) {
    if (!getDecNumber(tokens[1], &start) || start >= 0) {
      cPrintf("illegal trace buffer index (must be < 0)\n");
      return;
    }
    start = -start;
    if (!getDecNumber(tokens[2], &count) || count <= 0) {
      cPrintf("illegal trace buffer count (must be > 0)\n");
      return;
    }
  } else {
    help15();
    return;
  }
  if (start > TRACE_BUF_SIZE) {
    start = TRACE_BUF_SIZE;
  }
  stop = start - count;
  if (stop < 0) {
    stop = 0;
  }
  for (back = start; back > stop; back--) {
    cPrintf("trace[%5d]:  %s\n", -back, traceShow(back));
  }
}
 
 
static void doInit(char *tokens[], int n) {
  if (n == 1) {
    timerReset();
    displayReset();
    keyboardReset();
    serialReset();
    diskReset();
    outputReset();
    shutdownReset();
    graphReset();
    memoryReset();
    mmuReset();
    cpuReset();
  } else {
    help16();
  }
}
 
 
static void doQuit(char *tokens[], int n) {
  if (n == 1) {
    quit = true;
  } else {
    help17();
  }
}
 
 
Command commands[] = {
  { "help", help00, doHelp       },
  { "+",    help01, doArith      },
  { "a",    help02, doAssemble   },
  { "u",    help03, doUnassemble },
  { "b",    help04, doBreak      },
  { "c",    help05, doContinue   },
  { "s",    help06, doStep       },
  { "#",    help07, doPC         },
  { "p",    help08, doPSW        },
  { "r",    help09, doRegister   },
  { "d",    help10, doDump       },
  { "mw",   help11, doMemoryWord },
  { "mh",   help12, doMemoryHalf },
  { "mb",   help13, doMemoryByte },
  { "t",    help14, doTLB        },
  { "l",    help15, doList       },
  { "i",    help16, doInit       },
  { "q",    help17, doQuit       },
};
 
int numCommands = sizeof(commands) / sizeof(commands[0]);
 
 
static Bool doCommand(char *line) {
  char *tokens[MAX_TOKENS];
  int n;
  char *p;
  int i;
 
  n = 0;
  p = strtok(line, " \t\n");
  while (p != NULL) {
    if (n == MAX_TOKENS) {
      cPrintf("too many tokens on line\n");
      return false;
    }
    tokens[n++] = p;
    p = strtok(NULL, " \t\n");
  }
  if (n == 0) {
    return false;
  }
  quit = false;
  for (i = 0; i < sizeof(commands)/sizeof(commands[0]); i++) {
    if (strcmp(commands[i].name, tokens[0]) == 0) {
      (*commands[i].cmdProc)(tokens, n);
      return quit;
    }
  }
  help();
  return false;
}
 
 
static char *article(char firstLetterOfNoun) {
  switch (firstLetterOfNoun) {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
      return "An";
    default:
      return "A";
  }
}
 
 
static void interactiveException(int exception) {
  char *what;
 
  what = exceptionToString(exception);
  cPrintf("\n");
  cPrintf("NOTE: %s %s occurred while executing the command.\n",
          article(*what), what);
  cPrintf("      This event will not alter the state of the CPU.\n");
}
 
 
Bool execCommand(char *line) {
  jmp_buf myEnvironment;
  int exception;
  Bool quit;
 
  exception = setjmp(myEnvironment);
  if (exception == 0) {
    /* initialization */
    pushEnvironment(&myEnvironment);
    quit = doCommand(line);
  } else {
    /* an exception was thrown */
    interactiveException(exception);
    quit = false;
  }
  popEnvironment();
  return quit;
}

Line No.	Rev	Author	Line
1	8	hellwig	`/*`
2			`* command.c -- command interpreter`
3			`*/`
4
5
6			`#include <stdio.h>`
7			`#include <stdlib.h>`
8			`#include <string.h>`
9			`#include <setjmp.h>`
10
11			`#include "common.h"`
12			`#include "console.h"`
13			`#include "error.h"`
14			`#include "except.h"`
15			`#include "command.h"`
16			`#include "asm.h"`
17			`#include "disasm.h"`
18			`#include "cpu.h"`
19	275	hellwig	`#include "trace.h"`
20	8	hellwig	`#include "mmu.h"`
21			`#include "memory.h"`
22			`#include "timer.h"`
23			`#include "dspkbd.h"`
24	246	hellwig	`#include "serial.h"`
25	8	hellwig	`#include "disk.h"`
26	25	hellwig	`#include "output.h"`
27			`#include "shutdown.h"`
28	8	hellwig	`#include "graph.h"`
29
30
31			`#define MAX_TOKENS 10`
32
33
34			`static Bool quit;`
35
36
37	82	hellwig	`typedef struct {`
38			`char *name;`
39			`void (*hlpProc)(void);`
40			`void (cmdProc)(char tokens[], int n);`
41			`} Command;`
42
43			`extern Command commands[];`
44			`extern int numCommands;`
45
46
47	8	hellwig	`static void help(void) {`
48			`cPrintf("valid commands are:\n");`
49	82	hellwig	`cPrintf(" help get help\n");`
50			`cPrintf(" + add and subtract\n");`
51			`cPrintf(" a assemble\n");`
52			`cPrintf(" u unassemble\n");`
53			`cPrintf(" b set/reset breakpoint\n");`
54			`cPrintf(" c continue from breakpoint\n");`
55			`cPrintf(" s single-step\n");`
56			`cPrintf(" # show/set PC\n");`
57			`cPrintf(" p show/set PSW\n");`
58			`cPrintf(" r show/set register\n");`
59			`cPrintf(" d dump memory\n");`
60			`cPrintf(" mw show/set memory word\n");`
61			`cPrintf(" mh show/set memory halfword\n");`
62			`cPrintf(" mb show/set memory byte\n");`
63			`cPrintf(" t show/set TLB contents\n");`
64	275	hellwig	`cPrintf(" l list trace buffer\n");`
65	82	hellwig	`cPrintf(" i initialize hardware\n");`
66			`cPrintf(" q quit simulator\n");`
67			`cPrintf("type 'help <cmd>' to get help for <cmd>\n");`
68			`}`
69
70
71			`static void help00(void) {`
72			`cPrintf(" help show a list of commands\n");`
73			`cPrintf(" help <cmd> show help for <cmd>\n");`
74			`}`
75
76
77			`static void help01(void) {`
78	8	hellwig	`cPrintf(" + <num1> <num2> add and subtract <num1> and <num2>\n");`
79	82	hellwig	`}`
80
81
82			`static void help02(void) {`
83	8	hellwig	`cPrintf(" a assemble starting at PC\n");`
84			`cPrintf(" a <addr> assemble starting at <addr>\n");`
85	82	hellwig	`}`
86
87
88			`static void help03(void) {`
89	8	hellwig	`cPrintf(" u unassemble 16 instrs starting at PC\n");`
90			`cPrintf(" u <addr> unassemble 16 instrs starting at <addr>\n");`
91			`cPrintf(" u <addr> <cnt> unassemble <cnt> instrs starting at <addr>\n");`
92	82	hellwig	`}`
93
94
95			`static void help04(void) {`
96	8	hellwig	`cPrintf(" b reset break\n");`
97			`cPrintf(" b <addr> set break at <addr>\n");`
98	82	hellwig	`}`
99
100
101			`static void help05(void) {`
102	8	hellwig	`cPrintf(" c continue execution\n");`
103			`cPrintf(" c <cnt> continue execution <cnt> times\n");`
104	82	hellwig	`}`
105
106
107			`static void help06(void) {`
108	8	hellwig	`cPrintf(" s single-step one instruction\n");`
109			`cPrintf(" s <cnt> single-step <cnt> instructions\n");`
110	82	hellwig	`}`
111
112
113			`static void help07(void) {`
114			`cPrintf(" # show PC\n");`
115			`cPrintf(" # <addr> set PC to <addr>\n");`
116			`}`
117
118
119			`static void help08(void) {`
120	8	hellwig	`cPrintf(" p show PSW\n");`
121			`cPrintf(" p <data> set PSW to <data>\n");`
122	82	hellwig	`}`
123
124
125			`static void help09(void) {`
126	8	hellwig	`cPrintf(" r show all registers\n");`
127			`cPrintf(" r <reg> show register <reg>\n");`
128			`cPrintf(" r <reg> <data> set register <reg> to <data>\n");`
129	82	hellwig	`}`
130
131
132			`static void help10(void) {`
133	8	hellwig	`cPrintf(" d dump 256 bytes starting at PC\n");`
134			`cPrintf(" d <addr> dump 256 bytes starting at <addr>\n");`
135			`cPrintf(" d <addr> <cnt> dump <cnt> bytes starting at <addr>\n");`
136	82	hellwig	`}`
137
138
139			`static void help11(void) {`
140	8	hellwig	`cPrintf(" mw show memory word at PC\n");`
141			`cPrintf(" mw <addr> show memory word at <addr>\n");`
142			`cPrintf(" mw <addr> <data> set memory word at <addr> to <data>\n");`
143	82	hellwig	`}`
144
145
146			`static void help12(void) {`
147	8	hellwig	`cPrintf(" mh show memory halfword at PC\n");`
148			`cPrintf(" mh <addr> show memory halfword at <addr>\n");`
149			`cPrintf(" mh <addr> <data> set memory halfword at <addr> to <data>\n");`
150	82	hellwig	`}`
151
152
153			`static void help13(void) {`
154	8	hellwig	`cPrintf(" mb show memory byte at PC\n");`
155			`cPrintf(" mb <addr> show memory byte at <addr>\n");`
156			`cPrintf(" mb <addr> <data> set memory byte at <addr> to <data>\n");`
157	82	hellwig	`}`
158
159
160			`static void help14(void) {`
161	8	hellwig	`cPrintf(" t show TLB contents\n");`
162			`cPrintf(" t <i> show TLB contents at <i>\n");`
163			`cPrintf(" t <i> p <data> set TLB contents at <i> to page <data>\n");`
164			`cPrintf(" t <i> f <data> set TLB contents at <i> to frame <data>\n");`
165	82	hellwig	`}`
166
167
168			`static void help15(void) {`
169	275	hellwig	`cPrintf(" l list 16 trace entries starting at -16\n");`
170			`cPrintf(" l <i> list 16 trace entries starting at <i>\n");`
171			`cPrintf(" l <i> <cnt> list <cnt> trace entries starting at <i>\n");`
172	82	hellwig	`}`
173
174
175			`static void help16(void) {`
176	275	hellwig	`cPrintf(" i initialize hardware\n");`
177	8	hellwig	`}`
178
179
180	275	hellwig	`static void help17(void) {`
181			`cPrintf(" q quit simulator\n");`
182	8	hellwig	`}`
183
184
185			`static Bool getHexNumber(char str, Word valptr) {`
186			`char *end;`
187
188			`*valptr = strtoul(str, &end, 16);`
189			`return *end == '\0';`
190			`}`
191
192
193			`static Bool getDecNumber(char str, int valptr) {`
194			`char *end;`
195
196			`*valptr = strtoul(str, &end, 10);`
197			`return *end == '\0';`
198			`}`
199
200
201			`static void showPC(void) {`
202			`Word pc, psw;`
203			`Word instr;`
204
205			`pc = cpuGetPC();`
206			`psw = cpuGetPSW();`
207			`instr = mmuReadWord(pc, psw & PSW_UM);`
208			`cPrintf("PC %08X [PC] %08X %s\n",`
209			`pc, instr, disasm(instr, pc));`
210			`}`
211
212
213			`static void showBreakAndTotal(void) {`
214			`Word brk;`
215			`Word tot;`
216
217			`brk = cpuGetBreak();`
218			`tot = cpuGetTotal();`
219			`cPrintf("Brk ");`
220			`if (cpuTestBreak()) {`
221			`cPrintf("%08X", brk);`
222			`} else {`
223			`cPrintf("--------");`
224			`}`
225			`cPrintf(" Total %08X instructions\n", tot);`
226			`}`
227
228
229			`static void showIRQ(void) {`
230			`Word irq;`
231			`int i;`
232
233			`irq = cpuGetIRQ();`
234			`cPrintf("IRQ ");`
235			`for (i = 15; i >= 0; i--) {`
236			`cPrintf("%c", irq & (1 << i) ? '1' : '0');`
237			`}`
238			`cPrintf("\n");`
239			`}`
240
241
242			`static void showPSW(void) {`
243			`Word psw;`
244			`int i;`
245
246			`psw = cpuGetPSW();`
247			`cPrintf(" xxxx V UPO IPO IACK MASK\n");`
248			`cPrintf("PSW ");`
249			`for (i = 31; i >= 0; i--) {`
250			`if (i == 27 \|\| i == 26 \|\| i == 23 \|\| i == 20 \|\| i == 15) {`
251			`cPrintf(" ");`
252			`}`
253			`cPrintf("%c", psw & (1 << i) ? '1' : '0');`
254			`}`
255			`cPrintf("\n");`
256			`}`
257
258
259	82	hellwig	`static void doHelp(char *tokens[], int n) {`
260			`int i;`
261
262			`if (n == 1) {`
263			`help();`
264			`} else if (n == 2) {`
265			`for (i = 0; i < numCommands; i++) {`
266			`if (strcmp(commands[i].name, tokens[1]) == 0) {`
267			`(*commands[i].hlpProc)();`
268			`return;`
269			`}`
270			`}`
271			`cPrintf("no help available for '%s', sorry\n", tokens[1]);`
272			`} else {`
273			`help00();`
274			`}`
275			`}`
276
277
278	8	hellwig	`static void doArith(char *tokens[], int n) {`
279			`Word num1, num2, num3, num4;`
280
281			`if (n == 3) {`
282			`if (!getHexNumber(tokens[1], &num1)) {`
283			`cPrintf("illegal first number\n");`
284			`return;`
285			`}`
286			`if (!getHexNumber(tokens[2], &num2)) {`
287			`cPrintf("illegal second number\n");`
288			`return;`
289			`}`
290			`num3 = num1 + num2;`
291			`num4 = num1 - num2;`
292			`cPrintf("add = %08X, sub = %08X\n", num3, num4);`
293			`} else {`
294	83	hellwig	`help01();`
295	8	hellwig	`}`
296			`}`
297
298
299			`static void doAssemble(char *tokens[], int n) {`
300			`Word addr;`
301			`Word psw;`
302			`char prompt[30];`
303			`char *line;`
304			`char *msg;`
305			`Word instr;`
306
307			`if (n == 1) {`
308			`addr = cpuGetPC();`
309			`} else if (n == 2) {`
310			`if (!getHexNumber(tokens[1], &addr)) {`
311			`cPrintf("illegal address\n");`
312			`return;`
313			`}`
314			`} else {`
315	83	hellwig	`help02();`
316	8	hellwig	`return;`
317			`}`
318			`addr &= ~0x00000003;`
319			`psw = cpuGetPSW();`
320			`while (1) {`
321	82	hellwig	`sprintf(prompt, "ASM # %08X: ", addr);`
322	8	hellwig	`line = cGetLine(prompt);`
323			`if (line == '\0' \|\| line == '\n') {`
324			`break;`
325			`}`
326			`cAddHist(line);`
327			`msg = asmInstr(line, addr, &instr);`
328			`if (msg != NULL) {`
329			`cPrintf("%s\n", msg);`
330			`} else {`
331			`mmuWriteWord(addr, instr, psw & PSW_UM);`
332			`addr += 4;`
333			`}`
334			`}`
335			`}`
336
337
338			`static void doUnassemble(char *tokens[], int n) {`
339			`Word addr, count;`
340			`Word psw;`
341			`int i;`
342			`Word instr;`
343
344			`if (n == 1) {`
345			`addr = cpuGetPC();`
346			`count = 16;`
347			`} else if (n == 2) {`
348			`if (!getHexNumber(tokens[1], &addr)) {`
349			`cPrintf("illegal address\n");`
350			`return;`
351			`}`
352			`count = 16;`
353			`} else if (n == 3) {`
354			`if (!getHexNumber(tokens[1], &addr)) {`
355			`cPrintf("illegal address\n");`
356			`return;`
357			`}`
358			`if (!getHexNumber(tokens[2], &count)) {`
359			`cPrintf("illegal count\n");`
360			`return;`
361			`}`
362			`if (count == 0) {`
363			`return;`
364			`}`
365			`} else {`
366	83	hellwig	`help03();`
367	8	hellwig	`return;`
368			`}`
369			`addr &= ~0x00000003;`
370			`psw = cpuGetPSW();`
371			`for (i = 0; i < count; i++) {`
372			`instr = mmuReadWord(addr, psw & PSW_UM);`
373			`cPrintf("%08X: %08X %s\n",`
374			`addr, instr, disasm(instr, addr));`
375			`if (addr + 4 < addr) {`
376			`/* wrap-around */`
377			`break;`
378			`}`
379			`addr += 4;`
380			`}`
381			`}`
382
383
384			`static void doBreak(char *tokens[], int n) {`
385			`Word addr;`
386
387			`if (n == 1) {`
388			`cpuResetBreak();`
389			`showBreakAndTotal();`
390			`} else if (n == 2) {`
391			`if (!getHexNumber(tokens[1], &addr)) {`
392			`cPrintf("illegal address\n");`
393			`return;`
394			`}`
395			`addr &= ~0x00000003;`
396			`cpuSetBreak(addr);`
397			`showBreakAndTotal();`
398			`} else {`
399	83	hellwig	`help04();`
400	8	hellwig	`}`
401			`}`
402
403
404			`static void doContinue(char *tokens[], int n) {`
405			`Word count, i;`
406			`Word addr;`
407
408			`if (n == 1) {`
409			`count = 1;`
410			`} else if (n == 2) {`
411			`if (!getHexNumber(tokens[1], &count) \|\| count == 0) {`
412			`cPrintf("illegal count\n");`
413			`return;`
414			`}`
415			`} else {`
416	83	hellwig	`help05();`
417	8	hellwig	`return;`
418			`}`
419			`cPrintf("CPU is running, press ^C to interrupt...\n");`
420			`for (i = 0; i < count; i++) {`
421			`cpuRun();`
422			`}`
423			`addr = cpuGetPC();`
424			`cPrintf("Break at %08X\n", addr);`
425			`showPC();`
426			`}`
427
428
429			`static void doStep(char *tokens[], int n) {`
430			`Word count, i;`
431
432			`if (n == 1) {`
433			`count = 1;`
434			`} else if (n == 2) {`
435			`if (!getHexNumber(tokens[1], &count) \|\| count == 0) {`
436			`cPrintf("illegal count\n");`
437			`return;`
438			`}`
439			`} else {`
440	83	hellwig	`help06();`
441	8	hellwig	`return;`
442			`}`
443			`for (i = 0; i < count; i++) {`
444			`cpuStep();`
445			`}`
446			`showPC();`
447			`}`
448
449
450			`static void doPC(char *tokens[], int n) {`
451			`Word addr;`
452
453			`if (n == 1) {`
454			`showPC();`
455			`} else if (n == 2) {`
456			`if (!getHexNumber(tokens[1], &addr)) {`
457			`cPrintf("illegal address\n");`
458			`return;`
459			`}`
460			`addr &= ~0x00000003;`
461			`cpuSetPC(addr);`
462			`showPC();`
463			`} else {`
464	83	hellwig	`help07();`
465	8	hellwig	`}`
466			`}`
467
468
469			`static void explainPSW(Word data) {`
470			`int i;`
471
472			`cPrintf("interrupt vector : %s (%s)\n",`
473			`data & PSW_V ? "on " : "off",`
474			`data & PSW_V ? "RAM" : "ROM");`
475			`cPrintf("current user mode : %s (%s)\n",`
476			`data & PSW_UM ? "on " : "off",`
477			`data & PSW_UM ? "user" : "kernel");`
478			`cPrintf("previous user mode : %s (%s)\n",`
479			`data & PSW_PUM ? "on " : "off",`
480			`data & PSW_PUM ? "user" : "kernel");`
481			`cPrintf("old user mode : %s (%s)\n",`
482			`data & PSW_OUM ? "on " : "off",`
483			`data & PSW_OUM ? "user" : "kernel");`
484			`cPrintf("current interrupt enable : %s (%s)\n",`
485			`data & PSW_IE ? "on " : "off",`
486			`data & PSW_IE ? "enabled" : "disabled");`
487			`cPrintf("previous interrupt enable : %s (%s)\n",`
488			`data & PSW_PIE ? "on " : "off",`
489			`data & PSW_PIE ? "enabled" : "disabled");`
490			`cPrintf("old interrupt enable : %s (%s)\n",`
491			`data & PSW_OIE ? "on " : "off",`
492			`data & PSW_OIE ? "enabled" : "disabled");`
493	276	hellwig	`cPrintf("last interrupt acknowledged : %02d (%s)\n",`
494	8	hellwig	`(data & PSW_PRIO_MASK) >> 16,`
495			`exceptionToString((data & PSW_PRIO_MASK) >> 16));`
496			`for (i = 15; i >= 0; i--) {`
497			`cPrintf("%-35s: %s (%s)\n",`
498			`exceptionToString(i),`
499			`data & (1 << i) ? "on " : "off",`
500			`data & (1 << i) ? "enabled" : "disabled");`

Browse

Tools

Subversion Repositories eco32

[/] [eco32/] [trunk/] [sim/] [command.c] - Blame information for rev 296