1 ------------------------------------------------------------ 2 file name: sim.cc 3 0001 /**** SimCore since 2002-05-15 by Kenji KISE ****/ 4 0002 /************************************************/ 5 0003 #include "define.h" 6 0004 7 0005 /************************************************/ 8 0006 int main(int argc, char **argv){ 9 0007 printf("%s/%s %s\n", PROJ, NAME, VER); 10 0008 if(argc==1) usage(); 11 0009 char *p = argv[argc-1]; /* program name */ 12 0010 char **opt = argv; /* options */ 13 0011 14 0012 simple_chip *c = new simple_chip(p, opt); 15 0013 c->loop(); 16 0014 delete c; 17 0015 18 0016 return 0; 19 0017 } 20 0018 /************************************************/ 21 ------------------------------------------------------------ 22 file name: chip.cc 23 0001 /**** SimCore since 2002-05-15 by Kenji KISE ****/ 24 0002 /************************************************/ 25 0003 #include "define.h" 26 0004 27 0005 /************************************************/ 28 0006 simple_chip::simple_chip(char *prog, char **opt){ 29 0007 ev = new Env(); 30 0008 ev->sc = new system_config(prog, opt); 31 0009 ev->e = new evaluation_result(); 32 0010 ev->as = new architecture_state(ev); 33 0011 ev->mem = new memory_system(ev); 34 0012 ev->deb = new debug(ev); 35 0013 ev->sys = new system_manager(ev); 36 0014 p = new instruction(ev); 37 0015 38 0016 if(ev->sc->distrib_flag) 39 0017 ev->e->imix = new main_memory(); 40 0018 } 41 0019 42 0020 /************************************************/ 43 0021 simple_chip::~simple_chip(){ /** destructor **/ 44 0022 print_evaluation_result(ev); 45 0023 } 46 0024 47 0025 /************************************************/ 48 0026 int simple_chip::step(){ 49 0027 p->Fetch(&ev->as->pc); /* pipeline stage 0 */ 50 0028 p->Slot(); /* pipeline stage 1 */ 51 0029 p->Issue(); /* pipeline stage 3 */ 52 0030 p->RegisterRead(); /* pipeline stage 4 */ 53 0031 p->Execute(); /* pipeline stage 5 */ 54 0032 p->Memory(); /* pipeline stage 6 */ 55 0033 p->WriteBack(); 56 0034 57 0035 ev->e->retired_inst++; 58 0036 house_keeper(p); 59 0037 60 0038 return ev->sys->running; 61 0039 } 62 0040 63 0041 #define IB_MSK 0x0ffff /* mask of inst_buf */ 64 0042 /** main loop of the optimized version **/ 65 0043 /************************************************/ 66 0044 void simple_chip::loop(){ 67 0045 instruction **ib = new instruction*[IB_MSK+1]; 68 0046 for(int i=0; isys->running){ 73 0051 int index = (ev->as->pc>>2) & IB_MSK; 74 0052 instruction *pt = ib[index]; 75 0053 76 0054 if(pt->Cpc!=ev->as->pc){ 77 0055 pt->Fetch(&ev->as->pc); 78 0056 pt->Slot(); 79 0057 pt->Issue(); 80 0058 } 81 0059 pt->BackEnd(); 82 0060 83 0061 ev->e->retired_inst++; 84 0062 if(ev->sc->slow_mode) house_keeper(pt); 85 0063 } 86 0064 } 87 0065 /************************************************/ 88 ------------------------------------------------------------ 89 file name: instruction.cc 90 0001 /**** SimCore since 2002-05-15 by Kenji KISE ****/ 91 0002 /************************************************/ 92 0003 #include "define.h" 93 0004 #define R_ZERO 31 /** Index of zero register **/ 94 0005 95 0006 /************************************************/ 96 0007 int INTx_OP(int Op){/* 0x10-0x14 OP_INTx */ 97 0008 return ((Op&MSK2)==0x10); 98 0009 } 99 0010 100 0011 /* return 1 if data is written to integer reg. */ 101 0012 /************************************************/ 102 0013 int WR(int Op){ 103 0014 return !((Op&MSK2)==0x14 || (Op&MSK2)==0x20); 104 0015 } 105 0016 106 0017 /************************************************/ 107 0018 int LDAx(int CI){ 108 0019 return (CI==_LDA___ || CI==_LDAH__); 109 0020 } 110 0021 111 0022 /************************************************/ 112 0023 instruction::instruction(Env *ev_t){ 113 0024 ev = ev_t; 114 0025 } 115 0026 116 0027 /************************************************/ 117 0028 void instruction::Fetch(data_t *pc){ 118 0029 ev->mem->ld_inst(pc, &ir); 119 0030 Cpc = *pc; 120 0031 Npc = *pc + 4; 121 0032 } 122 0033 123 0034 /** decode the instruction **/ 124 0035 /************************************************/ 125 0036 void instruction::Slot(){ 126 0037 CI = get_code(ir); /* Code ID */ 127 0038 Op = (ir>>26) & 0x3f; /* Op field */ 128 0039 CM = cmov_ir(ir); /* set if CMOV */ 129 0040 BR = ((Op&MSK4)==0x30); /* 0x30-0x3f branch */ 130 0041 LD = ld_bytes(CI); /* not 0 if load */ 131 0042 ST = st_bytes(CI); /* not 0 if store */ 132 0043 133 0044 int Rc = ir & 0x1f; /* Rc field */ 134 0045 int Ra = (ir>>21)&0x1f; /* Ra field */ 135 0046 int Rb = (ir>>16)&0x1f; /* Rb field */ 136 0047 int Misc = (Op==OP_MISC || Op==OP_PAL); 137 0048 /***************** Rav ********************/ 138 0049 Ai = LDAx(CI); 139 0050 RA = (Ai || LD || Misc) ? R_ZERO : Ra; 140 0051 Ar = !Ai & 141 0052 !(Op==OP_FLTV || Op==OP_FLTI || 142 0053 Op==OP_FLTL || Op==OP_FPTI || 143 0054 (Op&MSK2)==0x24 || /* 0x24-27 STfloat */ 144 0055 (Op&MSK3)==0x30); /* 0x30-37 BR & FBR */ 145 0056 146 0057 /***************** Rbv ********************/ 147 0058 Bi = BR || (INTx_OP(Op) && (ir & BIT12)); 148 0059 RB = (Bi || Misc) ? R_ZERO : Rb; 149 0060 Br = !Bi && !((Op&MSK2)==0x14); /* 0x14-17 */ 150 0061 151 0062 /***************** WriteBack index ********/ 152 0063 WB = (LD || LDAx(CI) || Op==OP_JSR || 153 0064 CI==_BR__ || CI==_BSR_) ? Ra : 154 0065 ((Op&MSK3)==0x10 || /* 0x10-0x17 */ 155 0066 Op==OP_FPTI) ? Rc : R_ZERO; 156 0067 } 157 0068 158 0069 /************************************************/ 159 0070 void instruction::Rename(){ } 160 0071 161 0072 /** genarate the immediate data Imm **/ 162 0073 /************************************************/ 163 0074 void instruction::Issue(){ 164 0075 DATA_TYPE Lit = (ir >> 13) & MASK08; 165 0076 DATA_TYPE D21 = sext21(ir) << 2; 166 0077 DATA_TYPE D16 = (Op!=OP_LDAH) ? sext16(ir) : 167 0078 sext16(ir) << 16; 168 0079 169 0080 Imm = (LD || ST || LDAx(CI)) ? D16 : 170 0081 (BR) ? D21 : (Bi) ? Lit : 0; 171 0082 } 172 0083 173 0084 /** copy data to Rav and Rbv **/ 174 0085 /************************************************/ 175 0086 void instruction::RegisterRead(){ 176 0087 Rav = Ar ? ev->as->r[RA] : Ai ? Imm : 177 0088 ev->as->f[RA]; 178 0089 Rbv = Br ? ev->as->r[RB] : Bi ? Imm : 179 0090 ev->as->f[RB]; 180 0091 if(CM){ 181 0092 Adr = WR(Op) ? ev->as->r[WB] : ev->as->f[WB]; 182 0093 } 183 0094 } 184 0095 185 0096 /** update Rcv, Adr and Npc **/ 186 0097 /************************************************/ 187 0098 void instruction::Execute(){ 188 0099 if(LD || ST){ 189 0100 Adr = (CI==_LDQ_U_ || CI==_STQ_U_) ? 190 0101 (Rbv + Imm) & ~7 : Rbv + Imm; 191 0102 } 192 0103 else if(BR){ 193 0104 Rcv = Cpc+4; 194 0105 Npc = Btaken(CI, Rav) ? Cpc+4+Rbv : Cpc+4; 195 0106 } 196 0107 else if(CM){ /** Conditional move inst. **/ 197 0108 int cm=0; 198 0109 CmovUnit(CI, Rav, &cm); 199 0110 Rcv = (cm) ? Rbv : Adr; 200 0111 } 201 0112 else{ 202 0113 switch(Op){ 203 0114 case OP_JSR : 204 0115 Npc = Rbv & ~3ull; 205 0116 Rcv = Cpc + 4; 206 0117 break; 207 0118 case OP_LDA : Rcv = Rav + Rbv; break; 208 0119 case OP_LDAH: Rcv = Rav + Rbv; break; 209 0120 case OP_INTA: UnitA(CI, Rav, Rbv, &Rcv);break; 210 0121 case OP_INTL: UnitL(CI, Rav, Rbv, &Rcv);break; 211 0122 case OP_INTS: UnitS(CI, Rav, Rbv, &Rcv);break; 212 0123 case OP_INTM: UnitM(CI, Rav, Rbv, &Rcv);break; 213 0124 case OP_ITFP: FuITFP(ir,Rav, Rbv, &Rcv);break; 214 0125 case OP_FLTL: FuFLTL(ir,Rav, Rbv, &Rcv);break; 215 0126 case OP_FPTI: FuFPTI(ir,Rav, Rbv, &Rcv);break; 216 0127 case OP_FLTI: FuFLTI(ir,Rav, Rbv, &Rcv);break; 217 0128 case OP_PAL : Rcv=0; break; 218 0129 case OP_MISC: Rcv=0; break; 219 0130 default: printf("** ExeUnit_def: %x", CI); 220 0131 } 221 0132 } 222 0133 ev->as->pc = Npc; 223 0134 } 224 0135 225 0136 /** store Rav to mem or load to Rcv **/ 226 0137 /************************************************/ 227 0138 void instruction::Memory(){ 228 0139 if(LD){ 229 0140 data_t tmp; 230 0141 ev->mem->mm->ld_8byte(&Adr, &tmp); 231 0142 set_ld_data(CI, LD, &Adr, &tmp, &Rcv); 232 0143 } 233 0144 else if(ST){ 234 0145 data_t tmp; 235 0146 DATA_TYPE mask; 236 0147 set_st_data(CI, ST, &Adr, &Rav, &tmp, &mask); 237 0148 ev->mem->mm->st_8byte(&Adr, &tmp, mask); 238 0149 } 239 0150 } 240 0151 241 0152 /** PAL or copy Rcv into the regfile **/ 242 0153 /************************************************/ 243 0154 void instruction::WriteBack(){ 244 0155 if(Op==OP_PAL) ev->sys->execute_pal(this); 245 0156 if(WB!=R_ZERO){ 246 0157 if(WR(Op)) ev->as->r[WB] = Rcv; 247 0158 else ev->as->f[WB] = Rcv; 248 0159 } 249 0160 } 250 0161 251 0162 /** back-end stages for the optimized version **/ 252 0163 /************************************************/ 253 0164 void instruction::BackEnd(){ 254 0165 /***** RegisterRead **************************/ 255 0166 Rav = Ar ? ev->as->r[RA] : Ai ? Imm : 256 0167 ev->as->f[RA]; 257 0168 Rbv = Br ? ev->as->r[RB] : Bi ? Imm : 258 0169 ev->as->f[RB]; 259 0170 if(CM){ 260 0171 Adr = WR(Op) ? ev->as->r[WB] : ev->as->f[WB]; 261 0172 } 262 0173 263 0174 /***** Execute ********************************/ 264 0175 if(LD || ST){ 265 0176 Adr = (CI==_LDQ_U_ || CI==_STQ_U_) ? 266 0177 (Imm+Rbv) & ~7 : Imm+Rbv; 267 0178 } 268 0179 else if(BR){ 269 0180 Rcv = Cpc+4; 270 0181 Npc = Btaken(CI, Rav) ? Cpc+4+Rbv : Cpc+4; 271 0182 } 272 0183 else if(CM){ /** Conditional move inst. **/ 273 0184 int cm=0; 274 0185 CmovUnit(CI, Rav, &cm); 275 0186 Rcv = (cm) ? Rbv : Adr; 276 0187 } 277 0188 else{ 278 0189 switch(Op){ 279 0190 case OP_JSR : 280 0191 Npc = Rbv & ~3ull; 281 0192 Rcv = Cpc + 4; 282 0193 break; 283 0194 case OP_LDA : Rcv = Rav + Rbv; break; 284 0195 case OP_LDAH: Rcv = Rav + Rbv; break; 285 0196 case OP_INTA: UnitA(CI, Rav, Rbv, &Rcv);break; 286 0197 case OP_INTL: UnitL(CI, Rav, Rbv, &Rcv);break; 287 0198 case OP_INTS: UnitS(CI, Rav, Rbv, &Rcv);break; 288 0199 case OP_INTM: UnitM(CI, Rav, Rbv, &Rcv);break; 289 0200 case OP_ITFP: FuITFP(ir,Rav, Rbv, &Rcv);break; 290 0201 case OP_FLTL: FuFLTL(ir,Rav, Rbv, &Rcv);break; 291 0202 case OP_FPTI: FuFPTI(ir,Rav, Rbv, &Rcv);break; 292 0203 case OP_FLTI: FuFLTI(ir,Rav, Rbv, &Rcv);break; 293 0204 case OP_PAL : Rcv=0; break; 294 0205 case OP_MISC: Rcv=0; break; 295 0206 default: printf("** ExeUnit_def: %x", CI); 296 0207 } 297 0208 } 298 0209 ev->as->pc = Npc; 299 0210 300 0211 /***** Memory *********************************/ 301 0212 if(LD){ 302 0213 data_t tmp; 303 0214 ev->mem->mm->ld_8byte(&Adr, &tmp); 304 0215 set_ld_data(CI, LD, &Adr, &tmp, &Rcv); 305 0216 } 306 0217 else if(ST){ 307 0218 data_t tmp; 308 0219 DATA_TYPE mask; 309 0220 set_st_data(CI, ST, &Adr, &Rav, &tmp, &mask); 310 0221 ev->mem->mm->st_8byte(&Adr, &tmp, mask); 311 0222 } 312 0223 313 0224 /***** WriteBack ******************************/ 314 0225 if(Op==OP_PAL) ev->sys->execute_pal(this); 315 0226 if(WB!=R_ZERO){ 316 0227 if(WR(Op)) ev->as->r[WB]=Rcv; 317 0228 else ev->as->f[WB]=Rcv; 318 0229 } 319 0230 } 320 0231 /************************************************/ 321 ------------------------------------------------------------ 322 file name: memory.cc 323 0001 /**** SimCore since 2002-05-15 by Kenji KISE ****/ 324 0002 /************************************************/ 325 0003 #include "define.h" 326 0004 327 0005 /************************************************/ 328 0006 int ld_bytes(int CI){ 329 0007 switch(CI){ 330 0008 case _LDQ___: return 8; 331 0009 case _LDQ_L_: return 8; 332 0010 case _LDQ_U_: return 8; 333 0011 case _LDG___: return 8; 334 0012 case _LDT___: return 8; 335 0013 case _LDF___: return 8; 336 0014 case _LDL___: return 4; 337 0015 case _LDS___: return 4; 338 0016 case _LDL_L_: return 4; 339 0017 case _OPC0C_: return 2; 340 0018 case _OPC0A_: return 1; 341 0019 } 342 0020 return 0; 343 0021 } 344 0022 345 0023 /************************************************/ 346 0024 int st_bytes(int CI){ 347 0025 switch(CI){ 348 0026 case _STQ___: return 8; 349 0027 case _STQ_C_: return 8; 350 0028 case _STQ_U_: return 8; 351 0029 case _STG___: return 8; 352 0030 case _STT___: return 8; 353 0031 case _STF___: return 8; 354 0032 case _STL___: return 4; 355 0033 case _STS___: return 4; 356 0034 case _STL_C_: return 4; 357 0035 case _OPC0D_: return 2; 358 0036 case _OPC0E_: return 1; 359 0037 } 360 0038 return 0; 361 0039 } 362 0040 363 0041 /************************************************/ 364 0042 void set_ld_data(int CI, int n, data_t *adr, 365 0043 data_t *in, data_t *out){ 366 0044 int off8 = (*adr & 7) << 3; 367 0045 switch(n){ 368 0046 case 4: 369 0047 if(CI==_LDL___ || CI==_LDL_L_){ 370 0048 *out = sext((*in >> off8) & MASK32); 371 0049 } 372 0050 else if(CI==_LDS___){ 373 0051 DATA_TYPE tmp = (*in >> off8) & MASK32; 374 0052 DATA_TYPE rt = tmp; 375 0053 rt = (tmp >> 31) & 0x1ull; 376 0054 rt = (rt << 11) | (map_s(tmp) & 0x7ffull); 377 0055 rt = (rt << 23) | (tmp & 0x7FFFFFull); 378 0056 rt = rt << 29; 379 0057 *out = rt; 380 0058 } 381 0059 break; 382 0060 case 8: *out = *in; break; 383 0061 case 2: *out = (*in >> off8) & MASK16; break; 384 0062 case 1: *out = (*in >> off8) & MASK08; break; 385 0063 } 386 0064 } 387 0065 388 0066 /************************************************/ 389 0067 void set_st_data(int CI, int n, data_t *adr, 390 0068 data_t *in, data_t *out, 391 0069 DATA_TYPE *msk){ 392 0070 int off8 = (*adr & 7) << 3; 393 0071 if(CI==_STS___){ 394 0072 DATA_TYPE tmp; 395 0073 uint_32t intt = 0; 396 0074 intt |= ((*in >> 29) & 0x3FFFFFFFul); 397 0075 intt |= ((*in >> 32) & 0xc0000000ul); 398 0076 memcpy(&tmp, &intt, 4); 399 0077 *out = (tmp & MASK32) << off8; 400 0078 *msk = ~(MASK32 << off8); 401 0079 } 402 0080 else{ 403 0081 switch(n){ 404 0082 case 4: 405 0083 *out = (*in & MASK32) << off8; 406 0084 *msk = ~(MASK32 << off8); 407 0085 break; 408 0086 case 8: 409 0087 *out = *in; 410 0088 *msk = 0; 411 0089 break; 412 0090 case 2: 413 0091 *out = (*in & MASK16) << off8; 414 0092 *msk = ~(MASK16 << off8); 415 0093 break; 416 0094 case 1: 417 0095 *out = (*in & MASK08) << off8; 418 0096 *msk = ~(MASK08 << off8); 419 0097 break; 420 0098 } 421 0099 } 422 0100 } 423 0101 424 0102 /************************************************/ 425 0103 inline uint_32t gen_tag(uint_32t adr){ 426 0104 return (adr & 0xffffffc0); 427 0105 } 428 0106 429 0107 /************************************************/ 430 0108 void memory_system::ld_inst(data_t *a, 431 0109 INST_TYPE *ir){ 432 0110 data_t d; 433 0111 mm->ld_8byte(a, &d); 434 0112 if(*a%8==0) *ir = d & MASK32; 435 0113 if(*a%8==4) *ir = (d>>32) & MASK32; 436 0114 } 437 0115 438 0116 /************************************************/ 439 0117 void memory_system::ld_8byte(data_t *a, data_t *d){ 440 0118 mm->ld_8byte(a, d); 441 0119 } 442 0120 443 0121 void memory_system::st_8byte(data_t *a, data_t *d, 444 0122 DATA_TYPE msk){ 445 0123 mm->st_8byte(a, d, msk); 446 0124 } 447 0125 448 0126 /************************************************/ 449 0127 memory_system::~memory_system(){} 450 0128 451 0129 /************************************************/ 452 0130 memory_system::memory_system(Env *ev_t){ 453 0131 ev = ev_t; 454 0132 mm = new main_memory(); 455 0133 456 0134 char *prog_name = ev->sc->program_name; 457 0135 458 0136 /*** Read memory image from the file ***/ 459 0137 FILE *fp; 460 0138 if((fp = fopen(prog_name, "r")) == NULL) { 461 0139 fprintf(stderr, "Bad file name: %s\n", 462 0140 prog_name); 463 0141 exit(1); 464 0142 } 465 0143 char buf[4096]; 466 0144 while(!feof(fp)){ 467 0145 fgets(buf, 4096, fp); 468 0146 if(*buf=='@'){ 469 0147 470 0148 int ost=0; /* find the offset of dat */ 471 0149 for(int i=0; i<32; i++){ 472 0150 if(*(buf+i)==' '){ ost=i; break; } 473 0151 } 474 0152 475 0153 ADDR_TYPE adr = get_hex(buf+1); 476 0154 DATA_TYPE dat = get_hex(buf+ost+1); 477 0155 data_t a,d; 478 0156 a = adr; 479 0157 d = dat; 480 0158 mm->st_8byte(&a, &d, 0); 481 0159 } 482 0160 } 483 0161 fclose(fp); 484 0162 } 485 0163 486 0164 /************************************************/ 487 0165 void memory_system::ld_nbyte(int n, data_t *a, 488 0166 data_t *d){ 489 0167 if(*a%n!=0) 490 0168 printf("*** ld_nbyte %d miss-align.\n", n); 491 0169 if(n!=1 && n!=2 && n!=4 && n!=8) 492 0170 printf("*** Error in ld_nbyte %d.\n", n); 493 0171 494 0172 ld_8byte(a, d); /** Type Conversion **/ 495 0173 if(n==8) return; 496 0174 497 0175 int offset = *a & 7; 498 0176 if(n==4){ 499 0177 DATA_TYPE dt = (*d>>(offset*8))&MASK32; 500 0178 *d=dt; 501 0179 } 502 0180 else if(n==2){ 503 0181 DATA_TYPE dt = (*d>>(offset*8))&MASK16; 504 0182 *d=dt; 505 0183 } 506 0184 else if(n==1){ 507 0185 DATA_TYPE dt = (*d>>(offset*8))&MASK08; 508 0186 *d=dt; 509 0187 } 510 0188 } 511 0189 512 0190 /************************************************/ 513 0191 void memory_system::st_nbyte(int n, data_t *a, 514 0192 data_t *d){ 515 0193 if(*a%n!=0) 516 0194 printf("*** st_nbyte %d miss-alig.\n", n); 517 0195 if(n!=1 && n!=2 && n!=4 && n!=8) 518 0196 printf("*** Error in st_nbyte %d.\n", n); 519 0197 520 0198 int offset = *a & 7; 521 0199 DATA_TYPE mask=0; 522 0200 523 0201 if(n==4){ 524 0202 mask = ~(MASK32 << offset*8); 525 0203 DATA_TYPE dt = (*d&MASK32)<>BLOCK_MASK_BIT] = ret; 579 0257 if(ret==NULL){ 580 0258 printf("** Error in allocblock.\n"); 581 0259 exit(0); 582 0260 } 583 0261 return ret; 584 0262 } 585 0263 586 0264 /************************************************/ 587 0265 void main_memory::ld_8byte(data_t *a, data_t *d){ 588 0266 uint_32t adr = *a; 589 0267 data_t *bt = block_table[adr>>BLOCK_MASK_BIT]; 590 0268 data_t *ptr = (bt!=NULL) ? bt : allocblock(a); 591 0269 int offset = (adr & BLOCK_MASK)>>DATA_T_BIT; 592 0270 *d = ptr[offset]; 593 0271 } 594 0272 595 0273 /************************************************/ 596 0274 void main_memory::st_8byte(data_t *a, data_t *d, 597 0275 DATA_TYPE msk){ 598 0276 uint_32t adr = *a; 599 0277 data_t *bt = block_table[adr>>BLOCK_MASK_BIT]; 600 0278 data_t *ptr = (bt!=NULL) ? bt : allocblock(a); 601 0279 int offset = (adr & BLOCK_MASK)>>DATA_T_BIT; 602 0280 ptr[offset] = (msk==0) ? *d : 603 0281 (ptr[offset] & msk) | *d; 604 0282 } 605 0283 /************************************************/ 606 ------------------------------------------------------------ 607 file name: arithmetic.cc 608 0001 /**** SimCore since 2002-05-15 by Kenji KISE ****/ 609 0002 /************************************************/ 610 0003 #include "define.h" 611 0004 612 0005 /** sign extentions **/ 613 0006 /************************************************/ 614 0007 DATA_TYPE sext(DATA_TYPE d){ 615 0008 return (d & BIT31) ? d | EXTND32 : d & MASK32; 616 0009 } 617 0010 /************************************************/ 618 0011 DATA_TYPE sext16(DATA_TYPE d){ 619 0012 return (d & BIT15) ? d | EXTND16 : d & MASK16; 620 0013 } 621 0014 /************************************************/ 622 0015 DATA_TYPE sext21(DATA_TYPE d){ 623 0016 return (d & BIT20) ? d | EXTND21 : d & MASK21; 624 0017 } 625 0018 626 0019 /************************************************/ 627 0020 uint_64t bzap(uint_64t Rav, int byte_mask){ 628 0021 if(byte_mask & BIT0) Rav &= ZAP0; 629 0022 if(byte_mask & BIT1) Rav &= ZAP1; 630 0023 if(byte_mask & BIT2) Rav &= ZAP2; 631 0024 if(byte_mask & BIT3) Rav &= ZAP3; 632 0025 if(byte_mask & BIT4) Rav &= ZAP4; 633 0026 if(byte_mask & BIT5) Rav &= ZAP5; 634 0027 if(byte_mask & BIT6) Rav &= ZAP6; 635 0028 if(byte_mask & BIT7) Rav &= ZAP7; 636 0029 return Rav; 637 0030 } 638 0031 639 0032 /** 0x16 IEEE floating-point instruction **/ 640 0033 /************************************************/ 641 0034 void FuFLTI(INST_TYPE ir, DATA_TYPE Rav, 642 0035 DATA_TYPE Rbv, DATA_TYPE *w){ 643 0036 int CI= get_code(ir); 644 0037 DATA_TYPE Rcv=0; 645 0038 int func4 = (ir>>5) & 0xF; 646 0039 int func11 = (ir>>5) & 0x7FF; 647 0040 double Fav=0.0, Fbv=0.0, Fcv=0.0; 648 0041 memcpy(&Fav, &Rav, 8); 649 0042 memcpy(&Fbv, &Rbv, 8); 650 0043 651 0044 switch(func4){ 652 0045 case 0x0: Fcv=Fav + Fbv; break; 653 0046 case 0x1: Fcv=Fav - Fbv; break; 654 0047 case 0x2: Fcv=Fav * Fbv; break; 655 0048 case 0x5: Fcv=(Fav==Fbv) ? 2.0 : 0.0; break; 656 0049 case 0x6: Fcv=(Fav< Fbv) ? 2.0 : 0.0; break; 657 0050 case 0x7: Fcv=(Fav<=Fbv) ? 2.0 : 0.0; break; 658 0051 case 0xe: Fcv=(double)(int_64t)Rbv; break; 659 0052 case 0x4: 660 0053 Fcv=(isnan(Fav) || isnan(Fbv)) ? 2.0 : 0.0; 661 0054 break; 662 0055 case 0xc: { // CVTTS 663 0056 memcpy(&Fcv, &Rbv, 8); 664 0057 float tmp = (float)Fcv; 665 0058 Fcv = tmp; 666 0059 break; 667 0060 } 668 0061 case 0x3: // DIVT 669 0062 if(Fbv==0.0){ Fcv = 0.0; break; } 670 0063 Fcv = (double)(Fav / Fbv); 671 0064 break; 672 0065 case 0xf: { // CVTTQ 673 0066 int_64t tmp; 674 0067 tmp = (int_64t)Fbv; 675 0068 memcpy(&Fcv, &tmp, 8); 676 0069 break; 677 0070 } 678 0071 default: 679 0072 printf("*** FuFLTI %x\n", CI); 680 0073 exit(1); 681 0074 } 682 0075 683 0076 switch(func11){ 684 0077 case 0x0bc: 685 0078 case 0x03c: 686 0079 case 0x07c: 687 0080 case 0x0fc: 688 0081 case 0x7bc: 689 0082 case 0x73c: 690 0083 case 0x77c: 691 0084 case 0x7fc: // CVTQS 692 0085 Fcv = (double)(int_64t)Rbv; 693 0086 break; 694 0087 } 695 0088 696 0089 memcpy(&Rcv, &Fcv, 8); 697 0090 *w = Rcv; 698 0091 } 699 0092 700 0093 /** 0x1c Floating-point to integer register **/ 701 0094 /************************************************/ 702 0095 void FuFPTI(INST_TYPE ir, DATA_TYPE Rav, 703 0096 DATA_TYPE Rbv, DATA_TYPE *w){ 704 0097 int CI= get_code(ir); 705 0098 DATA_TYPE Rcv=0; 706 0099 int func11 = (ir>>5) & 0x7FF; 707 0100 double Fav=0.0, Fbv=0.0; 708 0101 memcpy(&Fav, &Rav, 8); 709 0102 memcpy(&Fbv, &Rbv, 8); 710 0103 711 0104 switch(func11){ 712 0105 case 0x000: 713 0106 Rcv = (Rbv & BIT7) ? 714 0107 Rbv |= EXTND8 : (Rbv & 0xffull); 715 0108 break; 716 0109 case 0x001: // SEXTW(Sign Extend Word) 717 0110 Rcv = (Rbv & BIT15) ? 718 0111 Rbv |= EXTND16 : (Rbv & 0xffffull); 719 0112 break; 720 0113 case 0x070: // FTOIT: Rc <= Fav 721 0114 Rcv = Rav; 722 0115 break; 723 0116 case 0x078: // FTOIS: Rc <= Fav 724 0117 Rcv = ((Rav>>32) & 0xc0000000) 725 0118 | ((Rav >> 29) & 0x3fffffff); 726 0119 if(Rav & BIT63) Rcv |= EXTND32; 727 0120 break; 728 0121 729 0122 default: 730 0123 printf("*** FuFPTI %x\n", CI); 731 0124 exit(1); 732 0125 } 733 0126 *w = Rcv; 734 0127 } 735 0128 736 0129 /** 0x17 Floating-point instruction **/ 737 0130 /************************************************/ 738 0131 void FuFLTL(INST_TYPE ir, DATA_TYPE Rav, 739 0132 DATA_TYPE Rbv, DATA_TYPE *w){ 740 0133 int CI= get_code(ir); 741 0134 DATA_TYPE Rcv=0; 742 0135 int func11 = (ir>>5) & 0x7FF; 743 0136 double Fav=0.0, Fbv=0.0, Fcv=0.0; 744 0137 memcpy(&Fav, &Rav, 8); 745 0138 memcpy(&Fbv, &Rbv, 8); 746 0139 747 0140 switch(func11){ 748 0141 case 0x020: { /*__CPYS; Copy Sign */ 749 0142 uint_64t tmp=0; 750 0143 tmp |= (Rav & BIT63); 751 0144 tmp |= (Rbv & ~BIT63); 752 0145 memcpy(&Fcv, &tmp, 8); 753 0146 break; 754 0147 } 755 0148 case 0x021: { /*__CPYSN; Copy Sign Negative */ 756 0149 uint_64t tmp=0; 757 0150 tmp |= (~Rav & BIT63); 758 0151 tmp |= ( Rbv & ~BIT63); 759 0152 memcpy(&Fcv, &tmp, 8); 760 0153 break; 761 0154 } 762 0155 /*__CPYSE; Copy Sign and Exponent */ 763 0156 case 0x022: { 764 0157 uint_64t tmp=0; 765 0158 tmp |= (Rav & 0xFFF0000000000000ull); 766 0159 tmp |= (Rbv & ~0xFFF0000000000000ull); 767 0160 memcpy(&Fcv, &tmp, 8); 768 0161 break; 769 0162 } 770 0163 case 0x010: { /*__CVTLQ; */ 771 0164 uint_64t tmp = 0; 772 0165 tmp = 0; 773 0166 tmp |= ((Rbv>>32) & 0xc0000000ull); 774 0167 tmp |= ((Rbv>>29) & 0x3fffffffull); 775 0168 if(tmp & BIT31) tmp |= EXTND32; 776 0169 memcpy(&Fcv, &tmp, 8); 777 0170 break; 778 0171 } 779 0172 case 0x030: { /*__CVTQL; */ 780 0173 DATA_TYPE tmp = 0; 781 0174 // SimpleScalar has a bug? 782 0175 tmp |= (((Rbv << 32) & 783 0176 0xc000000000000000ull)); 784 0177 tmp |= (((Rbv << 29) & 785 0178 0x07ffffffe0000000ull)); 786 0179 memcpy(&Fcv, &tmp, 8); 787 0180 break; 788 0181 } 789 0182 case 0x24: /* __MT_FPCR */ 790 0183 /* Move Fav to Floating-point 791 0184 Control Register 792 0185 Return 0.0 for the simplicity. 793 0186 */ 794 0187 Fcv=0.0; break; 795 0188 case 0x25: /* __MF_FPCR */ 796 0189 /* Move from Floating-point 797 0190 Control Register to Fa 798 0191 Return 0.0 for the simplicity. 799 0192 */ 800 0193 Fcv=0.0; break; 801 0194 default: 802 0195 printf("*** FuFLTL %x\n", CI); 803 0196 exit(1); 804 0197 } 805 0198 memcpy(&Rcv, &Fcv, 8); 806 0199 *w = Rcv; 807 0200 } 808 0201 809 0202 /** 0x14 Integer to floating-point register **/ 810 0203 /************************************************/ 811 0204 void FuITFP(INST_TYPE ir, DATA_TYPE Rav, 812 0205 DATA_TYPE Rbv, DATA_TYPE *w){ 813 0206 int CI= get_code(ir); 814 0207 DATA_TYPE Rcv=0; 815 0208 int func11 = (ir>>5) & 0x7FF; 816 0209 double Fav=0.0, Fbv=0.0, Fcv=0.0; 817 0210 memcpy(&Fav, &Rav, 8); 818 0211 memcpy(&Fbv, &Rbv, 8); 819 0212 820 0213 switch(func11){ 821 0214 case 0x024: // ITOFT 822 0215 memcpy(&Fcv, &Rav, 8); 823 0216 break; 824 0217 825 0218 case 0x004: { // ITOFS 826 0219 DATA_TYPE tmp = 0; 827 0220 tmp = ((Rav & BIT31) << 32) | 828 0221 (map_s(Rav) << 52) | 829 0222 ((Rav & 0x7fffff) << 29); 830 0223 memcpy(&Fcv, &tmp, 8); 831 0224 break; 832 0225 } 833 0226 case 0x0ab: // SQRTT 834 0227 Fcv = sqrt(Fbv); 835 0228 break; 836 0229 837 0230 default: 838 0231 printf("*** FuITFP %x\n", CI); 839 0232 exit(1); 840 0233 } 841 0234 memcpy(&Rcv, &Fcv, 8); 842 0235 *w = Rcv; 843 0236 } 844 0237 845 0238 /** Integer Logic Unit **/ 846 0239 /************************************************/ 847 0240 void UnitL(int CI, DATA_TYPE a, 848 0241 DATA_TYPE b, DATA_TYPE *c){ 849 0242 switch(CI){ 850 0243 case _BIS___: *c = a | b; break; 851 0244 case _AND___: *c = a & b; break; 852 0245 case _BIC___: *c = a & ~b; break; 853 0246 case _ORNOT_: *c = a | ~b; break; 854 0247 case _XOR___: *c = a ^ b; break; 855 0248 case _EQV___: *c = a ^ ~b; break; 856 0249 case _AMASK_: *c=b & ~CPU_FEATURE_MASK; break; 857 0250 case _IMPLVER:*c=IMPLEMENTATION_VERSION; break; 858 0251 default: 859 0252 printf("*** AluLogi %x\n", CI); 860 0253 } 861 0254 } 862 0255 863 0256 /** Integer Arithmetic **/ 864 0257 /************************************************/ 865 0258 void UnitA(int CI, DATA_TYPE a, 866 0259 DATA_TYPE b, DATA_TYPE *c){ 867 0260 switch(CI){ 868 0261 case _S4ADDQ: *c = (a<<2) + b; break; 869 0262 case _ADDQ__: *c = a + b; break; 870 0263 case _SUBQ__: *c = a - b; break; 871 0264 case _ADDL__: *c = sext(a + b); break; 872 0265 case _S4ADDL: *c = sext((a<<2) + b); break; 873 0266 case _SUBL__: *c = sext(a - b); break; 874 0267 case _S4SUBL: *c = sext((a<<2) - b); break; 875 0268 case _S8ADDL: *c = sext((a<<3) + b); break; 876 0269 case _S8SUBL: *c = sext((a<<3) - b); break; 877 0270 case _CMPULT: *c = (a < b); break; 878 0271 case _S4SUBQ: *c = (a<<2) - b; break; 879 0272 case _S8ADDQ: *c = (a<<3) + b; break; 880 0273 case _S8SUBQ: *c = (a<<3) - b; break; 881 0274 case _CMPEQ_: *c=((int_64t)a==(int_64t)b);break; 882 0275 case _CMPULE: *c=(a <= b); break; 883 0276 case _CMPLT_: *c=((int_64t)a< (int_64t)b);break; 884 0277 case _CMPLE_: *c=((int_64t)a<=(int_64t)b);break; 885 0278 case _CMPBGE: 886 0279 *c=0; 887 0280 if((a & ~ZAP0)>=(b & ~ZAP0)) *c|=BIT0; 888 0281 if((a & ~ZAP1)>=(b & ~ZAP1)) *c|=BIT1; 889 0282 if((a & ~ZAP2)>=(b & ~ZAP2)) *c|=BIT2; 890 0283 if((a & ~ZAP3)>=(b & ~ZAP3)) *c|=BIT3; 891 0284 if((a & ~ZAP4)>=(b & ~ZAP4)) *c|=BIT4; 892 0285 if((a & ~ZAP5)>=(b & ~ZAP5)) *c|=BIT5; 893 0286 if((a & ~ZAP6)>=(b & ~ZAP6)) *c|=BIT6; 894 0287 if((a & ~ZAP7)>=(b & ~ZAP7)) *c|=BIT7; 895 0288 break; 896 0289 897 0290 default: 898 0291 printf("*** AluUnit %x\n", CI); 899 0292 } 900 0293 } 901 0294 902 0295 /************************************************/ 903 0296 inline DATA_TYPE B4(DATA_TYPE b){ 904 0297 return ((b&0x7)==0) ? 0 : 64 - ((b&0x7)<<3); 905 0298 } 906 0299 907 0300 inline DATA_TYPE B3(DATA_TYPE b){ 908 0301 return (b & 0x7); 909 0302 } 910 0303 911 0304 inline DATA_TYPE B7(DATA_TYPE b){ 912 0305 return (b & 0x7)<<3; 913 0306 } 914 0307 915 0308 /************************************************/ 916 0309 void UnitS(int CI, DATA_TYPE a, 917 0310 DATA_TYPE b, DATA_TYPE *c){ 918 0311 uint_32t msk, loc; /* byte_mask, byte_loc */ 919 0312 switch(CI){ 920 0313 case _SLL___: *c = a<<(b & 0x3F); break; 921 0314 case _SRL___: *c = a>>(b & 0x3F); break; 922 0315 case _SRA___: *c =(int_64t)a>>(b & 0x3F); break; 923 0316 case _ZAPNOT: *c = bzap(a, (int)~b); break; 924 0317 case _ZAP___: *c = bzap(a, (int)b ); break; 925 0318 case _EXTBL_: *c = (a>>B7(b)) & MASK08; break; 926 0319 case _EXTWL_: *c = (a>>B7(b)) & MASK16; break; 927 0320 case _EXTLL_: *c = (a>>B7(b)) & MASK32; break; 928 0321 case _EXTQL_: *c = a>>B7(b); break; 929 0322 case _EXTWH_: *c = (a<>8); 937 0330 break; 938 0331 case _MSKLH_: *c = bzap(a, (0x0fu<>8); 939 0332 break; 940 0333 case _MSKQH_: *c = bzap(a, (0xffu<>8); 941 0334 break; 942 0335 case _INSBL_: 943 0336 *c =bzap(a<>8); 956 0349 loc = (uint_32t)(64 - ((b & 0x7)<<3)) & 0x3f; 957 0350 *c = bzap((a >> loc), ~msk); 958 0351 break; 959 0352 case _INSLH_: 960 0353 msk = (uint_32t)((0xFull << (b & 0x7))>>8); 961 0354 loc = (uint_32t)(64 - ((b & 0x7)<<3)) & 0x3f; 962 0355 *c = bzap((a >> loc), ~msk); 963 0356 break; 964 0357 case _INSQH_: 965 0358 msk = (uint_32t)((0xFFull << (b & 0x7))>>8); 966 0359 loc = (uint_32t)(64 - ((b & 0x7)<<3)) & 0x3f; 967 0360 *c = bzap((a >> loc), ~msk); 968 0361 break; 969 0362 default: 970 0363 printf("*** ShiftUnit %x\n", CI); 971 0364 } 972 0365 } 973 0366 974 0367 /** Convert double to uint_64t **/ 975 0368 /************************************************/ 976 0369 double Fcv(DATA_TYPE a){ 977 0370 double Fav; 978 0371 memcpy(&Fav, &a, 8); 979 0372 return Fav; 980 0373 } 981 0374 982 0375 /** 64 bit multiply Input of A and B **/ 983 0376 /** output of High 64b and Low 64b **/ 984 0377 /************************************************/ 985 0378 void mul128(DATA_TYPE a, DATA_TYPE b, 986 0379 DATA_TYPE *rh, DATA_TYPE *rl){ 987 0380 DATA_TYPE ah,al, bh, bl; 988 0381 DATA_TYPE x,y,z; 989 0382 int carry=0; /* has a value of 0, 1 or 2 */ 990 0383 991 0384 ah = a >> 32; 992 0385 al = a & 0xFFFFFFFF; 993 0386 994 0387 bh = b >> 32; 995 0388 bl = b & 0xFFFFFFFF; 996 0389 997 0390 x = al*bl; 998 0391 y = (al*bh << 32); 999 0392 z = x + y; 1000 0393 if(z> 32)+(ah*bl >> 32)+carry; 1008 0401 } 1009 0402 1010 0403 /************************************************/ 1011 0404 void UnitM(int CI, DATA_TYPE a, 1012 0405 DATA_TYPE b, DATA_TYPE *c){ 1013 0406 DATA_TYPE tmp2, tmp3; 1014 0407 switch(CI){ 1015 0408 case _MULL__: *c = sext(a*b); break; 1016 0409 case _MULQ__: mul128(a, b, &tmp2, c); break; 1017 0410 case _UMULH_: mul128(a, b, c, &tmp3); break; 1018 0411 default: 1019 0412 *c = 0; 1020 0413 printf("*** MulUnit %x\n", CI); 1021 0414 } 1022 0415 } 1023 0416 1024 0417 /** Integer Arithmetic and Logic Unit **/ 1025 0418 /************************************************/ 1026 0419 void CmovUnit(int CI, DATA_TYPE a, int *cm){ 1027 0420 double Fav =0.0; 1028 0421 switch(CI){ 1029 0422 case _CMOVEQ : *cm=(a==0); break; 1030 0423 case _CMOVNE : *cm=(a!=0); break; 1031 0424 case _CMOVLT : *cm=((int_64t)a< 0); break; 1032 0425 case _CMOVGE : *cm=((int_64t)a>=0); break; 1033 0426 case _CMOVLE : *cm=((int_64t)a<=0); break; 1034 0427 case _CMOVGT : *cm=((int_64t)a> 0); break; 1035 0428 case _CMOVLBC: *cm=(!(a & 1)); break; 1036 0429 case _CMOVLBS: *cm=(int)(a & 1); break; 1037 0430 case _FCMOVEQ: 1038 0431 memcpy(&Fav, &a, 8); 1039 0432 *cm = (Fav==0.0); 1040 0433 break; 1041 0434 case _FCMOVNE: 1042 0435 memcpy(&Fav, &a, 8); 1043 0436 *cm = (Fav!=0.0); 1044 0437 break; 1045 0438 default: 1046 0439 printf("*** CmovUnit %x\n", CI); 1047 0440 } 1048 0441 } 1049 0442 1050 0443 /** calculate branch condition : taken? **/ 1051 0444 /************************************************/ 1052 0445 int Btaken(int CI, DATA_TYPE a){ 1053 0446 int taken = 0; 1054 0447 switch(CI){ 1055 0448 case _BEQ_: taken = (a==0); break; 1056 0449 case _BNE_: taken = (a!=0); break; 1057 0450 case _BR__: taken = 1; break; 1058 0451 case _BSR_: taken = 1; break; 1059 0452 case _BLE_: taken = ((int_64t)a<=0); break; 1060 0453 case _BLT_: taken = ((int_64t)a< 0); break; 1061 0454 case _BGE_: taken = ((int_64t)a>=0); break; 1062 0455 case _BGT_: taken = ((int_64t)a> 0); break; 1063 0456 case _BLGC: taken = (!(a & 1)); break; 1064 0457 case _BLBS: taken = (int)(a & 1 ); break; 1065 0458 case _FBEQ: taken=(Fcv(a)==0.0); break; 1066 0459 case _FBLT: taken=(Fcv(a)< 0.0); break; 1067 0460 case _FBLE: taken=(Fcv(a)<=0.0); break; 1068 0461 case _FBNE: taken=(Fcv(a)!=0.0); break; 1069 0462 case _FBGE: taken=(Fcv(a)>=0.0); break; 1070 0463 case _FBGT: taken=(Fcv(a)> 0.0); break; 1071 0464 default: printf("*** Btaken %x\n", CI); 1072 0465 } 1073 0466 return taken; 1074 0467 } 1075 0468 /************************************************/ 1076 ------------------------------------------------------------ 1077 file name: debug.cc 1078 0001 /**** SimCore since 2002-05-15 by Kenji KISE ****/ 1079 0002 /************************************************/ 1080 0003 #include "define.h" 1081 0004 1082 0005 /* convert hexadecimal value into decimal value */ 1083 0006 /************************************************/ 1084 0007 uint_64t get_hex(char *buf){ 1085 0008 static char hex_chars[] = { 1086 0009 '0', '1', '2', '3', '4', '5', '6', '7', 1087 0010 '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; 1088 0011 1089 0012 uint_64t sum = 0; 1090 0013 1091 0014 for(int i=0; i<16; i++){ 1092 0015 char t = buf[i]; 1093 0016 if(t==' ' || t=='\n' || t==0) break; 1094 0017 int num=0; 1095 0018 for(int j=0; j<16; j++){ 1096 0019 if(hex_chars[j]==t) num=j; 1097 0020 } 1098 0021 sum = sum * 16 + num; 1099 0022 } 1100 0023 return sum; 1101 0024 } 1102 0025 1103 0026 /************************************************/ 1104 0027 void print_register_name(int i){ 1105 0028 static char *alpha_reg_name[] = { 1106 0029 "v0", "t0", "t1", "t2", 1107 0030 "t3", "t4", "t5", "t6", 1108 0031 "t7", "s0", "s1", "s2", 1109 0032 "s3", "s4", "s5", "fp", 1110 0033 "a0", "a1", "a2", "a3", 1111 0034 "a4", "a5", "t8", "t9", 1112 0035 "t10", "t11", "ra", "t12", 1113 0036 "at", "gp", "sp", "zero", 1114 0037 "pc", "vfp " 1115 0038 }; 1116 0039 printf("%-5s", alpha_reg_name[i]); 1117 0040 } 1118 0041 1119 0042 /************************************************/ 1120 0043 void print_status(ADDR_TYPE pc, data_t *reg){ 1121 0044 for(int i=0; i<32; i++){ 1122 0045 print_register_name(i); 1123 0046 printf(" r%-2d ", i); 1124 0047 printf("0x%-6llx ", reg[i]); 1125 0048 printf("%-8lld\n", reg[i]); 1126 0049 } 1127 0050 printf("fpcr 0x0 0\n"); 1128 0051 printf("pc 0x%-6llx %-8lld\n", 1129 0052 pc, pc); 1130 0053 printf("vfp 0x0 0\n"); 1131 0054 } 1132 0055 1133 0056 1134 0057 /************************************************/ 1135 0058 debug::debug(Env *e){ 1136 0059 ev = e; 1137 0060 } 1138 0061 1139 0062 /************************************************/ 1140 0063 void debug::debugmode(instruction *p){ 1141 0064 1142 0065 if(ev->sc->debug_flag==2){ 1143 0066 static architecture_state as_t; 1144 0067 printf("\n"); 1145 0068 1146 0069 printf("TC:%lld ", ev->e->retired_inst); 1147 0070 printf("pc:%llx\n", ev->as->pc); 1148 0071 1149 0072 for(int i=0; i<32; i++){ 1150 0073 DATA_TYPE tmp1 = ev->as->r[i]; 1151 0074 DATA_TYPE tmp2 = ev->as->f[i]; 1152 0075 if(as_t.r[i] != tmp1){ 1153 0076 printf("r[%d] 0x%-6llx\n", i, tmp1); 1154 0077 } 1155 0078 if(as_t.f[i] != tmp2){ 1156 0079 printf("f[%d] 0x%-6llx\n", i, tmp2); 1157 0080 } 1158 0081 } 1159 0082 as_t = *ev->as; /* remember old state */ 1160 0083 return; 1161 0084 } 1162 0085 1163 0086 char t_buf[256]; 1164 0087 static int stop = 1; 1165 0088 1166 0089 char *buf; 1167 0090 1168 0091 static uint_64t stop_count = 0; 1169 0092 static ADDR_TYPE stop_address = 0; 1170 0093 ADDR_TYPE address; 1171 0094 1172 0095 buf = t_buf; 1173 0096 1174 0097 if(stop_count==ev->e->retired_inst){ stop=1; } 1175 0098 if(stop_address==ev->as->pc){ stop=1; } 1176 0099 if(stop==0) return; 1177 0100 1178 0101 if(stop==1){ 1179 0102 data_t ir_t; 1180 0103 ev->mem->ld_nbyte(4, &ev->as->pc, &ir_t); 1181 0104 printf("TC:%lld ", ev->e->retired_inst); 1182 0105 printf("pc:%llx ", p->Cpc); 1183 0106 printf("ir:%08x ", p->ir); 1184 0107 int id = get_code(p->ir); 1185 0108 printf("ID:%02x.%04x\n", id>>16, id & 0xffff); 1186 0109 1187 0110 print_status(ev->as->pc, ev->as->r); 1188 0111 1189 0112 printf("(db)"); 1190 0113 fgets(buf,256, stdin); 1191 0114 1192 0115 while(*buf != (char)NULL){ 1193 0116 if(!strncmp(buf,"quit",4)) exit(1); 1194 0117 if(!strncmp(buf,"h",1)){ /* help */ 1195 0118 printf(" command\n"); 1196 0119 printf(" c: stop specified tc.\n"); 1197 0120 printf(" s: stop specified address.\n"); 1198 0121 printf(" x: examine memory contents.\n"); 1199 0122 printf(" quit: quit simulate.\n"); 1200 0123 } 1201 0124 if(*(buf)=='\n') break; 1202 0125 1203 0126 if(*(buf)=='x'){ 1204 0127 buf++; 1205 0128 address = get_hex(buf); 1206 0129 address = (address & ~7ull); 1207 0130 1208 0131 for(int j=0; j<16; j++){ 1209 0132 data_t tmp; 1210 0133 printf("0x%09llx: ", address); 1211 0134 for(int i=0; i<2; i++){ 1212 0135 data_t adr; 1213 0136 adr = address; 1214 0137 ev->mem->ld_nbyte(8, &adr, &tmp); 1215 0138 printf("0x%016llx ", tmp); 1216 0139 address +=8; 1217 0140 } 1218 0141 printf("\n"); 1219 0142 } 1220 0143 } 1221 0144 1222 0145 if(*(buf)=='c'){ /* stop by count */ 1223 0146 buf++; 1224 0147 stop_count = atol(buf); 1225 0148 printf("stop_tc = %lld\n", stop_count); 1226 0149 stop=0; 1227 0150 break; 1228 0151 } 1229 0152 1230 0153 if(*(buf)=='s'){ /* stop by address */ 1231 0154 buf++; 1232 0155 stop_address = get_hex(buf); 1233 0156 stop_address = stop_address; 1234 0157 printf("stop_address = 0x%llx\n", 1235 0158 stop_address); 1236 0159 stop=0; 1237 0160 break; 1238 0161 } 1239 0162 1240 0163 printf("\n(db)"); 1241 0164 fgets(buf,256,stdin); 1242 0165 } 1243 0166 } 1244 0167 } 1245 0168 /************************************************/ 1246 ------------------------------------------------------------ 1247 file name: etc.cc 1248 0001 /**** SimCore since 2002-05-15 by Kenji KISE ****/ 1249 0002 /************************************************/ 1250 0003 #include "define.h" 1251 0004 #include 1252 0005 1253 0006 /************************************************/ 1254 0007 void usage(){ 1255 0008 char UsageMessage[] = "\ 1256 0009 -d: debug mode\n\ 1257 0010 -a: print simple evaluation result\n\ 1258 0011 -c: print systemcall trace\n\ 1259 0012 -g: print instruction distribution data\n\ 1260 0013 -v[num]: verbose mode, prints '.' \ 1261 0014 by VERBOSE_INTERVAL\n\ 1262 0015 -f[num]: set fd_adjust to verify simulation\n\ 1263 0016 -t[num][m]: print execution trace\n\ 1264 0017 -e[num][m]: end simulation at num code run. \ 1265 0018 m means million\n\ 1266 0019 -i[file_name]: file_name as STDIN input file\n\ 1267 0020 "; 1268 0021 printf(" Usage: %s [-option] command\n", PROJ); 1269 0022 printf("%s", UsageMessage); exit(0); 1270 0023 } 1271 0024 1272 0025 /** return 24bit unique instruction ID **/ 1273 0026 /************************************************/ 1274 0027 int get_code(INST_TYPE ir){ 1275 0028 int id=0; 1276 0029 int op6 = (ir>>26) & 0x003f; 1277 0030 int func7 = (ir>>5 ) & 0x007f; 1278 0031 int func11 = (ir>>5 ) & 0x07ff; 1279 0032 int jmp_op = (ir>>14) & 0x0003; 1280 0033 1281 0034 if(op6<=0x0f || op6>=0x1b){ 1282 0035 id = op6 << 16; 1283 0036 } 1284 0037 else{ 1285 0038 switch(op6){ 1286 0039 case 0x10: 1287 0040 case 0x11: 1288 0041 case 0x12: 1289 0042 case 0x13: id = (op6 << 16) | func7; break; 1290 0043 case 0x14: id = op6 << 16; break; 1291 0044 case 0x15: 1292 0045 case 0x16: 1293 0046 case 0x17: 1294 0047 case 0x18: id = (op6 << 16) | func11; break; 1295 0048 case 0x19: id = op6 << 16; break; 1296 0049 case 0x1a: id = (op6 << 16) | jmp_op; break; 1297 0050 default: 1298 0051 printf("*** get_code default %x\n", op6); 1299 0052 } 1300 0053 } 1301 0054 return id; 1302 0055 } 1303 0056 1304 0057 /* If IR is not the cmov, return 0. */ 1305 0058 /************************************************/ 1306 0059 int cmov_ir(INST_TYPE ir){ 1307 0060 int op = (ir>>26) & 0x3F; 1308 0061 if(op==OP_INTL || op==OP_FLTL){ 1309 0062 switch(get_code(ir)){ 1310 0063 case _CMOVLBS: 1311 0064 case _CMOVLBC: 1312 0065 case _CMOVEQ : 1313 0066 case _CMOVNE : 1314 0067 case _CMOVLT : 1315 0068 case _CMOVGE : 1316 0069 case _CMOVLE : 1317 0070 case _CMOVGT : 1318 0071 case _FCMOVEQ: 1319 0072 case _FCMOVNE: 1320 0073 case _FCMOVLT: 1321 0074 case _FCMOVGE: 1322 0075 case _FCMOVLE: 1323 0076 case _FCMOVGT: return 1; 1324 0077 } 1325 0078 } 1326 0079 return 0; 1327 0080 } 1328 0081 1329 0082 /************************************************/ 1330 0083 void house_keeper(instruction *p){ 1331 0084 Env *ev = p->ev; 1332 0085 1333 0086 if(ev->sc->distrib_flag){ 1334 0087 data_t a = p->CI << DATA_T_BIT; 1335 0088 data_t d; 1336 0089 DATA_TYPE msk = 0; 1337 0090 ev->e->imix->ld_8byte(&a, &d); 1338 0091 d++; 1339 0092 ev->e->imix->st_8byte(&a, &d, msk); 1340 0093 } 1341 0094 1342 0095 if(ev->sc->trace_flag!=0 && 1343 0096 ev->sc->trace_flag<=ev->e->retired_inst){ 1344 0097 printf("TC:%lld ", ev->e->retired_inst); 1345 0098 printf("pc:%9llx ", p->Cpc); 1346 0099 printf("ir:%08x ", p->ir); 1347 0100 int id = get_code(p->ir); 1348 0101 printf("ID:%02x.%04x\n", id>>16, id&0xffff); 1349 0102 printf(" Rav: %016llx ", p->Rav); 1350 0103 printf("Rbv: %016llx\n", p->Rbv); 1351 0104 printf(" Imm: %016llx ", p->Imm); 1352 0105 printf("Adr: %016llx\n", p->Adr); 1353 0106 printf(" Rcv: %016llx\n", p->Rcv); 1354 0107 } 1355 0108 if(ev->sc->debug_flag) ev->deb->debugmode(p); 1356 0109 if(ev->sc->verbose_interval && 1357 0110 (ev->e->retired_inst % 1358 0111 ev->sc->verbose_interval)==0){ 1359 0112 write(1, ".", 1); 1360 0113 } 1361 0114 if(ev->sc->end_tc!=0 && 1362 0115 ev->e->retired_inst>=ev->sc->end_tc) 1363 0116 ev->sys->running = 0; 1364 0117 1365 0118 } 1366 0119 1367 0120 /************************************************/ 1368 0121 void option_from_file(char **opt, char *name){ 1369 0122 char *buf; 1370 0123 for(int i=0; iev->as->pc; 1397 0150 int running = chip->step(); 1398 0151 1399 0152 for(int i=0; i<31; i++) 1400 0153 *(p++)=chip->ev->as->r[i]; 1401 0154 for(int i=0; i<31; i++) 1402 0155 *(p++)=chip->ev->as->f[i]; 1403 0156 1404 0157 if(running==0) delete chip; 1405 0158 break; 1406 0159 } 1407 0160 default: 1408 0161 printf("Warning: %d siple_cpu.\n", job); 1409 0162 } 1410 0163 return 0; 1411 0164 } 1412 0165 1413 0166 /* map_s is used in LDS & ITOFS instruction */ 1414 0167 /* input of 8bit and output of 11bit */ 1415 0168 /************************************************/ 1416 0169 uint_64t map_s(DATA_TYPE in){ 1417 0170 uint_32t i8 = (uint_32t)((in >> 23) & 0xFF); 1418 0171 1419 0172 /** Next line should be valid, 1420 0173 SimpleScalar has a bug ? **/ 1421 0174 // if(i8==0xFF) return 0x00000000000007FFull; 1422 0175 if(i8==0x00) return 0x0000000000000000ull; 1423 0176 1424 0177 if(i8 & 0x80) return 0x400ull | (i8 & 0x7F); 1425 0178 else return 0x380ull | (i8 & 0x7F); 1426 0179 } 1427 0180 1428 0181 /************************************************/ 1429 0182 architecture_state::architecture_state(){ 1430 0183 for(int i=0; i<32; i++) r[i]=0; 1431 0184 for(int i=0; i<32; i++) f[i]=0; 1432 0185 } 1433 0186 1434 0187 /* 1435 0188 * Initialize the registers, data file format. 1436 0189 * Begin by "\@" to indicate the valid data. 1437 0190 * /@reg 28 0000000000000000 1438 0191 * /@reg 29 0000000140023e90 */ 1439 0192 /************************************************/ 1440 0193 architecture_state::architecture_state(Env *e){ 1441 0194 ev = e; 1442 0195 for(int i=0; i<32; i++) r[i]=0; 1443 0196 for(int i=0; i<32; i++) f[i]=0; 1444 0197 1445 0198 char *program = ev->sc->program_name; 1446 0199 FILE *fp = fp = fopen(program, "r"); 1447 0200 if(fp==NULL){ 1448 0201 printf("Bad file name: %s\n", program); 1449 0202 exit(1); 1450 0203 } 1451 0204 1452 0205 /*** File Format Check ***/ 1453 0206 DATA_TYPE dat; 1454 0207 char buf[4096]; 1455 0208 fgets(buf, 4096, fp); 1456 0209 if(strncmp(buf, "/* Sim", 6)){ 1457 0210 printf("%s: not a %s image file.\n", 1458 0211 program, PROJ); 1459 0212 exit(1); 1460 0213 } 1461 0214 1462 0215 while(!feof(fp)){ 1463 0216 int i; 1464 0217 fgets(buf, 4096, fp); 1465 0218 if(*buf=='/' && *(buf+1)=='@'){ 1466 0219 sscanf(buf+6,"%d", &i); 1467 0220 dat = get_hex(buf+9); 1468 0221 if(i==32) pc=dat; 1469 0222 else r[i]=dat; 1470 0223 } 1471 0224 if(i==32) break; 1472 0225 } 1473 0226 fclose(fp); 1474 0227 } 1475 0228 1476 0229 /************************************************/ 1477 0230 uint_64t architecture_state::rr(int n){ 1478 0231 if(n==0) return pc; 1479 0232 if(n>=1 && n<=32) return r[n-1]; 1480 0233 if(n>=33 && n<=64) return f[n-33]; 1481 0234 printf("Error:architecture_state::rr(%d)\n",n); 1482 0235 exit(1); 1483 0236 return 0; 1484 0237 } 1485 0238 1486 0239 /************************************************/ 1487 0240 void print_evaluation_result(Env *ev){ 1488 0241 class evaluation_result *e = ev->e; 1489 0242 struct timeval tp; 1490 0243 struct timezone tzp; 1491 0244 1492 0245 /***** print out the distribution data *****/ 1493 0246 if(ev->sc->distrib_flag){ 1494 0247 uint_64t sum_d = 0; 1495 0248 double sum_f = 0.0; 1496 0249 for(int i=0; i<64; i++) printf("="); 1497 0250 printf("\n"); 1498 0251 1499 0252 data_t a, d; 1500 0253 while(ev->e->imix->load_all(&a, &d)){ 1501 0254 int id = a >> DATA_T_BIT; 1502 0255 printf("ID: %02x.%04x ", id>>16, id&0xffff); 1503 0256 printf("%13lld ", d); 1504 0257 double rate = (double)d*100.0/ 1505 0258 (double)e->retired_inst; 1506 0259 printf("%13.3f\n", rate); 1507 0260 sum_d += d; 1508 0261 sum_f += rate; 1509 0262 } 1510 0263 printf("check sum : %13lld %13.3f\n", 1511 0264 sum_d, sum_f); 1512 0265 } 1513 0266 1514 0267 if(ev->sc->simple_result){ 1515 0268 printf("\n"); 1516 0269 for(int i=0; i<64; i++) printf("="); 1517 0270 printf("\n=== %s/%s %s\n", PROJ, NAME, VER); 1518 0271 printf("=== %6lld million code(%14lld code)\n", 1519 0272 e->retired_inst/1000000, 1520 0273 e->retired_inst); 1521 0274 return; 1522 0275 } 1523 0276 1524 0277 gettimeofday(&tp, &tzp); 1525 0278 uint_64t usec = 1526 0279 (uint_64t)(tp.tv_sec - e->tp.tv_sec) 1527 0280 * 1000000ull + (uint_64t)tp.tv_usec - 1528 0281 (uint_64t)e->tp.tv_usec; 1529 0282 fflush(stdout); 1530 0283 fflush(stderr); 1531 0284 uint_64t minute = (usec / 1000000) / 60; 1532 0285 uint_64t second = (usec / 1000000) % 60; 1533 0286 printf("\n"); 1534 0287 for(int i=0; i<64; i++) printf("="); 1535 0288 printf("\n=== %s/%s %s\n", PROJ, NAME, VER); 1536 0289 char buf[256]; 1537 0290 getcwd(buf, 256); 1538 0291 printf("=== cwd: %s\n", buf); 1539 0292 printf("=== %6lld million code(%14lld code)", 1540 0293 e->retired_inst/1000000,e->retired_inst); 1541 0294 printf(" %6.3f MIPS\n", 1542 0295 (double)e->retired_inst/(double)usec); 1543 0296 printf("=== %s takes ", PROJ); 1544 0297 printf("%5lld min %2lld second", 1545 0298 minute, second); 1546 0299 printf(" (%12lld usec)\n", usec); 1547 0300 printf("=== %s starts at %s", PROJ, 1548 0301 ctime(&e->time_begin)); 1549 0302 fflush(stdout); 1550 0303 } 1551 0304 1552 0305 /************************************************/ 1553 0306 system_config::system_config(char *program, 1554 0307 char **option){ 1555 0308 memset(this, 0, sizeof(system_config)); 1556 0309 strcpy(program_name, program); 1557 0310 1558 0311 if(option==NULL) return; 1559 0312 for(int i=0; option[i]!=NULL; i++){ 1560 0313 char opt[1024]; 1561 0314 strcpy(opt, option[i]); 1562 0315 if(opt[0]!='-') continue; 1563 0316 switch(opt[1]){ 1564 0317 case 'a': simple_result = 1; break; 1565 0318 case 'c': syscall_flag = 1; break; 1566 0319 case 'z': verify_flag = 1; break; 1567 0320 case 'g': distrib_flag = 1; break; 1568 0321 case 'd': 1569 0322 debug_flag = atoi(&opt[2]); 1570 0323 if(debug_flag==0) debug_flag=1; 1571 0324 break; 1572 0325 case 't': 1573 0326 trace_flag = atoi(&opt[2]); 1574 0327 if(opt[strlen(opt)-1]=='m') 1575 0328 trace_flag*=1000000; 1576 0329 if(trace_flag==0) trace_flag = 1; 1577 0330 printf("*** gen trace data at %lld exec.\n", 1578 0331 trace_flag); 1579 0332 break; 1580 0333 case 'v': 1581 0334 verbose_interval =atoi(&opt[2]); 1582 0335 if(verbose_interval == 0) 1583 0336 verbose_interval = 100000; 1584 0337 if(opt[strlen(opt)-1]=='m') 1585 0338 verbose_interval*=1000000; 1586 0339 printf("*** verbose interval: %d\n", 1587 0340 verbose_interval); 1588 0341 break; 1589 0342 case 'f': 1590 0343 fd_adjust = atoi(&opt[2]); 1591 0344 if(fd_adjust==0) fd_adjust=1; 1592 0345 printf("*** fd_adjust=%d \n",fd_adjust); 1593 0346 if(fd_adjust<0){ 1594 0347 printf("Error fd_adjust.\n"); 1595 0348 exit(1); 1596 0349 } 1597 0350 break; 1598 0351 case 'e': 1599 0352 end_tc =atoi(&opt[2]); 1600 0353 if(opt[strlen(opt)-1]=='m')end_tc*=1000000; 1601 0354 printf("** Finish at %lld code execution\n", 1602 0355 end_tc); 1603 0356 break; 1604 0357 case 'i': 1605 0358 fd_stdin_flag = 1; 1606 0359 fd_stdin = open(&opt[2], O_RDONLY); 1607 0360 printf("*** %s: use [%s] as STDIN.\n", 1608 0361 PROJ, &opt[2]); 1609 0362 if(fd_stdin<0){ 1610 0363 printf("Can not open file:%s\n",&opt[2]); 1611 0364 exit(1); 1612 0365 } 1613 0366 break; 1614 0367 default: 1615 0368 printf("*** Error:[%s] Wrong option!!\n\n", 1616 0369 opt); 1617 0370 usage(); 1618 0371 exit(1); 1619 0372 } 1620 0373 } 1621 0374 slow_mode = debug_flag || verbose_interval 1622 0375 || end_tc || trace_flag || distrib_flag; 1623 0376 } 1624 0377 1625 0378 /************************************************/ 1626 0379 evaluation_result::evaluation_result(){ 1627 0380 memset(this,0,sizeof(class evaluation_result)); 1628 0381 1629 0382 time_begin = time(0); 1630 0383 gettimeofday(&tp, &tzp); 1631 0384 } 1632 0385 /************************************************/ 1633 ------------------------------------------------------------ 1634 file name: syscall.cc 1635 0001 /**** SimCore since 2002-05-15 by Kenji KISE ****/ 1636 0002 /************************************************/ 1637 0003 #include "define.h" 1638 0004 #include 1639 0005 1640 0006 /************************************************/ 1641 0007 int system_manager::translate_fd(DATA_TYPE fd){ 1642 0008 for(int i=0; isc->fd_adjust; 1664 0030 } 1665 0031 1666 0032 /************************************************/ 1667 0033 void system_manager::execute_pal(instruction *p){ 1668 0034 INST_TYPE ir = p->ir; 1669 0035 int_64t ret=0; 1670 0036 int F = ev->sc->syscall_flag; 1671 0037 data_t *r = ev->as->r; 1672 0038 1673 0039 if(F) printf("%8lld: ", ev->e->retired_inst); 1674 0040 1675 0041 if((ir & 0xFFFF)!=0x0083){ 1676 0042 switch((ir & 0xFFFF)){ 1677 0043 case 0x009e: // rdunique(Read Unique Value) 1678 0044 r[0]=(uniq); 1679 0045 if(F){ 1680 0046 printf("call_pal rduniq=%llx\n", uniq); 1681 0047 } 1682 0048 return; 1683 0049 case 0x009f: // wrunique(Write Unique Value) 1684 0050 uniq = r[16]; 1685 0051 if(F){ 1686 0052 printf("call_pal wrruniq=%llx\n", 1687 0053 r[16]); 1688 0054 } 1689 0055 return; 1690 0056 default: 1691 0057 if(F){ 1692 0058 printf("*** PAL(ir & 0xFFFF)!=0x83 F=%x", 1693 0059 (ir & 0xffff)); 1694 0060 printf(" TC:%lld default. %llx\n", 1695 0061 ev->e->retired_inst, r[0]); 1696 0062 } 1697 0063 return; 1698 0064 } 1699 0065 } 1700 0066 1701 0067 if(r[0]==0){ 1702 0068 r[19]=(0); 1703 0069 return; 1704 0070 } 1705 0071 1706 0072 switch(r[0]){ 1707 0073 /********************************************/ 1708 0074 case ASYS_UNIMPLEMENT: { 1709 0075 ret = -1; 1710 0076 r[0]=(0); 1711 0077 r[19]=(ret); 1712 0078 if(F){ 1713 0079 printf("SYS_226 = %lld\n", ret); 1714 0080 } 1715 0081 break; 1716 0082 } 1717 0083 /********************************************/ 1718 0084 case ASYS_unlink: { 1719 0085 char buf[512]; /** file name **/ 1720 0086 for(int i=0; i<=512; i++){ 1721 0087 data_t d; 1722 0088 data_t adr; 1723 0089 adr=(r[16]+i); 1724 0090 ev->mem->ld_nbyte(1, &adr, &d); 1725 0091 buf[i] = (char)d; 1726 0092 if(buf[i]=='\0') break; 1727 0093 } 1728 0094 if(ev->sc->fd_adjust){ /** rename **/ 1729 0095 buf[1]='S'; 1730 0096 buf[2]='A'; 1731 0097 buf[3]='0'+ ev->sc->fd_adjust; 1732 0098 } 1733 0099 1734 0100 ret = unlink(buf); 1735 0101 if(ret==-1){ 1736 0102 r[0]=(errno); 1737 0103 r[19]=(ret); 1738 0104 } 1739 0105 else{ 1740 0106 r[19]=(0); 1741 0107 } 1742 0108 1743 0109 if(F){ 1744 0110 printf("unlink(%s) = %lld\n", buf, ret); 1745 0111 } 1746 0112 break; 1747 0113 } 1748 0114 /********************************************/ 1749 0115 case ASYS_open: { 1750 0116 int fd_t; 1751 0117 char buf[512]; /** file name **/ 1752 0118 for(int i=0; i<=512; i++){ 1753 0119 data_t d; 1754 0120 data_t adr; 1755 0121 adr=(r[16]+i); 1756 0122 ev->mem->ld_nbyte(1, &adr, &d); 1757 0123 buf[i] = (char)d; 1758 0124 if(buf[i]=='\0') break; 1759 0125 } 1760 0126 /** RDONLY or RDWR **/ 1761 0127 if(r[17]==0 || r[17]==2){ 1762 0128 fd_t = open(buf, r[17], r[18]); 1763 0129 } 1764 0130 else{ 1765 0131 if(ev->sc->fd_adjust){ /** rename **/ 1766 0132 buf[1]='S'; 1767 0133 buf[2]='A'; 1768 0134 buf[3]='0'+ ev->sc->fd_adjust; 1769 0135 } 1770 0136 int flag = (int)r[17] | O_CREAT; 1771 0137 fd_t = open(buf, flag, r[18]); 1772 0138 } 1773 0139 1774 0140 /* mapping from the real to the logical */ 1775 0141 if(fd_t==-1){ 1776 0142 ret = -1; 1777 0143 r[0]=(errno); 1778 0144 r[19]=(~0ull); 1779 0145 } 1780 0146 else{ 1781 0147 ret = fd_table[fd_t]; 1782 0148 r[0]=(ret); 1783 0149 r[19]=(0); 1784 0150 } 1785 0151 1786 0152 if(F){ 1787 0153 printf("open(\"%s\", 0x%llx, 0x%llx)", 1788 0154 buf, r[17], r[18]); 1789 0155 printf("= logic %lld(real %d)\n", 1790 0156 ret, fd_t); 1791 0157 } 1792 0158 break; 1793 0159 } 1794 0160 /*** Note that sigreturn updates as->pc ***/ 1795 0161 /********************************************/ 1796 0162 case ASYS_sigreturn: { 1797 0163 uint_64t pt[OSF_SIGCONTEXT_SIZE/8]; 1798 0164 char *buf = (char *)pt; 1799 0165 1800 0166 data_t d; 1801 0167 data_t adr; 1802 0168 for(int i=0; imem->ld_nbyte(1, &adr, &d); 1805 0171 buf[i] = (char)d; 1806 0172 } 1807 0173 for(int i=0; i<31; i++) r[i]=(pt[i+4]); 1808 0174 for(int i=0; i<31; i++){ 1809 0175 ev->as->f[i]=(pt[i+37]); 1810 0176 } 1811 0177 ev->as->pc=(pt[2]); /** Update PC **/ 1812 0178 1813 0179 if(F){ 1814 0180 printf("sigreturn(0x%llx),Npc:0x%llx\n", 1815 0181 r[16], ev->as->pc); 1816 0182 } 1817 0183 break; 1818 0184 } 1819 0185 /********************************************/ 1820 0186 case ASYS_close: { 1821 0187 int fd_t = translate_fd(r[16]); 1822 0188 1823 0189 if(fd_t!=0 && fd_t!=1 && fd_t!=2){ 1824 0190 ret = close(fd_t); 1825 0191 r[0]=(ret); 1826 0192 } 1827 0193 r[19]=(0); 1828 0194 if(F){ 1829 0195 printf("close(%lld(%d)) = %lld\n", 1830 0196 r[16], fd_t, ret); 1831 0197 } 1832 0198 break; 1833 0199 } 1834 0200 /********************************************/ 1835 0201 case ASYS_getpagesize: { 1836 0202 ret = 8192; /* getpagesize(); */ 1837 0203 r[0]=(ret); 1838 0204 r[19]=(0); 1839 0205 if(F){ 1840 0206 printf("getpagesize() = 0x%llx\n", ret); 1841 0207 } 1842 0208 break; 1843 0209 } 1844 0210 /********************************************/ 1845 0211 case ASYS_sigprocmask: { 1846 0212 ret = 0; 1847 0213 r[0]=(ret); 1848 0214 r[19]=(ret); 1849 0215 if(F){ 1850 0216 printf("%8lld: sigprocmask(%lld,%llx) = %lld\n", 1851 0217 ev->e->retired_inst, r[16], 1852 0218 r[17], ret); 1853 0219 } 1854 0220 break; 1855 0221 } 1856 0222 /********************************************/ 1857 0223 case ASYS_getrusage: { // Not Checked 1858 0224 struct rusage ru; 1859 0225 // ret=getrusage((enum __rusage_who)r[16], 1860 0226 ret=getrusage((int)r[16], 1861 0227 &ru); 1862 0228 1863 0229 for(int i=0; imem->st_nbyte(1, &adr, &dat); 1867 0233 } 1868 0234 1869 0235 r[0]=(ret); 1870 0236 r[19]=(0); 1871 0237 1872 0238 if(F){ 1873 0239 printf("getrusage(%lld, %llx)=%lld\n", 1874 0240 r[16], r[17], ret); 1875 0241 } 1876 0242 break; 1877 0243 } 1878 0244 /********************************************/ 1879 0245 case ASYS_gettimeofday:{ 1880 0246 r[19]=(0); 1881 0247 if(F){ 1882 0248 printf("gettimeofday(%lld,%llx) = %lld\n", 1883 0249 r[16], r[17], ret); 1884 0250 } 1885 0251 break; 1886 0252 } 1887 0253 /********************************************/ 1888 0254 case ASYS_fcntl: { 1889 0255 ret = 0; 1890 0256 r[0]=(ret); 1891 0257 r[19]=(0); 1892 0258 if(F){ 1893 0259 printf("fcntl(%lld,%llx) = %lld\n", 1894 0260 r[16], r[17], ret); 1895 0261 } 1896 0262 break; 1897 0263 } 1898 0264 /********************************************/ 1899 0265 case ASYS_sigaction: { 1900 0266 ret = 0; 1901 0267 r[0]=(ret); 1902 0268 r[18]=(r[17]); 1903 0269 r[19]=(0); 1904 0270 if(F){ 1905 0271 printf("sigaction(%llx,%llx,%llx,%llx)", 1906 0272 r[16], r[17], 1907 0273 r[18], r[19]); 1908 0274 printf(" = %lld\n", ret); 1909 0275 } 1910 0276 break; 1911 0277 } 1912 0278 /********************************************/ 1913 0279 case ASYS_osf_getsysinfo: { 1914 0280 ret = 0; 1915 0281 r[0]=(ret); 1916 0282 r[19]=(0); 1917 0283 if(F){ 1918 0284 printf("osf_getsysinfo(%llx,%llx,%llx,%llx)", 1919 0285 r[16], r[17], 1920 0286 r[18], r[19]); 1921 0287 printf(" = %lld\n", ret); 1922 0288 } 1923 0289 break; 1924 0290 } 1925 0291 /********************************************/ 1926 0292 case ASYS_osf_setsysinfo: { 1927 0293 ret = 0; 1928 0294 r[0]=(ret); 1929 0295 // r[20]= ret; 1930 0296 r[19]=(0); 1931 0297 if(F){ 1932 0298 printf("osf_setsysinfo(%llx,%llx,%llx,%llx)", 1933 0299 r[16], r[17], 1934 0300 r[18], r[19]); 1935 0301 printf(" = %lld\n", ret); 1936 0302 } 1937 0303 break; 1938 0304 } 1939 0305 /********************************************/ 1940 0306 case ASYS_getuid: { 1941 0307 ret = getuid(); 1942 0308 r[0]=(ret); 1943 0309 r[19]=(0); 1944 0310 r[20]=(geteuid()); 1945 0311 if(F){ 1946 0312 printf("getuid() = %lld\n", ret); 1947 0313 } 1948 0314 break; 1949 0315 } 1950 0316 /********************************************/ 1951 0317 case ASYS_getgid: { 1952 0318 ret = getgid(); 1953 0319 r[0]=(ret); 1954 0320 r[19]=(0); 1955 0321 r[20]=(getegid()); 1956 0322 if(F){ 1957 0323 printf("getgid(0x%llx) = %lld\n", 1958 0324 r[16], ret); 1959 0325 } 1960 0326 break; 1961 0327 } 1962 0328 /********************************************/ 1963 0329 case ASYS_brk: { 1964 0330 ret = r[16]; 1965 0331 r[0]=(ret); 1966 0332 r[19]=(0); 1967 0333 if(F){ 1968 0334 printf("brk(0x%llx) = %llx\n", 1969 0335 r[16], ret); 1970 0336 } 1971 0337 break; 1972 0338 } 1973 0339 /********************************************/ 1974 0340 case ASYS_getpid: { 1975 0341 ret = getpid(); 1976 0342 r[0]=(ret); 1977 0343 r[19]=(0); 1978 0344 if(F){ 1979 0345 printf("getpid() = %llx\n", ret); 1980 0346 } 1981 0347 break; 1982 0348 } 1983 0349 /********************************************/ 1984 0350 case ASYS_fstat: { 1985 0351 int fd_t = translate_fd(r[16]); 1986 0352 1987 0353 struct stat sbuf; 1988 0354 ret = fstat(fd_t, &sbuf); 1989 0355 1990 0356 struct osf_statbuf asbuf; 1991 0357 memset(&asbuf,0,sizeof(struct osf_statbuf)); 1992 0358 asbuf.a_st_dev = sbuf.st_dev; 1993 0359 asbuf.a_st_ino = sbuf.st_ino; 1994 0360 asbuf.a_st_mode = sbuf.st_mode; 1995 0361 asbuf.a_st_nlink = sbuf.st_nlink; 1996 0362 asbuf.a_st_uid = sbuf.st_uid; 1997 0363 asbuf.a_st_gid = sbuf.st_gid; 1998 0364 asbuf.a_st_rdev = sbuf.st_rdev; 1999 0365 asbuf.a_st_size = sbuf.st_size; 2000 0366 asbuf.a_st_atime = sbuf.st_atime; 2001 0367 asbuf.a_st_mtime = sbuf.st_mtime; 2002 0368 asbuf.a_st_ctime = sbuf.st_ctime; 2003 0369 asbuf.a_st_blksize = sbuf.st_blksize; 2004 0370 asbuf.a_st_blocks = sbuf.st_blocks; 2005 0371 2006 0372 char *buf = (char *)&asbuf; 2007 0373 2008 0374 for(int i=0; imem->st_nbyte(1, &adr, &dat); 2014 0380 } 2015 0381 2016 0382 r[0]=(ret); 2017 0383 r[19]=(0); 2018 0384 if(F){ 2019 0385 printf("fstat(logic %lld(real %d), 0x%llx)", 2020 0386 r[16],fd_t, r[17]); 2021 0387 printf(" = %lld\n", ret); 2022 0388 } 2023 0389 break; 2024 0390 } 2025 0391 /********************************************/ 2026 0392 case ASYS_ioctl: { 2027 0393 int fd_t = translate_fd(r[16]); 2028 0394 2029 0395 switch(r[17]){ 2030 0396 case 0x40067408: // OSF_TIOCGRETP 2031 0397 { 2032 0398 struct osf_sgttyb { 2033 0399 uint_08t sg_ispeed; /* input speed */ 2034 0400 uint_08t sg_ospeed; /* output speed */ 2035 0401 uint_08t sg_erase; /* erase char */ 2036 0402 uint_08t sg_kill; /* kill char */ 2037 0403 uint_16t sg_flags; /* mode flags */ 2038 0404 }; 2039 0405 2040 0406 struct termios lbuf; 2041 0407 ret = tcgetattr(fd_t, &lbuf); 2042 0408 2043 0409 /*** store 6 byte, value of 0 ***/ 2044 0410 for(int i=0; i<6; i++){ 2045 0411 data_t adr; adr=(r[18]+i); 2046 0412 data_t dat; dat=(0); 2047 0413 ev->mem->st_nbyte(1, &adr, &dat); 2048 0414 } 2049 0415 2050 0416 if(ret!=-1){ 2051 0417 r[0]=(ret); 2052 0418 r[19]=(0); // A3 2053 0419 } 2054 0420 else{ 2055 0421 r[0]=(errno); 2056 0422 r[19]=(ret); 2057 0423 } 2058 0424 break; 2059 0425 } 2060 0426 2061 0427 default: 2062 0428 ret = 0; 2063 0429 r[19]=(ret); 2064 0430 if(F) printf("*** ioctl default\n"); 2065 0431 break; 2066 0432 } 2067 0433 2068 0434 if(F){ 2069 0435 printf("ioctl(logic%lld(r%d),0x%llx,0x%llx)", 2070 0436 r[16], fd_t, 2071 0437 r[17], r[18]); 2072 0438 printf(" = %llx\n", ret); 2073 0439 } 2074 0440 break; 2075 0441 } 2076 0442 /********************************************/ 2077 0443 case ASYS_read: { 2078 0444 char *buf = (char *)calloc(1, (size_t)r[18]); 2079 0445 if(buf==NULL){ 2080 0446 printf("*** malloc error: "); 2081 0447 printf("in syscall.cc::read\n"); 2082 0448 } 2083 0449 2084 0450 int fd_t = translate_fd(r[16]); 2085 0451 if(ev->sc->fd_stdin_flag && fd_t==0) 2086 0452 fd_t=ev->sc->fd_stdin; /* STDIN */ 2087 0453 2088 0454 ret = read(fd_t, buf, r[18]); 2089 0455 2090 0456 // This is better. & 2091 0457 // simple scalar imple! 2092 0458 /* for(int i=0; imem->st_nbyte(1, &adr, &dat); 2098 0464 } 2099 0465 r[0]=(ret); 2100 0466 r[19]=(0); 2101 0467 free(buf); 2102 0468 2103 0469 if(F){ 2104 0470 printf("read(logic %lld(real%d),%llx,0x%llx)", 2105 0471 r[16], 2106 0472 fd_t, r[17], r[18]); 2107 0473 printf(" = %llx\n", ret); 2108 0474 } 2109 0475 break; 2110 0476 } 2111 0477 /********************************************/ 2112 0478 case ASYS_write: { 2113 0479 char *buf = (char *)malloc((size_t)r[18]); 2114 0480 if(buf==NULL){ 2115 0481 printf("*** malloc error: "); 2116 0482 printf("in syscall.cc::write\n"); 2117 0483 } 2118 0484 2119 0485 for(int i=0; i<(int)r[18]; i++){ 2120 0486 data_t d; 2121 0487 data_t adr; 2122 0488 adr=(r[17]+i); 2123 0489 ev->mem->ld_nbyte(1, &adr, &d); 2124 0490 buf[i] = (char)d; 2125 0491 } 2126 0492 2127 0493 int fd_t = translate_fd(r[16]); 2128 0494 2129 0495 ret = write(fd_t, (void *)buf, 2130 0496 (long)r[18]); 2131 0497 r[0]=(ret); 2132 0498 r[19]=(0); 2133 0499 free(buf); 2134 0500 2135 0501 if(F){ 2136 0502 printf("write(%lld(%d), 0x%llx, %lld)=%lld\n", 2137 0503 r[16], 2138 0504 fd_t, r[17], r[18], ret); 2139 0505 } 2140 0506 break; 2141 0507 } 2142 0508 /********************************************/ 2143 0509 case ASYS_lseek: { 2144 0510 int fd_t = translate_fd(r[16]); 2145 0511 if(ev->sc->fd_stdin_flag && fd_t==0) 2146 0512 fd_t=ev->sc->fd_stdin; /* STDIN */ 2147 0513 2148 0514 ret = lseek(fd_t, r[17], r[18]); 2149 0515 if(ret==-1){ 2150 0516 r[0]=(errno); 2151 0517 r[19]=(~0); 2152 0518 } 2153 0519 else{ 2154 0520 r[0]=(ret); 2155 0521 r[19]=(0); 2156 0522 } 2157 0523 if(F){ 2158 0524 printf("lseek(logic%lld(real%d),%lld,%lld)\n", 2159 0525 r[16], fd_t, 2160 0526 r[17], r[18]); 2161 0527 printf(" = %llx\n", ret); 2162 0528 } 2163 0529 break; 2164 0530 } 2165 0531 /********************************************/ 2166 0532 case ASYS_getrlimit: { 2167 0533 ret = 0; 2168 0534 r[19]=(ret); 2169 0535 if(F){ 2170 0536 printf("%8lld: getrlimit(%lld,%lld,%lld)", 2171 0537 ev->e->retired_inst, r[16], 2172 0538 r[17], r[18]); 2173 0539 printf(" = %llx\n", ret); 2174 0540 } 2175 0541 break; 2176 0542 } 2177 0543 /********************************************/ 2178 0544 case ASYS_setrlimit: { 2179 0545 ret = 0; 2180 0546 r[19]=(ret); 2181 0547 if(F){ 2182 0548 printf("setrlimit(%lld,%lld,%lld) = %lld\n", 2183 0549 r[16], 2184 0550 r[17], r[18], ret); 2185 0551 } 2186 0552 break; 2187 0553 } 2188 0554 /********************************************/ 2189 0555 case ASYS_exit: { 2190 0556 ret = 0; 2191 0557 running = 0; 2192 0558 if(F){ 2193 0559 printf("%8lld: exit() = %lld\n", 2194 0560 ev->e->retired_inst, ret); 2195 0561 } 2196 0562 break; 2197 0563 } 2198 0564 default: { 2199 0565 printf("systemcall not implemented!!: %lld\n", 2200 0566 r[0]); 2201 0567 r[0]=(0); 2202 0568 r[19]=((uint_64t)-1); 2203 0569 } 2204 0570 } 2205 0571 fflush(stdout); 2206 0572 } 2207 0573 /************************************************/ 2208 ------------------------------------------------------------ 2209 file name: define.h 2210 0001 /*** Yet Another Alpha Processor Simulator ***/ 2211 0002 /*** in C++ since 2002-05-15 by Kenji KISE ***/ 2212 0003 /************************************************/ 2213 0004 #include 2214 0005 #include 2215 0006 #include 2216 0007 #include 2217 0008 #include 2218 0009 #include 2219 0010 #include 2220 0011 #include 2221 0012 #include 2222 0013 #include 2223 0014 #include 2224 0015 #include 2225 0016 #include 2226 0017 #include 2227 0018 2228 0019 /* 1. Type Definition */ 2229 0020 /************************************************/ 2230 0021 typedef signed char int_08t; 2231 0022 typedef signed short int_16t; 2232 0023 typedef signed int int_32t; 2233 0024 typedef signed long long int_64t; 2234 0025 typedef unsigned char uint_08t; 2235 0026 typedef unsigned short uint_16t; 2236 0027 typedef unsigned int uint_32t; 2237 0028 typedef unsigned long long uint_64t; 2238 0029 2239 0030 typedef uint_32t INST_TYPE; 2240 0031 typedef uint_64t ADDR_TYPE; 2241 0032 typedef uint_64t DATA_TYPE; 2242 0033 typedef uint_64t data_t; 2243 0034 2244 0035 2245 0036 /* 2. Constant Definition */ 2246 0037 /************************************************/ 2247 0038 #define PROJ "SimCore" 2248 0039 #define NAME "Alpha Functional Simulator" 2249 0040 #define VER "Version 1.5.0 2003-09-28" 2250 0041 2251 0042 #define DEF_FILE_NAME "aout.txt" 2252 0043 #define BLOCK_SIZE 0x00002000 /* 8KB page */ 2253 0044 #define BLOCK_TABLE_SIZE 0x00080000 /* page size*/ 2254 0045 #define BLOCK_MASK 0x00001fff /* page mask*/ 2255 0046 #define BLOCK_MASK_BIT 13 /* mask bit */ 2256 0047 #define DATA_T_SIZE 8 /* size of data_t */ 2257 0048 #define DATA_T_BIT 3 /* s bit of data_t */ 2258 0049 2259 0050 /** for AMASK op and IMPLVER op **/ 2260 0051 #define IMPLEMENTATION_VERSION 2 2261 0052 #define CPU_FEATURE_MASK 0x0000000000000107ull 2262 0053 2263 0054 #define FD_MAPPING_MAX 128 /* read/write */ 2264 0055 #define OSF_SIGCONTEXT_SIZE 568 /* in byte */ 2265 0056 #define OSF_FSTAT_SIZE 80 /* in byte */ 2266 0057 #define OSF_RUSAGE_SIZE 72 /* in byte */ 2267 0058 #define OPTION_MAX 30 /* max options */ 2268 0059 2269 0060 /** for systemcall implementation **/ 2270 0061 /** I implement one used for SPEC CPU2000. **/ 2271 0062 /************************************************/ 2272 0063 #define ASYS_exit 1 2273 0064 #define ASYS_read 3 2274 0065 #define ASYS_write 4 2275 0066 #define ASYS_close 6 2276 0067 #define ASYS_unlink 10 2277 0068 #define ASYS_brk 17 2278 0069 #define ASYS_lseek 19 2279 0070 #define ASYS_getpid 20 2280 0071 #define ASYS_getuid 24 2281 0072 #define ASYS_open 45 2282 0073 #define ASYS_getgid 47 2283 0074 #define ASYS_sigprocmask 48 2284 0075 #define ASYS_ioctl 54 2285 0076 #define ASYS_getpagesize 64 2286 0077 #define ASYS_stat 67 2287 0078 #define ASYS_mmap 71 2288 0079 #define ASYS_munmap 73 2289 0080 #define ASYS_fstat 91 2290 0081 #define ASYS_fcntl 92 2291 0082 #define ASYS_sigreturn 103 2292 0083 #define ASYS_gettimeofday 116 2293 0084 #define ASYS_getrusage 117 2294 0085 #define ASYS_rename 128 2295 0086 #define ASYS_getrlimit 144 2296 0087 #define ASYS_setrlimit 145 2297 0088 #define ASYS_sigaction 156 2298 0089 #define ASYS_getdirentries 159 2299 0090 #define ASYS_UNIMPLEMENT 226 2300 0091 #define ASYS_osf_getsysinfo 256 2301 0092 #define ASYS_osf_setsysinfo 257 2302 0093 2303 0094 /** Table C-6: Opcode Summary **/ 2304 0095 /** by Alpha Architecture Handbook V.4 **/ 2305 0096 /************************************************/ 2306 0097 /** 0x00 PALcode instruction(CALL_PAL) **/ 2307 0098 /** 0x08 load address instruction **/ 2308 0099 /** 0x09 load address high instruction **/ 2309 0100 /** 0x10 Integer arithmetic instruction **/ 2310 0101 /** 0x11 Integer logical instruction **/ 2311 0102 /** 0x12 Integer shift instruction **/ 2312 0103 /** 0x13 Integer multiply instruction **/ 2313 0104 /** 0x14 Integer to floating-point register **/ 2314 0105 /** 0x15 VAX floating-point instruction **/ 2315 0106 /** 0x16 IEEE floating-point instruction **/ 2316 0107 /** 0x17 Floating-point instruction **/ 2317 0108 /** 0x18 Miscellaneous instruction **/ 2318 0109 /** 0x1a Jump instruction **/ 2319 0110 /** 0x1c Floating-point to integer register **/ 2320 0111 /************************************************/ 2321 0112 #define OP_PAL 0x00 2322 0113 #define OP_LDA 0x08 2323 0114 #define OP_LDAH 0x09 2324 0115 #define OP_INTA 0x10 2325 0116 #define OP_INTL 0x11 2326 0117 #define OP_INTS 0x12 2327 0118 #define OP_INTM 0x13 2328 0119 #define OP_ITFP 0x14 2329 0120 #define OP_FLTV 0x15 2330 0121 #define OP_FLTI 0x16 2331 0122 #define OP_FLTL 0x17 2332 0123 #define OP_MISC 0x18 2333 0124 #define OP_JSR 0x1a 2334 0125 #define OP_FPTI 0x1c 2335 0126 2336 0127 #define BIT0 0x0000000000000001ull 2337 0128 #define BIT1 0x0000000000000002ull 2338 0129 #define BIT2 0x0000000000000004ull 2339 0130 #define BIT3 0x0000000000000008ull 2340 0131 #define BIT4 0x0000000000000010ull 2341 0132 #define BIT5 0x0000000000000020ull 2342 0133 #define BIT6 0x0000000000000040ull 2343 0134 #define BIT7 0x0000000000000080ull 2344 0135 #define BIT8 0x0000000000000100ull 2345 0136 #define BIT9 0x0000000000000200ull 2346 0137 #define BIT10 0x0000000000000400ull 2347 0138 #define BIT11 0x0000000000000800ull 2348 0139 #define BIT12 0x0000000000001000ull 2349 0140 #define BIT15 0x0000000000008000ull 2350 0141 #define BIT20 0x0000000000100000ull 2351 0142 #define BIT31 0x0000000080000000ull 2352 0143 #define BIT63 0x8000000000000000ull 2353 0144 2354 0145 #define EXTND8 0xffffffffffffff00ull 2355 0146 #define EXTND16 0xffffffffffff0000ull 2356 0147 #define EXTND21 0xffffffffffe00000ull 2357 0148 #define EXTND32 0xffffffff00000000ull 2358 0149 #define MASK08 0x00000000000000ffull 2359 0150 #define MASK16 0x000000000000ffffull 2360 0151 #define MASK21 0x00000000001fffffull 2361 0152 #define MASK32 0x00000000ffffffffull 2362 0153 2363 0154 #define ZAP0 0xffffffffffffff00ull 2364 0155 #define ZAP1 0xffffffffffff00ffull 2365 0156 #define ZAP2 0xffffffffff00ffffull 2366 0157 #define ZAP3 0xffffffff00ffffffull 2367 0158 #define ZAP4 0xffffff00ffffffffull 2368 0159 #define ZAP5 0xffff00ffffffffffull 2369 0160 #define ZAP6 0xff00ffffffffffffull 2370 0161 #define ZAP7 0x00ffffffffffffffull 2371 0162 2372 0163 /** for instruction.cc **/ 2373 0164 #define MSK1 0x3e /* 6bit of 111110 */ 2374 0165 #define MSK2 0x3c /* 6bit of 111100 */ 2375 0166 #define MSK3 0x38 /* 6bit of 111000 */ 2376 0167 #define MSK4 0x30 /* 6bit of 110000 */ 2377 0168 2378 0169 /*** Control Transfer instructions ***/ 2379 0170 /************************************************/ 2380 0171 #define _JMP__ 0x1a0000 // 1a.0 2381 0172 #define _JSR__ 0x1a0001 // 1a.1 2382 0173 #define _RET__ 0x1a0002 // 1a.2 2383 0174 #define _JSR_C 0x1a0003 // 1a.3 JSR_COROUTINE 2384 0175 2385 0176 #define _BR__ 0x300000 2386 0177 #define _FBEQ 0x310000 2387 0178 #define _FBLT 0x320000 2388 0179 #define _FBLE 0x330000 2389 0180 #define _BSR_ 0x340000 2390 0181 #define _FBNE 0x350000 2391 0182 #define _FBGE 0x360000 2392 0183 #define _FBGT 0x370000 2393 0184 #define _BLGC 0x380000 2394 0185 #define _BEQ_ 0x390000 2395 0186 #define _BLT_ 0x3a0000 2396 0187 #define _BLE_ 0x3b0000 2397 0188 #define _BLBS 0x3c0000 2398 0189 #define _BNE_ 0x3d0000 2399 0190 #define _BGE_ 0x3e0000 2400 0191 #define _BGT_ 0x3f0000 2401 0192 2402 0193 /*** Memory Access & LDA & LDAH Instructions ***/ 2403 0194 /************************************************/ 2404 0195 #define _LDA___ 0x080000 2405 0196 #define _LDAH__ 0x090000 2406 0197 #define _OPC0A_ 0x0a0000 2407 0198 #define _LDQ_U_ 0x0b0000 2408 0199 #define _OPC0C_ 0x0c0000 2409 0200 #define _OPC0D_ 0x0d0000 2410 0201 #define _OPC0E_ 0x0e0000 2411 0202 #define _STQ_U_ 0x0f0000 2412 0203 2413 0204 #define _LDF___ 0x200000 2414 0205 #define _LDG___ 0x210000 2415 0206 #define _LDS___ 0x220000 2416 0207 #define _LDT___ 0x230000 2417 0208 #define _STF___ 0x240000 2418 0209 #define _STG___ 0x250000 2419 0210 #define _STS___ 0x260000 2420 0211 #define _STT___ 0x270000 2421 0212 #define _LDL___ 0x280000 2422 0213 #define _LDQ___ 0x290000 2423 0214 #define _LDL_L_ 0x2a0000 2424 0215 #define _LDQ_L_ 0x2b0000 2425 0216 #define _STL___ 0x2c0000 2426 0217 #define _STQ___ 0x2d0000 2427 0218 #define _STL_C_ 0x2e0000 2428 0219 #define _STQ_C_ 0x2f0000 2429 0220 2430 0221 /*** Arithmetic instructions (int and float) ***/ 2431 0222 /************************************************/ 2432 0223 #define _ADDL__ 0x100000 2433 0224 #define _S4ADDL 0x100002 2434 0225 #define _SUBL__ 0x100009 2435 0226 #define _S4SUBL 0x10000b 2436 0227 #define _CMPBGE 0x10000f 2437 0228 #define _S8ADDL 0x100012 2438 0229 #define _S8SUBL 0x10001b 2439 0230 #define _CMPULT 0x10001d 2440 0231 #define _ADDQ__ 0x100020 2441 0232 #define _S4ADDQ 0x100022 2442 0233 #define _SUBQ__ 0x100029 2443 0234 #define _S4SUBQ 0x10002b 2444 0235 #define _CMPEQ_ 0x10002d 2445 0236 #define _S8ADDQ 0x100032 2446 0237 #define _S8SUBQ 0x10003b 2447 0238 #define _CMPULE 0x10003d 2448 0239 #define _CMPLT_ 0x10004d 2449 0240 #define _CMPLE_ 0x10006d 2450 0241 2451 0242 /*** Arithmetic Logical ***/ 2452 0243 /************************************************/ 2453 0244 #define _AND___ 0x110000 2454 0245 #define _BIC___ 0x110008 2455 0246 #define _CMOVLBS 0x110014 2456 0247 #define _CMOVLBC 0x110016 2457 0248 #define _BIS___ 0x110020 2458 0249 #define _CMOVEQ 0x110024 2459 0250 #define _CMOVNE 0x110026 2460 0251 #define _ORNOT_ 0x110028 2461 0252 #define _XOR___ 0x110040 2462 0253 #define _CMOVLT 0x110044 2463 0254 #define _CMOVGE 0x110046 2464 0255 #define _EQV___ 0x110048 2465 0256 #define _AMASK_ 0x110061 2466 0257 #define _CMOVLE 0x110064 2467 0258 #define _CMOVGT 0x110066 2468 0259 #define _IMPLVER 0x11006c 2469 0260 2470 0261 /*** Integer shift instruction ***/ 2471 0262 /************************************************/ 2472 0263 #define _SRL___ 0x120034 2473 0264 #define _SLL___ 0x120039 2474 0265 #define _SRA___ 0x12003c 2475 0266 #define _ZAP___ 0x120030 2476 0267 #define _ZAPNOT 0x120031 2477 0268 #define _EXTBL_ 0x120006 2478 0269 #define _EXTWL_ 0x120016 2479 0270 #define _EXTLL_ 0x120026 2480 0271 #define _EXTQL_ 0x120036 2481 0272 #define _EXTWH_ 0x12005a 2482 0273 #define _EXTLH_ 0x12006a 2483 0274 #define _EXTQH_ 0x12007a 2484 0275 #define _INSBL_ 0x12000b 2485 0276 #define _INSWL_ 0x12001b 2486 0277 #define _INSLL_ 0x12002b 2487 0278 #define _INSQL_ 0x12003b 2488 0279 #define _MSKBL_ 0x120002 2489 0280 #define _MSKWL_ 0x120012 2490 0281 #define _MSKLL_ 0x120022 2491 0282 #define _MSKQL_ 0x120032 2492 0283 #define _MSKWH_ 0x120052 2493 0284 #define _MSKLH_ 0x120062 2494 0285 #define _MSKQH_ 0x120072 2495 0286 #define _INSWH_ 0x120057 2496 0287 #define _INSLH_ 0x120067 2497 0288 #define _INSQH_ 0x120077 2498 0289 2499 0290 /*** Floating instruction (a part of) ***/ 2500 0291 /************************************************/ 2501 0292 #define _FCMOVEQ 0x17002a 2502 0293 #define _FCMOVNE 0x17002b 2503 0294 #define _FCMOVLT 0x17002c 2504 0295 #define _FCMOVGE 0x17002d 2505 0296 #define _FCMOVLE 0x17002e 2506 0297 #define _FCMOVGT 0x17002f 2507 0298 2508 0299 /*** Multiply instruction ***/ 2509 0300 /************************************************/ 2510 0301 #define _MULL__ 0x130000 2511 0302 #define _MULQ__ 0x130020 2512 0303 #define _UMULH_ 0x130030 2513 0304 2514 0305 /************************************************/ 2515 0306 2516 0307 2517 0308 /* 4. structure and class definition */ 2518 0309 /************************************************/ 2519 0310 /*** Used in syscall.c SYS_fstat ***/ 2520 0311 struct osf_statbuf{ 2521 0312 uint_32t a_st_dev; 2522 0313 uint_32t a_st_ino; 2523 0314 uint_32t a_st_mode; 2524 0315 uint_16t a_st_nlink; 2525 0316 uint_16t a_pad0; 2526 0317 uint_32t a_st_uid; 2527 0318 uint_32t a_st_gid; 2528 0319 uint_32t a_st_rdev; 2529 0320 uint_32t a_pad1; 2530 0321 uint_64t a_st_size; 2531 0322 uint_32t a_st_atime; 2532 0323 uint_32t a_st_spare1; 2533 0324 uint_32t a_st_mtime; 2534 0325 uint_32t a_st_spare2; 2535 0326 uint_32t a_st_ctime; 2536 0327 uint_32t a_st_spare3; 2537 0328 uint_32t a_st_blksize; 2538 0329 uint_32t a_st_blocks; 2539 0330 uint_32t a_st_gennum; 2540 0331 uint_32t a_st_spare4; 2541 0332 }; 2542 0333 2543 0334 /************************************************/ 2544 0335 class Env{ 2545 0336 public: 2546 0337 class system_config *sc; 2547 0338 class evaluation_result *e; 2548 0339 class debug *deb; 2549 0340 class system_manager *sys; 2550 0341 class memory_system *mem; 2551 0342 class architecture_state *as; 2552 0343 }; 2553 0344 2554 0345 /************************************************/ 2555 0346 class system_config{ 2556 0347 public: 2557 0348 char program_name[512]; 2558 0349 uint_64t end_tc; 2559 0350 uint_64t trace_flag; 2560 0351 int slow_mode; 2561 0352 int verbose_interval; 2562 0353 int debug_flag; 2563 0354 int distrib_flag; 2564 0355 int verify_flag; 2565 0356 int syscall_flag; 2566 0357 int simple_result; 2567 0358 int fd_adjust; 2568 0359 int fd_stdin_flag; 2569 0360 int fd_stdin; /* file descripter for STDIN */ 2570 0361 system_config(char *, char**); 2571 0362 }; 2572 0363 2573 0364 /************************************************/ 2574 0365 class main_memory{ 2575 0366 data_t *block_table[BLOCK_TABLE_SIZE]; 2576 0367 data_t *allocblock(data_t *); 2577 0368 public: 2578 0369 main_memory(); 2579 0370 void ld_8byte(data_t *, data_t *); 2580 0371 void st_8byte(data_t *, data_t *, DATA_TYPE); 2581 0372 int load_all(data_t*, data_t*); 2582 0373 }; 2583 0374 2584 0375 /************************************************/ 2585 0376 class evaluation_result{ 2586 0377 public: 2587 0378 uint_64t retired_inst; 2588 0379 int used_memory_block; 2589 0380 time_t time_begin; /* start time stamp */ 2590 0381 struct timeval tp; /* start time stamp */ 2591 0382 struct timezone tzp; /* start time stamp */ 2592 0383 evaluation_result(); 2593 0384 main_memory *imix; /* for instructio mix */ 2594 0385 }; 2595 0386 2596 0387 /************************************************/ 2597 0388 class architecture_state{ 2598 0389 Env *ev; 2599 0390 public: 2600 0391 data_t pc; /* program counter */ 2601 0392 data_t r[32]; /* general purpose regs */ 2602 0393 data_t f[32]; /* floating point regs */ 2603 0394 uint_64t rr(int); /* register read */ 2604 0395 architecture_state(Env*); 2605 0396 architecture_state(); 2606 0397 }; 2607 0398 2608 0399 /************************************************/ 2609 0400 class memory_system{ 2610 0401 Env *ev; 2611 0402 public: 2612 0403 class main_memory *mm; 2613 0404 void ld_8byte(data_t *, data_t *); 2614 0405 void st_8byte(data_t *, data_t *, DATA_TYPE); 2615 0406 void ld_inst(data_t *, INST_TYPE *); 2616 0407 void ld_nbyte(int, data_t *, data_t *); 2617 0408 void st_nbyte(int, data_t *, data_t *); 2618 0409 ~memory_system(); 2619 0410 memory_system(Env*); 2620 0411 }; 2621 0412 2622 0413 /************************************************/ 2623 0414 class system_manager{ 2624 0415 Env *ev; 2625 0416 /* File Descriptor Mapping Table */ 2626 0417 DATA_TYPE fd_table[FD_MAPPING_MAX]; 2627 0418 /* Unique Data for rduniq & wruniq inst */ 2628 0419 DATA_TYPE uniq; 2629 0420 public: 2630 0421 int running; /* chip is running ? */ 2631 0422 void execute_pal(class instruction*); 2632 0423 int translate_fd(DATA_TYPE); 2633 0424 system_manager(Env*); 2634 0425 }; 2635 0426 2636 0427 /************************************************/ 2637 0428 class debug{ 2638 0429 Env *ev; 2639 0430 public: 2640 0431 debug(Env*); 2641 0432 void debugmode(instruction*); 2642 0433 }; 2643 0434 2644 0435 /************************************************/ 2645 0436 class instruction{ 2646 0437 public: 2647 0438 Env *ev; /* pointer to the environment */ 2648 0439 INST_TYPE ir; /* 32b: instruction code */ 2649 0440 int CI; /* 24b: Code ID */ 2650 0441 char Op; /* 6b: Opcode field */ 2651 0442 char BR; /* 1b: branch inst ? */ 2652 0443 char CM; /* 1b: CMOV inst ? */ 2653 0444 char ST; /* 4b: store inst & byte num */ 2654 0445 char LD; /* 4b: load inst & byte num */ 2655 0446 char Ai; /* 1b: Rav is immediate ? */ 2656 0447 char Bi; /* 1b: Rbv is immediate ? */ 2657 0448 char Ar; /* 1b: Rav from general-reg ? */ 2658 0449 char Br; /* 1b: Rbv from general-reg ? */ 2659 0450 char RA; /* 5b: Rav reg-read index */ 2660 0451 char RB; /* 5b: Rbv reg-read index */ 2661 0452 char WB; /* 5b: Writeback reg index */ 2662 0453 data_t Cpc; /* PC of the instruction */ 2663 0454 data_t Npc; /* PC of the next inst. */ 2664 0455 /* Calculate in Exe. stage */ 2665 0456 data_t Imm; /* immediate */ 2666 0457 data_t Adr; /* load & store : mem address */ 2667 0458 /* cmov inst. : Rmv value */ 2668 0459 data_t Rav; /* Ra */ 2669 0460 data_t Rbv; /* Rb */ 2670 0461 data_t Rcv; /* Rc */ 2671 0462 void Fetch(data_t*); /* stage 0 */ 2672 0463 void Slot(); /* stage 1 */ 2673 0464 void Rename(); /* stage 2 */ 2674 0465 void Issue(); /* stage 3 */ 2675 0466 void RegisterRead(); /* stage 4 */ 2676 0467 void Execute(); /* stage 5 */ 2677 0468 void Memory(); /* stage 6 */ 2678 0469 void WriteBack(); /* stage 7 */ 2679 0470 void BackEnd(); /* stage 4,5,6,7 */ 2680 0471 instruction(Env*); 2681 0472 }; 2682 0473 2683 0474 /************************************************/ 2684 0475 class simple_chip{ 2685 0476 public: 2686 0477 Env *ev; 2687 0478 instruction *p; 2688 0479 simple_chip(char*, char**); 2689 0480 ~simple_chip(); 2690 0481 int step(); 2691 0482 void loop(); 2692 0483 }; 2693 0484 2694 0485 /************************************************/ 2695 0486 struct alpha_stat{ /*** for syscall.cc ***/ 2696 0487 uint_64t a_st_dev; 2697 0488 uint_32t a_st_ino; 2698 0489 int_32t a___pad1; 2699 0490 uint_32t a_st_mode; 2700 0491 uint_32t a_st_nlink; 2701 0492 uint_32t a_st_uid; 2702 0493 uint_32t a_st_gid; 2703 0494 uint_64t a_st_rdev; 2704 0495 int_64t a_st_size; 2705 0496 int_64t a_st_atime; 2706 0497 int_64t a_st_mtime; 2707 0498 int_64t a_st_ctime; 2708 0499 uint_32t a_st_blocks; 2709 0500 int_32t a___pad2; 2710 0501 uint_32t a_st_blksize; 2711 0502 uint_32t a_st_flags; 2712 0503 uint_32t a_st_gen; 2713 0504 int_32t a___pad3; 2714 0505 int_64t a___unused[4]; 2715 0506 }; 2716 0507 2717 0508 2718 0509 /* 5. function prototypes */ 2719 0510 /************************************************/ 2720 0511 extern void print_evaluation_result(Env*); 2721 0512 extern void usage(); 2722 0513 extern uint_64t map_s(DATA_TYPE); 2723 0514 extern int cmov_ir(INST_TYPE); 2724 0515 extern void option_from_file(char**, char*); 2725 0516 extern void house_keeper(instruction*); 2726 0517 extern "C" int simple_cpu(int, uint_64t*); 2727 0518 extern uint_64t get_hex(char*); 2728 0519 extern int get_code(INST_TYPE); 2729 0520 extern int ld_bytes(int); 2730 0521 extern int st_bytes(int); 2731 0522 extern DATA_TYPE sext(DATA_TYPE); 2732 0523 extern DATA_TYPE sext16(DATA_TYPE); 2733 0524 extern DATA_TYPE sext21(DATA_TYPE); 2734 0525 extern void set_ld_data(int, int, data_t*, 2735 0526 data_t*, data_t*); 2736 0527 extern void set_st_data(int, int, data_t*, 2737 0528 data_t*, data_t*, 2738 0529 DATA_TYPE*); 2739 0530 extern void UnitA(int, DATA_TYPE, 2740 0531 DATA_TYPE, DATA_TYPE*); 2741 0532 extern void UnitL(int, DATA_TYPE, 2742 0533 DATA_TYPE, DATA_TYPE*); 2743 0534 extern void UnitS(int, DATA_TYPE, 2744 0535 DATA_TYPE, DATA_TYPE*); 2745 0536 extern void UnitM(int, DATA_TYPE, 2746 0537 DATA_TYPE, DATA_TYPE*); 2747 0538 extern void FuITFP(INST_TYPE, DATA_TYPE, 2748 0539 DATA_TYPE, DATA_TYPE*); 2749 0540 extern void FuFLTL(INST_TYPE, DATA_TYPE, 2750 0541 DATA_TYPE, DATA_TYPE*); 2751 0542 extern void FuFPTI(INST_TYPE, DATA_TYPE, 2752 0543 DATA_TYPE, DATA_TYPE*); 2753 0544 extern void FuFLTI(INST_TYPE, DATA_TYPE, 2754 0545 DATA_TYPE, DATA_TYPE*); 2755 0546 extern void CmovUnit(int, DATA_TYPE, int*); 2756 0547 extern int Btaken(int, DATA_TYPE); 2757 0548 extern void print_register_name(int); 2758 0549 /************************************************/