src/exec.c

   1 #include <stdio.h>
   2 #include <assert.h>
   3 #include <time.h>
   4
   5 #include "exec.h"
   6 #include "cerr.h"
   7
   8 /* 実行エラーの定義 */
   9 static CERR cerr_loadassemble[] = {
  10     { 201, "Loading - full of COMET II memory" },
  11 };
  12
  13 static CERR cerr_exec[] = {
  14     { 202, "SVC input - out of Input memory" },
  15     { 203, "SVC output - out of COMET II memory" },
  16     { 204, "Program Register (PR) - out of COMET II memory" },
  17     { 205, "Stack Pointer (SP) - cannot allocate stack buffer" },
  18     { 206, "Address - out of COMET II memory" },
  19     { 207, "Stack Pointer (SP) - out of COMET II memory" },
  20 };
  21
  22 /**
  23  * 実行モード: trace, logical, dump
  24  */
  25 EXECMODE execmode = {false, false, false};
  26
  27 /**
  28  * 指定されたファイルからアセンブル結果を読み込む
  29  */
  30 bool loadassemble(char *file) {
  31     FILE *fp;
  32     bool status = true;
  33
  34     addcerrlist(ARRAYSIZE(cerr_exec), cerr_loadassemble);       /* エラーリスト作成 */
  35     assert(file != NULL);
  36     if((fp = fopen(file, "r")) == NULL) {
  37         perror(file);
  38         return false;
  39     }
  40     prog->end = prog->start +
  41         fread(sys->memory, sizeof(WORD), sys->memsize - prog->start, fp);
  42     if(prog->end == sys->memsize) {
  43         setcerr(201, file);    /* Loading - full of COMET II memory */
  44         fprintf(stderr, "Load error - %d: %s\n", cerr->num, cerr->msg);
  45         status = false;
  46     }
  47     fclose(fp);
  48     return status;
  49 }
  50
  51 /**
  52  * 標準入力から文字データを読込（SVC 1）
  53  */
  54 static void svcin()
  55 {
  56     int i;
  57     char *buffer = malloc_chk(INSIZE + 1, "svcin.buffer");
  58
  59     if(fgets(buffer, INSIZE, stdin) == NULL) {
  60         sys->memory[sys->cpu->gr[1]] = sys->memory[sys->cpu->gr[2]] = 0x0;
  61         return;
  62     }
  63     for(i = 0; i < INSIZE; i++) {
  64         if(*(buffer + i) == '\0' || *(buffer + i) == '\n') {
  65             --i;
  66             break;
  67         }
  68         if(sys->cpu->gr[1] + i >= sys->memsize - 1) {
  69             setcerr(202, NULL);    /* SVC input - out of Input memory */
  70             break;
  71         }
  72         sys->memory[sys->cpu->gr[1]+i] = *(buffer + i);
  73     }
  74     sys->memory[sys->cpu->gr[2]] = i + 1;
  75     free_chk(buffer, "buffer");
  76 }
  77
  78 /**
  79  * 標準出力へ文字データを書出（SVC 2）
  80  */
  81 static void svcout()
  82 {
  83     int i;
  84     WORD w;
  85
  86     for(i = 0; i < sys->memory[sys->cpu->gr[2]]; i++) {
  87         if(sys->cpu->gr[1] + i >= sys->memsize - 1) {
  88             setcerr(203, NULL);    /* SVC output - out of Comet II memory */
  89             return;
  90         }
  91         /* 「文字の組」の符号表に記載された文字と、改行（CR）／タブを表示 */
  92         /* それ以外の文字は、「.」で表す */
  93         if(((w = sys->memory[sys->cpu->gr[1]+i]) >= 0x20 && w <= 0x7E) || w == 0xA || w == '\t') {
  94             putchar((char)w);
  95         } else {
  96             putchar('.');
  97         }
  98     }
  99 }
 100
 101 /**
 102  * ロード／論理積／論理和／排他的論理和のフラグ設定。OFは常に0
 103  */
 104 static void setfr(WORD val)
 105 {
 106     sys->cpu->fr = 0x0;
 107     /* 第15ビットが1のとき、SFは1 */
 108     if((val & 0x8000) == 0x8000) {
 109         sys->cpu->fr += SF;
 110     }
 111     /* 演算結果が0のとき、ZFは1 */
 112     if(val == 0x0) {
 113         sys->cpu->fr += ZF;
 114     }
 115 }
 116
 117 /**
 118  * 算術加算。フラグを設定して値を返す
 119  */
 120 static WORD adda(WORD val0, WORD val1)
 121 {
 122     WORD res;
 123     long tmp;
 124
 125     sys->cpu->fr = 0x0;
 126     /* 引数の値を16ビット符号付整数として加算し、オーバーフローをチェック */
 127     assert(sizeof(short)*8 == 16 && (short)0xFFFF == -1);
 128     if((tmp = (short)val0 + (short)val1) > 32767 || tmp < -32768) {
 129         sys->cpu->fr += OF;
 130     }
 131     /* 加算した結果を、WORD値に戻す */
 132     res = (WORD)(tmp & 0xFFFF);
 133     if((res & 0x8000) == 0x8000) {
 134         sys->cpu->fr += SF;
 135     } else if(res == 0x0) {
 136         sys->cpu->fr += ZF;
 137     }
 138     return res;
 139 }
 140
 141 /**
 142  * 算術減算。フラグを設定して値を返す
 143  */
 144 static WORD suba(WORD val0, WORD val1)
 145 {
 146     return adda(val0, (~val1 + 1));
 147 }
 148
 149 /**
 150  * 論理加算。フラグを設定して値を返す
 151  */
 152 static WORD addl(WORD val0, WORD val1)
 153 {
 154     long tmp;
 155     WORD res;
 156     sys->cpu->fr = 0x0;
 157
 158     if((tmp = val0 + val1) < 0 || tmp > 65535) {
 159         sys->cpu->fr += OF;
 160     }
 161     if(((res = (WORD)(tmp & 0xFFFF)) & 0x8000) == 0x8000) {
 162         sys->cpu->fr += SF;
 163     } else if(res == 0x0) {
 164         sys->cpu->fr += ZF;
 165     }
 166     return res;
 167 }
 168
 169 /**
 170  * 論理減算。フラグを設定して値を返す
 171  */
 172 static WORD subl(WORD val0, WORD val1)
 173 {
 174     return addl(val0, (~val1 + 1));
 175 }
 176
 177 /**
 178  * 算術比較のフラグ設定。OFは常に0
 179  */
 180 static void cpa(WORD val0, WORD val1)
 181 {
 182     sys->cpu->fr = 0x0;
 183     if((short)val0 < (short)val1) {
 184         sys->cpu->fr = SF;
 185     } else if(val0 == val1) {
 186         sys->cpu->fr = ZF;
 187     }
 188 }
 189
 190 /**
 191  * 論理比較のフラグ設定。OFは常に0
 192  */
 193 static void cpl(WORD val0, WORD val1)
 194 {
 195     sys->cpu->fr = 0x0;
 196     if(val0 < val1) {
 197         sys->cpu->fr = SF;
 198     } else if(val0 == val1) {
 199         sys->cpu->fr = ZF;
 200     }
 201 }
 202
 203 /**
 204  * 算術左シフト。フラグを設定して値を返す
 205  * 算術演算なので、第15ビットは送り出されない
 206  */
 207 static WORD sla(WORD val0, WORD val1)
 208 {
 209     WORD sign, res, last = 0x0;
 210     int i;
 211
 212     sys->cpu->fr = 0x0;
 213     sign = val0 & 0x8000;
 214     res = val0 & 0x7FFF;
 215     for(i = 0; i < val1; i++) {
 216         last = res & 0x4000;
 217         res <<= 1;
 218     }
 219     res = sign | (res & 0x7FFF);
 220     /* OFに、レジスタから最後に送り出されたビットの値を設定 */
 221     if(last > 0x0) {
 222         sys->cpu->fr += OF;
 223     }
 224     /* 符号（第15ビット）が1のとき、SFは1 */
 225     if(sign > 0x0) {
 226         sys->cpu->fr += SF;
 227     }
 228     /* 演算結果が0のとき、ZFは1 */
 229     if(res == 0x0) {
 230         sys->cpu->fr += ZF;
 231     }
 232     return res;
 233 }
 234
 235 /**
 236  * 算術右シフト。フラグを設定して値を返す
 237  * 算術演算なので、第15ビットは送り出されない
 238  * 空いたビット位置には符号と同じものが入る
 239  */
 240 static WORD sra(WORD val0, WORD val1)
 241 {
 242     WORD sign, res, last = 0x0;
 243     int i;
 244
 245     sys->cpu->fr = 0x0;
 246     sign = val0 & 0x8000;
 247     res = val0 & 0x7FFF;
 248     for(i = 0; i < val1; i++) {
 249         last = res & 0x1;
 250         res >>= 1;
 251         if(sign > 0) {
 252             res |= 0x4000;
 253         }
 254     }
 255     res = sign | res;
 256     /* OFに、レジスタから最後に送り出されたビットの値を設定 */
 257     if(last > 0x0) {
 258         sys->cpu->fr += OF;
 259     }
 260     /* 符号（第15ビット）が1のとき、SFは1 */
 261     if(sign > 0x0) {
 262         sys->cpu->fr += SF;
 263     }
 264     /* 演算結果が0のとき、ZFは1 */
 265     if(res == 0x0) {
 266         sys->cpu->fr += ZF;
 267     }
 268     return res;
 269 }
 270
 271 /**
 272  * 論理左シフト。フラグを設定して値を返す
 273  */
 274 static WORD sll(WORD val0, WORD val1)
 275 {
 276     WORD res = val0, last = 0x0;
 277     int i;
 278
 279     sys->cpu->fr = 0x0;
 280     for(i = 0; i < val1; i++) {
 281         last = res & 0x8000;
 282         res <<= 1;
 283     }
 284     /* OFに、レジスタから最後に送り出されたビットの値を設定 */
 285     if(last > 0x0) {
 286         sys->cpu->fr += OF;
 287     }
 288     /* 第15ビットが1のとき、SFは1 */
 289     if((res & 0x8000) > 0x0) {
 290         sys->cpu->fr += SF;
 291     }
 292     /* 演算結果が0のとき、ZFは1 */
 293     if(res == 0x0) {
 294         sys->cpu->fr += ZF;
 295     }
 296     return res;
 297 }
 298
 299 /**
 300  * 論理右シフト。フラグを設定して値を返す
 301  */
 302 static WORD srl(WORD val0, WORD val1)
 303 {
 304     WORD res = val0, last = 0x0;
 305     int i;
 306
 307     sys->cpu->fr = 0x0;
 308     for(i = 0; i < val1; i++) {
 309         last = res & 0x0001;
 310         res >>= 1;
 311     }
 312     /* OFに、レジスタから最後に送り出されたビットの値を設定 */
 313     if(last > 0x0) {
 314         sys->cpu->fr += OF;
 315     }
 316     /* 第15ビットが1のとき、SFは1 */
 317     if((res & 0x8000) > 0x0) {
 318         sys->cpu->fr += SF;
 319     }
 320     /* 演算結果が0のとき、ZFは1 */
 321     if(res == 0x0) {
 322         sys->cpu->fr += ZF;
 323     }
 324     return res;
 325 }
 326
 327 /**
 328  * 仮想マシンCOMET IIの実行
 329  */
 330 bool exec()
 331 {
 332     WORD op, r_r1, x_r2, val;
 333     CMDTYPE cmdtype;
 334     char *errpr = malloc_chk(CERRSTRSIZE + 1, "exec.errpr");
 335     clock_t clock_begin, clock_end;
 336
 337     addcerrlist(ARRAYSIZE(cerr_exec), cerr_exec);         /* エラーリスト作成 */
 338     if(execmode.trace == true) {
 339         fprintf(stdout, "\nExecuting machine codes\n");
 340     }
 341     /* フラグレジスタの初期値設定 */
 342     sys->cpu->fr = 0x0;
 343     sys->cpu->sp = sys->memsize;
 344     sys->cpu->pr = prog->start;
 345     /* 機械語の実行 */
 346     for (; ; ) {
 347         clock_begin = clock();
 348         /* プログラムレジスタのアドレスが主記憶の範囲外の場合はエラー */
 349         if(sys->cpu->pr >= sys->memsize) {
 350             sprintf(errpr, "PR:#%04X", sys->cpu->pr);
 351             setcerr(204, errpr);    /* Program Register (PR) - out of COMET II memory */
 352         }
 353         /* スタック領域のアドレスが主記憶の範囲外の場合はエラー */
 354         if(sys->cpu->sp > sys->memsize) {
 355             sprintf(errpr, "PR:#%04X", sys->cpu->pr);
 356             setcerr(207, errpr);    /* Stack Pointer (SP) - out of COMET II memory */
 357         }
 358         /* スタック領域を確保できない場合はエラー */
 359         if(sys->cpu->sp <= prog->end) {
 360             sprintf(errpr, "PR:#%04X", sys->cpu->pr);
 361             setcerr(205, errpr);    /* Stack Pointer (SP) - cannot allocate stack buffer */
 362         }
 363         /* 命令の取り出し */
 364         op = sys->memory[sys->cpu->pr] & 0xFF00;
 365         /* 命令の解読 */
 366         cmdtype = getcmdtype(op);
 367         r_r1 = (sys->memory[sys->cpu->pr] >> 4) & 0xF;
 368         x_r2 = sys->memory[sys->cpu->pr] & 0xF;
 369         /* エラー発生時は終了 */
 370         if(cerr->num > 0) {
 371             goto execerr;
 372         }
 373         /* traceオプション指定時、レジスタを出力 */
 374         if(execmode.trace){
 375             fprintf(stdout, "#%04X: Register::::\n", sys->cpu->pr);
 376             dspregister();
 377         }
 378         /* dumpオプション指定時、メモリを出力 */
 379         if(execmode.dump){
 380             fprintf(stdout, "#%04X: Memory::::\n", sys->cpu->pr);
 381             dumpmemory();
 382         }
 383         /* どちらかのオプション指定時、改行を出力 */
 384         if(execmode.dump || execmode.trace) {
 385             fprintf(stdout, "\n");
 386         }
 387         sys->cpu->pr++;
 388         /* オペランドの取り出し */
 389         if(cmdtype == R1_R2) {
 390             assert(x_r2 < GRSIZE);
 391             val = sys->cpu->gr[x_r2];
 392         }
 393         else if(cmdtype ==  R_ADR_X || cmdtype == R_ADR_X_ || cmdtype == ADR_X) {
 394             assert(x_r2 < GRSIZE);
 395             /* 実効アドレス（値または値が示す番地）を取得  */
 396             val = sys->memory[sys->cpu->pr++];
 397             /* 指標アドレスを加算  */
 398             if(x_r2 > 0x0) {
 399                 val += sys->cpu->gr[x_r2];
 400             }
 401             /* ロード／算術論理演算命令／比較演算命令では、アドレスに格納されている内容を取得 */
 402             if(cmdtype == R_ADR_X_) {
 403                 if(val >= sys->memsize) {
 404                     sprintf(errpr, "PR:#%04X", sys->cpu->pr-1);
 405                     setcerr(206, errpr);    /* Address - out of COMET II memory */
 406                     goto execerr;
 407                 }
 408                 val = sys->memory[val];
 409             }
 410         }
 411         free_chk(errpr, "errpr");
 412         /* 主オペランドが1〜4の場合、第2ビットを無視 */
 413         if(op >= 0x1000 && op <= 0x4FFF) {
 414             op &= 0xFB00;
 415         }
 416         /* 命令の実行 */
 417         switch(op)
 418         {
 419         case 0x0:       /* NOP */
 420             break;
 421         case 0x1000:    /* LD */
 422             setfr(sys->cpu->gr[r_r1] = val);
 423             break;
 424         case 0x1100:    /* ST */
 425             sys->memory[val] = sys->cpu->gr[r_r1];
 426             break;
 427         case 0x1200:    /* LAD */
 428             sys->cpu->gr[r_r1] = val;
 429             break;
 430         case 0x2000:    /* ADDA */
 431             sys->cpu->gr[r_r1] = adda(sys->cpu->gr[r_r1], val);
 432             break;
 433         case 0x2100:    /* SUBA */
 434             sys->cpu->gr[r_r1] = suba(sys->cpu->gr[r_r1], val);
 435             break;
 436         case 0x2200:    /* ADDL */
 437             sys->cpu->gr[r_r1] = addl(sys->cpu->gr[r_r1], val);
 438             break;
 439         case 0x2300:    /* SUBL */
 440             sys->cpu->gr[r_r1] = subl(sys->cpu->gr[r_r1], val);
 441             break;
 442         case 0x3000:    /* AND */
 443             setfr(sys->cpu->gr[r_r1] &= val);
 444             break;
 445         case 0x3100:    /* OR */
 446             setfr(sys->cpu->gr[r_r1] |= val);
 447             break;
 448         case 0x3200:    /* XOR */
 449             setfr(sys->cpu->gr[r_r1] ^= val);
 450             break;
 451         case 0x4000:    /* CPA */
 452             cpa(sys->cpu->gr[r_r1], val);
 453             break;
 454         case 0x4100:    /* CPL */
 455             cpl(sys->cpu->gr[r_r1], val);
 456             break;
 457         case 0x5000:    /* SLA */
 458             sys->cpu->gr[r_r1] = sla(sys->cpu->gr[r_r1], val);
 459             break;
 460         case 0x5100:    /* SRA */
 461             sys->cpu->gr[r_r1] = sra(sys->cpu->gr[r_r1], val);
 462             break;
 463         case 0x5200:    /* SLL */
 464             sys->cpu->gr[r_r1] = sll(sys->cpu->gr[r_r1], val);
 465             break;
 466         case 0x5300:    /* SRL */
 467             sys->cpu->gr[r_r1] = srl(sys->cpu->gr[r_r1], val);
 468             break;
 469         case 0x6100:    /* JMI */
 470             if((sys->cpu->fr & SF) > 0) {
 471                 sys->cpu->pr = val;
 472             }
 473             break;
 474         case 0x6200:    /* JNZ */
 475             if((sys->cpu->fr & ZF) == 0) {
 476                 sys->cpu->pr = val;
 477             }
 478             break;
 479         case 0x6300:    /* JZE */
 480             if((sys->cpu->fr & ZF) > 0) {
 481                 sys->cpu->pr = val;
 482             }
 483             break;
 484         case 0x6400:    /* JUMP */
 485             sys->cpu->pr = val;
 486             break;
 487         case 0x6500:    /* JPL */
 488             if((sys->cpu->fr & (SF | ZF)) == 0) {
 489                 sys->cpu->pr = val;
 490             }
 491             break;
 492         case 0x6600:    /* JOV */
 493             if((sys->cpu->fr & OF) > 0) {
 494                 sys->cpu->pr = val;
 495             }
 496             break;
 497         case 0x7000:    /* PUSH */
 498             assert(sys->cpu->sp > prog->end && sys->cpu->sp <= sys->memsize);
 499             sys->memory[--(sys->cpu->sp)] = val;
 500             break;
 501         case 0x7100:    /* POP */
 502             assert(sys->cpu->sp > prog->end && sys->cpu->sp <= sys->memsize);
 503             sys->cpu->gr[r_r1] = sys->memory[(sys->cpu->sp)++];
 504             break;
 505         case 0x8000:    /* CALL */
 506             assert(sys->cpu->sp > prog->end && sys->cpu->sp <= sys->memsize);
 507             sys->memory[--(sys->cpu->sp)] = sys->cpu->pr;
 508             sys->cpu->pr = val;
 509             break;
 510         case 0x8100:    /* RET */
 511             assert(sys->cpu->sp > prog->end && sys->cpu->sp <= sys->memsize);
 512             if(sys->cpu->sp == sys->memsize) {
 513                 return true;
 514             } else {
 515                 sys->cpu->pr = sys->memory[(sys->cpu->sp)++];
 516                 break;
 517             }
 518         case 0xF000:    /* SVC */
 519             switch(val)
 520             {
 521             case 0x0: /* EXIT */
 522                 return true;
 523             case 0x1: /* IN */
 524                 svcin();
 525                 break;
 526             case 0x2: /* OUT */
 527                 svcout();
 528                 break;
 529             }
 530         default:
 531             break;
 532         }
 533         do {
 534             clock_end = clock();
 535         } while(clock_end - clock_begin < CLOCKS_PER_SEC / sys->clocks);
 536     }
 537     return true;
 538 execerr:
 539     fprintf(stderr, "Execute error - %d: %s\n", cerr->num, cerr->msg);
 540     return false;
 541 }