1 /* syscall.c This is a part of SimuSparc Version 0.9b 2 * Copyright (c) 1996,1997,1998,1999,2000,2001, Kenji KISE 3 ***************************************************************/ 4 #include 5 #include 6 #include 7 #include 8 9 #include "define.h" 10 11 char *check_register(int no){ 12 13 char *temp; 14 char temp_t[256]; 15 char reg_no[256]; 16 17 temp = temp_t; 18 19 if(no<8){ /* 0 to7 */ 20 strcpy(temp, "%g"); 21 } 22 if(no>7 && no<16){ /* 8 to 15 */ 23 strcpy(temp, "%o"); 24 no -=8; 25 } 26 if(no>15 && no<24){ /* 16 to 23 */ 27 strcpy(temp, "%l"); 28 no -=16; 29 } 30 if(no>23 && no<32){ /* 24 to 31 */ 31 strcpy(temp, "%i"); 32 no -=24; 33 } 34 sprintf(reg_no,"%d", no); 35 strcat(temp, reg_no); 36 37 return temp; 38 } 39 40 char *type3(unsigned int ir) 41 { 42 unsigned int simm, rd, rs1, rs2; 43 int simm13,i; 44 int fop2; 45 char *buff; 46 char *temp; 47 48 char buff_t[256]; 49 char temp_t[256]; 50 51 buff = buff_t; 52 temp = temp_t; 53 54 rd = (ir >> 25) & 32; 55 rs1 = (ir >> 14) & 32; 56 if (((ir >> 13) & 1) ==1){ 57 simm = ir & 0xFFF; 58 rs2 = 0; 59 } 60 else{ 61 rs2 = ir & 0xFF; 62 simm =0; 63 } 64 65 strcpy(buff, ""); 66 fop2= (ir >> 19) & 0x3F; 67 switch(fop2) 68 { 69 case 0: strcpy(buff, "ld"); break; 70 case 0x10: strcpy(buff ,"lda"); break; 71 case 0x30: strcpy(buff ,"ldc"); break; 72 case 0x31: strcpy(buff ,"ldcsr"); break; 73 case 0x3: strcpy(buff ,"ldd"); break; 74 case 0x13: strcpy(buff ,"ldda"); break; 75 case 0x33: strcpy(buff ,"lddc"); break; 76 case 0x23: strcpy(buff ,"lddf"); break; 77 case 0x20: strcpy(buff ,"ldf"); break; 78 case 0x21: strcpy(buff ,"ldfsr"); break; 79 case 0x9: strcpy(buff ,"ldsb"); break; 80 case 0x19: strcpy(buff ,"ldsba"); break; 81 case 0xA: strcpy(buff ,"ldsh"); break; 82 case 0x1A: strcpy(buff ,"ldsha"); break; 83 case 0xD: strcpy(buff ,"ldstub"); break; 84 case 0x1D: strcpy(buff ,"ldstuba"); break; 85 case 0x1: strcpy(buff ,"ldub"); break; 86 case 0x11: strcpy(buff ,"lduba"); break; 87 case 0x2: strcpy(buff ,"lduh"); break; 88 case 0x12: strcpy(buff, "lduha"); break; 89 } 90 91 if(strcmp(buff,"")){ 92 i = (ir >> 13) & 0x1; 93 rd = (ir >> 25) & 0x1F; 94 rs1 = (ir >> 14) & 0x1F; 95 rs2 = (ir ) & 0x1F; 96 97 simm13 = ir & SIMM13; 98 if( (simm13 & BIT12)>>12 ) simm13=(ir & SIMM13) | EXTND13; 99 /* get sign extended ,negative value */ 100 101 if(i==0){ 102 strcat(buff, " [ "); 103 strcat(buff, check_register(rs1)); 104 strcat(buff, " + "); 105 strcat(buff, check_register(rs2)); 106 strcat(buff, " ],"); 107 strcat(buff, check_register(rd)); 108 } 109 else{ 110 if(simm13<0) 111 sprintf(temp,"%d", simm13); /* negative */ 112 else 113 sprintf(temp,"0x%x", simm13); /* positive */ 114 strcat(buff, " ["); 115 strcat(buff, (char *)check_register(rs1)); 116 strcat(buff, " + "); 117 strcat(buff, temp); 118 strcat(buff, "], "); 119 strcat(buff, (char *)check_register(rd)); 120 } 121 return buff; 122 } 123 124 switch(fop2) /* not load above */ 125 { 126 case 0x4: strcpy(buff ,"st"); break; 127 case 0x14: strcpy(buff ,"sta"); break; 128 case 0x5: strcpy(buff ,"stb"); break; 129 case 0x15: strcpy(buff ,"stba"); break; 130 case 0x34: strcpy(buff ,"stc"); break; 131 case 0x35: strcpy(buff ,"stcsr"); break; 132 case 0x7: strcpy(buff ,"std"); break; 133 case 0x17: strcpy(buff ,"stda"); break; 134 case 0x37: strcpy(buff ,"stdc"); break; 135 case 0x36: strcpy(buff ,"stdcq"); break; 136 case 0x27: strcpy(buff ,"stdf"); break; 137 case 0x26: strcpy(buff ,"stdfq"); break; 138 case 0x24: strcpy(buff ,"stf"); break; 139 case 0x25: strcpy(buff ,"stfsr"); break; 140 case 0x6: strcpy(buff ,"sth"); break; 141 case 0x16: strcpy(buff ,"stha"); break; 142 case 0xF: strcpy(buff ,"swap"); break; 143 case 0x1F: strcpy(buff ,"swapa"); break; 144 default: strcpy(buff ,"case3 default"); break; 145 } 146 i = (ir >> 13) & 0x1; 147 rd = (ir >> 25) & 0x1F; 148 rs1 = (ir >> 14) & 0x1F; 149 rs2 = (ir ) & 0x1F; 150 151 simm13 = ir & SIMM13; 152 if( (simm13 & BIT12)>>12 ) simm13=(ir & SIMM13) | EXTND13; 153 /* get sign extended ,negative value */ 154 155 if(i==0){ 156 strcat(buff, " "); 157 strcat(buff, check_register(rd)); 158 strcat(buff, ", [ "); 159 strcat(buff, check_register(rs1)); 160 strcat(buff, " + "); 161 strcat(buff, check_register(rs2)); 162 strcat(buff, "]"); 163 } 164 else{ 165 if(simm13<0) 166 sprintf(temp,"%d", simm13); /* negative */ 167 else 168 sprintf(temp,"0x%x", simm13); /* positive */ 169 strcat(buff, " "); 170 strcat(buff, (char *)check_register(rd)); 171 strcat(buff, ", ["); 172 strcat(buff, (char *)check_register(rs1)); 173 strcat(buff, " + "); 174 strcat(buff, temp); 175 strcat(buff, "]"); 176 } 177 return buff; 178 } 179 180 181 char *type2(unsigned int ir) /* arithmetic/logic */ 182 { 183 unsigned int fop2; 184 unsigned int opc; 185 int i; 186 unsigned int rd,rs1,rs2; 187 int simm13; 188 unsigned int cond,a; 189 char *buff; 190 char *temp; 191 192 char buff_t[256]; 193 char temp_t[256]; 194 195 buff = buff_t; 196 temp = temp_t; 197 198 i = (ir >> 13) & 1; 199 200 strcpy(buff, ""); /* initialize buff[] */ 201 202 fop2= (ir >> 19) & 0x3F; 203 opc = (ir >> 5) & 0x1FF; 204 switch(fop2) 205 { 206 case 0x0: strcpy(buff ,"add"); break; 207 case 0x10: strcpy(buff ,"addcc"); break; 208 case 0x8: strcpy(buff ,"addx"); break; 209 case 0x18: strcpy(buff ,"addxcc"); break; 210 case 0x1: strcpy(buff ,"and"); break; 211 case 0x11: strcpy(buff ,"andcc"); break; 212 case 0x5: strcpy(buff ,"andn"); break; 213 case 0x15: strcpy(buff ,"andncc"); break; 214 case 0x24: strcpy(buff ,"mulscc"); break; 215 case 0x2: strcpy(buff ,"or"); break; 216 case 0x12: strcpy(buff ,"orcc"); break; 217 case 0x6: strcpy(buff ,"orn"); break; 218 case 0x16: strcpy(buff ,"orncc"); break; 219 case 0x25: strcpy(buff ,"sll"); break; 220 case 0x27: strcpy(buff ,"sra"); break; 221 case 0x26: strcpy(buff ,"srl"); break; 222 case 0x4: strcpy(buff ,"sub"); break; 223 case 0x14: strcpy(buff ,"subcc"); break; 224 case 0xC: strcpy(buff ,"subx"); break; 225 case 0x1C: strcpy(buff ,"subxcc"); break; 226 case 0x20: strcpy(buff ,"TADDcc"); break; 227 case 0x21: strcpy(buff ,"TSUBcc"); break; 228 case 0x22: strcpy(buff ,"TADDccTV"); break; 229 case 0x23: strcpy(buff ,"TAUBccTV"); break; 230 case 0x7: strcpy(buff ,"xnor"); break; 231 case 0x17: strcpy(buff ,"xnorcc"); break; 232 case 0x3: strcpy(buff ,"xor"); break; 233 case 0x13: strcpy(buff ,"xorcc"); break; 234 case 0x3D: strcpy(buff ,"restore"); break; 235 case 0x3C: strcpy(buff ,"save"); break; 236 case 0x29: strcpy(buff ,"rdpsr"); break; 237 case 0x2a: strcpy(buff ,"rdwim"); break; 238 case 0x28: strcpy(buff ,"rdy"); break; 239 case 0x2b: strcpy(buff ,"rdtbr"); break; 240 case 0x31: strcpy(buff ,"wrpsr"); break; 241 case 0x33: strcpy(buff ,"wrtbr"); break; 242 case 0x32: strcpy(buff ,"wrwim"); break; 243 case 0x30: strcpy(buff ,"wry"); break; 244 245 case 0x38: strcpy(buff ,"jmpl"); break; /*in fact controll*/ 246 247 } 248 if(strcmp(buff,"")){ /* if instruction is part 1 */ 249 i = (ir >> 13) & 0x1; 250 rd = (ir >> 25) & 0x1F; 251 rs1 = (ir >> 14) & 0x1F; 252 rs2 = (ir ) & 0x1F; 253 254 simm13 = ir & SIMM13; 255 if( (simm13 & BIT12)>>12 ) simm13=(ir & SIMM13) | EXTND13; 256 /* get sign extended ,negative value */ 257 258 if(i==0){ 259 strcat(buff, " "); 260 strcat(buff, check_register(rs1)); 261 strcat(buff, ", "); 262 strcat(buff, check_register(rs2)); 263 strcat(buff, ", "); 264 strcat(buff, check_register(rd)); 265 } 266 else{ 267 if(simm13<0) 268 sprintf(temp,"%d", simm13); /* negative */ 269 else 270 sprintf(temp,"0x%x", simm13); /* positive */ 271 strcat(buff, " "); 272 strcat(buff, (char *)check_register(rs1)); 273 strcat(buff, ", "); 274 strcat(buff, temp); 275 strcat(buff, ", "); 276 strcat(buff, (char *)check_register(rd)); 277 } 278 } 279 280 281 /* Table 2-25 Control Transfer Buff Opcodes */ 282 switch(fop2) 283 { 284 /* case 0x38: 285 strcpy(buff ,"jmpl"); 286 rd = (ir >> 25) & 0x1F; 287 strcat(buff, " "); 288 strcat(buff, (char *)check_register(rd)); 289 break; 290 */ 291 case 0x39: 292 strcpy(buff ,"RETT"); 293 break; 294 295 case 0x3A: /* ticc */ 296 cond = (ir >> 25) & 0xF; 297 switch(cond) 298 { 299 case 0: strcat(buff,"tn"); break; 300 case 1: strcat(buff,"te"); break; 301 case 2: strcat(buff,"tle"); break; 302 case 3: strcat(buff,"tl"); break; 303 case 4: strcat(buff,"tleu");break; 304 case 5: strcat(buff,"tcs"); break; 305 case 6: strcat(buff,"tneg");break; 306 case 7: strcat(buff,"tvs"); break; 307 case 8: strcat(buff,"ta"); break; 308 case 9: strcat(buff,"tne"); break; 309 case 10: strcat(buff,"tg"); break; 310 case 11: strcat(buff,"tge"); break; 311 case 12: strcat(buff,"tgu"); break; 312 case 13: strcat(buff,"tcc"); break; 313 case 14: strcat(buff,"tpos");break; 314 case 15: strcat(buff,"tsvc");break; 315 } 316 a = (ir >> 29) & 1; 317 if (a) strcat(buff, ",a"); 318 break; 319 } 320 if(strcmp(buff,"")) return buff; 321 322 /* floating point opcodes */ 323 if(fop2==0x36) strcpy(buff ,"cpop1"); 324 if(fop2==0x37) strcpy(buff ,"cpop2"); 325 if(fop2==0x34 && opc==0x09) strcpy(buff ,"fabss"); 326 if(fop2==0x34 && opc==0x41) strcpy(buff ,"fadds"); 327 if(fop2==0x34 && opc==0x42) strcpy(buff ,"faddd"); 328 if(fop2==0x34 && opc==0x43) strcpy(buff ,"faddx"); 329 if(fop2==0x35 && opc==0x51) strcpy(buff ,"fcmps"); 330 if(fop2==0x35 && opc==0x52) strcpy(buff ,"fcmpd"); 331 if(fop2==0x35 && opc==0x53) strcpy(buff ,"fcmpx"); 332 if(fop2==0x35 && opc==0x55) strcpy(buff ,"fcmpes"); 333 if(fop2==0x35 && opc==0x56) strcpy(buff ,"fcmped"); 334 if(fop2==0x35 && opc==0x57) strcpy(buff ,"fcmpex"); 335 if(fop2==0x34 && opc==0x4d) strcpy(buff ,"fdivs"); 336 if(fop2==0x34 && opc==0x4e) strcpy(buff ,"fdivd"); 337 if(fop2==0x34 && opc==0x4f) strcpy(buff ,"fdivx"); 338 if(fop2==0x34 && opc==0x01) strcpy(buff ,"fmovs"); 339 if(fop2==0x34 && opc==0x49) strcpy(buff ,"fmuls"); 340 if(fop2==0x34 && opc==0x4a) strcpy(buff ,"fmuld"); 341 if(fop2==0x34 && opc==0x4b) strcpy(buff ,"fmulx"); 342 if(fop2==0x34 && opc==0x05) strcpy(buff ,"fnegs"); 343 if(fop2==0x34 && opc==0x29) strcpy(buff ,"fsqrts"); 344 if(fop2==0x34 && opc==0x2a) strcpy(buff ,"fsqrtd"); 345 if(fop2==0x34 && opc==0x2b) strcpy(buff ,"fsqrtx"); 346 if(fop2==0x34 && opc==0x45) strcpy(buff ,"fsubs"); 347 if(fop2==0x34 && opc==0x46) strcpy(buff ,"fsubd"); 348 if(fop2==0x34 && opc==0x47) strcpy(buff ,"fsubx"); 349 if(fop2==0x34 && opc==0xd2) strcpy(buff ,"fdtoi"); 350 if(fop2==0x34 && opc==0xc6) strcpy(buff ,"fdtos"); 351 if(fop2==0x34 && opc==0xce) strcpy(buff ,"fdtox"); 352 if(fop2==0x34 && opc==0xc8) strcpy(buff ,"fitod"); 353 if(fop2==0x34 && opc==0xc4) strcpy(buff ,"fitos"); 354 if(fop2==0x34 && opc==0xcc) strcpy(buff ,"fitox"); 355 if(fop2==0x34 && opc==0xc9) strcpy(buff ,"fstod"); 356 if(fop2==0x34 && opc==0xd1) strcpy(buff ,"fstoi"); 357 if(fop2==0x34 && opc==0xcd) strcpy(buff ,"fstox"); 358 if(fop2==0x34 && opc==0xd3) strcpy(buff ,"fxtoi"); 359 if(fop2==0x34 && opc==0xc7) strcpy(buff ,"fxtos"); 360 if(fop2==0x34 && opc==0xcb) strcpy(buff ,"fxtod"); 361 362 return buff; 363 } 364 365 char *type0(unsigned int ir) 366 { 367 unsigned int imm22; 368 unsigned int simm, rd, rs1, rs2; 369 unsigned int cond,a; 370 int fop2; 371 char *buff; 372 char *temp; 373 374 char buff_t[256]; 375 char temp_t[256]; 376 377 buff = buff_t; 378 temp = temp_t; 379 380 rd = (ir >> 25) & 32; 381 rs1 = (ir >> 14) & 32; 382 if (((ir >> 13) & 1) ==1){ 383 simm = ir & 0xFFF; 384 rs2 = 0; 385 } 386 else{ 387 rs2 = ir & 0xFF; 388 simm =0; 389 } 390 391 imm22 = (ir & 0x3FFFFF); 392 fop2= (ir >> 22) & 0x7; 393 394 switch(fop2) 395 { 396 397 case 0x4: /* sethi */ 398 rd = (ir >> 25) & 0x1F; 399 if(rd == 0) 400 strcpy(buff,"nop"); 401 else{ 402 strcpy(buff,"sethi"); 403 strcat(buff," "); 404 imm22 = (ir << 10 ); 405 sprintf(temp,"%%hi(0x%x)", imm22); 406 strcat(buff, temp); 407 strcat(buff, ", "); 408 strcat(buff, (char *)check_register(rd)); 409 } 410 break; 411 412 case 0x0: strcpy(buff, "UNIMP"); break; 413 case 0x7: strcpy(buff, "CBccc"); break; 414 case 0x6: strcpy(buff, "FBfcc"); break; 415 case 0x2: /* bicc */ 416 cond = (ir >> 25) & 0xF; 417 switch(cond) 418 { 419 case 0: strcpy(buff,"bn"); break; 420 case 1: strcpy(buff,"be"); break; 421 case 2: strcpy(buff,"ble"); break; 422 case 3: strcpy(buff,"bl"); break; 423 case 4: strcpy(buff,"bleu");break; 424 case 5: strcpy(buff,"bcs"); break; 425 case 6: strcpy(buff,"bneg");break; 426 case 7: strcpy(buff,"bvs"); break; 427 case 8: strcpy(buff,"ba"); break; 428 case 9: strcpy(buff,"bne"); break; 429 case 10: strcpy(buff,"bg"); break; 430 case 11: strcpy(buff,"bge"); break; 431 case 12: strcpy(buff,"bgu"); break; 432 case 13: strcpy(buff,"bcc"); break; 433 case 14: strcpy(buff,"bpos");break; 434 case 15: strcpy(buff,"bvc"); break; 435 } 436 a = (ir >> 29) & 1; 437 if (a) strcat(buff, ",a"); 438 break; 439 default : strcpy(buff, "case 0, default"); 440 } 441 442 return buff; 443 } 444 445 char *get_assem(unsigned int ir) 446 { 447 unsigned int fop; 448 char *buff; 449 static char temp[256]; 450 buff = temp; 451 452 fop = (ir >> 30) & 3; 453 454 switch(fop){ 455 case 0: buff = (char *)type0(ir); break; 456 case 1: strcpy(buff,"call %o7"); break; 457 case 2: buff = (char *)type2(ir); break; 458 case 3: buff = (char *)type3(ir); break; 459 } 460 461 return buff; 462 } 463 char *FFget_assem(unsigned int ir) 464 { 465 unsigned int fop; 466 char *buff; 467 static char temp[256]; 468 buff = temp; 469 470 fop = (ir >> 30) & 3; 471 472 switch(fop){ 473 case 0: buff = (char *)type0(ir); break; 474 case 1: strcpy(buff,"call %o7"); break; 475 case 2: buff = (char *)type2(ir); break; 476 case 3: buff = (char *)type3(ir); break; 477 } 478 479 return buff; 480 481 } 482 /* debug.c This is a part of SimuSparc Version 0.9b 483 * Copyright (c) 1999,2000,2001, Kenji KISE 484 ***************************************************************/ 485 #include 486 #include 487 #include 488 #include 489 #include "define.h" 490 491 extern unsigned int ir; /* current instruction */ 492 extern unsigned int r[32]; /* integer register */ 493 extern unsigned int f[33]; /* floating register */ 494 extern unsigned int y; /* y register */ 495 extern unsigned int n,z,v,c; /* flags */ 496 extern unsigned int pc, npc; /* program counter, next */ 497 498 extern unsigned int inst_sort; 499 extern unsigned long long total_c ; 500 extern int toend; 501 502 extern char *FFget_assem(unsigned int); 503 extern unsigned int load_word(unsigned int address); 504 505 unsigned int get_hex(char *buf); 506 507 void print_status(){ 508 int i; 509 510 printf("tc:%llu ", total_c); 511 printf("pc:0x%x ", pc); 512 printf("npc:0x%x ", npc); 513 printf("%s\n", FFget_assem(ir)); 514 515 for(i=0; i<8; i++){ /* print registers */ 516 printf("g%d[%2d] 0x%-8x %-8d \n",i,i, r[i],r[i]); 517 } 518 for(i=8; i<16; i++){ /* print registers */ 519 if(i==14) 520 printf("sp[%2d] 0x%-8x %-8d \n", i, r[i],r[i]); 521 else 522 printf("o%d[%2d] 0x%-8x %-8d \n",i%8, i, r[i],r[i]); 523 } 524 for(i=16; i<24; i++){ /* print registers */ 525 printf("l%d[%2d] 0x%-8x %-8d \n",i%8, i, r[i],r[i]); 526 } 527 for(i=24; i<32; i++){ /* print registers */ 528 if(i==30) 529 printf("fp[%2d] 0x%-8x %-8d \n",i, r[i],r[i]); 530 else 531 printf("i%d[%2d] 0x%-8x %-8d \n",i%8, i, r[i],r[i]); 532 } 533 printf("y 0x%-8x %d\n",y,y); 534 printf("psr\n"); 535 printf("win\n"); 536 printf("tbr\n"); 537 printf("pc 0x%-8x %-8d\n",pc,pc); 538 printf("npc 0x%-8x %-8d\n",npc,npc); 539 printf("fpsr\n"); 540 printf("cpsr\n"); 541 } 542 543 void debugmode(){ 544 int i,j; 545 char t_buf[256]; 546 char t_temp[256]; 547 static int stop = 1; 548 549 char *buf; 550 char *temp; 551 552 static long long stop_count = 0; 553 static int stop_address = NULL; 554 unsigned int address; 555 556 buf = t_buf; 557 temp = t_temp; 558 559 if(stop_count==total_c){ 560 stop = 1; 561 } 562 563 if(stop_address==pc){ 564 stop = 1; 565 } 566 567 if(stop==1){ 568 569 print_status(); 570 571 printf("(db)"); 572 gets(buf); 573 574 while(*buf != NULL){ 575 if(!strncmp(buf,"quit",4)) exit(1); 576 577 if(!strcmp(buf,"i r")){ /* information register */ 578 printf("go 0x0 %x %d \n",r[0],r[0]); 579 } 580 581 if(!strcmp(buf,"h")){ /* help */ 582 printf(" command\n"); 583 printf(" c followd by number: stop specified tc.\n"); 584 printf(" s followd by address: stop specified address.\n"); 585 printf(" x followd by address: examine specified address.\n"); 586 printf(" quit: quit simulate.\n"); 587 } 588 589 if(*(buf)=='c'){ /* stop by total count */ 590 buf++; 591 stop_count = atoll(buf); /* for int use atoi */ 592 printf("stop_tc = %d\n", stop_count); 593 stop=0; 594 break; 595 } 596 597 if(*(buf)=='s'){ /* stop by address */ 598 buf++; 599 stop_address = get_hex(buf); 600 printf("stop_address = 0x%x\n", stop_address); 601 stop=0; 602 break; 603 } 604 605 if(*(buf)=='x'){ 606 buf++; 607 address = get_hex(buf); 608 for(j=0; j<20; j++){ 609 printf("0x%08x: ", address); 610 for(i=0; i<4; i++){ 611 printf("0x%08x ", load_word(address)); 612 address +=4; 613 } 614 printf("\n"); 615 } 616 } 617 printf("\n"); 618 619 printf("(db)"); 620 gets(buf); 621 } 622 } 623 } 624 625 /* 626 * convert hexadecimal value into decimal value 627 **************************************************/ 628 unsigned int get_hex(char *buf){ 629 int i; 630 int num; 631 int temp=0; 632 char t; 633 unsigned int sum; 634 635 sum=0; 636 num = strlen(buf); 637 if(num>8){ 638 printf("hex can treat within 8digit numbers.\n"); 639 exit(1); 640 } 641 642 for(i=0; i 671 #include 672 #include 673 #include 674 #include "define.h" 675 676 677 extern ARCH_STATE as; 678 679 extern unsigned int inst_sort; 680 extern float f[33]; 681 extern unsigned int total_c; 682 extern unsigned int pc; 683 684 int fprintf(); 685 686 int fcmps(unsigned int ir) 687 { 688 unsigned int fcc; 689 unsigned int opf; 690 unsigned int rs1,rs2; 691 double ds1,ds2; 692 693 rs1 = ( ir & RS1)>>14; 694 rs2 = ir & RS2; 695 opf = (ir & OPF) >> 5; 696 697 fcc = 0; 698 switch(opf) 699 { 700 case 0x51: inst_sort=_FCMPs_; 701 if(f[rs1]==f[rs2]) fcc=0; 702 else if(f[rs1]f[rs2]) fcc=2; 704 else fcc=3; 705 break; 706 707 case 0x52: inst_sort=_FCMPd_; 708 memcpy(&ds1 ,&f[rs1], 8); 709 memcpy(&ds2 ,&f[rs2], 8); 710 if(ds1==ds2) fcc=0; 711 else if(ds1ds2) fcc=2; 713 else fcc=3; 714 break; 715 716 case 0x53: inst_sort=_FCMPx_; 717 printf("FCMPx is used, check fpop.c\n"); 718 exit(1); 719 break; 720 721 case 0x55: inst_sort=_FCMPEs_; 722 if(f[rs1]==f[rs2]) fcc=0; 723 else if(f[rs1]f[rs2]) fcc=2; 725 else fcc=3; 726 break; 727 728 case 0x56: inst_sort=_FCMPEd_; 729 memcpy(&ds1 ,&f[rs1], 8); 730 memcpy(&ds2 ,&f[rs2], 8); 731 if(ds1==ds2) fcc=0; 732 else if(ds1ds2) fcc=2; 734 else fcc=3; 735 break; 736 737 case 0x57: inst_sort=_FCMPEx_; 738 printf("FCMPEx is used, check fpop.c\n"); 739 exit(1); 740 break; 741 742 default: 743 fprintf(stderr,"unimplemented fcmp(0x%x).check fpop.c.\n", opf); 744 exit(1); 745 } 746 as.fsr = (as.fsr & FCCMASK) | (fcc<<10); 747 return 0; 748 } 749 750 int fpops(unsigned int ir) 751 { 752 753 unsigned int opf; 754 unsigned int rd,rs1,rs2; 755 unsigned int u_int; 756 double dd,ds1,ds2; 757 758 rd = ( ir & RD )>>25; 759 rs1 = ( ir & RS1)>>14; 760 rs2 = ir & RS2; 761 opf = (ir & OPF) >> 5; 762 763 switch(opf) 764 { 765 766 case 0x9: inst_sort=_FABSs_; 767 if(f[rs2]<0) f[rs2] *=-1; 768 f[rd]= f[rs2]; 769 break; 770 771 case 0x41: inst_sort=_FADDs_; 772 /* printf("FADDs TC:%d, PC:%x\n f[rs1]:%f, f[rs2]:%f ", total_c, pc, 773 f[rs1], f[rs2]); */ 774 f[rd]=f[rs1]+f[rs2]; 775 /* printf(" -> f[rd]:%f\n", f[rd]); */ 776 break; 777 778 case 0x42: inst_sort=_FADDd_; 779 memcpy(&ds1 ,&f[rs1], 8); 780 memcpy(&ds2 ,&f[rs2], 8); 781 /* printf("FADDd TC:%d, PC:%x, f[rs1] %lf, %lf\n", total_c, pc, 782 ds1, ds2); */ 783 dd=ds1+ds2; 784 memcpy(&f[rd], &dd, 8); 785 break; 786 787 case 0x43: inst_sort=_FADDx_; 788 printf("FADDx is used, check fpop.c\n"); 789 exit(1); 790 break; 791 792 case 0x4d: inst_sort=_FDIVs_; 793 f[rd]=f[rs1]/f[rs2]; 794 break; 795 796 case 0x4e: inst_sort=_FDIVd_; 797 memcpy(&ds1 ,&f[rs1], 8); 798 memcpy(&ds2 ,&f[rs2], 8); 799 dd=ds1/ds2; 800 memcpy(&f[rd], &dd, 8); 801 break; 802 803 case 0x4f: inst_sort=_FDIVx_; 804 printf("FDIVx is used, check fpop.c\n"); 805 exit(1); 806 break; 807 808 case 0x1: inst_sort=_FMOVs_; 809 f[rd]=f[rs2]; 810 break; 811 812 case 0x49: inst_sort=_FMULs_; 813 f[rd]=f[rs1]*f[rs2]; 814 break; 815 816 case 0x4a: inst_sort=_FMULd_; 817 memcpy(&ds1 ,&f[rs1], 8); 818 memcpy(&ds2 ,&f[rs2], 8); 819 dd=ds1*ds2; 820 memcpy(&f[rd], &dd, 8); 821 break; 822 823 case 0x4b: inst_sort=_FMULx_; 824 printf("FMULx is used, check fpop.c\n"); 825 exit(1); 826 break; 827 828 case 0x5: inst_sort=_FNEGs_; 829 f[rs2] *=-1; 830 f[rd]=f[rs2]; 831 break; 832 833 case 0x29: inst_sort=_FSQRTs_; 834 ds2 = (double)f[rs2]; 835 f[rd] =(float)sqrt(ds2); 836 break; 837 838 case 0x2a: inst_sort=_FSQRTd_; 839 memcpy(&ds2 ,&f[rs2], 8); 840 dd =sqrt(ds2); 841 memcpy(&f[rd], &dd, 8); 842 break; 843 844 case 0x2b: inst_sort=_FSQRTx_; 845 printf("FSQRTx is used, check fpop.c\n"); 846 exit(1); 847 break; 848 849 case 0x45: inst_sort=_FSUBs_; 850 f[rd]=f[rs1]-f[rs2]; 851 break; 852 853 case 0x46: inst_sort=_FSUBd_; 854 memcpy(&ds1 ,&f[rs1], 8); 855 memcpy(&ds2 ,&f[rs2], 8); 856 dd=ds1-ds2; 857 memcpy(&f[rd], &dd, 8); 858 break; 859 860 case 0x47: inst_sort=_FSUBx_; 861 printf("FSUBx is used, check fpop.c\n"); 862 exit(1); 863 break; 864 865 866 867 868 case 0xd2: inst_sort=_FdTOi_; 869 memcpy(&dd, &f[rs2], 8); 870 u_int = (int)dd; 871 memcpy(&f[rd], &u_int, 4); 872 break; 873 874 case 0xc6: inst_sort=_FdTOs_; 875 memcpy(&dd, &f[rs2], 8); 876 f[rd]=(float)dd; 877 break; 878 879 case 0xce: inst_sort=_FdTOx_; 880 printf("FdTOx is used, check fpop.c\n"); 881 exit(1); 882 break; 883 884 case 0xc8: inst_sort=_FiTOd_; 885 memcpy(&u_int, &f[rs2], 4); 886 dd = (double)u_int; 887 memcpy(&f[rd], &dd, 8); 888 break; 889 890 case 0xc4: inst_sort=_FiTOs_; 891 memcpy(&u_int, &f[rs2], 4); 892 f[rd] = (float)u_int; 893 break; 894 895 case 0xcc: inst_sort=_FiTOx_; 896 printf("FiTOx is used, check fpop.c\n"); 897 exit(1); 898 break; 899 900 case 0xc9: inst_sort=_FsTOd_; 901 dd = (double)f[rs2]; 902 memcpy(&f[rd], &dd, 8); 903 break; 904 905 case 0xd1: inst_sort=_FsTOi_; 906 u_int = (int)f[rs2]; 907 memcpy(&f[rd], &u_int, 4); 908 break; 909 910 case 0xcd: inst_sort=_FsTOx_; 911 printf("FxTOx is used, check fpop.c\n"); 912 exit(1); 913 break; 914 915 case 0xc3: inst_sort=_FxTOi_; 916 printf("FxTOi is used, check fpop.c\n"); 917 exit(1); 918 break; 919 920 case 0xc7: inst_sort=_FxTOs_; 921 printf("FxTOs is used, check fpop.c\n"); 922 exit(1); 923 break; 924 925 case 0xcb: inst_sort=_FxTOd_; 926 printf("FxTOd is used, check fpop.c\n"); 927 exit(1); 928 break; 929 930 default: 931 fprintf(stderr,"unimplemented fpop(0x%x).check fpop.c.\n", opf); 932 exit(1); 933 } 934 return 0; 935 } 936 /* memory.c This is a part of SimuSparc Version 0.9b 937 * Copyright (c) 1999,2000,2001, Kenji KISE 938 ***************************************************************/ 939 #include 940 #include 941 #include 942 #include 943 #include 944 #include 945 #include 946 #include 947 #include /* open */ 948 #include 949 #include 950 #include 951 #include 952 #include 953 #include 954 #include 955 #include 956 #include 957 958 #include "define.h" 959 960 961 #define LAST_ADDRESS 0xf0000000u 962 /* becouse of this setting, compress, sc cant work. */ 963 964 #define STACK_SIZE 0x400000u 965 #define STACK_START LAST_ADDRESS - STACK_SIZE /* stack area 10Mbyte */ 966 967 unsigned char *mem; /* memory area */ 968 unsigned char *mem_stack; /* stack area */ 969 unsigned int th = STACK_START; 970 971 extern char *FFget_assem(unsigned int); 972 973 extern unsigned int argv_argp_count; 974 extern unsigned int r[32]; 975 extern unsigned int memory_area; 976 extern unsigned int pc; 977 extern unsigned int total_c; 978 extern unsigned int ir; 979 980 /* 981 * Translate the address to phisical address. 982 **********************************************************/ 983 unsigned int mem_address(unsigned int address){ 984 985 if(address=th) 988 return (unsigned int)mem_stack +address-th; 989 990 printf("TC:%d Access address is illegal %u, %x, %s\n", 991 total_c,address, address, FFget_assem(ir)); 992 printf("mem_area_size %dMbyte\n", memory_area/1000000); 993 printf("STACK_START: 0x%x\n", STACK_START); 994 printf("STACK_END: 0x%x\n", LAST_ADDRESS); 995 exit(1); 996 } 997 998 /************************************************************/ 999 unsigned int load_word(unsigned int address){ 1000 unsigned int tmp; 1001 memcpy(&tmp, (char *)mem_address(address), 4); 1002 return tmp; 1003 } 1004 1005 unsigned short load_half(unsigned int address){ 1006 unsigned short tmp; 1007 memcpy(&tmp, (char *)mem_address(address), 2); 1008 return tmp; 1009 } 1010 1011 unsigned char load_byte(unsigned int address){ 1012 unsigned char tmp; 1013 memcpy(&tmp, (char *)mem_address(address), 1); 1014 return tmp; 1015 } 1016 1017 /************************************************************/ 1018 void store_word(unsigned int data, unsigned int address){ 1019 memcpy((char *)mem_address(address), &data, 4); 1020 } 1021 1022 void store_half(unsigned short data, unsigned int address){ 1023 memcpy((char *)mem_address(address), &data, 2); 1024 } 1025 1026 void store_byte(unsigned char data, unsigned int address){ 1027 memcpy((char *)mem_address(address), &data, 1); 1028 } 1029 1030 /************************************************************/ 1031 void set_text_area(char *program_name){ 1032 1033 int cnt; 1034 Elf * elf; 1035 Elf32_Shdr * shdr; /* section header */ 1036 Elf32_Ehdr * elf_header; 1037 Elf_Scn * scn; /* section */ 1038 Elf_Data * data; 1039 Elf_Data * text_data; 1040 int fd; /* file discripter */ 1041 FILE *program; 1042 unsigned int sec_addr; 1043 unsigned int sec_size; 1044 1045 if(NULL==(program=fopen(program_name,"r"))) assert(0); 1046 if((fd = open(program_name, O_RDONLY)) == -1) assert(0); 1047 1048 (void) elf_version(EV_CURRENT); 1049 if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) exit(1); 1050 1051 if (((elf_header = elf32_getehdr(elf)) == NULL) || 1052 ((scn = elf_getscn(elf, elf_header->e_shstrndx)) == NULL) || 1053 ((data = elf_getdata(scn, NULL)) == NULL)) 1054 exit(1); 1055 1056 /* malloc memory area at the beggining of the run */ 1057 for (cnt=1, scn=NULL; scn = elf_nextscn(elf, scn); cnt++) { 1058 if ((shdr = elf32_getshdr(scn)) == NULL) 1059 exit(1); 1060 sec_addr = (unsigned int )shdr->sh_addr; 1061 sec_size = (unsigned int )shdr->sh_size; 1062 if(!strcmp((char *)data->d_buf + shdr->sh_name, ".bss")){ 1063 memory_area = sec_addr + sec_size; 1064 if((mem = (char *)calloc(memory_area, 1))==0){ /* memory area */ 1065 printf("malloc error for mem[] in memory.c\n"); exit(1);} 1066 break; 1067 } 1068 } 1069 1070 for (cnt=1, scn=NULL; scn = elf_nextscn(elf, scn); cnt++) { 1071 if ((shdr = elf32_getshdr(scn)) == NULL) 1072 exit(1); 1073 1074 sec_addr = (unsigned int )shdr->sh_addr; 1075 sec_size = (unsigned int )shdr->sh_size; 1076 1077 /* 1078 printf("[%02d] size:%8d 0x%08x", cnt, 1079 sec_size, sec_addr); 1080 printf(" %d %s\n", 1081 shdr->sh_name, 1082 (char *)data->d_buf + shdr->sh_name); 1083 */ 1084 1085 if(!strcmp((char *)data->d_buf + shdr->sh_name, ".text")){ 1086 pc = shdr->sh_addr; 1087 } 1088 if(!strcmp((char *)data->d_buf + shdr->sh_name, ".bss")){ 1089 break; 1090 } 1091 1092 if(sec_addr != 0){ 1093 text_data = elf_getdata(scn, NULL); 1094 memcpy((void *)mem_address(sec_addr), 1095 text_data->d_buf, sec_size); 1096 } 1097 } 1098 fclose(program); 1099 } 1100 1101 /* 1102 * initialize memory, set environment variables here. 1103 **********************************************************/ 1104 void initialize_memory(int argc, char **argv, char **argp){ 1105 int i,j; 1106 int k; 1107 int argpc; 1108 unsigned int sp; /* stack point */ 1109 1110 unsigned int string_size; 1111 unsigned int string_start; 1112 unsigned int stack_start; 1113 int ptr_num; 1114 int fd; 1115 char char_tmp[10]; 1116 1117 if((mem_stack = (char *)malloc(STACK_SIZE+100))==0){ 1118 printf("malloc error for mem_stack[] in memory.c\n"); exit(1);} 1119 memset(mem_stack, 0, STACK_SIZE+100); 1120 1121 1122 /* [sp+0x44]=&argv[0], [sp+0x48]=&argv[1] ... =&argv[n] , 0x00000000, 1123 argp[0], arg[1],,,,, 0x00000000 */ 1124 1125 string_size=0; 1126 ptr_num=1; /* 1 for argc */ 1127 for(i=0; i<(argc-1); i++){ 1128 string_size+=strlen(argv[i+1]); 1129 string_size++; /* for NULL of each argv */ 1130 ptr_num++; 1131 } 1132 ptr_num++; 1133 for(j=0; 1; j++){ 1134 if(argp[j]==NULL) break; 1135 string_size+=strlen(argp[j]); 1136 string_size++; /* for NULL of each argp */ 1137 ptr_num++; 1138 } 1139 ptr_num++; 1140 string_size+=21; /* for "SUNW,Ultra-1\n" only for xlisp */ 1141 1142 if((string_size % 4)!=0) string_size+=(4- (string_size %4)); 1143 string_size+=4; /* for 0xefffffff NULL */ 1144 1145 string_start = LAST_ADDRESS-string_size; /* decide string_starg */ 1146 stack_start = string_start - 4*ptr_num; 1147 if((stack_start % 8)!=0) stack_start -=4; 1148 1149 r[14]= sp = stack_start-0x40; 1150 1151 store_word((argc-1), stack_start); /* for argc */ 1152 stack_start+=4; 1153 1154 for(i=0; i<(argc-1); i++){ /* for argv */ 1155 store_word(string_start, stack_start ); 1156 for(k=0; k 1207 #include 1208 #include 1209 #include 1210 #include 1211 #include 1212 #include /* open */ 1213 #include 1214 #include 1215 #include 1216 #include 1217 #include 1218 #include 1219 #include 1220 #include 1221 #include 1222 1223 static char UsageMessage[] = 1224 "SimuSparc version 0.9b last updated Jan 2001\n\ 1225 Usage: SimuSparc [-option] command\n\ 1226 -h: help. print this message.\n\ 1227 -d: debug mode\n\ 1228 -e[NUM][m]: simu ends the execution at specified TC.\n\ 1229 m stands for million, ex. 10m means 10 million instructions.\n\ 1230 "; 1231 1232 /* global variables */ 1233 ARCH_STATE as; /*** following must be in the as **/ 1234 char *mem_temp; /* temporary mem area*/ 1235 unsigned int r[32]; /* integer register */ 1236 float f[33]; /* floating register */ 1237 unsigned int y; /* y register, for MULScc etc. */ 1238 unsigned int n; /* N-Negative, icc Bit23 of PSR */ 1239 unsigned int z; /* Z-Zero , icc Bit22 of PSR */ 1240 unsigned int v; /* V-Overflow, icc Bit21 of PSR */ 1241 unsigned int c; /* C-Carry , icc Bit20 of PSR */ 1242 unsigned int ir; /* instruction at pc */ 1243 unsigned int pc, npc; /* program counter, next */ 1244 unsigned int inst_sort; /* instruntion sorts, instruction.h */ 1245 int reg_size; /* for save and restore */ 1246 unsigned int argv_argp_count; /* for stack */ 1247 1248 1249 unsigned int toend; 1250 unsigned int option_flag; /*for option*/ 1251 unsigned int value1,value2; /* value of loads and stores */ 1252 1253 1254 ULL end_tc=0; /* outfile1 */ 1255 ULL start_tc=0; /* outfile1 */ 1256 unsigned int memory_area; /* segmentation fault check */ 1257 FILE *outfile; 1258 ULL total_c; /* in main_loop etc. */ 1259 1260 1261 1262 void usage(){ 1263 printf("%s", UsageMessage); 1264 exit(0); 1265 } 1266 1267 int destruct_data(int argc, char **argv){ 1268 fprintf(stderr,"** %lld instructions are executed.\n", total_c); 1269 fprintf(stderr,"** Simulation finished normally.\n"); 1270 return 0; 1271 } 1272 1273 int construct_data(int argc, char **argv, char **argp){ 1274 int i; 1275 int value; 1276 1277 time_t time_tmp; 1278 unsigned long long temp=0; 1279 char *buf; 1280 1281 buf = (char *)malloc(1024); 1282 y=n=v=c=0; /* initialize flag */ 1283 z=1; 1284 1285 memset(&as, 0, sizeof(as)); 1286 option_flag = 0; /* options are parsed here */ 1287 if(argc>1){ 1288 for(i=0; i<10; i++){ /* at most ten options are available */ 1289 if(argc==1) break; 1290 if((*(char *)(argv[1]))=='-'){ 1291 switch( *((char *)(argv[1]) +1) ) 1292 { 1293 case 'h': usage(); break; 1294 case 'd': option_flag |= DEBUG_FLAG; break; 1295 case 'i': option_flag |= TICC_FLAG; break; 1296 case 'f': option_flag |= STDOUT_TO_FILE; break; 1297 case 'c': option_flag |= SYSTEMCALL_FLAG; break; 1298 case 't': option_flag |= DISTRIBUTION_FLAG; break; 1299 1300 case 'e': /* end of simusparc */ 1301 end_tc =atoll((char *)(argv[1])+2); 1302 if(*((char *)(argv[1])+strlen(argv[1])-1)=='m') 1303 end_tc *=1000000; 1304 fprintf(stderr,"Specified end TC : %lld\n", 1305 end_tc); 1306 break; 1307 1308 default: 1309 fprintf(stderr, "Perhaps illegal options are used.\n"); 1310 fprintf(stderr, "See the manual.\n"); 1311 exit(1); 1312 } 1313 argv++; 1314 argc--; 1315 } 1316 } 1317 } 1318 if(argc < 2) usage(); 1319 1320 for(i=0;i<32;i++) {r[i]=0; f[i]=0;} 1321 initialize_memory(argc, argv, argp); /* important */ 1322 if((mem_temp = (char *)malloc(MEM_TEMP_SIZE))==0){ 1323 fprintf(OUTFILE1,"malloc error for mem_temp[]\n"); exit(1);} 1324 /* memory temp this is used for system call */ 1325 npc = pc+4; 1326 1327 return 0; 1328 } 1329 1330 1331 /* 1332 * From now on, definitions of instructions follow. 1333 ************************************************************/ 1334 int call(){ 1335 unsigned int disp30; 1336 unsigned int t; 1337 1338 inst_sort=_CALL_; 1339 1340 disp30=(ir & DISP30); 1341 t = pc; 1342 r[15]=pc; 1343 pc = npc; 1344 npc = t + disp30*4; 1345 1346 value1 = r[15]; /* for outfile */ 1347 return 0; 1348 } 1349 1350 int Bicc(unsigned int ir){ 1351 unsigned int cond; 1352 unsigned int imm22; 1353 unsigned int ttrue; 1354 unsigned int pc_temp; 1355 int sign=0; 1356 int rss; 1357 int a; 1358 1359 inst_sort=_Bicc_; 1360 1361 a=( ir & A )>>29; 1362 cond=( ir & COND)>>25; 1363 imm22= ir & IMM22 ; 1364 1365 ttrue = 0; 1366 switch(cond) 1367 { 1368 case 0: ttrue=0; break; /*bn*/ 1369 case 1: if(z)ttrue=1; break; /*be */ 1370 case 2: if(z | (n^v)) ttrue=1; break; /*ble*/ 1371 case 3: if(n^v)ttrue=1;break; /*bl */ 1372 case 4: if(c|z)ttrue=1;break; /*bleu*/ 1373 case 5: if(c)ttrue=1; break; /*bcs*/ 1374 case 6: if(n)ttrue=1; break; /*bneg*/ 1375 case 7: if(v)ttrue=1; break; /*bvs*/ 1376 case 8: ttrue=1; break; /*ba*/ 1377 case 9: if(z==0)ttrue=1; break; /*bne*/ 1378 case 10: if(!(z | (n^v)))ttrue=1; break;/*bg*/ 1379 case 11: if(!(n^v))ttrue=1; break; /*bge*/ 1380 case 12: if(!(c|z))ttrue=1; break; /*bgu*/ 1381 case 13: if(!c)ttrue=1; break; /*bcc*/ 1382 case 14: if(!n)ttrue=1; break; /*bpos*/ 1383 case 15: if(!v)ttrue=1; break; /*bvc*/ 1384 default: fprintf(stderr,"bicc unknown default in branch.cc\n"); 1385 exit(1); 1386 } 1387 1388 sign=(imm22 & BIT21) >>21; 1389 if(sign) rss = (ir & IMM22) | EXTND22; 1390 else rss = ir & IMM22; 1391 pc_temp = pc; 1392 1393 pc=npc; 1394 if(ttrue){ 1395 npc = pc_temp+rss*4; 1396 if(cond==8 && a==1) 1397 as.annul = 1; 1398 } 1399 else{ 1400 npc +=4; 1401 if(a==1) 1402 as.annul = 1; 1403 } 1404 1405 return 0; 1406 } 1407 1408 int FBfcc(unsigned int ir){ 1409 unsigned int cond; 1410 unsigned int imm22; 1411 unsigned int ttrue; 1412 unsigned int pc_temp; 1413 int sign=0; 1414 int rss; 1415 int a; 1416 unsigned int temp,E,L,G,U; 1417 1418 inst_sort=_FBfcc_; 1419 1420 a=( ir & A )>>29; 1421 imm22= ir & IMM22 ; 1422 temp = (as.fsr>>10) & 0x3; 1423 1424 E = (temp==0); 1425 L = (temp==1); 1426 G = (temp==2); 1427 U = (temp==3); 1428 1429 ttrue = 0; 1430 cond=( ir & COND)>>25; 1431 switch(cond) 1432 { 1433 case 0: ttrue=0; break; /*fbn*/ 1434 case 1: if(U || L || G)ttrue=1; break; /*fbne*/ 1435 case 2: if(L || G) ttrue=1; break; /*fblg*/ 1436 case 3: if(U || L) ttrue=1; break; /*fbul*/ 1437 case 4: if(L) ttrue=1; break; /*fbl*/ 1438 case 5: if(U || G) ttrue=1; break; /*fbug*/ 1439 case 6: if(G) ttrue=1; break; /*fbg*/ 1440 case 7: if(U) ttrue=1; break; /*fbu*/ 1441 case 8: ttrue=1; break; /*fba*/ 1442 case 9: if(E) ttrue=1; break; /*fbe*/ 1443 case 10:if(U || E) ttrue=1; break; /*fbue*/ 1444 case 11:if(G || E) ttrue=1; break; /*fbge*/ 1445 case 12:if(U || G || E)ttrue=1; break; /*fbuge*/ 1446 case 13:if(L || E) ttrue=1; break; /*fble*/ 1447 case 14:if(U || L || E)ttrue=1; break; /*fbule*/ 1448 case 15:if(L || G || E)ttrue=1; break; /*fbo*/ 1449 default:fprintf(OUTFILE1,"fbicc unknown default\n");exit(1); 1450 } 1451 1452 sign=(imm22 & BIT21) >>21; 1453 if(sign) rss = (ir & IMM22) | EXTND22; 1454 else rss = ir & IMM22; 1455 pc_temp = pc; 1456 1457 pc=npc; 1458 if(ttrue){ 1459 npc = pc_temp+rss*4; 1460 if(cond==8 && a==1) 1461 as.annul = 1; 1462 } 1463 else{ 1464 npc +=4; 1465 if(a==1) 1466 as.annul = 1; 1467 } 1468 1469 return 0; 1470 } 1471 1472 int SETHI(unsigned int ir){ 1473 unsigned rd; 1474 unsigned imm22; 1475 1476 inst_sort=_SETHI_; 1477 1478 rd=( ir & RD )>>25; 1479 imm22=ir & IMM22; 1480 1481 if(rd!=0){ 1482 r[rd]=imm22<<10; 1483 } 1484 value1 = r[rd]; /* for outfile */ 1485 return 0; 1486 } 1487 1488 1489 int CBccc(){ 1490 inst_sort=_CBccc_; 1491 fprintf(OUTFILE1,"CBfcc is used. \n"); 1492 fprintf(stderr, "CBfcc is used. \n"); 1493 exit(1); 1494 } 1495 1496 1497 int ar_log(){ 1498 unsigned int op3; 1499 unsigned int result; 1500 unsigned int opt1; 1501 unsigned int opt2; 1502 unsigned int rss; 1503 int shift; 1504 int msb; 1505 unsigned int rd,rs1,rs2; 1506 unsigned int simm13; 1507 unsigned int i; 1508 1509 rd = ( ir & RD )>>25; 1510 rs1 = ( ir & RS1)>>14; 1511 rs2 = ir & RS2; 1512 1513 simm13=ir & SIMM13; 1514 i =( ir & I)>>13; 1515 1516 if(i){ /* get rss by simm13*/ 1517 if( (simm13 & BIT12)>>12 ) rss=(ir & SIMM13) | EXTND13; 1518 else rss=ir & SIMM13; 1519 } 1520 else rss=r[rs2]; 1521 1522 op3 = (ir & OP3)>>19; 1523 1524 switch(op3) 1525 { 1526 case 0 :r[rd]=r[rs1]+rss; inst_sort=_ADD_; value1=r[rd]; break; 1527 case 1 :r[rd]=r[rs1]&rss; inst_sort=_AND_; value1=r[rd]; break; 1528 case 2 :r[rd]=r[rs1]|rss; inst_sort=_OR_; value1=r[rd]; break; 1529 case 3 :r[rd]=r[rs1]^rss; inst_sort=_XOR_; value1=r[rd]; break; 1530 case 4 :r[rd]=r[rs1]-rss; inst_sort=_SUB_; value1=r[rd]; break; 1531 case 5 :r[rd]=r[rs1]&(~rss);inst_sort=_ANDN_; value1=r[rd]; break; 1532 case 6 :r[rd]=r[rs1]|(~rss);inst_sort=_ORN_; value1=r[rd]; break; 1533 case 7 :r[rd]=r[rs1]^(~rss);inst_sort=_XNOR_; value1=r[rd]; break; 1534 case 8 :r[rd]=r[rs1]+rss +c;inst_sort=_ADDX_; value1=r[rd]; break; 1535 case 12:r[rd]=r[rs1]-rss -c;inst_sort=_SUBX_; value1=r[rd]; break; 1536 1537 case 0x10: inst_sort=_ADDcc_; 1538 result=r[rs1] + rss; 1539 n=bit31(result); 1540 if(result==0) z=1; else z=0; 1541 v=(bit31(r[rs1]) & bit31(rss) & !bit31(result) ) | 1542 (!bit31(r[rs1]) & !bit31(rss) & bit31(result) ); 1543 c=( bit31(r[rs1]) & bit31(rss) ) | 1544 ( !bit31(result) & ( bit31(r[rs1]) | bit31(rss) ) ); 1545 r[rd]=result; 1546 value1=r[rd]; /* for outfile */ 1547 break; 1548 1549 case 0x11: inst_sort=_ANDcc_; 1550 result=r[rs1] & rss; 1551 n=bit31(result); 1552 if(result==0) z=1; else z=0; 1553 v=0; 1554 c=0; 1555 r[rd]=result; 1556 value1=r[rd]; /* for outfile */ 1557 break; 1558 1559 case 18 : inst_sort=_ORcc_; 1560 r[rd]=r[rs1] | rss; 1561 n=bit31(r[rd]); 1562 if(r[rd]==0) z=1; else z=0; 1563 v=0; 1564 c=0; 1565 value1=r[rd]; /* for outfile */ 1566 break; 1567 1568 case 19 : inst_sort=_XORcc_; 1569 r[rd]=r[rs1] ^ rss; 1570 n=bit31(r[rd]); 1571 if(r[rd]==0) z=1; else z=0; 1572 v=0; 1573 c=0; 1574 value1=r[rd]; /* for outfile */ 1575 break; 1576 1577 case 20: inst_sort=_SUBcc_; 1578 result=r[rs1]-rss; 1579 n=bit31(result); 1580 if(result==0) z=1; else z=0; 1581 v=(bit31(r[rs1]) & !bit31(rss) & !bit31(result) ) | 1582 (!bit31(r[rs1]) & bit31(rss) & bit31(result) ); 1583 c=( !bit31(r[rs1]) & bit31(rss) ) | 1584 ( bit31(result) & (!bit31(r[rs1]) | bit31(rss))); 1585 r[rd]=result; 1586 value1=r[rd]; /* for outfile */ 1587 break; 1588 1589 case 21: inst_sort=_ANDNcc_; 1590 r[rd]=r[rs1] & (~rss); 1591 n=bit31(r[rd]); 1592 if(r[rd]==0) z=1; else z=0; 1593 v=0; 1594 c=0; 1595 value1=r[rd]; /* for outfile */ 1596 break; 1597 1598 case 22 : inst_sort=_ORNcc_; 1599 r[rd]=r[rs1] | (~rss) ; 1600 n=bit31(r[rd]); 1601 if(r[rd]==0) z=1; else z=0; 1602 v=0; 1603 c=0; 1604 value1=r[rd]; /* for outfile */ 1605 break; 1606 1607 case 23 : inst_sort=_XNORcc_; 1608 r[rd]=r[rs1] ^ (~rss) ; 1609 n=bit31(r[rd]); 1610 if(r[rd]==0) z=1; else z=0; 1611 v=0; 1612 c=0; 1613 value1=r[rd]; /* for outfile */ 1614 break; 1615 1616 case 24: inst_sort=_ADDXcc_; 1617 result=r[rs1]+rss+c; 1618 n=bit31(r[rd]); 1619 if(result==0)z=1; else z=0; 1620 v=(bit31(r[rs1]) & bit31(rss) & !bit31(result) ) | 1621 (!bit31(r[rs1]) & !bit31(rss) & bit31(result) ); 1622 c=( bit31(r[rs1]) & bit31(rss) ) | 1623 ( !bit31(result) & ( bit31(r[rs1]) | bit31(rss) ) ); 1624 r[rd]=result; 1625 value1=r[rd]; /* for outfile */ 1626 break; 1627 1628 case 28: inst_sort=_SUBXcc_; 1629 result=r[rs1]-rss-c; 1630 n=bit31(r[rd]); 1631 if(r[rd]==0) z=1; else z=0; 1632 v=(bit31(r[rs1]) & !bit31(rss) & !bit31(result) ) | 1633 (!bit31(r[rs1]) & bit31(rss) & bit31(result) ); 1634 c=( !bit31(r[rs1]) & bit31(rss) ) | 1635 ( bit31(result) & (!bit31(r[rs1]) | bit31(rss))); 1636 r[rd]=result; 1637 value1=r[rd]; /* for outfile */ 1638 break; 1639 1640 case 32: inst_sort=_TADDcc_; 1641 fprintf(OUTFILE1, "used TADDcc instruction \n ") ; 1642 exit(1); 1643 break; 1644 1645 case 33: inst_sort=_TSUBcc_; 1646 fprintf(OUTFILE1, "used TSUBcc instruction \n") ; 1647 exit(1); 1648 break; 1649 1650 case 34: inst_sort=_TADDccTV_; 1651 fprintf(OUTFILE1," used TADDccTV instruvtion \n") ; 1652 exit(1); 1653 break; 1654 1655 case 35: inst_sort=_TSUBccTV_; 1656 fprintf(OUTFILE1," used TSUBccTV instruction \n") ; 1657 exit(1); 1658 break; 1659 1660 case 36: inst_sort=_MULScc_; 1661 if(n^v) opt1=BIT31 | (r[rs1]>>1); /*step 3*/ 1662 else opt1= r[rs1]>>1; 1663 /* flag = (y & 1) ; */ /* for outfile1 */ 1664 if((y & 1)==1)opt2= rss; /*step 2*/ 1665 else opt2=0; 1666 result=opt1+opt2; 1667 if(r[rs1]&1) y=(y>>1)|BIT31; /*step 3*/ 1668 else y=y>>1; 1669 n=bit31(r[rd]); 1670 if(result==0) z=1; else z=0; 1671 v=((bit31(opt1) & bit31(opt2) & !bit31(result)) | 1672 (!bit31(opt1) & !bit31(opt2) & bit31(result))) ; 1673 c= ( bit31(opt1) & bit31(opt2) ) | 1674 (!bit31(result) & (bit31(opt1) | bit31(opt2)) ); 1675 r[rd]=result; 1676 value1=r[rd]; /* for outfile */ 1677 value2=y; /* for outfile */ 1678 break; 1679 1680 case 37: inst_sort=_SLL_; 1681 if(i) shift= simm13 & RS2 ; 1682 else shift=r[rs2] & RS2 ; 1683 r[rd]=r[rs1] << shift; 1684 value1=r[rd]; /* for outfile */ 1685 break; 1686 1687 case 38: inst_sort=_SRL_; 1688 if(i) shift= simm13 & RS2 ; 1689 else shift=r[rs2] & RS2 ; 1690 r[rd]=r[rs1] >> shift; 1691 value1=r[rd]; /* for outfile */ 1692 break; 1693 1694 case 39: inst_sort=_SRA_; 1695 if(i) shift= simm13 & RS2 ; 1696 else shift=r[rs2] & RS2 ; 1697 result=r[rs1] >> shift; 1698 msb= r[rs1] >>31; 1699 r[rd]=result; 1700 if(msb)r[rd]=r[rd]|( 0xffffffff<<(32-shift) ); 1701 else r[rd]=r[rd]; 1702 value1=r[rd]; /* for outfile */ 1703 break; 1704 1705 case 40: inst_sort=_RDY_; 1706 r[rd]=y; 1707 value1=r[rd]; /* for outfile */ 1708 break; 1709 1710 case 48: inst_sort=_WRY_; 1711 y=r[rs1]^rss; 1712 value1=y; /* for outfile */ 1713 break; 1714 1715 case 0x34: 1716 fpops(ir); 1717 break; 1718 1719 case 0x35: 1720 fcmps(ir); 1721 break; 1722 1723 case 56: inst_sort=_JMPL_; 1724 r[rd] = pc; 1725 pc = npc; 1726 npc = r[rs1] + rss; 1727 1728 value1=r[rd]; /* for outfile */ 1729 break; 1730 1731 case 58: inst_sort=_Ticc_; 1732 Ticc( (r[rs1]+rss) & USGNB ); 1733 break; 1734 1735 case 60: inst_sort=_SAVE_; 1736 for(i=0; i<16; i++) store_word(r[i+16], r[14]+4*i); 1737 /* store locals and outs registers into memory */ 1738 result=r[rs1]+rss; 1739 for(i=24; i<32; i++) r[i]=r[i-16]; 1740 for(i=8; i<16; i++) r[i]=0; /* set 0 outs registers */ 1741 for(i=16; i<24; i++) r[i]=load_word(result+4*i); 1742 r[rd]=result; 1743 break; 1744 1745 case 61: inst_sort=_RESTORE_; 1746 for(i=0; i<16; i++) store_word(r[i+16], r[14]+4*i); 1747 result=r[rs1]+rss; 1748 for(i=8; i<16; i++) r[i]=r[i+16]; 1749 r[rd]=result; 1750 for(i=0; i<16; i++) r[i+16]=load_word(r[14]+4*i); 1751 break; 1752 1753 case 59: inst_sort=_IFLUSH_; 1754 fprintf(stderr," used IFLUSH instruction \n") ; 1755 exit(1); 1756 break; 1757 1758 default: 1759 fprintf(stderr,"\nError ar_log."); 1760 exit(1); 1761 } 1762 return 0; 1763 } 1764 1765 unsigned int ld_st(){ 1766 unsigned int rd,rs1,rs2 ; 1767 unsigned int op3; 1768 unsigned int i, rss, simm13; 1769 unsigned int temp_swap, word_swap; 1770 unsigned char byte; 1771 unsigned short halfwd; 1772 unsigned int sign; 1773 unsigned int mem_adr; 1774 1775 rd=( ir & RD )>>25; 1776 rs1=( ir & RS1)>>14; 1777 rs2= ir & RS2; 1778 1779 simm13=ir & SIMM13; 1780 i=( ir & I)>>13; 1781 1782 if(i){ /* get rss by simm13 */ 1783 if((simm13 &BIT12)>>12) rss=(ir & SIMM13) | EXTND13; 1784 else rss=ir & SIMM13; 1785 } 1786 else rss=r[rs2]; 1787 1788 mem_adr=r[rs1]+rss; 1789 1790 op3 = (ir & OP3)>>19; 1791 switch(op3) 1792 { 1793 case 0 : inst_sort=_LD_; 1794 memcpy(&r[rd], (char *)mem_address(mem_adr), 4); 1795 value1 = r[rd]; /* for debug */ 1796 break; 1797 1798 case 1 : inst_sort=_LDUB_; 1799 memcpy(&byte, (char *)mem_address(mem_adr), 1); 1800 r[rd]= (unsigned int)byte; 1801 value1 = r[rd]; /* for debug */ 1802 break; 1803 1804 case 2 : inst_sort=_LDUH_; 1805 memcpy(&halfwd, (char *)mem_address(mem_adr), 2); 1806 r[rd]= (unsigned int)halfwd ; 1807 value1 = r[rd]; /* for debug */ 1808 break; 1809 1810 case 3 : inst_sort=_LDD_; 1811 memcpy(&r[rd],(char *)mem_address(mem_adr),8); 1812 value1 = r[rd]; /* for debug */ 1813 value2 = r[rd+1]; /* for debug */ 1814 break; 1815 1816 case 9 : inst_sort=_LDSB_; 1817 memcpy(&byte, (char *)mem_address(mem_adr), 1); 1818 sign=(byte & BIT7)>>7; 1819 if(sign) r[rd]= (unsigned int)byte | EXTND8; 1820 else r[rd]= (unsigned int)byte; 1821 value1 = r[rd]; /* for debug */ 1822 break; 1823 1824 case 10 : inst_sort=_LDSH_; 1825 memcpy(&halfwd, (char *)mem_address(mem_adr), 2); 1826 sign=(halfwd & BIT15)>>15; 1827 if(sign) r[rd] = (unsigned int)halfwd | EXTND16; 1828 else r[rd]= (unsigned int)halfwd ; 1829 value1 = r[rd]; /* for debug */ 1830 break; 1831 1832 case 13 : inst_sort=_LDSTUB_; 1833 memcpy(&byte, (char *)mem_address(mem_adr), 1); 1834 r[rd]= (unsigned int)byte; 1835 value1 = r[rd]; /* for debug */ 1836 store_byte((unsigned char)0xff, mem_adr); 1837 break; 1838 1839 case 32 : inst_sort=_LDF_; 1840 memcpy(&f[rd],(char *)mem_address(mem_adr),4); 1841 value1 = f[rd]; /* for debug */ 1842 break; 1843 1844 case 35 : inst_sort=_LDDF_; 1845 memcpy(&f[rd], (char *)mem_address(mem_adr),8); 1846 value1 = f[rd]; /* for debug */ 1847 value2 = f[rd+1]; /* for debug */ 1848 break; 1849 1850 case 33 : inst_sort=_LDFSR_; 1851 memcpy(&as.fsr, (char *)mem_address(mem_adr), 4); 1852 value1 = as.fsr; /* for debug */ 1853 break; 1854 1855 1856 case 4 : inst_sort=_ST_; /* Store Word */ 1857 memcpy((char *)mem_address(mem_adr), &r[rd], 4); 1858 break; 1859 1860 case 5 : inst_sort=_STB_; /* Store Byte */ 1861 byte = (unsigned char)(r[rd] & 0xff); 1862 memcpy((char *)mem_address(mem_adr), &byte, 1); 1863 break; 1864 1865 case 6 : inst_sort=_STH_; /* Store Halfword */ 1866 halfwd = (unsigned short)(r[rd] & 0xffff);; 1867 memcpy((char *)mem_address(mem_adr), &halfwd, 2); 1868 break; 1869 1870 case 7 : inst_sort=_STD_; /* Store Doubleword */ 1871 memcpy((char *)mem_address(mem_adr), &r[rd], 8); 1872 break; 1873 1874 case 36 : inst_sort=_STF_; /* Store Floating-Point register */ 1875 memcpy((char *)mem_address(mem_adr), &f[rd], 4); 1876 break; 1877 1878 case 37 : inst_sort=_STFSR_; /* Store Floating-Point Sta1te Register */ 1879 memcpy((char *)mem_address(mem_adr), &as.fsr, 4); 1880 break; 1881 1882 case 39 : inst_sort=_STDF_; /* Store Doubleword Floating-Point */ 1883 memcpy((char *)mem_address(mem_adr), &f[rd], 8); 1884 break; 1885 1886 case 15 : inst_sort=_SWAP_; /* Swap r register with memory */ 1887 memcpy(&word_swap, (char *)mem_address(mem_adr), 4); 1888 temp_swap = r[rd]; 1889 r[rd] = word_swap; 1890 memcpy((char *)mem_address(mem_adr), &temp_swap, 4); 1891 break; 1892 1893 default: 1894 fprintf(stderr,"ld/st default in ld_st.cc\n"); exit(1); 1895 } 1896 return 0; 1897 } 1898 1899 int transfer(){ 1900 unsigned int op2; 1901 1902 op2=(ir & OP2)>>22; 1903 switch(op2){ 1904 case 0:{ 1905 inst_sort=_UNIMP_; 1906 printf("TC:%d ,UNIMP is executed at pc:0x%x\n", total_c, pc); 1907 exit(0); 1908 } 1909 case 4:SETHI(ir); break; 1910 case 2:Bicc(ir); break; 1911 case 6:FBfcc(ir); break; 1912 case 7:CBccc(); break; 1913 } 1914 } 1915 1916 /************************************************************/ 1917 void main_loop(int argc, char **argv){ 1918 unsigned int pc_tmp; 1919 total_c=0 ; 1920 toend=0; 1921 1922 while(!toend){ 1923 ir = load_word(pc); 1924 r[0]=0; /* initialize global 0 */ 1925 1926 inst_sort = 0; /* initialize instruction */ 1927 pc_tmp = pc; 1928 1929 value1=value2=0; /* for debug */ 1930 1931 if(end_tc!=0 && total_c>=end_tc){ 1932 printf("\n%lld inst executed. and finish.\n",total_c); 1933 break; 1934 } 1935 1936 if(as.annul == 0){ 1937 if(option_flag & DEBUG_FLAG) debugmode(); 1938 1939 switch( (ir & OP)>>30 ){ 1940 case 0: transfer(); break; 1941 case 1: call(); break; 1942 case 2: ar_log(); break; 1943 case 3: ld_st(); break; 1944 } 1945 1946 if(inst_sort!=_CALL_ && inst_sort!=_RETT_ && 1947 inst_sort!=_JMPL_ && inst_sort!=_Bicc_ && 1948 inst_sort!=_FBfcc_ && inst_sort!=_CBccc_){ 1949 pc = npc; 1950 npc +=4; 1951 } 1952 1953 total_c++; 1954 } 1955 else{ 1956 as.annul = 0; 1957 pc = npc; 1958 npc +=4; 1959 } 1960 } 1961 } 1962 1963 int main(int argc, char **argv, char **argp){ 1964 construct_data(argc, argv, argp); 1965 main_loop(argc, argv); 1966 destruct_data(argc, argv); 1967 return 0; 1968 } 1969 /* syscall.c This is a part of SimuSparc Version 0.9b 1970 * Copyright (c) 1999,2000,2001, Kenji KISE 1971 ***************************************************************/ 1972 #include 1973 #include /* stat */ 1974 #include /* stat */ 1975 #include /* writev */ 1976 #include 1977 #include 1978 #include 1979 #include 1980 #include 1981 #include 1982 #include 1983 #include 1984 1985 #include 1986 #include 1987 #include 1988 #include 1989 #include 1990 #include 1991 #include /* open */ 1992 #include 1993 #include 1994 #include 1995 #include 1996 #include 1997 #include 1998 #include 1999 #include 2000 #include 2001 2002 #include "define.h" 2003 2004 /* global variables */ 2005 extern char *mem; /* memory area */ 2006 extern char *mem_temp; /* temporary mem area*/ 2007 extern unsigned int ir; /* instruction at pc */ 2008 extern unsigned int r[32], *rr; /* integer register */ 2009 extern float f[33]; /* floating register */ 2010 extern unsigned int y; /* y register */ 2011 extern unsigned int n,z,v,c,fsr;/* flags */ 2012 extern unsigned int pc, npc; /* program counter, next */ 2013 2014 extern unsigned int memory_area; 2015 extern unsigned int option_flag; /*for option*/ 2016 extern FILE *outfile; 2017 extern unsigned int flag; 2018 2019 extern unsigned int mem_address(unsigned int address); 2020 extern int getpagesize(void); 2021 2022 unsigned long long total_c; 2023 int toend; 2024 int fd_stdout=0; /* for OUTFILE_PRINT_FLAG */ 2025 2026 int Ticc(int num) 2027 { 2028 unsigned int rd=0; 2029 unsigned int temp; 2030 unsigned int cond ; 2031 unsigned int ttrue=0 ; 2032 2033 if(r[1]>256){ 2034 /* gdb says so, but I'm not sure, 2035 printf("this ticc is JUST NOP.\n"); */ 2036 return 0; 2037 } 2038 2039 2040 if(option_flag & SYSTEMCALL_FLAG){ /* r[1] specifies the sort */ 2041 fprintf(OUTFILE1, "[%3d] TC:%07lld pc:%05x ", r[1], total_c, pc); 2042 fflush(OUTFILE1); 2043 } 2044 2045 if(option_flag & TICC_FLAG) 2046 fwrite(&total_c, 4, 1, outfile); 2047 2048 cond=(mem[pc] & COND)>>25; 2049 2050 ttrue = 0; 2051 switch(cond) 2052 { 2053 case 0: break; /* TN */ 2054 case 1: if(z) ttrue=1; break; /* TE */ 2055 case 2: if(z | (n^v)) ttrue=1; break; /* TLE */ 2056 case 3: if(n^v) ttrue=1; break; /* TL */ 2057 case 4: if(c|z) ttrue=1; break; /* TLEU */ 2058 case 5: if(c) ttrue=1; break; /* TCS */ 2059 case 6: if(n) ttrue=1; break; /* TNEG */ 2060 case 7: if(v) ttrue=1; break; /* TVS */ 2061 case 8: ttrue=1; break; /* TA */ 2062 case 9: if(!z) ttrue=1; break; /* TNE */ 2063 case 10: if(!(z|(n^v))) ttrue=1; break; /* TG */ 2064 case 11: if(!(n^v)) ttrue=1; break; /* TGE */ 2065 case 12: if(!(c|z)) ttrue=1; break; /* TGU */ 2066 case 13: if(!c) ttrue=1; break; /* TCC */ 2067 case 14: if(!n) ttrue=1; break; /* TPOS */ 2068 case 15: if(!v) ttrue=1; break; /* TVC */ 2069 default: fprintf(OUTFILE1,"unknown condition ? cond=%x ",cond); 2070 } 2071 2072 temp = r[8]; 2073 2074 if(ttrue){ /* as to numbers see /usr/include/syscall.h */ 2075 switch(r[1]) 2076 { 2077 case SYS_access: /* this used in SPEC95 tomcatv */ 2078 rd=(int)access((const char *)mem_address(r[8]),r[9]); 2079 if(option_flag & SYSTEMCALL_FLAG){ 2080 fprintf(OUTFILE1,"access (\"%s\", %d) = %d", 2081 (char *)mem_address(r[8]), r[9], rd); 2082 fflush(OUTFILE1); 2083 } 2084 2085 break; 2086 2087 case SYS_mmap: 2088 /* rd=mmap(r[8],r[9],r[10], r[11], r[12],r[13]); 2089 rd-=0x80000000; */ 2090 2091 /* read(r[12], mem_address(rd), r[9]); */ 2092 if(option_flag & SYSTEMCALL_FLAG){ 2093 fprintf(OUTFILE1, "mmap(0x%08x,%d, ", r[8],r[9]); 2094 if(r[10]==PROT_READ) fprintf(OUTFILE1, "PROT_READ "); 2095 if(r[11]==MAP_PRIVATE) fprintf(OUTFILE1, "MAP_PRIVATE "); 2096 else fprintf(OUTFILE1, "0x%X ",r[11]); 2097 fprintf(OUTFILE1, "%d, %d) = 0x%X\n", r[12],r[13], rd); 2098 } 2099 2100 printf("mmap is executed. and exit(1)\n"); 2101 exit(1); 2102 break; 2103 2104 case SYS_sysconfig: 2105 if(r[8]==_CONFIG_PAGESIZE){ 2106 rd=getpagesize(); 2107 } 2108 if(option_flag & SYSTEMCALL_FLAG) /* compiler says so */ 2109 fprintf(OUTFILE1, "sysconfig(%d) = %d ", r[8], rd); 2110 break; 2111 2112 case SYS_time: /* vortex */ 2113 rd=time((time_t *)r[8]); 2114 if(option_flag & SYSTEMCALL_FLAG) 2115 fprintf(OUTFILE1, "time() = %d ", rd); 2116 break; 2117 2118 case SYS_times: /* vortex */ 2119 rd=times((struct tms *)mem_address(r[8])); 2120 if(option_flag & SYSTEMCALL_FLAG) 2121 fprintf(OUTFILE1, "times(0x%X) = %d ", r[8], rd); 2122 break; 2123 2124 case SYS_getrlimit: /* cc1.v8 use this */ 2125 rd=getrlimit(r[8],(struct rlimit *)mem_address(r[9])); 2126 if(option_flag & SYSTEMCALL_FLAG) 2127 fprintf(OUTFILE1, "getrlimit (%d, 0x%x) = %d ", 2128 r[8], r[9], rd); 2129 break; 2130 2131 case SYS_setrlimit: /* cc1.v8 use this */ 2132 rd=setrlimit(r[8],(struct rlimit *)mem_address(r[9])); 2133 if(option_flag & SYSTEMCALL_FLAG) 2134 fprintf(OUTFILE1, "setrlimit (%d, 0x%x) = %d ", 2135 r[8], r[9], rd); 2136 break; 2137 2138 2139 case SYS_chmod: 2140 temp = r[8]; 2141 rd=chmod((const char *)mem_address(r[8]),(mode_t)r[9]); 2142 if(option_flag & SYSTEMCALL_FLAG) 2143 fprintf(OUTFILE1, "chmod (\"%s\", 0%o) = %d ", 2144 (char *)mem_address(temp), r[9], rd); 2145 break; 2146 2147 case SYS_chown: 2148 rd=chown((const char *)mem_address(r[8]),(uid_t)r[9],(gid_t)r[10]); 2149 if(option_flag & SYSTEMCALL_FLAG) 2150 fprintf(OUTFILE1, "chown (\"%s\", %d, %d) = %d ", 2151 (char *)mem_address(temp), r[9], r[10], rd); 2152 break; 2153 2154 case SYS_unlink: 2155 rd=unlink((const char *)mem_address(r[8])); 2156 if(option_flag & SYSTEMCALL_FLAG) 2157 fprintf(OUTFILE1, "unlink (\"%s\") = %d ", 2158 (char *)mem_address(temp), rd); 2159 break; 2160 2161 case SYS_stat: 2162 rd=stat((const char *)mem_address(r[8]), 2163 (struct stat *)(mem_address(r[9]))); 2164 if(option_flag & SYSTEMCALL_FLAG) 2165 fprintf(OUTFILE1, "stat (\"%s\", 0x%x) = %d ", 2166 (char *)(mem_address(r[8])), r[9],rd); 2167 break; 2168 2169 case SYS_utime: 2170 rd=utime((const char *)mem_address(r[8]), 2171 (const struct utimbuf *)mem_address(r[9])); 2172 if(option_flag & SYSTEMCALL_FLAG) 2173 fprintf(OUTFILE1, "utime (\"%s\", 0x%X) = %d ", 2174 (char *)mem_address(temp), r[9], rd); 2175 break; 2176 2177 case SYS_fstat: 2178 rd=fstat(r[8],(struct stat *)(mem_address(r[9]))); 2179 if(option_flag & SYSTEMCALL_FLAG) 2180 fprintf(OUTFILE1, "fstat(%d, 0x%08X) = %d ", 2181 temp, r[9], rd); 2182 break; 2183 2184 case SYS_lstat: 2185 rd=lstat((const char *)mem_address(r[8]), 2186 (struct stat *)(mem_address(r[9]))); 2187 if(option_flag & SYSTEMCALL_FLAG) 2188 fprintf(OUTFILE1, "lstat(%s,0x%08x) = %d ", 2189 (char *)mem_address(r[8]), r[9], rd); 2190 break; 2191 2192 case SYS_exit: /* ok kis */ 2193 toend = 1; 2194 if(option_flag & SYSTEMCALL_FLAG) 2195 fprintf(OUTFILE1, "exit"); 2196 break; 2197 2198 case SYS_brk: 2199 rd=0; 2200 mem = realloc(mem, r[8]); 2201 memory_area = r[8]; 2202 if(option_flag & SYSTEMCALL_FLAG) 2203 fprintf(OUTFILE1, "brk (0x%08X) = %d", r[8],rd); 2204 break; 2205 2206 case SYS_ioctl: 2207 rd=ioctl(r[8], r[9], mem_address(r[10])); 2208 if(option_flag & SYSTEMCALL_FLAG) 2209 fprintf(OUTFILE1,"ioctl (%d, 0x%x, 0x%x) = %d", 2210 temp, r[9], r[10], rd); 2211 break; 2212 2213 case SYS_read: /* ok kis */ 2214 if(r[8]>1000){ 2215 rd=r[8]; 2216 if(option_flag & SYSTEMCALL_FLAG) 2217 fprintf(OUTFILE1,"read () do nothing"); 2218 break; 2219 } 2220 rd=read(r[8], (void *)mem_address(r[9]) ,(size_t)r[10]); 2221 if(option_flag & SYSTEMCALL_FLAG) 2222 fprintf(OUTFILE1, "read (%d,0x%x, %d) = %d", 2223 temp, mem_address(r[9]), r[10], rd); 2224 break; 2225 2226 case SYS_write: /* ok kis */ 2227 if(r[8]>1000){ 2228 rd=r[8]; 2229 if(option_flag & SYSTEMCALL_FLAG) 2230 fprintf(OUTFILE1,"write () do nothing"); 2231 break; 2232 } 2233 if(r[8]==1 && (option_flag & STDOUT_TO_FILE)){ 2234 if(fd_stdout==0){ 2235 unlink("stdout~"); /* delete file */ 2236 fd_stdout = open("stdout~", O_CREAT | O_WRONLY, 0644); 2237 } 2238 r[8]=fd_stdout; 2239 } 2240 2241 rd=write(r[8], (const void *)mem_address(r[9]),(size_t)r[10]); 2242 if(option_flag & SYSTEMCALL_FLAG) 2243 fprintf(OUTFILE1,"write (%d,0x%x,%d) = %d", 2244 temp, mem_address(r[9]),r[10],rd); 2245 break; 2246 2247 case SYS_lseek: 2248 rd=lseek(r[8],r[9],r[10]); 2249 if(option_flag & SYSTEMCALL_FLAG) 2250 fprintf(OUTFILE1, "lseek(%d, %d, %d) >> %d ", 2251 temp, r[9], r[10], rd); 2252 break; 2253 2254 case SYS_llseek: 2255 rd=lseek(r[8],r[9],r[10]); 2256 if(option_flag & SYSTEMCALL_FLAG) 2257 fprintf(OUTFILE1, "llseek(%d, %d, %d) >> %d ", 2258 temp, r[9], r[10], rd); 2259 break; 2260 2261 case SYS_open: /* open chenges c flag */ 2262 rd=open((char *)mem_address(r[8]),r[9],r[10]); 2263 if(option_flag & SYSTEMCALL_FLAG){ 2264 fprintf(OUTFILE1,"open (\"%s\", %d, 0%o) = %d", 2265 (char *)mem_address(r[8]), r[9], r[10], rd); 2266 fflush(OUTFILE1); 2267 } 2268 2269 break; 2270 2271 case SYS_close: /* this couse error ?? */ 2272 if(option_flag & SYSTEMCALL_FLAG) 2273 fprintf(OUTFILE1, "close (%d) = %d ",temp, rd); 2274 2275 if(r[8]==2){ 2276 rd = 0; /* standard err case */ 2277 if(option_flag & SYSTEMCALL_FLAG) 2278 fprintf(OUTFILE1, "close stderr ignored."); 2279 } 2280 else rd=close(r[8]); 2281 break; 2282 2283 2284 case SYS_sigaction: 2285 rd=sigaction(r[8], (const struct sigaction *)mem_address(r[9]), 2286 (struct sigaction *)mem_address(r[10])); 2287 if(option_flag & SYSTEMCALL_FLAG){ 2288 fprintf(OUTFILE1,"sigaction (0x%x, 0x%X, 0x%X) = %d", 2289 r[8], r[9], r[10], rd); 2290 } 2291 break; 2292 2293 default: 2294 fprintf(stderr,"System call =%d pc=%x,not implemented.\n", 2295 r[1],pc); 2296 exit(1); 2297 } 2298 2299 } 2300 if(rd==FALLMASK) 2301 {c=1; 2302 r[8]=errno; 2303 if(option_flag & SYSTEMCALL_FLAG) fprintf(OUTFILE1, "<%d> ",errno); 2304 } 2305 else 2306 {c=0; r[8] = rd;} 2307 2308 if(option_flag & SYSTEMCALL_FLAG){ 2309 fprintf(OUTFILE1, "\n"); 2310 fflush(OUTFILE1); 2311 } 2312 return 0; 2313 } 2314 /***** 1. type definitions *****/ 2315 typedef unsigned long long ULL; 2316 typedef int ADDR_TYPE; 2317 typedef int DATA_TYPE; 2318 2319 typedef struct architecture_state{ 2320 unsigned int annul; 2321 unsigned int psr; 2322 unsigned int fsr; 2323 } ARCH_STATE; 2324 2325 #define ENV_AREA_SIZE 0x2000 /* size of argc argv argp */ 2326 #define ENV_AREA_START 0x500 /* start of argv & argp */ 2327 #define MEM_AREA_SIZE 10000000 /* 10M memory area as you want*/ 2328 #define MEM_TEMP_SIZE 1000 /* temp mem used by syscall */ 2329 2330 #define bit31(N) (N >> 31) 2331 #define OUTFILE1 outfile /* stderr */ 2332 2333 #define FCCMASK 0xFFFFF3FF 2334 /*call:(format 1) */ 2335 #define OP 0xc0000000 2336 #define DISP30 0x3fffffff 2337 2338 #define MASK31 0x80000000 2339 2340 /*branch:(format 2)*/ 2341 #define A 0x20000000 2342 #define COND 0x1e000000 2343 #define OP2 0x1c00000 2344 #define DISP22 0x3fffff 2345 #define RD 0x3e000000 2346 #define IMM22 0x3fffff 2347 2348 /*others:(format 3)*/ 2349 #define OP3 0x1f80000 2350 #define RS1 0x7c000 2351 #define I 0x2000 2352 #define ASI 0x1fe0 2353 #define RS2 0x1f 2354 #define SIMM13 0x1fff 2355 #define BIT0_1 0x3 2356 2357 #define BIT0 0x1 2358 #define BIT1 0x2 2359 #define BIT2 0x4 2360 #define BIT3 0x8 2361 #define BIT4 0x10 2362 #define BIT5 0x20 2363 #define BIT6 0x40 2364 #define BIT7 0x80 2365 #define BIT8 0x100 2366 #define BIT9 0x200 2367 #define BIT10 0x400 2368 #define BIT11 0x800 2369 #define BIT12 0x1000 2370 #define BIT13 0x2000 2371 #define BIT14 0x4000 2372 #define BIT15 0x8000 2373 #define BIT16 0x10000 2374 #define BIT17 0x20000 2375 #define BIT18 0x40000 2376 #define BIT19 0x80000 2377 #define BIT20 0x100000 2378 #define BIT21 0x200000 2379 #define BIT22 0x400000 2380 #define BIT23 0x800000 2381 #define BIT24 0x1000000 2382 #define BIT25 0x2000000 2383 #define BIT26 0x4000000 2384 #define BIT27 0x8000000 2385 #define BIT28 0x10000000 2386 #define BIT29 0x20000000 2387 #define BIT30 0x40000000 2388 #define BIT31 0x80000000 2389 2390 #define EXTND22 0xffc00000 2391 #define EXTND16 0xffff0000 2392 #define EXTND13 0xffffe000 2393 #define EXTND8 0xffffff00 2394 #define HALFWDH 0xffff0000 2395 #define HALFWDL 0xffff 2396 #define BYTEH 0xff000000 2397 #define BYTEL 0xff 2398 #define USGNB 0x7f 2399 #define OPF 0x3fe0 2400 #define OPC 0x3fe0 2401 #define FALLMASK 0xFFFFFFFF 2402 2403 #define TRACE_FLAG 32768u 2404 #define VALUE_IR 16384u 2405 #define VALUE_ALL 8192u 2406 #define OUTFILE_PRINT_ST 4096u 2407 #define OUTFILE_PRINT_LD 2048u 2408 #define ICOUNT_FLAG 1024u 2409 #define VERBOSE_FLAG 512u 2410 #define OUTFILE_PRINT_LD_ST 256u 2411 #define STDOUT_TO_FILE 128u /* for command options */ 2412 #define OUTFILE_PRINT_FLAG 64u 2413 #define TICC_FLAG 32u 2414 #define DISTRIBUTION_FLAG 8u 2415 #define SYSTEMCALL_FLAG 4u 2416 #define DEBUG_FLAG 2u 2417 #define OUTFILE_FLAG 1u 2418 2419 /* 2420 #include 2421 #include 2422 #include 2423 #include 2424 #include 2425 #include 2426 #include 2427 #include 2428 #include 2429 #include 2430 #include 2431 #include 2432 #include 2433 #include 2434 #include 2435 #include 2436 #include 2437 #include 2438 #include 2439 2440 */ 2441 2442 #define __COPRO 200 /* temporal */ 2443 #define __FPOP 300 /* temporal */ 2444 2445 #define __ADD 7 2446 #define __ADDcc 8 2447 #define __ADDX 9 2448 #define __ADDXcc 10 2449 #define __AND 11 2450 #define __ANDcc 12 2451 #define __ANDN 13 2452 #define __ANDNcc 14 2453 #define __Bicc 15 2454 #define __CALL 17 2455 #define __CBccc 18 2456 #define __Cpop 20 2457 #define __FABSs 21 2458 #define __FADDd 22 2459 #define __FADDs 23 2460 #define __FADDx 24 2461 #define __FBfcc 25 2462 #define __FCMPd 27 2463 #define __FCMPEd 28 2464 #define __FCMPEs 29 2465 #define __FCMPEx 30 2466 #define __FCMPs 31 2467 #define __FCMPx 32 2468 #define __FDIVd 33 2469 #define __FDIVs 34 2470 #define __FDIVx 35 2471 #define __FdTOi 36 2472 #define __FdTOs 37 2473 #define __FdTOx 38 2474 #define __FiTOd 39 2475 #define __FiTOs 40 2476 #define __FiTOx 41 2477 #define __FMOVs 42 2478 #define __FMULd 43 2479 #define __FMULs 44 2480 #define __FMULx 45 2481 #define __FNEGs 46 2482 #define __FSQRTd 47 2483 #define __FSQRTs 48 2484 #define __FSQRTx 49 2485 #define __FsTOd 50 2486 #define __FsTOi 51 2487 #define __FsTOx 52 2488 #define __FSUBd 53 2489 #define __FSUBs 54 2490 #define __FSUBx 55 2491 #define __FxTOd 56 2492 #define __FxTOi 57 2493 #define __FxTOs 58 2494 #define __IFLUSH 59 2495 #define __JMPL 60 2496 #define __LD 61 2497 #define __LDA 62 2498 #define __LDC 63 2499 #define __LDCRS 64 2500 #define __LDD 65 2501 #define __LDDA 66 2502 #define __LDDC 67 2503 #define __LDDF 68 2504 #define __LDF 69 2505 #define __LDFSR 70 2506 #define __LDSB 71 2507 #define __LDSBA 72 2508 #define __LDSH 73 2509 #define __LDSHA 74 2510 #define __LDSTUB 75 2511 #define __LDSTUBA 76 2512 #define __LDUB 77 2513 #define __LDUBA 78 2514 #define __LDUH 79 2515 #define __LDUHA 80 2516 #define __MULScc 81 2517 #define __OR 82 2518 #define __ORcc 83 2519 #define __ORN 84 2520 #define __ORNcc 85 2521 #define __RDPSR 86 2522 #define __RDTBR 87 2523 #define __RDWIM 88 2524 #define __RDY 89 2525 #define __RESTORE 90 2526 #define __RETT 91 2527 /* #define 92 */ 2528 #define __SAVE 93 2529 #define __SETHI 94 2530 #define __SLL 95 2531 #define __SRA 96 2532 #define __SRL 97 2533 #define __ST 98 2534 #define __STA 99 2535 #define __STB 100 2536 #define __STBA 101 2537 #define __STC 102 2538 #define __STCSR 103 2539 #define __STD 104 2540 #define __STDA 105 2541 #define __STDC 106 2542 #define __STDCQ 107 2543 #define __STDF 108 2544 #define __STDFQ 109 2545 #define __STF 110 2546 #define __STFSR 111 2547 #define __STH 112 2548 #define __STHA 113 2549 #define __SUB 114 2550 #define __SUBcc 115 2551 #define __SUBX 116 2552 #define __SUBXcc 117 2553 #define __SWAP 118 2554 #define __SWAPA 119 2555 #define __TADDcc 120 2556 #define __TADDccTV 121 2557 #define __Ticc 122 2558 /* #define __ 123 */ 2559 #define __TSUBcc 124 2560 #define __TSUBccTV 125 2561 #define __UNIMP 126 2562 #define __WRPSR 127 2563 #define __WRTBR 128 2564 #define __WRWIM 129 2565 #define __WRY 130 2566 #define __XNOR 131 2567 #define __XNORcc 132 2568 #define __XOR 133 2569 #define __XORcc 134 2570 2571 2572 /** for get_class **/ 2573 2574 #define _DONT_CR 0 2575 #define _CONTROL 10 2576 #define _CON_SUB 11 2577 #define _LD 31 2578 #define _LD_SUB 32 2579 #define _ST 40 2580 #define _NOP 50 2581 #define _FLOAT 70 2582 #define _ARITH 80 2583 #define _TICC 90 2584 2585 /**********************************************************/ 2586 #define _ADD_ 7 2587 #define _ADDcc_ 8 2588 #define _ADDX_ 9 2589 #define _ADDXcc_ 10 2590 #define _AND_ 11 2591 #define _ANDcc_ 12 2592 #define _ANDN_ 13 2593 #define _ANDNcc_ 14 2594 #define _Bicc_ 15 2595 #define _CALL_ 17 2596 #define _CBccc_ 18 2597 #define _Cpop_ 20 2598 #define _FABSs_ 21 2599 #define _FADDd_ 22 2600 #define _FADDs_ 23 2601 #define _FADDx_ 24 2602 #define _FBfcc_ 25 2603 #define _FCMPd_ 27 2604 #define _FCMPEd_ 28 2605 #define _FCMPEs_ 29 2606 #define _FCMPEx_ 30 2607 #define _FCMPs_ 31 2608 #define _FCMPx_ 32 2609 #define _FDIVd_ 33 2610 #define _FDIVs_ 34 2611 #define _FDIVx_ 35 2612 #define _FdTOi_ 36 2613 #define _FdTOs_ 37 2614 #define _FdTOx_ 38 2615 #define _FiTOd_ 39 2616 #define _FiTOs_ 40 2617 #define _FiTOx_ 41 2618 #define _FMOVs_ 42 2619 #define _FMULd_ 43 2620 #define _FMULs_ 44 2621 #define _FMULx_ 45 2622 #define _FNEGs_ 46 2623 #define _FSQRTd_ 47 2624 #define _FSQRTs_ 48 2625 #define _FSQRTx_ 49 2626 #define _FsTOd_ 50 2627 #define _FsTOi_ 51 2628 #define _FsTOx_ 52 2629 #define _FSUBd_ 53 2630 #define _FSUBs_ 54 2631 #define _FSUBx_ 55 2632 #define _FxTOd_ 56 2633 #define _FxTOi_ 57 2634 #define _FxTOs_ 58 2635 #define _IFLUSH_ 59 2636 #define _JMPL_ 60 2637 #define _LD_ 61 2638 #define _LDA_ 62 2639 #define _LDC_ 63 2640 #define _LDCRS_ 64 2641 #define _LDD_ 65 2642 #define _LDDA_ 66 2643 #define _LDDC_ 67 2644 #define _LDDF_ 68 2645 #define _LDF_ 69 2646 #define _LDFSR_ 70 2647 #define _LDSB_ 71 2648 #define _LDSBA_ 72 2649 #define _LDSH_ 73 2650 #define _LDSHA_ 74 2651 #define _LDSTUB_ 75 2652 #define _LDSTUBA_ 76 2653 #define _LDUB_ 77 2654 #define _LDUBA_ 78 2655 #define _LDUH_ 79 2656 #define _LDUHA_ 80 2657 #define _MULScc_ 81 2658 #define _OR_ 82 2659 #define _ORcc_ 83 2660 #define _ORN_ 84 2661 #define _ORNcc_ 85 2662 #define _RDPSR_ 86 2663 #define _RDTBR_ 87 2664 #define _RDWIM_ 88 2665 #define _RDY_ 89 2666 #define _RESTORE_ 90 2667 #define _RETT_ 91 2668 #define _SAVE_ 93 2669 #define _SETHI_ 94 2670 #define _SLL_ 95 2671 #define _SRA_ 96 2672 #define _SRL_ 97 2673 #define _ST_ 98 2674 #define _STA_ 99 2675 #define _STB_ 100 2676 #define _STBA_ 101 2677 #define _STC_ 102 2678 #define _STCSR_ 103 2679 #define _STD_ 104 2680 #define _STDA_ 105 2681 #define _STDC_ 106 2682 #define _STDCQ_ 107 2683 #define _STDF_ 108 2684 #define _STDFQ_ 109 2685 #define _STF_ 110 2686 #define _STFSR_ 111 2687 #define _STH_ 112 2688 #define _STHA_ 113 2689 #define _SUB_ 114 2690 #define _SUBcc_ 115 2691 #define _SUBX_ 116 2692 #define _SUBXcc_ 117 2693 #define _SWAP_ 118 2694 #define _SWAPA_ 119 2695 #define _TADDcc_ 120 2696 #define _TADDccTV_ 121 2697 #define _Ticc_ 122 2698 #define _TSUBcc_ 124 2699 #define _TSUBccTV_ 125 2700 #define _UNIMP_ 126 2701 #define _WRPSR_ 127 2702 #define _WRTBR_ 128 2703 #define _WRWIM_ 129 2704 #define _WRY_ 130 2705 #define _XNOR_ 131 2706 #define _XNORcc_ 132 2707 #define _XOR_ 133 2708 #define _XORcc_ 134 2709 2710 2711 extern int fpops(); 2712 extern int fcmps(); 2713 extern void debugmode(); /* -d option is added */ 2714 extern void syscallmode(); /* -s option is added */ 2715 extern int Ticc(); 2716 2717 extern void initialize_memory(int argc, char **argv, char **argp); 2718 extern unsigned int load_word(unsigned int address); 2719 extern void store_word(unsigned int data, unsigned int address); 2720 extern unsigned int mem_address(unsigned int address); 2721 extern void store_byte(unsigned char data, unsigned int address);