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