1 /* simu.c This is a part of SimuSimple Version 0.5a 2 * Copyright (c) 2000,2001, Kenji KISE 3 ***************************************************************/ 4 #include 5 #include 6 #include 7 #include "define.h" 8 9 static char UsageMessage[] = 10 "SimpleScalar Simulator Ver 0.5a by Kenji KISE, Jan 2001\n\ 11 Usage: SimuSimple [-option] executable [arguments]\n\ 12 -d: debug mode(set ms.debug_flag).\n\ 13 -s: print systemcall trace(set ms.syscall_flag).\n\ 14 -e[num][m]: finish after the num instructions run.\n\ 15 -i: create icount.dat\n\ 16 #-t: trace mode(set ms.trace_flag).\n\ 17 "; 18 19 struct architecture_state as; 20 struct machine_setting ms; 21 struct evaluate e; 22 23 void usage(){ 24 printf("%s", UsageMessage); 25 exit(0); 26 } 27 28 void finish_simulator(){ 29 int i; 30 FILE *fp; 31 char buf[1024]; 32 33 fprintf(stderr,"** %qd instructions are executed.\n", e.tc); 34 fprintf(stderr,"** Simulation finished normally.\n"); 35 36 if(ms.icount_flag){ 37 fp = fopen("icount.dat", "w"); 38 for(i=0; i<256; i++){ 39 if(i==0x01) fprintf(fp, "** Control transfer instruction\n"); 40 if(i==0x20) fprintf(fp, "** Load instruction\n"); 41 if(i==0x30) fprintf(fp, "** Store instruction\n"); 42 if(i==0x40) fprintf(fp, "** Arithmetic instruction\n"); 43 if(i==0x50) fprintf(fp, "** Logical instruction\n"); 44 if(i==0x70) fprintf(fp, "** Floating-point instruction\n"); 45 if(i==0x80) fprintf(fp, "** Convert instruction\n"); 46 if(i==0x90) fprintf(fp, "** Fcc set instruction\n"); 47 if(i==0xa0) fprintf(fp, "** Systemcall Etc.\n"); 48 49 getopcode(i, buf); 50 if(e.icount[i]) 51 fprintf(fp, "0x%2x %8s %10qd\n", i, buf, e.icount[i]); 52 } 53 fprintf(fp,"** %qd instructions are executed.\n", e.tc); 54 fprintf(fp,"** Simulation finished normally.\n"); 55 fprintf(fp,"** icount.dat was created.\n"); 56 fclose(fp); 57 fprintf(stderr,"** icount.dat was created.\n"); 58 } 59 exit(0); 60 } 61 62 void init(int argc, char **argv, char **argp){ 63 int i; 64 memset(&as, 0, sizeof(as)); 65 memset(&e , 0, sizeof(e)); 66 memset(&ms, 0, sizeof(ms)); 67 if(argc>1){ 68 for(i=0; i<10; i++){ 69 if(argc==1) break; 70 if((*(char *)(argv[1]))=='-'){ 71 switch( *((char *)(argv[1]) +1) ) 72 { 73 case 'h': usage(); break; 74 case 'd': ms.debug_flag=1; break; 75 case 't': ms.trace_flag=1; break; 76 case 's': ms.syscall_flag=1; break; 77 case 'i': ms.icount_flag=1; break; 78 case 'e': 79 ms.end_tc =atol((char *)(argv[1])+2); 80 if(*((char *)(argv[1])+strlen(argv[1])-1)=='m') 81 ms.end_tc *=1000000; 82 printf("End tc: %.0f\n", (double)ms.end_tc); 83 break; 84 default: 85 fprintf(stderr, "Illegal option -%c is used.\n", 86 *((char *)(argv[1]) +1)); 87 exit(1); 88 } 89 argv++; 90 argc--; 91 } 92 } 93 } 94 if(argc < 2) usage(); 95 argv++; 96 argc--; 97 98 ms.trace_start = 0; 99 ms.trace_end = 20000; 100 mem_init(argc, argv, argp); 101 } 102 103 void main_loop(){ 104 while(1){ 105 as.r[0]=0; 106 fetch_instruction(as.pc, &as.ir); as.npc=as.pc+8; 107 execute_instruction(&as); 108 109 e.tc++; 110 e.icount[as.ir.op & 0xff]++; 111 112 if(ms.end_tc==e.tc) finish_simulator(); 113 if(ms.debug_flag) debugmode(&as); 114 if(ms.trace_flag && e.tc>ms.trace_start) print_status(&as); 115 if(ms.trace_flag && e.tc==ms.trace_end) exit(0); 116 117 as.pc = as.npc; 118 } 119 } 120 121 int main(int argc, char **argv, char **argp){ 122 init(argc, argv, argp); 123 main_loop(); 124 return 0; 125 } 126 /* execute.c This is a part of SimuSimple Version 0.5a 127 * Copyright (c) 2000,2001, Kenji KISE 128 ***************************************************************/ 129 #include 130 #include 131 #include "define.h" 132 133 extern struct machine_setting ms; 134 extern struct evaluate e; 135 136 void execute_instruction(struct architecture_state *as){ 137 float FVd, FVs, FVt; 138 double FDd, FDs, FDt; 139 memcpy(&FVs, &as->f[Rs_i], 4); 140 memcpy(&FVt, &as->f[Rt_i], 4); 141 memcpy(&FDs, &as->f[Rs_i], 8); 142 memcpy(&FDt, &as->f[Rt_i], 8); 143 144 switch(as->ir.op & 0xff){ 145 case __JALR: Rd=Cpc+8; Npc=Rs; break; 146 case __JR: Npc=Rs; break; 147 case __J: Npc=(Cpc&0xf0000000)|(Target<<2); break; 148 case __JAL: Npc=(Cpc&0xf0000000)|(Target<<2); as->r[31]=Cpc+8; 149 break; 150 151 case __BEQ: if(Rs==Rt) Npc=Cpc+8+(Imm<<2); break; 152 case __BNE: if(Rs!=Rt) Npc=Cpc+8+(Imm<<2); break; 153 case __BLEZ: if(Rs<=Rt) Npc=Cpc+8+(Imm<<2); break; 154 case __BGTZ: if(Rs> Rt) Npc=Cpc+8+(Imm<<2); break; 155 case __BLTZ: if(Rs< Rt) Npc=Cpc+8+(Imm<<2); break; 156 case __BGEZ: if(Rs>=Rt) Npc=Cpc+8+(Imm<<2); break; 157 case __BC1F: if(!as->fcc) Npc=Cpc+8+(Imm<<2); break; 158 case __BC1T: if( as->fcc) Npc=Cpc+8+(Imm<<2); break; 159 160 case __LB: load_nbyte(1, SIGNED, Rs+Imm, &Rt); break; 161 case __LH: load_nbyte(2, SIGNED, Rs+Imm, &Rt); break; 162 case __LW: load_nbyte(4, SIGNED, Rs+Imm, &Rt); break; 163 case __LBU: load_nbyte(1, UNSIGN, Rs+Imm, &Rt); break; 164 case __LHU: load_nbyte(2, UNSIGN, Rs+Imm, &Rt); break; 165 case __DLW: 166 load_nbyte(4, SIGNED, Rs+Imm, &as->r[Rt_i]); 167 load_nbyte(4, SIGNED, Rs+Imm+4, &as->r[Rt_i+1]); 168 break; 169 170 case __L_S: 171 load_nbyte(4, SIGNED, Rs+Imm, &as->f[Rt_i]); 172 break; 173 case __L_D: 174 load_nbyte(4, SIGNED, Rs+Imm, &as->f[Rt_i]); 175 load_nbyte(4, SIGNED, Rs+Imm+4, &as->f[Rt_i+1]); 176 break; 177 178 case __SB: store_nbyte(1, Imm+Rs, Rt); break; 179 case __SH: store_nbyte(2, Imm+Rs, Rt); break; 180 case __SW: store_nbyte(4, Rs+Imm, Rt); break; 181 182 case __DSW: 183 store_nbyte(4, Rs+Imm, as->r[Rt_i]); 184 store_nbyte(4, Rs+Imm+4, as->r[Rt_i+1]); 185 break; 186 187 case __S_S: 188 store_nbyte(4, Rs+Imm, as->f[Rt_i]); 189 break; 190 191 case __S_D: 192 store_nbyte(4, Imm+Rs, as->f[Rt_i]); 193 store_nbyte(4, Imm+Rs+4, as->f[Rt_i+1]); 194 break; 195 196 case __DSZ: 197 store_nbyte(4, Rs+Imm, 0); 198 store_nbyte(4, Rs+Imm+4, 0); 199 break; 200 201 /* You shold not use LWL/LWR/SWL/SWR, it is not safe. */ 202 case __LWL: load_nbyte(4, SIGNED, (Rs+Imm) & ~0x3, &Rt); break; 203 case __LWR: load_nbyte(4, SIGNED, (Rs+Imm) & ~0x3, &Rt); break; 204 case __SWL: 205 { 206 DATA_TYPE tmp, dat=0; 207 load_nbyte(4, SIGNED, (Rs+Imm) & ~0x3, &tmp); 208 switch(((Rs+Imm) & 0x03)){ 209 case 0: dat=(tmp & 0xFFFFFF00)|(Rt>>24 & 0x0000FF); break; 210 case 1: dat=(tmp & 0xFFFF0000)|(Rt>>16 & 0x00FFFF); break; 211 case 2: dat=(tmp & 0xFF000000)|(Rt>> 8 & 0xFFFFFF); break; 212 case 3: dat=Rt; break; 213 default: printf("SWL address error\n"); 214 } 215 store_nbyte(4, (Rs+Imm) & ~0x3, dat); 216 } 217 break; 218 case __SWR: 219 { 220 DATA_TYPE tmp, dat=0; 221 load_nbyte(4, SIGNED, (Rs+Imm) & ~0x3, &tmp); 222 switch(((Rs+Imm) & 0x03)){ 223 case 0: dat=Rt; break; 224 case 1: dat=(tmp & 0x000000FF)|(Rt<< 8 & 0xFFFFFF00); break; 225 case 2: dat=(tmp & 0x0000FFFF)|(Rt<<16 & 0xFFFF0000); break; 226 case 3: dat=(tmp & 0x00FFFFFF)|(Rt<<24 & 0xFF000000); break; 227 default: printf("SWR address error\n"); 228 } 229 store_nbyte(4, (Rs+Imm) & ~0x3, dat); 230 } 231 break; 232 233 case __ADD: Rd = Rs + Rt; break; 234 case __ADDI: Rt = Rs + Imm; break; 235 case __ADDU: Rd = Rs + Rt; break; 236 case __ADDIU: Rt = Rs + Imm; break; 237 case __SUB: Rd = Rs - Rt; break; 238 case __SUBU: Rd = Rs - Rt; break; 239 case __MFHI: Rd = as->hi; break; 240 case __AND: Rd = Rs & Rt; break; 241 case __ANDI: Rt = Rs & UImm; break; 242 case __OR: Rd = Rs | Rt; break; 243 case __ORI: Rt = Rs | UImm; break; 244 case __XOR: Rd = Rs ^ Rt; break; 245 case __XORI: Rt = Rs ^ UImm; break; 246 case __NOR: Rd = ~(Rs | Rt); break; 247 case __SLL: Rd = Rt << Shamt; break; 248 case __SLLV: Rd = Rt << (Rs & 0x1f); break; 249 case __SRL: Rd = (unsigned)Rt >> Shamt; break; 250 case __SRLV: Rd = (unsigned)Rt >> (Rs & 0x1f); break; 251 case __SRA: Rd = Rt >> Shamt; break; 252 case __SRAV: Rd = Rt >> (Rs & 0x1f); break; 253 case __SLT: Rd = (Rs < Rt); break; 254 case __SLTI: Rt = (Rs < Imm); break; 255 case __SLTU: Rd = ((unsigned)Rs < (unsigned) Rt); break; 256 case __SLTIU: Rt = ((unsigned)Rs < (unsigned)Imm); break; 257 258 case __DIV: 259 as->lo = Rs / Rt; 260 as->hi = Rs % Rt; 261 break; 262 263 case __DIVU: 264 as->lo = (unsigned)Rs / (unsigned)Rt; 265 as->hi = (unsigned)Rs % (unsigned)Rt; 266 break; 267 268 case __MULT: 269 { 270 long long out; 271 out =(long long)Rs * (long long)Rt; 272 as->lo = (int)out; 273 as->hi = (int)(out >> 32); 274 } 275 break; 276 277 case __MULTU: 278 { 279 ULL out; 280 out =((ULL)Rs & 0xFFFFFFFF) * ((ULL)Rt & 0xFFFFFFFF); 281 as->lo = (unsigned int)out; 282 as->hi = (unsigned int)(out >> 32); 283 } 284 break; 285 286 case __MTHI: as->hi = Rs; break; 287 case __MTLO: as->lo = Rs; break; 288 case __MFLO: Rd = as->lo; break; 289 290 case __FADD_S: FVd = FVs + FVt; memcpy(&Fd, &FVd, 4); break; 291 case __FADD_D: FDd = FDs + FDt; memcpy(&Fd, &FDd, 8); break; 292 case __FSUB_S: FVd = FVs - FVt; memcpy(&Fd, &FVd, 4); break; 293 case __FSUB_D: FDd = FDs - FDt; memcpy(&Fd, &FDd, 8); break; 294 case __FMUL_S: FVd = FVs * FVt; memcpy(&Fd, &FVd, 4); break; 295 case __FMUL_D: FDd = FDs * FDt; memcpy(&Fd, &FDd, 8); break; 296 case __FDIV_S: FVd = FVs / FVt; memcpy(&Fd, &FVd, 4); break; 297 case __FDIV_D: FDd = FDs / FDt; memcpy(&Fd, &FDd, 8); break; 298 case __FMOV_S: FVd = FVs; memcpy(&Fd, &FVd, 4); break; 299 case __FMOV_D: FDd = FDs; memcpy(&Fd, &FDd, 8); break; 300 case __FNEG_S: FVd =-FVs; memcpy(&Fd, &FVd, 4); break; 301 case __FNEG_D: FDd =-FDs; memcpy(&Fd, &FDd, 8); break; 302 case __FABS_S: FVd = fabs((double)FVs); memcpy(&Fd, &FVd, 4); break; 303 case __FSQRT_S:FDd = sqrt((double)FDs); memcpy(&Fd, &FDd, 4); break; 304 case __FABS_D: FDd = fabs(FDs); memcpy(&Fd, &FDd, 8); break; 305 case __FSQRT_D:FDd = sqrt(FDs); memcpy(&Fd, &FDd, 8); break; 306 307 case __CVT_S_D: FVd = (float )FDs; memcpy(&Fd, &FVd, 4); break; 308 case __CVT_D_S: FDd = (double)FVs; memcpy(&Fd, &FDd, 8); break; 309 case __CVT_S_W: FVd = (float )as->f[Rs_i]; memcpy(&Fd,&FVd,4);break; 310 case __CVT_D_W: FDd = (double)as->f[Rs_i]; memcpy(&Fd,&FDd,8);break; 311 case __CVT_W_S: as->f[Rd_i] = (int)FVs; break; 312 case __CVT_W_D: as->f[Rd_i] = (int)FDs; break; 313 314 case __C_EQ_S: as->fcc=(FVs==FVt); break; 315 case __C_EQ_D: as->fcc=(FDs==FDt); break; 316 case __C_LT_S: as->fcc=(FVs fcc=(FDs fcc=(FVs<=FVt); break; 319 case __C_LE_D: as->fcc=(FDs<=FDt); break; 320 321 case __NOP: break; 322 case __SYSCALL: execute_syscall(as); break; 323 case __BREAK: fprintf(stderr, "__BREAK\n"); exit(0); break; 324 case __LUI: Rt = UImm << 16; break; 325 case __MFC1: Rt = as->f[Rs_i]; break; 326 case __CFC1: break; 327 case __MTC1: as->f[Rs_i] = Rt; break; 328 case __CTC1: break; 329 case __DMFC1: 330 Rt = as->f[Rs_i]; 331 as->r[Rt_i+1] = as->f[Rs_i+1]; 332 break; 333 case __DMTC1: 334 as->f[Rs_i] = as->r[Rt_i]; 335 as->f[Rs_i+1] = as->r[Rt_i+1] ; 336 break; 337 338 case __LB_RR: 339 case __LBU_RR: 340 case __LHU_RR: 341 case __LW_RR: 342 case __L_S_RR: 343 case __SB_RR: 344 case __SH_RR: 345 case __SW_RR: 346 case __S_S_RR: 347 case __L_S_RR_R2: 348 case __S_S_RR_R2: 349 case __LW_RR_R2: 350 case __SW_RR_R2: 351 case __DLW_RR: 352 case __L_D_RR: 353 case __DSW_RR: 354 case __DSZ_RR: 355 case __S_D_RR: 356 case __LH_RR : 357 default: 358 fprintf(stderr, "TC:%qd 0x%x Not Implemented.\n", 359 e.tc, as->ir.op & 0xff); 360 exit(0); 361 } 362 } 363 /* memory.c This is a part of SimuSimple Version 0.5a 364 * Copyright (c) 2000,2001, Kenji KISE 365 ***************************************************************/ 366 #include 367 #include 368 #include 369 #include "define.h" 370 371 extern struct architecture_state as; 372 extern struct evaluate e; 373 374 void mem_init(int argc, char **argv, char **argp){ 375 FILE *fp; 376 FILE *fp_tmp; 377 int i,j; 378 int *buf; 379 char *cbuf; 380 ADDR_TYPE sp; 381 ADDR_TYPE argv_addr, argp_addr; 382 char *envp[] = { 383 "TERM=vt100", 384 NULL 385 }; 386 387 struct ecoff_filehdr fhdr; 388 struct ecoff_aouthdr ahdr; 389 struct ecoff_scnhdr shdr; 390 391 char *program_name = argv[0]; 392 393 /* initialize a page table */ 394 for(i=0; ipc || as.text_max_addressop); 523 load_nbyte(4, SIGNED, pc+4, &ir->low); 524 } 525 526 void load_byte(int fnc, ADDR_TYPE adr, DATA_TYPE *data){ 527 char c; 528 char *ptr = as.block_table[TABLE_INDEX(adr)]; 529 unsigned int offset = adr & BLOCK_MASK; 530 if(ptr==NULL) ptr=allocblock(adr); 531 c = *(ptr+offset); 532 if(fnc==SIGNED) *data = (DATA_TYPE)c; 533 else *data = (DATA_TYPE)c & 0xFF; 534 } 535 536 void load_2byte(int fnc, ADDR_TYPE adr, DATA_TYPE *data){ 537 short srt; 538 char *ptr = as.block_table[TABLE_INDEX(adr)]; 539 unsigned int offset = adr & BLOCK_MASK; 540 if(adr%2!=0) printf("load_2byte miss-alignment.\n"); 541 if(ptr==NULL) ptr=allocblock(adr); 542 memcpy(&srt, ptr+offset, 2); 543 if(fnc==SIGNED) *data = srt; 544 else *data = (int)srt & 0xFFFF; 545 } 546 547 void load_4byte(ADDR_TYPE adr, DATA_TYPE *data){ 548 char *ptr = as.block_table[TABLE_INDEX(adr)]; 549 unsigned int offset = adr & BLOCK_MASK; 550 if(adr%4!=0) printf("%qd load_4byte miss-alignment.\n", e.tc); 551 if(ptr==NULL) ptr=allocblock(adr); 552 memcpy(data, ptr+offset, 4); 553 } 554 555 void store_byte(ADDR_TYPE adr, DATA_TYPE data){ 556 char c = (char)(data & 0xFF); 557 char *ptr = as.block_table[TABLE_INDEX(adr)]; 558 unsigned int offset = adr & BLOCK_MASK; 559 if(ptr==NULL) ptr=allocblock(adr); 560 *(ptr+offset) = c; 561 } 562 563 void store_2byte(ADDR_TYPE adr, DATA_TYPE data){ 564 short srt = (short)(data & 0xFFFF); 565 char *ptr = as.block_table[TABLE_INDEX(adr)]; 566 unsigned int offset = adr & BLOCK_MASK; 567 if(ptr==NULL) ptr=allocblock(adr); 568 memcpy(ptr+offset, &srt, 2); 569 } 570 571 void store_4byte(ADDR_TYPE adr, DATA_TYPE data){ 572 char *ptr = as.block_table[TABLE_INDEX(adr)]; 573 unsigned int offset = adr & BLOCK_MASK; 574 if(adr%4!=0) printf("store_4byte miss-alignment.\n"); 575 if(ptr==NULL) ptr=allocblock(adr); 576 memcpy(ptr+offset, &data, 4); 577 } 578 579 void store_nbyte(int n, ADDR_TYPE adr, DATA_TYPE data){ 580 switch(n){ 581 case 1: store_byte( adr, data); break; 582 case 2: store_2byte(adr, data); break; 583 case 4: store_4byte(adr, data); break; 584 default: 585 printf("Case %d, Error in store_nbyte\n", n); exit(1); 586 } 587 } 588 589 void load_nbyte(int n, int fnc, ADDR_TYPE adr, DATA_TYPE *data){ 590 switch(n){ 591 case 1: load_byte( fnc, adr, data); break; 592 case 2: load_2byte(fnc, adr, data); break; 593 case 4: load_4byte( adr, data); break; 594 default: 595 printf("Case %d, Error in load_nbyte\n", n); exit(1); 596 } 597 } 598 /* syscall.c This is a part of SimuSimple Version 0.5a 599 * Copyright (c) 2000,2001, Kenji KISE 600 ***************************************************************/ 601 #include 602 #include 603 #include 604 #include 605 #include 606 #include 607 #include 608 #include 609 #include 610 #include 611 #include "define.h" 612 613 extern struct machine_setting ms; 614 extern struct evaluate e; 615 616 struct ss_flag_table ss_flag_table[] = { 617 {0,00}, {1,01}, {2,02}, {0x0008,02000}, 618 {0x0200,0100}, {0x0400,01000}, {0x0800,0200}, 619 {0x4000,04000}, {0x8000,0400}, {0x2000,010000}, 620 }; 621 622 void sys_error_check(struct architecture_state *as){ 623 if(as->r[2]!=-1) as->r[7]=0; 624 else{as->r[2]=errno; as->r[7]=1;} 625 } 626 627 628 void execute_syscall(struct architecture_state *as){ 629 int code = as->r[2]; 630 char *buf; 631 632 switch(code){ 633 case SYS_exit: 634 finish_simulator(); 635 break; 636 637 case SYS_getrusage: 638 { 639 struct rusage local_rusage; 640 struct ss_rusage rusage; 641 as->r[2]=getrusage((enum __rusage_who)as->r[4], 642 &local_rusage); 643 sys_error_check(as); 644 645 rusage.ss_ru_utime.ss_tv_sec = local_rusage.ru_utime.tv_sec; 646 rusage.ss_ru_utime.ss_tv_usec= local_rusage.ru_utime.tv_usec; 647 rusage.ss_ru_utime.ss_tv_sec = local_rusage.ru_utime.tv_sec; 648 rusage.ss_ru_utime.ss_tv_usec= local_rusage.ru_utime.tv_usec; 649 rusage.ss_ru_stime.ss_tv_sec = local_rusage.ru_stime.tv_sec; 650 rusage.ss_ru_stime.ss_tv_usec= local_rusage.ru_stime.tv_usec; 651 rusage.ss_ru_stime.ss_tv_sec = local_rusage.ru_stime.tv_sec; 652 rusage.ss_ru_stime.ss_tv_usec= local_rusage.ru_stime.tv_usec; 653 rusage.ss_ru_maxrss = local_rusage.ru_maxrss; 654 rusage.ss_ru_ixrss = local_rusage.ru_ixrss; 655 rusage.ss_ru_idrss = local_rusage.ru_idrss; 656 rusage.ss_ru_isrss = local_rusage.ru_isrss; 657 rusage.ss_ru_minflt = local_rusage.ru_minflt; 658 rusage.ss_ru_majflt = local_rusage.ru_majflt; 659 rusage.ss_ru_nswap = local_rusage.ru_nswap; 660 rusage.ss_ru_inblock = local_rusage.ru_inblock; 661 rusage.ss_ru_oublock = local_rusage.ru_oublock; 662 rusage.ss_ru_msgsnd = local_rusage.ru_msgsnd; 663 rusage.ss_ru_msgrcv = local_rusage.ru_msgrcv; 664 rusage.ss_ru_nsignals= local_rusage.ru_nsignals; 665 rusage.ss_ru_nvcsw = local_rusage.ru_nvcsw; 666 rusage.ss_ru_nivcsw = local_rusage.ru_nivcsw; 667 668 store_memory(as->r[5], (char *)&rusage, 669 sizeof(struct ss_rusage)); 670 } 671 break; 672 673 case SYS_gettimeofday: 674 { 675 struct ss_timeval ss_tv; 676 struct ss_timezone ss_tz; 677 struct timezone tz, *tzp; 678 struct timeval tv, *tvp; 679 680 if(as->r[4]!=0){ 681 load_memory(as->r[4], (char *)&ss_tv, 682 sizeof(struct ss_timeval)); 683 tv.tv_sec = ss_tv.ss_tv_sec; 684 tv.tv_usec = ss_tv.ss_tv_usec; 685 tvp = &tv; 686 } 687 else tvp=0; 688 689 if (as->r[5]!=0){ 690 load_memory(as->r[5], (char *)&ss_tz, 691 sizeof(struct ss_timezone)); 692 tz.tz_minuteswest = ss_tz.ss_tz_minuteswest; 693 tz.tz_dsttime = ss_tz.ss_tz_dsttime; 694 tzp = &tz; 695 } 696 else tzp=0; 697 698 as->r[2]=gettimeofday(tvp, tzp); 699 sys_error_check(as); 700 701 if(as->r[4]!=0){ 702 ss_tv.ss_tv_sec = tv.tv_sec; 703 ss_tv.ss_tv_usec = tv.tv_usec; 704 store_memory(as->r[4], (char *)&ss_tv, 705 sizeof(struct ss_timeval)); 706 } 707 if(as->r[5] != 0){ 708 ss_tz.ss_tz_minuteswest = tz.tz_minuteswest; 709 ss_tz.ss_tz_dsttime = tz.tz_dsttime; 710 store_memory(as->r[5], (char *)&ss_tz, 711 sizeof(struct ss_timezone)); 712 } 713 } 714 break; 715 716 case SYS_sigvec: 717 as->r[2]=as->r[7]=0; 718 break; 719 720 case SYS_getpagesize: 721 as->r[2] = PAGE_SIZE; 722 break; 723 724 case SYS_read: 725 buf = (char *)calloc(as->r[6], 1); 726 as->r[2] = read(as->r[4], buf, as->r[6]); 727 sys_error_check(as); 728 store_memory(as->r[5], buf, as->r[2]); 729 free(buf); 730 break; 731 732 case SYS_write: 733 buf=(char *)calloc(as->r[6], 1); 734 load_memory(as->r[5], buf, as->r[6]); 735 as->r[2] = write(as->r[4], buf, as->r[6]); 736 fflush(stdout); 737 if(as->r[2]==as->r[6]) as->r[7]=0; 738 else{as->r[2]=errno; as->r[7]=1;} 739 free(buf); 740 break; 741 742 case SYS_open: 743 { 744 char buf[1024]; 745 unsigned int i; 746 DATA_TYPE d; 747 int ss_flags = as->r[5]; 748 int local_flags = 0; 749 750 for(i=0; ir[4]+i, &d); 759 *(buf+i) = (char)(d & 0xFF); 760 if(*(buf+i)==0) break; 761 } 762 as->r[2]=open(buf, local_flags, as->r[6]); 763 sys_error_check(as); 764 } 765 break; 766 767 case SYS_close: 768 if(as->r[4]==0 || as->r[4]==1 || as->r[4]==2){ 769 as->r[7]=0; 770 } 771 else{ 772 as->r[2]=close(as->r[4]); 773 sys_error_check(as); 774 } 775 break; 776 777 case SYS_lseek: 778 as->r[2]=lseek(as->r[4], as->r[5], as->r[6]); 779 sys_error_check(as); 780 break; 781 782 case SYS_getpid: 783 as->r[2]=getpid(); 784 sys_error_check(as); 785 break; 786 787 case SYS_brk: 788 { 789 ADDR_TYPE addr=(as->r[4]+PAGE_SIZE-1) & ~(PAGE_SIZE-1); 790 if(addr>=as->brk && addr<(unsigned int)as->r[29]){ 791 as->r[2]=0; 792 as->r[7]=0; 793 as->brk=addr; 794 } 795 else{ 796 as->r[2]=ENOMEM; 797 as->r[7]=1; 798 } 799 } 800 break; 801 802 case SYS_ioctl: 803 { 804 char buf[128]; 805 int local_req=0; 806 807 switch(as->r[5]){ 808 case 1074164744: local_req = 0x5481; break; 809 case -2147060727: local_req = 0x5482; break; 810 case 1076130901: local_req = 0x5481; break; 811 case 1075082331: local_req = 0x5405; break; 812 case 1074164852: local_req = 0x5485; break; 813 case -2147060619: local_req = 0x5486; break; 814 case 1074295912: local_req = 0x5413; break; 815 case -2146143143: local_req = 0x5407; break; 816 case 1074164754: local_req = 0x5483; break; 817 case -2147060719: local_req = 0x5484; break; 818 case 0x4004747c: local_req = 0x5487; break; 819 case 0x8004747d: local_req = 0x5488; break; 820 } 821 822 if(!local_req){ 823 printf("syscall: ioctl error.\n"); exit(0); 824 } 825 else{ 826 if(as->r[6]!=0) load_memory(as->r[6], buf, 128); 827 as->r[2]=ioctl(as->r[4], local_req, buf); 828 if(as->r[6]!=0) store_memory(as->r[6], buf, 128); 829 sys_error_check(as); 830 } 831 } 832 break; 833 834 case SYS_fstat: 835 { 836 struct ss_statbuf ss_sbuf; 837 struct stat sbuf; 838 839 as->r[2]=fstat(as->r[4], &sbuf); 840 sys_error_check(as); 841 842 ss_sbuf.ss_st_dev = sbuf.st_dev; 843 ss_sbuf.ss_st_ino = sbuf.st_ino; 844 ss_sbuf.ss_st_mode = sbuf.st_mode; 845 ss_sbuf.ss_st_nlink = sbuf.st_nlink; 846 ss_sbuf.ss_st_uid = sbuf.st_uid; 847 ss_sbuf.ss_st_gid = sbuf.st_gid; 848 ss_sbuf.ss_st_rdev = sbuf.st_rdev; 849 ss_sbuf.ss_st_size = sbuf.st_size; 850 ss_sbuf.ss_st_atime = sbuf.st_atime; 851 ss_sbuf.ss_st_mtime = sbuf.st_mtime; 852 ss_sbuf.ss_st_ctime = sbuf.st_ctime; 853 ss_sbuf.ss_st_blksize = sbuf.st_blksize; 854 ss_sbuf.ss_st_blocks = sbuf.st_blocks; 855 store_memory(as->r[5], (char*)&ss_sbuf, 856 sizeof(struct ss_statbuf)); 857 } 858 break; 859 860 default: 861 printf("Tc:%8qd In syscall.c Default Error %d\n", 862 e.tc, as->r[2]); 863 exit(1); 864 } 865 866 if(ms.syscall_flag){ 867 printf("** TC:%qd: %d syscall(%d,%d,%d) => %d \n", 868 e.tc, code, as->r[4], as->r[5], as->r[6], as->r[2]); 869 fflush(stdout); 870 } 871 } 872 /* getasm.c This is a part of SimuSimple Version 0.5a 873 * Copyright (c) 2000,2001, Kenji KISE 874 ***************************************************************/ 875 #include 876 #include 877 #include 878 #include "define.h" 879 880 void getopcode(int op, char *b){ 881 switch(op){ 882 case __J: sprintf(b,"j"); break; 883 case __JAL: sprintf(b,"jal"); break; 884 case __JR: sprintf(b,"jr"); break; 885 case __JALR: sprintf(b,"jalr"); break; 886 case __BEQ: sprintf(b,"beq"); break; 887 case __BNE: sprintf(b,"bne"); break; 888 case __BLEZ: sprintf(b,"blez"); break; 889 case __BGTZ: sprintf(b,"bgtz"); break; 890 case __BLTZ: sprintf(b,"bltz"); break; 891 case __BGEZ: sprintf(b,"bgez"); break; 892 case __BC1F: sprintf(b,"bc1f"); break; 893 case __BC1T: sprintf(b,"bc1t"); break; 894 895 case __LB: sprintf(b,"lb"); break; 896 case __LBU: sprintf(b,"lbu"); break; 897 case __LH: sprintf(b,"lh"); break; 898 case __LHU: sprintf(b,"lhu"); break; 899 case __LW: sprintf(b,"lw"); break; 900 case __DLW: sprintf(b,"dlw"); break; 901 case __L_S: sprintf(b,"l.s."); break; 902 case __L_D: sprintf(b,"l.d."); break; 903 case __LWL: sprintf(b,"lwl"); break; 904 case __LWR: sprintf(b,"lwr"); break; 905 case __SB: sprintf(b,"sb"); break; 906 case __SH: sprintf(b,"sh"); break; 907 case __SW: sprintf(b,"sw"); break; 908 case __S_S: sprintf(b,"s.s."); break; 909 case __DSW: sprintf(b,"dsw"); break; 910 case __S_D: sprintf(b,"s.d."); break; 911 case __DSZ: sprintf(b,"dsz"); break; 912 case __SWL: sprintf(b,"swl"); break; 913 case __SWR: sprintf(b,"swr"); break; 914 915 case __ADD: sprintf(b,"add"); break; 916 case __ADDI: sprintf(b,"addi"); break; 917 case __ADDU: sprintf(b,"addu"); break; 918 case __ADDIU: sprintf(b,"addiu"); break; 919 case __SUB: sprintf(b,"sub"); break; 920 case __SUBU: sprintf(b,"subu"); break; 921 case __MULT: sprintf(b,"mult"); break; 922 case __MULTU: sprintf(b,"multu"); break; 923 case __DIV: sprintf(b,"div"); break; 924 case __DIVU: sprintf(b,"divu"); break; 925 case __MFHI: sprintf(b,"mfhi"); break; 926 case __MTHI: sprintf(b,"mthi"); break; 927 case __MFLO: sprintf(b,"mflo"); break; 928 case __MTLO: sprintf(b,"mtlo"); break; 929 case __AND: sprintf(b,"and"); break; 930 case __ANDI: sprintf(b,"andi"); break; 931 case __OR: sprintf(b,"or"); break; 932 case __ORI: sprintf(b,"ori"); break; 933 case __XOR: sprintf(b,"xor"); break; 934 case __XORI: sprintf(b,"xori"); break; 935 case __NOR: sprintf(b,"nor"); break; 936 case __SLL: sprintf(b,"sll"); break; 937 case __SLLV: sprintf(b,"sllv"); break; 938 case __SRL: sprintf(b,"srl"); break; 939 case __SRLV: sprintf(b,"srlv"); break; 940 case __SRA: sprintf(b,"sra"); break; 941 case __SRAV: sprintf(b,"srav"); break; 942 case __SLT: sprintf(b,"slt"); break; 943 case __SLTI: sprintf(b,"slti"); break; 944 case __SLTU: sprintf(b,"sltu"); break; 945 case __SLTIU: sprintf(b,"sltiu"); break; 946 947 case __FADD_S: sprintf(b,"fadd.s"); break; 948 case __FADD_D: sprintf(b,"fadd.d"); break; 949 case __FSUB_S: sprintf(b,"fsub.s"); break; 950 case __FSUB_D: sprintf(b,"fsub.d"); break; 951 case __FMUL_S: sprintf(b,"fmul.s"); break; 952 case __FMUL_D: sprintf(b,"fmul.d"); break; 953 case __FDIV_S: sprintf(b,"fdiv.s"); break; 954 case __FDIV_D: sprintf(b,"fdiv.d"); break; 955 case __FABS_S: sprintf(b,"fabs.s"); break; 956 case __FABS_D: sprintf(b,"fabs.d"); break; 957 case __FMOV_S: sprintf(b,"fmov.s"); break; 958 case __FMOV_D: sprintf(b,"fmov.d"); break; 959 case __FNEG_S: sprintf(b,"fneg.s"); break; 960 case __FNEG_D: sprintf(b,"fneg.d"); break; 961 case __CVT_S_D: sprintf(b,"cvt.s.d"); break; 962 case __CVT_S_W: sprintf(b,"cvt.s.w"); break; 963 case __CVT_D_S: sprintf(b,"cvt.d.s"); break; 964 case __CVT_D_W: sprintf(b,"cvt.d.w"); break; 965 case __CVT_W_S: sprintf(b,"cvt.w.s"); break; 966 case __CVT_W_D: sprintf(b,"cvt.w.d"); break; 967 case __C_EQ_S: sprintf(b,"c.eq.s"); break; 968 case __C_EQ_D: sprintf(b,"c.eq.d"); break; 969 case __C_LT_S: sprintf(b,"c.lt.s"); break; 970 case __C_LT_D: sprintf(b,"c.lt.d"); break; 971 case __C_LE_S: sprintf(b,"c.le.s"); break; 972 case __C_LE_D: sprintf(b,"c.le.d"); break; 973 case __FSQRT_S: sprintf(b,"fsqrt.s"); break; 974 case __FSQRT_D: sprintf(b,"fsqrt.d"); break; 975 976 case __NOP: sprintf(b,"nop"); break; 977 case __SYSCALL: sprintf(b,"syscall"); break; 978 case __BREAK: sprintf(b,"break"); break; 979 case __LUI: sprintf(b,"lui"); break; 980 case __MFC1: sprintf(b,"mfc1"); break; 981 case __CFC1: sprintf(b,"cfc1"); break; 982 case __MTC1: sprintf(b,"mtc1"); break; 983 case __CTC1: sprintf(b,"ctc1"); break; 984 case __DMFC1: sprintf(b,"dmfc1"); break; 985 case __DMTC1: sprintf(b,"dmtc1"); break; 986 case __LB_RR: sprintf(b,"lb.rr"); break; 987 case __LBU_RR: sprintf(b,"lbu.rr"); break; 988 case __LHU_RR: sprintf(b,"lhu.rr"); break; 989 case __LW_RR: sprintf(b,"l.w.rr"); break; 990 case __L_S_RR: sprintf(b,"l.s.rr"); break; 991 case __SB_RR: sprintf(b,"sb.rr"); break; 992 case __SH_RR: sprintf(b,"sh.rr"); break; 993 case __SW_RR: sprintf(b,"sw.rr"); break; 994 case __S_S_RR: sprintf(b,"s.s.rr"); break; 995 case __L_S_RR_R2: sprintf(b,"l.s.rr.r2"); break; 996 case __S_S_RR_R2: sprintf(b,"s.s.rr_r2"); break; 997 case __LW_RR_R2: sprintf(b,"lw.rr.r2"); break; 998 case __SW_RR_R2: sprintf(b,"sw.rr.r2"); break; 999 case __DLW_RR: sprintf(b,"dlw.rr"); break; 1000 case __L_D_RR: sprintf(b,"l.d.rr"); break; 1001 case __DSW_RR: sprintf(b,"dsw.rr"); break; 1002 case __DSZ_RR: sprintf(b,"dsz.rr"); break; 1003 case __S_D_RR: sprintf(b,"s.d.rr"); break; 1004 case __LH_RR : sprintf(b,"lh.rr"); break; 1005 default: sprintf(b,"N/A"); break; 1006 } 1007 } 1008 1009 1010 void getasm(struct architecture_state *as, char *buf){ 1011 char b[128]; 1012 int opcode = as->ir.op & 0xff; 1013 1014 getopcode(opcode, buf); 1015 switch(opcode){ 1016 case __J: sprintf(b,"0x%08x",(Cpc&0xf0000000)|(Target<<2));break; 1017 case __JAL: sprintf(b,"0x%08x",(Cpc&0xf0000000)|(Target<<2));break; 1018 case __JR: sprintf(b,"0x%08x", Rs);break; 1019 case __JALR:sprintf(b,"0x%08x", Rs);break; 1020 case __BEQ: sprintf(b,"$%d, $%d, 0x%08x",Rt_i,Rs_i,Imm);break; 1021 case __BNE: sprintf(b,"$%d, $%d, 0x%08x",Rt_i,Rs_i,Imm);break; 1022 case __BLEZ:sprintf(b,"$%d, $%d, 0x%08x",Rt_i,Rs_i,Imm);break; 1023 case __BGTZ:sprintf(b,"$%d, $%d, 0x%08x",Rt_i,Rs_i,Imm);break; 1024 case __BLTZ:sprintf(b,"$%d, $%d, 0x%08x",Rt_i,Rs_i,Imm);break; 1025 case __BGEZ:sprintf(b,"$%d, $%d, 0x%08x",Rt_i,Rs_i,Imm);break; 1026 case __BC1F:sprintf(b,"0x%x", Imm);break; 1027 case __BC1T:sprintf(b,"0x%x", Imm);break; 1028 1029 case __LB: 1030 case __LBU: 1031 case __LH: 1032 case __LHU: 1033 case __LW: 1034 case __DLW: 1035 case __LWL: 1036 case __LWR: 1037 case __SB: 1038 case __SH: 1039 case __SW: 1040 case __DSZ: 1041 case __SWL: 1042 case __SWR:sprintf(b,"$%d, %d($%d)", Rt_i, Imm, Rs_i);break; 1043 1044 case __L_S: 1045 case __L_D: 1046 case __S_S: 1047 case __DSW: 1048 case __S_D:sprintf(b,"$f%d, %d($%d)", Rt_i, Imm, Rs_i);break; 1049 1050 case __ADDI: 1051 case __ADDIU: 1052 case __ANDI: 1053 case __ORI: 1054 case __XORI: 1055 case __SLTI: 1056 case __SLTIU:sprintf(b,"$%d, $%d, 0x%x", Rt_i,Rs_i,Imm);break; 1057 1058 case __ADD: 1059 case __ADDU: 1060 case __SUB: 1061 case __SUBU: 1062 case __AND: 1063 case __OR: 1064 case __XOR: 1065 case __NOR: 1066 case __SLLV: 1067 case __SRLV: 1068 case __SRAV: 1069 case __SLT: 1070 case __SLTU: sprintf(b,"$%d, $%d, $%d", Rd_i,Rs_i,Rt_i);break; 1071 1072 case __MULT: 1073 case __MULTU: 1074 case __DIV: 1075 case __DIVU: 1076 case __MFHI: 1077 case __MTHI: 1078 case __MFLO: 1079 case __MTLO: sprintf(b, " "); break; 1080 1081 case __SLL: 1082 case __SRL: 1083 case __SRA: sprintf(b,"$%d, $%d, %d", Rd_i, Rt_i, Shamt);break; 1084 1085 case __FADD_S: 1086 case __FADD_D: 1087 case __FSUB_S: 1088 case __FSUB_D: 1089 case __FMUL_S: 1090 case __FMUL_D: 1091 case __FDIV_S: 1092 case __FDIV_D: 1093 case __FABS_S: sprintf(b,"$f%d, $f%d, $f%d", Rd_i,Rs_i,Rt_i);break; 1094 1095 case __FABS_D : 1096 case __FMOV_S : 1097 case __FMOV_D : 1098 case __FNEG_S : 1099 case __FNEG_D : 1100 case __CVT_S_D : 1101 case __CVT_S_W : 1102 case __CVT_D_S : 1103 case __CVT_D_W : 1104 case __CVT_W_S : 1105 case __CVT_W_D : 1106 case __FSQRT_S : 1107 case __FSQRT_D :sprintf(b,"$f%d, $f%d", Rd_i, Rs_i);break; 1108 case __C_EQ_S : 1109 case __C_EQ_D : 1110 case __C_LT_S : 1111 case __C_LT_D : 1112 case __C_LE_S : 1113 case __C_LE_D :sprintf(b,"$f%d, $f%d", Rs_i, Rt_i);break; 1114 1115 1116 case __LUI :sprintf(b,"$%d, 0x%08x", Rt_i, UImm<<16);break; 1117 case __MFC1 :sprintf(b,"$%d, $f%d", Rt_i, Rs_i);break; 1118 case __MTC1 :sprintf(b,"$f%d, $%d", Rs_i, Rt_i);break; 1119 case __DMFC1 :sprintf(b,"$%d, $f%d", Rt_i, Rs_i);break; 1120 1121 case __DMTC1 : 1122 case __LB_RR : 1123 case __LBU_RR : 1124 case __LHU_RR : 1125 case __LW_RR : 1126 case __L_S_RR : 1127 case __SB_RR : 1128 case __SH_RR : 1129 case __SW_RR : 1130 case __S_S_RR : 1131 case __L_S_RR_R2: 1132 case __S_S_RR_R2: 1133 case __LW_RR_R2 : 1134 case __SW_RR_R2 : 1135 case __DLW_RR : 1136 case __L_D_RR : 1137 case __DSW_RR : 1138 case __DSZ_RR : 1139 case __S_D_RR : 1140 case __LH_RR : 1141 1142 /* Miscellaneous instructions */ 1143 case __NOP: 1144 case __CTC1: 1145 case __CFC1: 1146 case __SYSCALL: 1147 case __BREAK: sprintf(b," ");break; 1148 } 1149 strcat(buf, " "); 1150 strcat(buf, b); 1151 } 1152 /* debug.c This is a part of SimuSimple Version 0.5a 1153 * Copyright (c) 2000,2001, Kenji KISE 1154 ***************************************************************/ 1155 #include 1156 #include 1157 #include 1158 #include "define.h" 1159 1160 extern struct evaluate e; 1161 1162 unsigned int get_hex(char *buf){ 1163 int i; 1164 unsigned int temp=0; 1165 unsigned int sum=0; 1166 for(i=0; i<16; i++){ 1167 switch(*(buf+i)){ 1168 case '0': temp=0; break; 1169 case '1': temp=1; break; 1170 case '2': temp=2; break; 1171 case '3': temp=3; break; 1172 case '4': temp=4; break; 1173 case '5': temp=5; break; 1174 case '6': temp=6; break; 1175 case '7': temp=7; break; 1176 case '8': temp=8; break; 1177 case '9': temp=9; break; 1178 case 'a': temp=10;break; 1179 case 'b': temp=11;break; 1180 case 'c': temp=12;break; 1181 case 'd': temp=13;break; 1182 case 'e': temp=14;break; 1183 case 'f': temp=15;break; 1184 default : return sum; 1185 } 1186 sum = sum * 16 + temp; 1187 } 1188 return sum; 1189 } 1190 1191 void print_status(struct architecture_state *as){ 1192 char buf[256]; 1193 1194 getasm(as, buf); 1195 printf("TC:%qd ", e.tc); 1196 printf("PC:0x%08x: IR:0x%02x-%08x %s\n", 1197 as->pc, as->ir.op, as->ir.low, buf); 1198 printf("fcc:%08x hi:%08x lo:%08x\n", 1199 as->fcc, as->hi, as->lo); 1200 1201 printf("$zero r0 %08x %08x: ", as->r[0], as->f[0] ); 1202 printf("$at r1 %08x %08x\n", as->r[1], as->f[1] ); 1203 printf("$v0 r2 %08x %08x: ", as->r[2], as->f[2] ); 1204 printf("$v1 r3 %08x %08x\n", as->r[3], as->f[3] ); 1205 printf("$a0 r4 %08x %08x: ", as->r[4], as->f[4] ); 1206 printf("$a1 r5 %08x %08x\n", as->r[5], as->f[5] ); 1207 printf("$a2 r6 %08x %08x: ", as->r[6], as->f[6] ); 1208 printf("$a3 r7 %08x %08x\n", as->r[7], as->f[7] ); 1209 printf("$t0 r8 %08x %08x: ", as->r[8], as->f[8] ); 1210 printf("$t1 r9 %08x %08x\n", as->r[9], as->f[9] ); 1211 printf("$t2 r10 %08x %08x: ", as->r[10],as->f[10]); 1212 printf("$t3 r11 %08x %08x\n", as->r[11],as->f[11]); 1213 printf("$t4 r12 %08x %08x: ", as->r[12],as->f[12]); 1214 printf("$t5 r13 %08x %08x\n", as->r[13],as->f[13]); 1215 printf("$t6 r14 %08x %08x: ", as->r[14],as->f[14]); 1216 printf("$t7 r15 %08x %08x\n", as->r[15],as->f[15]); 1217 printf("$s0 r16 %08x %08x: ", as->r[16],as->f[16]); 1218 printf("$s1 r17 %08x %08x\n", as->r[17],as->f[17]); 1219 printf("$s2 r18 %08x %08x: ", as->r[18],as->f[18]); 1220 printf("$s3 r19 %08x %08x\n", as->r[19],as->f[19]); 1221 printf("$s4 r20 %08x %08x: ", as->r[20],as->f[20]); 1222 printf("$s5 r21 %08x %08x\n", as->r[21],as->f[21]); 1223 printf("$s6 r22 %08x %08x: ", as->r[22],as->f[22]); 1224 printf("$s7 r23 %08x %08x\n", as->r[23],as->f[23]); 1225 printf("$t8 r24 %08x %08x: ", as->r[24],as->f[24]); 1226 printf("$t9 r25 %08x %08x\n", as->r[25],as->f[25]); 1227 printf("$k0 r26 %08x %08x: ", as->r[26],as->f[26]); 1228 printf("$k1 r27 %08x %08x\n", as->r[27],as->f[27]); 1229 printf("$gp r28 %08x %08x: ", as->r[28],as->f[28]); 1230 printf("$sp r29 %08x %08x\n", as->r[29],as->f[29]); 1231 printf("$s8 r30 %08x %08x: ", as->r[30],as->f[30]); 1232 printf("$ra r31 %08x %08x\n", as->r[31],as->f[31]); 1233 fflush(stdout); 1234 } 1235 1236 void debugmode(struct architecture_state *as){ 1237 static int stop=1; 1238 int i, j; 1239 static ULL stop_count=0; 1240 char *buf =(char *)calloc(256,1); 1241 1242 if(e.tc==stop_count) stop=1; 1243 if(stop==0) return; 1244 if(stop==1){ 1245 print_status(as); 1246 printf("(db)"); 1247 1248 fgets(buf, 256, stdin); 1249 while(*buf != (char)NULL){ 1250 if(*(buf)=='\n') break; 1251 1252 if(!strncmp(buf,"q",1)){ 1253 printf("Exit\n"); fflush(stdout); exit(0); 1254 } 1255 1256 if(!strncmp(buf,"h",1)){ /* Print help message */ 1257 printf(" command\n"); 1258 printf(" c followd by number: stop specified tc\n"); 1259 printf(" x followd by address: examine specified address\n"); 1260 printf(" q: quit the simulator\n"); 1261 } 1262 1263 if(*(buf)=='c'){ /* stop by total count,TC */ 1264 buf++; 1265 stop_count = atol(buf); 1266 printf("stop_tc = %qd\n", stop_count); 1267 stop=0; 1268 break; 1269 } 1270 1271 if(*(buf)=='x'){ 1272 ADDR_TYPE tmp; 1273 ADDR_TYPE address; 1274 address = get_hex(buf+1); 1275 for(j=0; j<20; j++){ 1276 printf("0x%08x: ",address); 1277 for(i=0; i<4; i++){ 1278 load_nbyte(4, SIGNED, address, (int *)&tmp); 1279 printf("0x%08x ", tmp); 1280 address +=4; 1281 } 1282 printf("\n"); 1283 } 1284 } 1285 printf("\n"); printf("(db)"); 1286 fgets(buf,256,stdin); 1287 } 1288 } 1289 } 1290 /***** 1. type definitions *****/ 1291 typedef unsigned long long ULL; 1292 typedef unsigned int ADDR_TYPE; 1293 typedef int DATA_TYPE; 1294 typedef struct{int op; int low;} INST_TYPE; 1295 1296 /***** 2. Constant Definition *****/ 1297 #define PAGE_SIZE 4096 /* 4KB page */ 1298 #define BLOCK_SIZE 0x00010000 /* 64KB block */ 1299 #define BLOCK_TABLE_SIZE 0x00008000 1300 #define BLOCK_MASK 0x0000FFFF 1301 #define STACK_BASE 0x7fffc000 1302 #define MAX_ENVIRON 16384 1303 #define SS_TEXT_BASE 0x00400000 1304 1305 #define SIGNED 1 1306 #define UNSIGN 2 1307 1308 #define __J 0x01 1309 #define __JAL 0x02 1310 #define __JR 0x03 1311 #define __JALR 0x04 1312 #define __BEQ 0x05 1313 #define __BNE 0x06 1314 #define __BLEZ 0x07 1315 #define __BGTZ 0x08 1316 #define __BLTZ 0x09 1317 #define __BGEZ 0x0a 1318 #define __BC1F 0x0b 1319 #define __BC1T 0x0c 1320 1321 #define __LB 0x20 1322 #define __LBU 0x22 1323 #define __LH 0x24 1324 #define __LHU 0x26 1325 #define __LW 0x28 1326 #define __DLW 0x29 1327 #define __L_S 0x2a 1328 #define __L_D 0x2b 1329 #define __LWL 0x2c 1330 #define __LWR 0x2d 1331 1332 #define __SB 0x30 1333 #define __SH 0x32 1334 #define __SW 0x34 1335 #define __S_S 0x36 1336 #define __DSW 0x35 1337 #define __S_D 0x37 1338 #define __DSZ 0x38 1339 #define __SWL 0x39 1340 #define __SWR 0x3a 1341 1342 #define __ADD 0x40 1343 #define __ADDI 0x41 1344 #define __ADDU 0x42 1345 #define __ADDIU 0x43 1346 #define __SUB 0x44 1347 #define __SUBU 0x45 1348 #define __MULT 0x46 1349 #define __MULTU 0x47 1350 #define __DIV 0x48 1351 #define __DIVU 0x49 1352 #define __MFHI 0x4a 1353 #define __MTHI 0x4b 1354 #define __MFLO 0x4c 1355 #define __MTLO 0x4d 1356 #define __AND 0x4e 1357 #define __ANDI 0x4f 1358 1359 #define __OR 0x50 1360 #define __ORI 0x51 1361 #define __XOR 0x52 1362 #define __XORI 0x53 1363 #define __NOR 0x54 1364 #define __SLL 0x55 1365 #define __SLLV 0x56 1366 #define __SRL 0x57 1367 #define __SRLV 0x58 1368 #define __SRA 0x59 1369 #define __SRAV 0x5a 1370 #define __SLT 0x5b 1371 #define __SLTI 0x5c 1372 #define __SLTU 0x5d 1373 #define __SLTIU 0x5e 1374 1375 #define __FADD_S 0x70 1376 #define __FADD_D 0x71 1377 #define __FSUB_S 0x72 1378 #define __FSUB_D 0x73 1379 #define __FMUL_S 0x74 1380 #define __FMUL_D 0x75 1381 #define __FDIV_S 0x76 1382 #define __FDIV_D 0x77 1383 #define __FABS_S 0x78 1384 #define __FABS_D 0x79 1385 #define __FMOV_S 0x7a 1386 #define __FMOV_D 0x7b 1387 #define __FNEG_S 0x7c 1388 #define __FNEG_D 0x7d 1389 1390 #define __CVT_S_D 0x80 1391 #define __CVT_S_W 0x81 1392 #define __CVT_D_S 0x82 1393 #define __CVT_D_W 0x83 1394 #define __CVT_W_S 0x84 1395 #define __CVT_W_D 0x85 1396 1397 #define __C_EQ_S 0x90 1398 #define __C_EQ_D 0x91 1399 #define __C_LT_S 0x92 1400 #define __C_LT_D 0x93 1401 #define __C_LE_S 0x94 1402 #define __C_LE_D 0x95 1403 #define __FSQRT_S 0x96 1404 #define __FSQRT_D 0x97 1405 1406 #define __NOP 0x00 1407 #define __SYSCALL 0xa0 1408 #define __BREAK 0xa1 1409 #define __LUI 0xa2 1410 #define __MFC1 0xa3 1411 #define __CFC1 0xa4 1412 #define __MTC1 0xa5 1413 1414 #define __CTC1 0xa6 1415 #define __DMFC1 0xa7 1416 #define __DMTC1 0xa8 1417 1418 #define __LB_RR 0xc0 1419 #define __LBU_RR 0xc1 1420 #define __LHU_RR 0xc3 1421 #define __LW_RR 0xc4 1422 #define __L_S_RR 0xc5 1423 #define __SB_RR 0xc6 1424 #define __SH_RR 0xc7 1425 #define __SW_RR 0xc8 1426 #define __S_S_RR 0xc9 1427 #define __L_S_RR_R2 0xca 1428 #define __S_S_RR_R2 0xcb 1429 #define __LW_RR_R2 0xcc 1430 #define __SW_RR_R2 0xcd 1431 #define __DLW_RR 0xce 1432 #define __L_D_RR 0xcf 1433 1434 #define __DSW_RR 0xd0 1435 #define __DSZ_RR 0xd1 1436 #define __S_D_RR 0xd2 1437 #define __LH_RR 0xc2 1438 1439 1440 #define ECOFF_EL_MAGIC 0x0162 1441 #define ECOFF_STYP_TEXT 0x0020 1442 #define ECOFF_STYP_RDATA 0x0100 1443 #define ECOFF_STYP_DATA 0x0040 1444 #define ECOFF_STYP_SDATA 0x0200 1445 #define ECOFF_STYP_SBSS 0x0400 1446 #define ECOFF_STYP_BSS 0x0080 1447 1448 1449 #define SYS_exit 1 1450 #define SYS_fork 2 1451 #define SYS_read 3 1452 #define SYS_write 4 1453 #define SYS_open 5 1454 #define SYS_close 6 1455 #define SYS_execv 11 1456 #define SYS_chdir 12 1457 #define SYS_brk 17 1458 #define SYS_lseek 19 1459 #define SYS_getpid 20 1460 #define SYS_ioctl 54 1461 #define SYS_fstat 62 1462 #define SYS_getpagesize 64 1463 #define SYS_sigvec 108 1464 #define SYS_gettimeofday 116 1465 #define SYS_getrusage 117 1466 1467 /***** 3. macro definition *****/ 1468 #define Imm ((int)((short)(as->ir.low & 0xffff))) 1469 #define UImm (as->ir.low & 0xffff) 1470 /* #define Shamt (as->ir.low & 0xff) */ 1471 #define Shamt (as->ir.low & 0x1f) 1472 #define Rd_i (as->ir.low>>8 & 0xFF) 1473 #define Rt_i (as->ir.low>>16 & 0xFF) 1474 #define Rs_i (as->ir.low>>24 & 0xFF) 1475 #define Rd (as->r[as->ir.low>>8 & 0xFF]) 1476 #define Fd (as->f[as->ir.low>>8 & 0xFF]) 1477 #define Rt (as->r[as->ir.low>>16 & 0xFF]) 1478 #define Rs (as->r[as->ir.low>>24 & 0xFF]) 1479 #define Cpc as->pc 1480 #define Npc as->npc 1481 #define Target (as->ir.low & 0x3ffffff) 1482 1483 #define TABLE_INDEX(addr) (((unsigned int)(addr)) >> 16 & 0x7fff) 1484 #define SS_NFLAGS (sizeof(ss_flag_table)/sizeof(ss_flag_table[0])) 1485 1486 /***** 4. structure definitions *****/ 1487 struct evaluate{ 1488 FILE *debug; 1489 ULL end_tc; 1490 unsigned int hi; 1491 unsigned int lo; 1492 ULL tc; /* retired instrunctions, total count */ 1493 ULL icount[256]; 1494 }; 1495 1496 struct architecture_state{ 1497 ADDR_TYPE pc; /* program counter 32-bit width. */ 1498 ADDR_TYPE npc; /* next program counter 32-bit width. */ 1499 INST_TYPE ir; 1500 DATA_TYPE r[32]; /* integer register file */ 1501 DATA_TYPE f[32]; /* floating point register file */ 1502 DATA_TYPE hi; 1503 DATA_TYPE lo; 1504 DATA_TYPE fcc; 1505 char *block_table[BLOCK_TABLE_SIZE]; 1506 1507 ADDR_TYPE brk; /* max address of the data segment */ 1508 ADDR_TYPE text_min_address; /* min address of the text segment */ 1509 ADDR_TYPE text_max_address; /* max address of the text segment */ 1510 }; 1511 1512 struct machine_setting{ 1513 int debug_flag; 1514 int trace_flag; 1515 int distrib_flag; 1516 int syscall_flag; 1517 int icount_flag; 1518 ULL end_tc; 1519 ULL trace_start; 1520 ULL trace_end; 1521 }; 1522 1523 struct ss_timeval{ 1524 int ss_tv_sec; 1525 int ss_tv_usec; 1526 }; 1527 1528 struct ss_timezone{ 1529 int ss_tz_minuteswest; 1530 int ss_tz_dsttime; 1531 }; 1532 1533 struct ss_rlimit{ 1534 int ss_rlim_cur; 1535 int ss_rlim_max; 1536 }; 1537 1538 struct ss_flag_table{ 1539 int ss_flag; 1540 int local_flag; 1541 }; 1542 1543 struct ss_rusage{ 1544 struct ss_timeval ss_ru_utime; 1545 struct ss_timeval ss_ru_stime; 1546 int ss_ru_maxrss; 1547 int ss_ru_ixrss; 1548 int ss_ru_idrss; 1549 int ss_ru_isrss; 1550 int ss_ru_minflt; 1551 int ss_ru_majflt; 1552 int ss_ru_nswap; 1553 int ss_ru_inblock; 1554 int ss_ru_oublock; 1555 int ss_ru_msgsnd; 1556 int ss_ru_msgrcv; 1557 int ss_ru_nsignals; 1558 int ss_ru_nvcsw; 1559 int ss_ru_nivcsw; 1560 }; 1561 1562 struct ss_statbuf{ 1563 short ss_st_dev; 1564 unsigned int ss_st_ino; 1565 unsigned short ss_st_mode; 1566 short ss_st_nlink; 1567 short ss_st_uid; 1568 short ss_st_gid; 1569 short ss_st_rdev; 1570 int ss_st_size; 1571 int ss_st_atime; 1572 int ss_st_spare1; 1573 int ss_st_mtime; 1574 int ss_st_spare2; 1575 int ss_st_ctime; 1576 int ss_st_spare3; 1577 int ss_st_blksize; 1578 int ss_st_blocks; 1579 unsigned int ss_st_gennum; 1580 int ss_st_spare4; 1581 }; 1582 1583 struct ecoff_filehdr{ 1584 unsigned short f_magic; 1585 unsigned short f_nscns; 1586 int f_timdat; 1587 int f_symptr; 1588 int f_nsyms; 1589 unsigned short f_opthdr; 1590 unsigned short f_flags; 1591 }; 1592 1593 struct ecoff_aouthdr{ 1594 short magic; 1595 short vstamp; 1596 int tsize; 1597 int dsize; 1598 int bsize; 1599 int entry; 1600 int text_start; 1601 int data_start; 1602 int bss_start; 1603 int gprmask; 1604 int cprmask[4]; 1605 int gp_value; 1606 }; 1607 1608 struct ecoff_scnhdr{ 1609 char s_name[8]; 1610 int s_paddr; 1611 int s_vaddr; 1612 int s_size; 1613 int s_scnptr; 1614 int s_relptr; 1615 int s_lnnoptr; 1616 unsigned short s_nreloc; 1617 unsigned short s_nlnno; 1618 int s_flags; 1619 }; 1620 1621 /***** 5. function prototypes *****/ 1622 extern void fetch_instruction(ADDR_TYPE, INST_TYPE *); 1623 extern void load_byte(int, ADDR_TYPE, DATA_TYPE*); 1624 extern void load_2byte(int, ADDR_TYPE, DATA_TYPE*); 1625 extern void load_4byte(ADDR_TYPE, DATA_TYPE*); 1626 extern void load_nbyte(int, int, ADDR_TYPE, DATA_TYPE*); 1627 extern void load_memory(ADDR_TYPE, char *, int); 1628 extern void store_memory(ADDR_TYPE, char *, int); 1629 extern void store_byte( ADDR_TYPE, DATA_TYPE); 1630 extern void store_2byte(ADDR_TYPE, DATA_TYPE); 1631 extern void store_4byte(ADDR_TYPE, DATA_TYPE); 1632 extern void store_nbyte(int, ADDR_TYPE, DATA_TYPE); 1633 1634 extern void execute_instruction(struct architecture_state *); 1635 extern void execute_syscall(struct architecture_state *); 1636 extern void debugmode(struct architecture_state *); 1637 extern void getasm(struct architecture_state *, char *); 1638 extern void print_status(struct architecture_state *); 1639 extern void mem_init(int, char **, char **); 1640 extern void getopcode(int, char*); 1641 extern void finish_simulator();