00001
00036 #include "mips1-isa.H"
00037 #include "ac_isa_init.cpp"
00038
00039
00040
00041
00042 #include "ac_debug_model.H"
00043
00044
00046 #define Ra 31
00047 #define Sp 29
00048 #define Lo 32
00049 #define Hi 33
00050
00051
00053 void ac_behavior( instruction )
00054 {
00055 dbg_printf("----- PC=%#x ----- %lld\n", (int) ac_pc, ac_instr_counter);
00056 #ifndef NO_NEED_PC_UPDATE
00057 ac_pc = ac_pc +4;
00058 #endif
00059 };
00060
00062 void ac_behavior( Type_R ){}
00063 void ac_behavior( Type_I ){}
00064 void ac_behavior( Type_J ){}
00065
00067 void ac_behavior(begin)
00068 {
00069 dbg_printf("@@@ begin behavior @@@\n");
00070 RB[0] = 0;
00071 }
00072
00074 void ac_behavior(end)
00075 {
00076 dbg_printf("@@@ end behavior @@@\n");
00077 }
00078
00079
00081 void ac_behavior( lb )
00082 {
00083 char byte;
00084 dbg_printf("lb r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00085 byte = DM.read_byte(RB[rs]+ imm);
00086 RB[rt] = (ac_Sword)byte ;
00087 dbg_printf("Result = %#x\n", RB[rt]);
00088 };
00089
00091 void ac_behavior( lbu )
00092 {
00093 unsigned char byte;
00094 dbg_printf("lbu r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00095 byte = DM.read_byte(RB[rs]+ imm);
00096 RB[rt] = byte ;
00097 dbg_printf("Result = %#x\n", RB[rt]);
00098 };
00099
00101 void ac_behavior( lh )
00102 {
00103 short int half;
00104 dbg_printf("lh r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00105 half = DM.read_half(RB[rs]+ imm);
00106 RB[rt] = (ac_Sword)half ;
00107 dbg_printf("Result = %#x\n", RB[rt]);
00108 };
00109
00111 void ac_behavior( lhu )
00112 {
00113 unsigned short int half;
00114 half = DM.read_half(RB[rs]+ imm);
00115 RB[rt] = half ;
00116 dbg_printf("Result = %#x\n", RB[rt]);
00117 };
00118
00120 void ac_behavior( lw )
00121 {
00122 dbg_printf("lw r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00123 RB[rt] = DM.read(RB[rs]+ imm);
00124 dbg_printf("Result = %#x\n", RB[rt]);
00125 };
00126
00128 void ac_behavior( lwl )
00129 {
00130 dbg_printf("lwl r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00131 unsigned int addr, offset;
00132 ac_Uword data;
00133
00134 addr = RB[rs] + imm;
00135 offset = (addr & 0x3) * 8;
00136 data = DM.read(addr & 0xFFFFFFFC);
00137 data <<= offset;
00138 data |= RB[rt] & ((1<<offset)-1);
00139 RB[rt] = data;
00140 dbg_printf("Result = %#x\n", RB[rt]);
00141 };
00142
00144 void ac_behavior( lwr )
00145 {
00146 dbg_printf("lwr r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00147 unsigned int addr, offset;
00148 ac_Uword data;
00149
00150 addr = RB[rs] + imm;
00151 offset = (3 - (addr & 0x3)) * 8;
00152 data = DM.read(addr & 0xFFFFFFFC);
00153 data >>= offset;
00154 data |= RB[rt] & (0xFFFFFFFF << (32-offset));
00155 RB[rt] = data;
00156 dbg_printf("Result = %#x\n", RB[rt]);
00157 };
00158
00160 void ac_behavior( sb )
00161 {
00162 unsigned char byte;
00163 dbg_printf("sb r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00164 byte = RB[rt] & 0xFF;
00165 DM.write_byte(RB[rs] + imm, byte);
00166 dbg_printf("Result = %#x\n", (int) byte);
00167 };
00168
00170 void ac_behavior( sh )
00171 {
00172 unsigned short int half;
00173 dbg_printf("sh r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00174 half = RB[rt] & 0xFFFF;
00175 DM.write_half(RB[rs] + imm, half);
00176 dbg_printf("Result = %#x\n", (int) half);
00177 };
00178
00180 void ac_behavior( sw )
00181 {
00182 dbg_printf("sw r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00183 DM.write(RB[rs] + imm, RB[rt]);
00184 dbg_printf("Result = %#x\n", RB[rt]);
00185 };
00186
00188 void ac_behavior( swl )
00189 {
00190 dbg_printf("swl r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00191 unsigned int addr, offset;
00192 ac_Uword data;
00193
00194 addr = RB[rs] + imm;
00195 offset = (addr & 0x3) * 8;
00196 data = RB[rt];
00197 data >>= offset;
00198 data |= DM.read(addr & 0xFFFFFFFC) & (0xFFFFFFFF << (32-offset));
00199 DM.write(addr & 0xFFFFFFFC, data);
00200 dbg_printf("Result = %#x\n", data);
00201 };
00202
00204 void ac_behavior( swr )
00205 {
00206 dbg_printf("swr r%d, %d(r%d)\n", rt, imm & 0xFFFF, rs);
00207 unsigned int addr, offset;
00208 ac_Uword data;
00209
00210 addr = RB[rs] + imm;
00211 offset = (3 - (addr & 0x3)) * 8;
00212 data = RB[rt];
00213 data <<= offset;
00214 data |= DM.read(addr & 0xFFFFFFFC) & ((1<<offset)-1);
00215 DM.write(addr & 0xFFFFFFFC, data);
00216 dbg_printf("Result = %#x\n", data);
00217 };
00218
00220 void ac_behavior( addi )
00221 {
00222 dbg_printf("addi r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00223 RB[rt] = RB[rs] + imm;
00224 dbg_printf("Result = %#x\n", RB[rt]);
00225
00226 if ( ((RB[rs] & 0x80000000) == (imm & 0x80000000)) &&
00227 ((imm & 0x80000000) != (RB[rt] & 0x80000000)) ) {
00228 fprintf(stderr, "EXCEPTION(addi): integer overflow.\n"); exit(EXIT_FAILURE);
00229 }
00230 };
00231
00233 void ac_behavior( addiu )
00234 {
00235 dbg_printf("addiu r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00236 RB[rt] = RB[rs] + imm;
00237 dbg_printf("Result = %#x\n", RB[rt]);
00238 };
00239
00241 void ac_behavior( slti )
00242 {
00243 dbg_printf("slti r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00244
00245 if( (ac_Sword) RB[rs] < (ac_Sword) imm )
00246 RB[rt] = 1;
00247
00248 else
00249 RB[rt] = 0;
00250 dbg_printf("Result = %#x\n", RB[rt]);
00251 };
00252
00254 void ac_behavior( sltiu )
00255 {
00256 dbg_printf("sltiu r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00257
00258 if( (ac_Uword) RB[rs] < (ac_Uword) imm )
00259 RB[rt] = 1;
00260
00261 else
00262 RB[rt] = 0;
00263 dbg_printf("Result = %#x\n", RB[rt]);
00264 };
00265
00267 void ac_behavior( andi )
00268 {
00269 dbg_printf("andi r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00270 RB[rt] = RB[rs] & (imm & 0xFFFF) ;
00271 dbg_printf("Result = %#x\n", RB[rt]);
00272 };
00273
00275 void ac_behavior( ori )
00276 {
00277 dbg_printf("ori r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00278 RB[rt] = RB[rs] | (imm & 0xFFFF) ;
00279 dbg_printf("Result = %#x\n", RB[rt]);
00280 };
00281
00283 void ac_behavior( xori )
00284 {
00285 dbg_printf("xori r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00286 RB[rt] = RB[rs] ^ (imm & 0xFFFF) ;
00287 dbg_printf("Result = %#x\n", RB[rt]);
00288 };
00289
00291 void ac_behavior( lui )
00292 {
00293 dbg_printf("lui r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00294
00295
00296
00297 RB[rt] = imm << 16;
00298 dbg_printf("Result = %#x\n", RB[rt]);
00299 };
00300
00302 void ac_behavior( add )
00303 {
00304 dbg_printf("add r%d, r%d, r%d\n", rd, rs, rt);
00305 RB[rd] = RB[rs] + RB[rt];
00306 dbg_printf("Result = %#x\n", RB[rd]);
00307
00308 if ( ((RB[rs] & 0x80000000) == (RB[rd] & 0x80000000)) &&
00309 ((RB[rd] & 0x80000000) != (RB[rt] & 0x80000000)) ) {
00310 fprintf(stderr, "EXCEPTION(add): integer overflow.\n"); exit(EXIT_FAILURE);
00311 }
00312 };
00313
00315 void ac_behavior( addu )
00316 {
00317 dbg_printf("addu r%d, r%d, r%d\n", rd, rs, rt);
00318 RB[rd] = RB[rs] + RB[rt];
00319
00320
00321 dbg_printf("Result = %#x\n", RB[rd]);
00322 };
00323
00325 void ac_behavior( sub )
00326 {
00327 dbg_printf("sub r%d, r%d, r%d\n", rd, rs, rt);
00328 RB[rd] = RB[rs] - RB[rt];
00329 dbg_printf("Result = %#x\n", RB[rd]);
00330
00331 };
00332
00334 void ac_behavior( subu )
00335 {
00336 dbg_printf("subu r%d, r%d, r%d\n", rd, rs, rt);
00337 RB[rd] = RB[rs] - RB[rt];
00338 dbg_printf("Result = %#x\n", RB[rd]);
00339 };
00340
00342 void ac_behavior( slt )
00343 {
00344 dbg_printf("slt r%d, r%d, r%d\n", rd, rs, rt);
00345
00346 if( (ac_Sword) RB[rs] < (ac_Sword) RB[rt] )
00347 RB[rd] = 1;
00348
00349 else
00350 RB[rd] = 0;
00351 dbg_printf("Result = %#x\n", RB[rd]);
00352 };
00353
00355 void ac_behavior( sltu )
00356 {
00357 dbg_printf("sltu r%d, r%d, r%d\n", rd, rs, rt);
00358
00359 if( RB[rs] < RB[rt] )
00360 RB[rd] = 1;
00361
00362 else
00363 RB[rd] = 0;
00364 dbg_printf("Result = %#x\n", RB[rd]);
00365 };
00366
00368 void ac_behavior( instr_and )
00369 {
00370 dbg_printf("instr_and r%d, r%d, r%d\n", rd, rs, rt);
00371 RB[rd] = RB[rs] & RB[rt];
00372 dbg_printf("Result = %#x\n", RB[rd]);
00373 };
00374
00376 void ac_behavior( instr_or )
00377 {
00378 dbg_printf("instr_or r%d, r%d, r%d\n", rd, rs, rt);
00379 RB[rd] = RB[rs] | RB[rt];
00380 dbg_printf("Result = %#x\n", RB[rd]);
00381 };
00382
00384 void ac_behavior( instr_xor )
00385 {
00386 dbg_printf("instr_xor r%d, r%d, r%d\n", rd, rs, rt);
00387 RB[rd] = RB[rs] ^ RB[rt];
00388 dbg_printf("Result = %#x\n", RB[rd]);
00389 };
00390
00392 void ac_behavior( instr_nor )
00393 {
00394 dbg_printf("nor r%d, r%d, r%d\n", rd, rs, rt);
00395 RB[rd] = ~(RB[rs] | RB[rt]);
00396 dbg_printf("Result = %#x\n", RB[rd]);
00397 };
00398
00400 void ac_behavior( nop )
00401 {
00402 dbg_printf("nop\n");
00403 };
00404
00406 void ac_behavior( sll )
00407 {
00408 dbg_printf("sll r%d, r%d, %d\n", rd, rs, shamt);
00409 RB[rd] = RB[rt] << shamt;
00410 dbg_printf("Result = %#x\n", RB[rd]);
00411 };
00412
00414 void ac_behavior( srl )
00415 {
00416 dbg_printf("srl r%d, r%d, %d\n", rd, rs, shamt);
00417 RB[rd] = RB[rt] >> shamt;
00418 dbg_printf("Result = %#x\n", RB[rd]);
00419 };
00420
00422 void ac_behavior( sra )
00423 {
00424 dbg_printf("sra r%d, r%d, %d\n", rd, rs, shamt);
00425 RB[rd] = (ac_Sword) RB[rt] >> shamt;
00426 dbg_printf("Result = %#x\n", RB[rd]);
00427 };
00428
00430 void ac_behavior( sllv )
00431 {
00432 dbg_printf("sllv r%d, r%d, r%d\n", rd, rt, rs);
00433 RB[rd] = RB[rt] << (RB[rs] & 0x1F);
00434 dbg_printf("Result = %#x\n", RB[rd]);
00435 };
00436
00438 void ac_behavior( srlv )
00439 {
00440 dbg_printf("srlv r%d, r%d, r%d\n", rd, rt, rs);
00441 RB[rd] = RB[rt] >> (RB[rs] & 0x1F);
00442 dbg_printf("Result = %#x\n", RB[rd]);
00443 };
00444
00446 void ac_behavior( srav )
00447 {
00448 dbg_printf("srav r%d, r%d, r%d\n", rd, rt, rs);
00449 RB[rd] = (ac_Sword) RB[rt] >> (RB[rs] & 0x1F);
00450 dbg_printf("Result = %#x\n", RB[rd]);
00451 };
00452
00454 void ac_behavior( mult )
00455 {
00456 dbg_printf("mult r%d, r%d\n", rs, rt);
00457
00458 long long result;
00459 int half_result;
00460
00461 result = (ac_Sword) RB[rs];
00462 result *= (ac_Sword) RB[rt];
00463
00464 half_result = (result & 0xFFFFFFFF);
00465
00466 RB[Lo] = half_result;
00467
00468 half_result = ((result >> 32) & 0xFFFFFFFF);
00469
00470 RB[Hi] = half_result ;
00471
00472 dbg_printf("Result = %#llx\n", result);
00473 };
00474
00476 void ac_behavior( multu )
00477 {
00478 dbg_printf("multu r%d, r%d\n", rs, rt);
00479
00480 unsigned long long result;
00481 unsigned int half_result;
00482
00483 result = RB[rs];
00484 result *= RB[rt];
00485
00486 half_result = (result & 0xFFFFFFFF);
00487
00488 RB[Lo] = half_result;
00489
00490 half_result = ((result>>32) & 0xFFFFFFFF);
00491
00492 RB[Hi] = half_result ;
00493
00494 dbg_printf("Result = %#llx\n", result);
00495 };
00496
00498 void ac_behavior( div )
00499 {
00500 dbg_printf("div r%d, r%d\n", rs, rt);
00501
00502 RB[Lo] = (ac_Sword) RB[rs] / (ac_Sword) RB[rt];
00503
00504 RB[Hi] = (ac_Sword) RB[rs] % (ac_Sword) RB[rt];
00505 };
00506
00508 void ac_behavior( divu )
00509 {
00510 dbg_printf("divu r%d, r%d\n", rs, rt);
00511
00512 RB[Lo] = RB[rs] / RB[rt];
00513
00514 RB[Hi] = RB[rs] % RB[rt];
00515 };
00516
00518 void ac_behavior( mfhi )
00519 {
00520 dbg_printf("mfhi r%d\n", rd);
00521 RB[rd] = RB[Hi];
00522 dbg_printf("Result = %#x\n", RB[rd]);
00523 };
00524
00526 void ac_behavior( mthi )
00527 {
00528 dbg_printf("mthi r%d\n", rs);
00529 RB[Hi] = RB[rs];
00530 dbg_printf("Result = %#x\n", RB[Hi]);
00531 };
00532
00534 void ac_behavior( mflo )
00535 {
00536 dbg_printf("mflo r%d\n", rd);
00537 RB[rd] = RB[Lo];
00538 dbg_printf("Result = %#x\n", RB[rd]);
00539 };
00540
00542 void ac_behavior( mtlo )
00543 {
00544 dbg_printf("mtlo r%d\n", rs);
00545 RB[Lo] = RB[rs];
00546 dbg_printf("Result = %#x\n", RB[Lo]);
00547 };
00548
00550 void ac_behavior( j )
00551 {
00552 dbg_printf("j %d\n", addr);
00553 addr = addr << 2;
00554 #ifndef NO_NEED_PC_UPDATE
00555 ac_pc = delay( (ac_pc & 0xF0000000) | addr , 1);
00556 #endif
00557 dbg_printf("Target = %#x\n", (ac_pc & 0xF0000000) | addr );
00558 };
00559
00561 void ac_behavior( jal )
00562 {
00563 dbg_printf("jal %d\n", addr);
00564
00565
00566
00567 RB[Ra] = ac_pc+4;
00568
00569 addr = addr << 2;
00570 #ifndef NO_NEED_PC_UPDATE
00571 ac_pc = delay( (ac_pc & 0xF0000000) | addr , 1);
00572 #endif
00573
00574 dbg_printf("Target = %#x\n", (ac_pc & 0xF0000000) | addr );
00575 dbg_printf("Return = %#x\n", ac_pc+4);
00576 };
00577
00579 void ac_behavior( jr )
00580 {
00581 dbg_printf("jr r%d\n", rs);
00582
00583
00584 #ifndef NO_NEED_PC_UPDATE
00585 ac_pc = delay(RB[rs], 1);
00586 #endif
00587 dbg_printf("Target = %#x\n", RB[rs]);
00588 };
00589
00591 void ac_behavior( jalr )
00592 {
00593 dbg_printf("jalr r%d, r%d\n", rd, rs);
00594
00595
00596
00597 #ifndef NO_NEED_PC_UPDATE
00598 ac_pc = delay(RB[rs], 1);
00599 #endif
00600 dbg_printf("Target = %#x\n", RB[rs]);
00601
00602 if( rd == 0 )
00603 rd = Ra;
00604 RB[rd] = ac_pc+4;
00605 dbg_printf("Return = %#x\n", ac_pc+4);
00606 };
00607
00609 void ac_behavior( beq )
00610 {
00611 dbg_printf("beq r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00612 if( RB[rs] == RB[rt] ){
00613 #ifndef NO_NEED_PC_UPDATE
00614 ac_pc = delay(ac_pc + (imm<<2), 1);
00615 #endif
00616 dbg_printf("Taken to %#x\n", ac_pc + (imm<<2));
00617 }
00618 };
00619
00621 void ac_behavior( bne )
00622 {
00623 dbg_printf("bne r%d, r%d, %d\n", rt, rs, imm & 0xFFFF);
00624 if( RB[rs] != RB[rt] ){
00625 #ifndef NO_NEED_PC_UPDATE
00626 ac_pc = delay(ac_pc + (imm<<2), 1);
00627 #endif
00628 dbg_printf("Taken to %#x\n", ac_pc + (imm<<2));
00629 }
00630 };
00631
00633 void ac_behavior( blez )
00634 {
00635 dbg_printf("blez r%d, %d\n", rs, imm & 0xFFFF);
00636 if( (RB[rs] == 0 ) || (RB[rs]&0x80000000 ) ){
00637 #ifndef NO_NEED_PC_UPDATE
00638 ac_pc = delay(ac_pc + (imm<<2), 1);
00639 #endif
00640 dbg_printf("Taken to %#x\n", ac_pc + (imm<<2));
00641 }
00642 };
00643
00645 void ac_behavior( bgtz )
00646 {
00647 dbg_printf("bgtz r%d, %d\n", rs, imm & 0xFFFF);
00648 if( !(RB[rs] & 0x80000000) && (RB[rs]!=0) ){
00649 #ifndef NO_NEED_PC_UPDATE
00650 ac_pc = delay(ac_pc + (imm<<2), 1);
00651 #endif
00652 dbg_printf("Taken to %#x\n", ac_pc + (imm<<2));
00653 }
00654 };
00655
00657 void ac_behavior( bltz )
00658 {
00659 dbg_printf("bltz r%d, %d\n", rs, imm & 0xFFFF);
00660 if( RB[rs] & 0x80000000 ){
00661 #ifndef NO_NEED_PC_UPDATE
00662 ac_pc = delay(ac_pc + (imm<<2), 1);
00663 #endif
00664 dbg_printf("Taken to %#x\n", ac_pc + (imm<<2));
00665 }
00666 };
00667
00669 void ac_behavior( bgez )
00670 {
00671 dbg_printf("bgez r%d, %d\n", rs, imm & 0xFFFF);
00672 if( !(RB[rs] & 0x80000000) ){
00673 #ifndef NO_NEED_PC_UPDATE
00674 ac_pc = delay(ac_pc + (imm<<2), 1);
00675 #endif
00676 dbg_printf("Taken to %#x\n", ac_pc + (imm<<2));
00677 }
00678 };
00679
00681 void ac_behavior( bltzal )
00682 {
00683 dbg_printf("bltzal r%d, %d\n", rs, imm & 0xFFFF);
00684 RB[Ra] = ac_pc+4;
00685 if( RB[rs] & 0x80000000 ){
00686 #ifndef NO_NEED_PC_UPDATE
00687 ac_pc = delay(ac_pc + (imm<<2), 1);
00688 #endif
00689 dbg_printf("Taken to %#x\n", ac_pc + (imm<<2));
00690 }
00691 dbg_printf("Return = %#x\n", ac_pc+4);
00692 };
00693
00695 void ac_behavior( bgezal )
00696 {
00697 dbg_printf("bgezal r%d, %d\n", rs, imm & 0xFFFF);
00698 RB[Ra] = ac_pc+4;
00699 if( !(RB[rs] & 0x80000000) ){
00700 #ifndef NO_NEED_PC_UPDATE
00701 ac_pc = delay(ac_pc + (imm<<2), 1);
00702 #endif
00703 dbg_printf("Taken to %#x\n", ac_pc + (imm<<2));
00704 }
00705 dbg_printf("Return = %#x\n", ac_pc+4);
00706 };
00707
00709 void ac_behavior( sys_call )
00710 {
00711 dbg_printf("syscall\n");
00712 ac_stop();
00713 }
00714
00716 void ac_behavior( instr_break )
00717 {
00718 fprintf(stderr, "instr_break behavior not implemented.\n");
00719 exit(EXIT_FAILURE);
00720 }