/* Clemson University -- CPSC 231
 * load/store machine simulator
 * mark smotherman, summer 1995
 *
 * accompanies R.P. Paul, SPARC Arch., Assembly Lang. Programming, & C.
 *
 * instructions
 *
 * opcode operands operation name          machine action
 * ------ -------- --------------          --------------
 *   00    ----    halt                    stop execution
 *   10    a,b,c   divide                  reg[c] = reg[a]/reg[b]
 *   20    a,b,c   multiply                reg[c] = reg[a]*reg[b]
 *   30    a,b,c   subtract                reg[c] = reg[a]-reg[b]
 *   40    a,b,c   add                     reg[c] = reg[a]+reg[b]
 *   50    addr,r  load                    reg[r] = memory[addr]
 *   60    r,addr  store                   memory[addr] = reg[r]
 *   70    addr    branch always           pc = addr
 *   71    r,addr  branch on less than     if reg[r]<0  then pc = addr
 *   72    r,addr  branch on less than
 *                   or equal              if reg[r]<=0 then pc = addr
 *   73    r,addr  branch on equal         if reg[r]==0 then pc = addr
 *   74    r,addr  branch on not equal     if reg[r]/=0 then pc = addr
 *   75    r,addr  branch on greater than
 *                   or equal              if reg[r]>=0 then pc = addr
 *   76    r,addr  branch on greater than  if reg[r]>0  then pc = addr
 *   90    addr    print                   display contents of memory[addr]
 *
 */


#include <stdio.h>

int memory[1000];		/* program memory  */
int pc = 0;			/* program counter */
int reg[8];			/* the register file */


main() {

  int run = 1;			/* run flag, initialized to true */
  int sym;			/* value read in */
  int a,b,c,r;			/* register specifiers */
  int addr;			/* memory address field in instruction */

  /* read in program */
  while (scanf("%d", &sym) != EOF)
    { printf("%2d: %d\n", pc,sym); memory[pc++] = sym; }

  /* set starting address to last value read in */
  pc = memory[--pc];

  printf("\nsimulation of load/store machine begins\n");

  /* fetch/execute loop */
  while (run) {

    printf("%2d: ",pc);
    switch (memory[pc++]) {

      case 00:
        run = 0; printf("halt\n"); break;

      case 10:						/* div(a,b,c) */
        a = memory[pc]; b = memory[pc+1]; c = memory[pc+2];
        if (reg[b] == 0)
          { printf("divide by zero\n"); exit(0); }
        reg[c] = reg[a]/reg[b];
        pc += 3;
        printf("div  r%d,r%d,r%d (result is %d)\n",a,b,c,reg[c]);
        break;

      case 20:						/* mul(a,b,c) */
        a = memory[pc]; b = memory[pc+1]; c = memory[pc+2];
        reg[c] = reg[a]*reg[b];
        pc += 3;
        printf("mul  r%d,r%d,r%d (result is %d)\n",a,b,c,reg[c]);
        break;

      case 30:						/* sub(a,b,c) */
        a = memory[pc]; b = memory[pc+1]; c = memory[pc+2];
        reg[c] = reg[a]-reg[b];
        pc += 3;
        printf("sub  r%d,r%d,r%d (result is %d)\n",a,b,c,reg[c]);
        break;

      case 40:						/* add(a,b,c) */
        a = memory[pc]; b = memory[pc+1]; c = memory[pc+2];
        reg[c] = reg[a]+reg[b];
        pc += 3;
        printf("add  r%d,r%d,r%d (result is %d)\n",a,b,c,reg[c]);
        break;

      case 50:						/* load(addr,r) */
        addr = memory[pc]; r = memory[pc+1];
        reg[r] = memory[addr]; 
        pc += 2;
        printf("ld   %d,r%d (result is %d)\n",addr,r,reg[r]);
        break;

      case 60:						/* store(r,addr) */
        r = memory[pc]; addr = memory[pc+1];
        memory[addr] = reg[r];
        pc += 2;
        printf("st   r%d,%d\n",r,addr);
        break;

      case 70:						/* ba(addr) */
        addr = memory[pc];
        pc = addr;
        printf("ba   %d\n",addr);
        break;

      case 71:						/* blt0(r,addr) */
        r = memory[pc]; addr = memory[pc+1];
        if (reg[r] < 0) pc = addr;
        else pc += 2;
        printf("blt0 r%d,%d\n",r,addr);
        break;

      case 72:						/* ble0(r,addr) */
        r = memory[pc]; addr = memory[pc+1];
        if (reg[r] <= 0) pc = addr;
        else pc += 2;
        printf("ble0 r%d,%d\n",r,addr);
        break;
	
      case 73:						/* beq0(r,addr) */
        r = memory[pc]; addr = memory[pc+1];
        if (reg[r] == 0) pc = addr;
        else pc += 2;
        printf("beq0 r%d,%d\n",r,addr);
        break;

      case 74:						/* bne0(r,addr) */
        r = memory[pc]; addr = memory[pc+1];
        if (reg[r] != 0) pc = addr;
        else pc += 2;
        printf("bne0 r%d,%d\n",r,addr);
        break;

      case 75:						/* bge0(r,addr) */
        r = memory[pc]; addr = memory[pc+1];
        if (reg[r] >= 0) pc = addr;
        else pc += 2;
        printf("bge0 r%d,%d\n",r,addr);
        break;

      case 76:						/* bgt0(r,addr) */
        r = memory[pc]; addr = memory[pc+1];
        if (reg[r] > 0) pc = addr;
        else pc += 2;
        printf("bgt0 r%d,%d\n",r,addr);
        break;

      case 90:						/* print(addr) */
        printf("prt  %d => ",memory[pc]);
        printf("%d\n", memory[memory[pc++]]); break;

      default:
        printf("unknown instruction at memory[%d]: %d\n",
          pc - 1, memory[pc - 1]);
        exit(0); break;
    }
  }
  printf("simulation of load/store machine ends\n");
}