projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Switch erc32 simulator copyright headers to FSF.
[deliverable/binutils-gdb.git] / sim / erc32 / func.c
1 /* Copyright (C) 1995-2015 Free Software Foundation, Inc.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 3 of the License, or
6 (at your option) any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12
13 You should have received a copy of the GNU General Public License
14 along with this program. If not, see <http://www.gnu.org/licenses/>. */
15
16 #include "config.h"
17 #include <signal.h>
18 #include <string.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <ctype.h>
22 #include "sis.h"
23 #include <dis-asm.h>
24 #include "sim-config.h"
25 #include <inttypes.h>
26
27 #define VAL(x) strtoul(x,(char **)NULL,0)
28
29 struct disassemble_info dinfo;
30 struct pstate sregs;
31 extern struct estate ebase;
32 int ctrl_c = 0;
33 int sis_verbose = 0;
34 char *sis_version = "2.7.5";
35 int nfp = 0;
36 int ift = 0;
37 int wrp = 0;
38 int rom8 = 0;
39 int uben = 0;
40 int termsave;
41 int sparclite = 0; /* emulating SPARClite instructions? */
42 int sparclite_board = 0; /* emulating SPARClite board RAM? */
43 char uart_dev1[128] = "";
44 char uart_dev2[128] = "";
45 extern int ext_irl;
46 uint32 last_load_addr = 0;
47
48 #ifdef ERRINJ
49 uint32 errcnt = 0;
50 uint32 errper = 0;
51 uint32 errtt = 0;
52 uint32 errftt = 0;
53 uint32 errmec = 0;
54 #endif
55
56 /* Forward declarations */
57
58 static int batch (struct pstate *sregs, char *fname);
59 static void set_rega (struct pstate *sregs, char *reg, uint32 rval);
60 static void disp_reg (struct pstate *sregs, char *reg);
61 static uint32 limcalc (float32 freq);
62 static void int_handler (int32 sig);
63 static void init_event (void);
64 static int disp_fpu (struct pstate *sregs);
65 static void disp_regs (struct pstate *sregs, int cwp);
66 static void disp_ctrl (struct pstate *sregs);
67 static void disp_mem (uint32 addr, uint32 len);
68
69 static int
70 batch(sregs, fname)
71 struct pstate *sregs;
72 char *fname;
73 {
74 FILE *fp;
75 char *lbuf = NULL;
76 size_t len = 0;
77 size_t slen;
78
79 if ((fp = fopen(fname, "r")) == NULL) {
80 fprintf(stderr, "couldn't open batch file %s\n", fname);
81 return 0;
82 }
83 while (getline(&lbuf, &len, fp) > -1) {
84 slen = strlen(lbuf);
85 if (slen && (lbuf[slen - 1] == '\n')) {
86 lbuf[slen - 1] = 0;
87 printf("sis> %s\n", lbuf);
88 exec_cmd(sregs, lbuf);
89 }
90 }
91 free(lbuf);
92 fclose(fp);
93 return 1;
94 }
95
96 void
97 set_regi(sregs, reg, rval)
98 struct pstate *sregs;
99 int32 reg;
100 uint32 rval;
101 {
102 uint32 cwp;
103
104 cwp = ((sregs->psr & 0x7) << 4);
105 if ((reg > 0) && (reg < 8)) {
106 sregs->g[reg] = rval;
107 } else if ((reg >= 8) && (reg < 32)) {
108 sregs->r[(cwp + reg) & 0x7f] = rval;
109 } else if ((reg >= 32) && (reg < 64)) {
110 sregs->fsi[reg - 32] = rval;
111 } else {
112 switch (reg) {
113 case 64:
114 sregs->y = rval;
115 break;
116 case 65:
117 sregs->psr = rval;
118 break;
119 case 66:
120 sregs->wim = rval;
121 break;
122 case 67:
123 sregs->tbr = rval;
124 break;
125 case 68:
126 sregs->pc = rval;
127 break;
128 case 69:
129 sregs->npc = rval;
130 break;
131 case 70:
132 sregs->fsr = rval;
133 set_fsr(rval);
134 break;
135 default:break;
136 }
137 }
138 }
139
140 void
141 get_regi(struct pstate * sregs, int32 reg, char *buf)
142 {
143 uint32 cwp;
144 uint32 rval = 0;
145
146 cwp = ((sregs->psr & 0x7) << 4);
147 if ((reg >= 0) && (reg < 8)) {
148 rval = sregs->g[reg];
149 } else if ((reg >= 8) && (reg < 32)) {
150 rval = sregs->r[(cwp + reg) & 0x7f];
151 } else if ((reg >= 32) && (reg < 64)) {
152 rval = sregs->fsi[reg - 32];
153 } else {
154 switch (reg) {
155 case 64:
156 rval = sregs->y;
157 break;
158 case 65:
159 rval = sregs->psr;
160 break;
161 case 66:
162 rval = sregs->wim;
163 break;
164 case 67:
165 rval = sregs->tbr;
166 break;
167 case 68:
168 rval = sregs->pc;
169 break;
170 case 69:
171 rval = sregs->npc;
172 break;
173 case 70:
174 rval = sregs->fsr;
175 break;
176 default:break;
177 }
178 }
179 buf[0] = (rval >> 24) & 0x0ff;
180 buf[1] = (rval >> 16) & 0x0ff;
181 buf[2] = (rval >> 8) & 0x0ff;
182 buf[3] = rval & 0x0ff;
183 }
184
185
186 static void
187 set_rega(sregs, reg, rval)
188 struct pstate *sregs;
189 char *reg;
190 uint32 rval;
191 {
192 uint32 cwp;
193 int32 err = 0;
194
195 cwp = ((sregs->psr & 0x7) << 4);
196 if (strcmp(reg, "psr") == 0)
197 sregs->psr = (rval = (rval & 0x00f03fff));
198 else if (strcmp(reg, "tbr") == 0)
199 sregs->tbr = (rval = (rval & 0xfffffff0));
200 else if (strcmp(reg, "wim") == 0)
201 sregs->wim = (rval = (rval & 0x0ff));
202 else if (strcmp(reg, "y") == 0)
203 sregs->y = rval;
204 else if (strcmp(reg, "pc") == 0)
205 sregs->pc = rval;
206 else if (strcmp(reg, "npc") == 0)
207 sregs->npc = rval;
208 else if (strcmp(reg, "fsr") == 0) {
209 sregs->fsr = rval;
210 set_fsr(rval);
211 } else if (strcmp(reg, "g0") == 0)
212 err = 2;
213 else if (strcmp(reg, "g1") == 0)
214 sregs->g[1] = rval;
215 else if (strcmp(reg, "g2") == 0)
216 sregs->g[2] = rval;
217 else if (strcmp(reg, "g3") == 0)
218 sregs->g[3] = rval;
219 else if (strcmp(reg, "g4") == 0)
220 sregs->g[4] = rval;
221 else if (strcmp(reg, "g5") == 0)
222 sregs->g[5] = rval;
223 else if (strcmp(reg, "g6") == 0)
224 sregs->g[6] = rval;
225 else if (strcmp(reg, "g7") == 0)
226 sregs->g[7] = rval;
227 else if (strcmp(reg, "o0") == 0)
228 sregs->r[(cwp + 8) & 0x7f] = rval;
229 else if (strcmp(reg, "o1") == 0)
230 sregs->r[(cwp + 9) & 0x7f] = rval;
231 else if (strcmp(reg, "o2") == 0)
232 sregs->r[(cwp + 10) & 0x7f] = rval;
233 else if (strcmp(reg, "o3") == 0)
234 sregs->r[(cwp + 11) & 0x7f] = rval;
235 else if (strcmp(reg, "o4") == 0)
236 sregs->r[(cwp + 12) & 0x7f] = rval;
237 else if (strcmp(reg, "o5") == 0)
238 sregs->r[(cwp + 13) & 0x7f] = rval;
239 else if (strcmp(reg, "o6") == 0)
240 sregs->r[(cwp + 14) & 0x7f] = rval;
241 else if (strcmp(reg, "o7") == 0)
242 sregs->r[(cwp + 15) & 0x7f] = rval;
243 else if (strcmp(reg, "l0") == 0)
244 sregs->r[(cwp + 16) & 0x7f] = rval;
245 else if (strcmp(reg, "l1") == 0)
246 sregs->r[(cwp + 17) & 0x7f] = rval;
247 else if (strcmp(reg, "l2") == 0)
248 sregs->r[(cwp + 18) & 0x7f] = rval;
249 else if (strcmp(reg, "l3") == 0)
250 sregs->r[(cwp + 19) & 0x7f] = rval;
251 else if (strcmp(reg, "l4") == 0)
252 sregs->r[(cwp + 20) & 0x7f] = rval;
253 else if (strcmp(reg, "l5") == 0)
254 sregs->r[(cwp + 21) & 0x7f] = rval;
255 else if (strcmp(reg, "l6") == 0)
256 sregs->r[(cwp + 22) & 0x7f] = rval;
257 else if (strcmp(reg, "l7") == 0)
258 sregs->r[(cwp + 23) & 0x7f] = rval;
259 else if (strcmp(reg, "i0") == 0)
260 sregs->r[(cwp + 24) & 0x7f] = rval;
261 else if (strcmp(reg, "i1") == 0)
262 sregs->r[(cwp + 25) & 0x7f] = rval;
263 else if (strcmp(reg, "i2") == 0)
264 sregs->r[(cwp + 26) & 0x7f] = rval;
265 else if (strcmp(reg, "i3") == 0)
266 sregs->r[(cwp + 27) & 0x7f] = rval;
267 else if (strcmp(reg, "i4") == 0)
268 sregs->r[(cwp + 28) & 0x7f] = rval;
269 else if (strcmp(reg, "i5") == 0)
270 sregs->r[(cwp + 29) & 0x7f] = rval;
271 else if (strcmp(reg, "i6") == 0)
272 sregs->r[(cwp + 30) & 0x7f] = rval;
273 else if (strcmp(reg, "i7") == 0)
274 sregs->r[(cwp + 31) & 0x7f] = rval;
275 else
276 err = 1;
277 switch (err) {
278 case 0:
279 printf("%s = %d (0x%08x)\n", reg, rval, rval);
280 break;
281 case 1:
282 printf("no such regiser: %s\n", reg);
283 break;
284 case 2:
285 printf("cannot set g0\n");
286 break;
287 default:
288 break;
289 }
290
291 }
292
293 static void
294 disp_reg(sregs, reg)
295 struct pstate *sregs;
296 char *reg;
297 {
298 if (strncmp(reg, "w",1) == 0)
299 disp_regs(sregs, VAL(&reg[1]));
300 }
301
302 #ifdef ERRINJ
303
304 void
305 errinj()
306 {
307 int err;
308
309 switch (err = (random() % 12)) {
310 case 0: errtt = 0x61; break;
311 case 1: errtt = 0x62; break;
312 case 2: errtt = 0x63; break;
313 case 3: errtt = 0x64; break;
314 case 4: errtt = 0x65; break;
315 case 5:
316 case 6:
317 case 7: errftt = err;
318 break;
319 case 8: errmec = 1; break;
320 case 9: errmec = 2; break;
321 case 10: errmec = 5; break;
322 case 11: errmec = 6; break;
323 }
324 errcnt++;
325 if (errper) event(errinj, 0, (random()%errper));
326 }
327
328 void
329 errinjstart()
330 {
331 if (errper) event(errinj, 0, (random()%errper));
332 }
333
334 #endif
335
336 static uint32
337 limcalc (freq)
338 float32 freq;
339 {
340 uint32 unit, lim;
341 double flim;
342 char *cmd1, *cmd2;
343
344 unit = 1;
345 lim = -1;
346 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
347 lim = VAL(cmd1);
348 if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL) {
349 if (strcmp(cmd2,"us")==0) unit = 1;
350 if (strcmp(cmd2,"ms")==0) unit = 1000;
351 if (strcmp(cmd2,"s")==0) unit = 1000000;
352 }
353 flim = (double) lim * (double) unit * (double) freq +
354 (double) ebase.simtime;
355 if ((flim > ebase.simtime) && (flim < 4294967296.0)) {
356 lim = (uint32) flim;
357 } else {
358 printf("error in expression\n");
359 lim = -1;
360 }
361 }
362 return lim;
363 }
364
365 int
366 exec_cmd(struct pstate *sregs, const char *cmd)
367 {
368 char *cmd1, *cmd2;
369 int32 stat;
370 uint32 len, i, clen, j;
371 static uint32 daddr = 0;
372 char *cmdsave, *cmdsave2 = NULL;
373
374 stat = OK;
375 cmdsave = strdup(cmd);
376 cmdsave2 = strdup (cmd);
377 if ((cmd1 = strtok (cmdsave2, " \t")) != NULL) {
378 clen = strlen(cmd1);
379 if (strncmp(cmd1, "bp", clen) == 0) {
380 for (i = 0; i < sregs->bptnum; i++) {
381 printf(" %d : 0x%08x\n", i + 1, sregs->bpts[i]);
382 }
383 } else if (strncmp(cmd1, "+bp", clen) == 0) {
384 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
385 sregs->bpts[sregs->bptnum] = VAL(cmd1) & ~0x3;
386 printf("added breakpoint %d at 0x%08x\n",
387 sregs->bptnum + 1, sregs->bpts[sregs->bptnum]);
388 sregs->bptnum += 1;
389 }
390 } else if (strncmp(cmd1, "-bp", clen) == 0) {
391 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
392 i = VAL(cmd1) - 1;
393 if ((i >= 0) && (i < sregs->bptnum)) {
394 printf("deleted breakpoint %d at 0x%08x\n", i + 1,
395 sregs->bpts[i]);
396 for (; i < sregs->bptnum - 1; i++) {
397 sregs->bpts[i] = sregs->bpts[i + 1];
398 }
399 sregs->bptnum -= 1;
400 }
401 }
402 } else if (strncmp(cmd1, "batch", clen) == 0) {
403 if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
404 printf("no file specified\n");
405 } else {
406 batch(sregs, cmd1);
407 }
408 } else if (strncmp(cmd1, "cont", clen) == 0) {
409 if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
410 stat = run_sim(sregs, UINT64_MAX, 0);
411 } else {
412 stat = run_sim(sregs, VAL(cmd1), 0);
413 }
414 daddr = sregs->pc;
415 sim_halt();
416 } else if (strncmp(cmd1, "debug", clen) == 0) {
417 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
418 sis_verbose = VAL(cmd1);
419 }
420 printf("Debug level = %d\n",sis_verbose);
421 } else if (strncmp(cmd1, "dis", clen) == 0) {
422 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
423 daddr = VAL(cmd1);
424 }
425 if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL) {
426 len = VAL(cmd2);
427 } else
428 len = 16;
429 printf("\n");
430 dis_mem(daddr, len, &dinfo);
431 printf("\n");
432 daddr += len * 4;
433 } else if (strncmp(cmd1, "echo", clen) == 0) {
434 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
435 printf("%s\n", (&cmdsave[clen+1]));
436 }
437 #ifdef ERRINJ
438 } else if (strncmp(cmd1, "error", clen) == 0) {
439 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
440 errper = VAL(cmd1);
441 if (errper) {
442 event(errinj, 0, (len = (random()%errper)));
443 printf("Error injection started with period %d\n",len);
444 }
445 } else printf("Injected errors: %d\n",errcnt);
446 #endif
447 } else if (strncmp(cmd1, "float", clen) == 0) {
448 stat = disp_fpu(sregs);
449 } else if (strncmp(cmd1, "go", clen) == 0) {
450 if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
451 len = last_load_addr;
452 } else {
453 len = VAL(cmd1);
454 }
455 sregs->pc = len & ~3;
456 sregs->npc = sregs->pc + 4;
457 if ((sregs->pc != 0) && (ebase.simtime == 0))
458 boot_init();
459 printf("resuming at 0x%08x\n",sregs->pc);
460 if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL) {
461 stat = run_sim(sregs, VAL(cmd2), 0);
462 } else {
463 stat = run_sim(sregs, UINT64_MAX, 0);
464 }
465 daddr = sregs->pc;
466 sim_halt();
467 } else if (strncmp(cmd1, "help", clen) == 0) {
468 gen_help();
469 } else if (strncmp(cmd1, "history", clen) == 0) {
470 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
471 sregs->histlen = VAL(cmd1);
472 if (sregs->histbuf != NULL)
473 free(sregs->histbuf);
474 sregs->histbuf = (struct histype *) calloc(sregs->histlen, sizeof(struct histype));
475 printf("trace history length = %d\n\r", sregs->histlen);
476 sregs->histind = 0;
477
478 } else {
479 j = sregs->histind;
480 for (i = 0; i < sregs->histlen; i++) {
481 if (j >= sregs->histlen)
482 j = 0;
483 printf(" %8d ", sregs->histbuf[j].time);
484 dis_mem(sregs->histbuf[j].addr, 1, &dinfo);
485 j++;
486 }
487 }
488
489 } else if (strncmp(cmd1, "load", clen) == 0) {
490 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
491 last_load_addr = bfd_load(cmd1);
492 while ((cmd1 = strtok(NULL, " \t\n\r")) != NULL)
493 last_load_addr = bfd_load(cmd1);
494 } else {
495 printf("load: no file specified\n");
496 }
497 } else if (strncmp(cmd1, "mem", clen) == 0) {
498 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL)
499 daddr = VAL(cmd1);
500 if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL)
501 len = VAL(cmd2);
502 else
503 len = 64;
504 disp_mem(daddr, len);
505 daddr += len;
506 } else if (strncmp(cmd1, "perf", clen) == 0) {
507 cmd1 = strtok(NULL, " \t\n\r");
508 if ((cmd1 != NULL) &&
509 (strncmp(cmd1, "reset", strlen(cmd1)) == 0)) {
510 reset_stat(sregs);
511 } else
512 show_stat(sregs);
513 } else if (strncmp(cmd1, "quit", clen) == 0) {
514 exit(0);
515 } else if (strncmp(cmd1, "reg", clen) == 0) {
516 cmd1 = strtok(NULL, " \t\n\r");
517 cmd2 = strtok(NULL, " \t\n\r");
518 if (cmd2 != NULL)
519 set_rega(sregs, cmd1, VAL(cmd2));
520 else if (cmd1 != NULL)
521 disp_reg(sregs, cmd1);
522 else {
523 disp_regs(sregs,sregs->psr);
524 disp_ctrl(sregs);
525 }
526 } else if (strncmp(cmd1, "reset", clen) == 0) {
527 ebase.simtime = 0;
528 reset_all();
529 reset_stat(sregs);
530 } else if (strncmp(cmd1, "run", clen) == 0) {
531 ebase.simtime = 0;
532 reset_all();
533 reset_stat(sregs);
534 if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
535 stat = run_sim(sregs, UINT64_MAX, 0);
536 } else {
537 stat = run_sim(sregs, VAL(cmd1), 0);
538 }
539 daddr = sregs->pc;
540 sim_halt();
541 } else if (strncmp(cmd1, "shell", clen) == 0) {
542 if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
543 if (system(&cmdsave[clen])) {
544 /* Silence unused return value warning. */
545 }
546 }
547 } else if (strncmp(cmd1, "step", clen) == 0) {
548 stat = run_sim(sregs, 1, 1);
549 daddr = sregs->pc;
550 sim_halt();
551 } else if (strncmp(cmd1, "tcont", clen) == 0) {
552 sregs->tlimit = limcalc(sregs->freq);
553 stat = run_sim(sregs, UINT64_MAX, 0);
554 daddr = sregs->pc;
555 sim_halt();
556 } else if (strncmp(cmd1, "tgo", clen) == 0) {
557 if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
558 len = last_load_addr;
559 } else {
560 len = VAL(cmd1);
561 sregs->tlimit = limcalc(sregs->freq);
562 }
563 sregs->pc = len & ~3;
564 sregs->npc = sregs->pc + 4;
565 printf("resuming at 0x%08x\n",sregs->pc);
566 stat = run_sim(sregs, UINT64_MAX, 0);
567 daddr = sregs->pc;
568 sim_halt();
569 } else if (strncmp(cmd1, "tlimit", clen) == 0) {
570 sregs->tlimit = limcalc(sregs->freq);
571 if (sregs->tlimit != (uint32) -1)
572 printf("simulation limit = %u (%.3f ms)\n",(uint32) sregs->tlimit,
573 sregs->tlimit / sregs->freq / 1000);
574 } else if (strncmp(cmd1, "tra", clen) == 0) {
575 if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
576 stat = run_sim(sregs, UINT64_MAX, 1);
577 } else {
578 stat = run_sim(sregs, VAL(cmd1), 1);
579 }
580 printf("\n");
581 daddr = sregs->pc;
582 sim_halt();
583 } else if (strncmp(cmd1, "trun", clen) == 0) {
584 ebase.simtime = 0;
585 reset_all();
586 reset_stat(sregs);
587 sregs->tlimit = limcalc(sregs->freq);
588 stat = run_sim(sregs, UINT64_MAX, 0);
589 daddr = sregs->pc;
590 sim_halt();
591 } else
592 printf("syntax error\n");
593 }
594 if (cmdsave2 != NULL)
595 free(cmdsave2);
596 if (cmdsave != NULL)
597 free(cmdsave);
598 return stat;
599 }
600
601
602 void
603 reset_stat(sregs)
604 struct pstate *sregs;
605 {
606 sregs->tottime = 0.0;
607 sregs->pwdtime = 0;
608 sregs->ninst = 0;
609 sregs->fholdt = 0;
610 sregs->holdt = 0;
611 sregs->icntt = 0;
612 sregs->finst = 0;
613 sregs->nstore = 0;
614 sregs->nload = 0;
615 sregs->nbranch = 0;
616 sregs->simstart = ebase.simtime;
617
618 }
619
620 void
621 show_stat(sregs)
622 struct pstate *sregs;
623 {
624 uint32 iinst;
625 uint32 stime;
626
627 if (sregs->tottime == 0.0)
628 sregs->tottime += 1E-6;
629 stime = ebase.simtime - sregs->simstart; /* Total simulated time */
630 #ifdef STAT
631
632 iinst = sregs->ninst - sregs->finst - sregs->nload - sregs->nstore -
633 sregs->nbranch;
634 #endif
635
636 printf("\n Cycles : %9" PRIu64 "\n\r", ebase.simtime - sregs->simstart);
637 printf(" Instructions : %9" PRIu64 "\n", sregs->ninst);
638
639 #ifdef STAT
640 printf(" integer : %9.2f %%\n", 100.0 * (float) iinst / (float) sregs->ninst);
641 printf(" load : %9.2f %%\n",
642 100.0 * (float) sregs->nload / (float) sregs->ninst);
643 printf(" store : %9.2f %%\n",
644 100.0 * (float) sregs->nstore / (float) sregs->ninst);
645 printf(" branch : %9.2f %%\n",
646 100.0 * (float) sregs->nbranch / (float) sregs->ninst);
647 printf(" float : %9.2f %%\n",
648 100.0 * (float) sregs->finst / (float) sregs->ninst);
649 printf(" Integer CPI : %9.2f\n",
650 ((float) (stime - sregs->pwdtime - sregs->fholdt - sregs->finst))
651 /
652 (float) (sregs->ninst - sregs->finst));
653 printf(" Float CPI : %9.2f\n",
654 ((float) sregs->fholdt / (float) sregs->finst) + 1.0);
655 #endif
656 printf(" Overall CPI : %9.2f\n",
657 (float) (stime - sregs->pwdtime) / (float) sregs->ninst);
658 printf("\n ERC32 performance (%4.1f MHz): %5.2f MOPS (%5.2f MIPS, %5.2f MFLOPS)\n",
659 sregs->freq, sregs->freq * (float) sregs->ninst / (float) (stime - sregs->pwdtime),
660 sregs->freq * (float) (sregs->ninst - sregs->finst) /
661 (float) (stime - sregs->pwdtime),
662 sregs->freq * (float) sregs->finst / (float) (stime - sregs->pwdtime));
663 printf(" Simulated ERC32 time : %.2f s\n",
664 (float) (ebase.simtime - sregs->simstart) / 1000000.0 / sregs->freq);
665 printf(" Processor utilisation : %.2f %%\n",
666 100.0 * (1.0 - ((float) sregs->pwdtime / (float) stime)));
667 printf(" Real-time performance : %.2f %%\n",
668 100.0 / (sregs->tottime / ((double) (stime) / (sregs->freq * 1.0E6))));
669 printf(" Simulator performance : %.2f MIPS\n",
670 (double)(sregs->ninst) / sregs->tottime / 1E6);
671 printf(" Used time (sys + user) : %.2f s\n\n", sregs->tottime);
672 }
673
674
675
676 void
677 init_bpt(sregs)
678 struct pstate *sregs;
679 {
680 sregs->bptnum = 0;
681 sregs->histlen = 0;
682 sregs->histind = 0;
683 sregs->histbuf = NULL;
684 sregs->tlimit = -1;
685 }
686
687 static void
688 int_handler(sig)
689 int32 sig;
690 {
691 if (sig != 2)
692 printf("\n\n Signal handler error (%d)\n\n", sig);
693 ctrl_c = 1;
694 }
695
696 void
697 init_signals()
698 {
699 typedef void (*PFI) ();
700 static PFI int_tab[2];
701
702 int_tab[0] = signal(SIGTERM, int_handler);
703 int_tab[1] = signal(SIGINT, int_handler);
704 }
705
706
707 extern struct disassemble_info dinfo;
708
709 struct estate ebase;
710 struct evcell evbuf[EVENT_MAX];
711 struct irqcell irqarr[16];
712
713 static int
714 disp_fpu(sregs)
715 struct pstate *sregs;
716 {
717
718 int i;
719 float t;
720
721 printf("\n fsr: %08X\n\n", sregs->fsr);
722
723 #ifdef HOST_LITTLE_ENDIAN
724 for (i = 0; i < 32; i++)
725 sregs->fdp[i ^ 1] = sregs->fs[i];
726 #endif
727
728 for (i = 0; i < 32; i++) {
729 t = sregs->fs[i];
730 printf(" f%02d %08x %14e ", i, sregs->fsi[i], sregs->fs[i]);
731 if (!(i & 1))
732 printf("%14e\n", sregs->fd[i >> 1]);
733 else
734 printf("\n");
735 }
736 printf("\n");
737 return OK;
738 }
739
740 static void
741 disp_regs(sregs,cwp)
742 struct pstate *sregs;
743 int cwp;
744 {
745
746 int i;
747
748 cwp = ((cwp & 0x7) << 4);
749 printf("\n\t INS LOCALS OUTS GLOBALS\n");
750 for (i = 0; i < 8; i++) {
751 printf(" %d: %08X %08X %08X %08X\n", i,
752 sregs->r[(cwp + i + 24) & 0x7f],
753 sregs->r[(cwp + i + 16) & 0x7f], sregs->r[(cwp + i + 8) & 0x7f],
754 sregs->g[i]);
755 }
756 }
757
758 static void print_insn_sparc_sis(uint32 addr, struct disassemble_info *info)
759 {
760 unsigned char i[4];
761
762 sis_memory_read(addr, i, 4);
763 dinfo.buffer_vma = addr;
764 dinfo.buffer_length = 4;
765 dinfo.buffer = i;
766 print_insn_sparc(addr, info);
767 }
768
769 static void
770 disp_ctrl(sregs)
771 struct pstate *sregs;
772 {
773
774 uint32 i;
775
776 printf("\n psr: %08X wim: %08X tbr: %08X y: %08X\n",
777 sregs->psr, sregs->wim, sregs->tbr, sregs->y);
778 sis_memory_read (sregs->pc, (char *) &i, 4);
779 printf ("\n pc: %08X = %08X ", sregs->pc, i);
780 print_insn_sparc_sis(sregs->pc, &dinfo);
781 sis_memory_read (sregs->npc, (char *) &i, 4);
782 printf ("\n npc: %08X = %08X ", sregs->npc, i);
783 print_insn_sparc_sis(sregs->npc, &dinfo);
784 if (sregs->err_mode)
785 printf("\n IU in error mode");
786 printf("\n\n");
787 }
788
789 static void
790 disp_mem(addr, len)
791 uint32 addr;
792 uint32 len;
793 {
794
795 uint32 i;
796 union {
797 unsigned char u8[4];
798 uint32 u32;
799 } data;
800 uint32 mem[4], j;
801 char *p;
802
803 for (i = addr & ~3; i < ((addr + len) & ~3); i += 16) {
804 printf("\n %8X ", i);
805 for (j = 0; j < 4; j++) {
806 sis_memory_read ((i + (j * 4)), data.u8, 4);
807 printf ("%08x ", data.u32);
808 mem[j] = data.u32;
809 }
810 printf(" ");
811 p = (char *) mem;
812 for (j = 0; j < 16; j++) {
813 if (isprint (p[j ^ EBT]))
814 putchar (p[j ^ EBT]);
815 else
816 putchar('.');
817 }
818 }
819 printf("\n\n");
820 }
821
822 void
823 dis_mem(addr, len, info)
824 uint32 addr;
825 uint32 len;
826 struct disassemble_info *info;
827 {
828 uint32 i;
829 union {
830 unsigned char u8[4];
831 uint32 u32;
832 } data;
833
834 for (i = addr & -3; i < ((addr & -3) + (len << 2)); i += 4) {
835 sis_memory_read (i, data.u8, 4);
836 printf (" %08x %08x ", i, data.u32);
837 print_insn_sparc_sis(i, info);
838 if (i >= 0xfffffffc) break;
839 printf("\n");
840 }
841 }
842
843 /* Add event to event queue */
844
845 void
846 event(cfunc, arg, delta)
847 void (*cfunc) ();
848 int32 arg;
849 uint64 delta;
850 {
851 struct evcell *ev1, *evins;
852
853 if (ebase.freeq == NULL) {
854 printf("Error, too many events in event queue\n");
855 return;
856 }
857 ev1 = &ebase.eq;
858 delta += ebase.simtime;
859 while ((ev1->nxt != NULL) && (ev1->nxt->time <= delta)) {
860 ev1 = ev1->nxt;
861 }
862 if (ev1->nxt == NULL) {
863 ev1->nxt = ebase.freeq;
864 ebase.freeq = ebase.freeq->nxt;
865 ev1->nxt->nxt = NULL;
866 } else {
867 evins = ebase.freeq;
868 ebase.freeq = ebase.freeq->nxt;
869 evins->nxt = ev1->nxt;
870 ev1->nxt = evins;
871 }
872 ev1->nxt->time = delta;
873 ev1->nxt->cfunc = cfunc;
874 ev1->nxt->arg = arg;
875 }
876
877 #if 0 /* apparently not used */
878 void
879 stop_event()
880 {
881 }
882 #endif
883
884 void
885 init_event()
886 {
887 int32 i;
888
889 ebase.eq.nxt = NULL;
890 ebase.freeq = evbuf;
891 for (i = 0; i < EVENT_MAX; i++) {
892 evbuf[i].nxt = &evbuf[i + 1];
893 }
894 evbuf[EVENT_MAX - 1].nxt = NULL;
895 }
896
897 void
898 set_int(level, callback, arg)
899 int32 level;
900 void (*callback) ();
901 int32 arg;
902 {
903 irqarr[level & 0x0f].callback = callback;
904 irqarr[level & 0x0f].arg = arg;
905 }
906
907 /* Advance simulator time */
908
909 void
910 advance_time(sregs)
911 struct pstate *sregs;
912 {
913
914 struct evcell *evrem;
915 void (*cfunc) ();
916 uint32 arg;
917 uint64 endtime;
918
919 #ifdef STAT
920 sregs->fholdt += sregs->fhold;
921 sregs->holdt += sregs->hold;
922 sregs->icntt += sregs->icnt;
923 #endif
924
925 endtime = ebase.simtime + sregs->icnt + sregs->hold + sregs->fhold;
926
927 while ((ebase.eq.nxt->time <= (endtime)) && (ebase.eq.nxt != NULL)) {
928 ebase.simtime = ebase.eq.nxt->time;
929 cfunc = ebase.eq.nxt->cfunc;
930 arg = ebase.eq.nxt->arg;
931 evrem = ebase.eq.nxt;
932 ebase.eq.nxt = ebase.eq.nxt->nxt;
933 evrem->nxt = ebase.freeq;
934 ebase.freeq = evrem;
935 cfunc(arg);
936 }
937 ebase.simtime = endtime;
938
939 }
940
941 uint32
942 now()
943 {
944 return ebase.simtime;
945 }
946
947
948 /* Advance time until an external interrupt is seen */
949
950 int
951 wait_for_irq()
952 {
953 struct evcell *evrem;
954 void (*cfunc) ();
955 int32 arg;
956 uint64 endtime;
957
958 if (ebase.eq.nxt == NULL)
959 printf("Warning: event queue empty - power-down mode not entered\n");
960 endtime = ebase.simtime;
961 while (!ext_irl && (ebase.eq.nxt != NULL)) {
962 ebase.simtime = ebase.eq.nxt->time;
963 cfunc = ebase.eq.nxt->cfunc;
964 arg = ebase.eq.nxt->arg;
965 evrem = ebase.eq.nxt;
966 ebase.eq.nxt = ebase.eq.nxt->nxt;
967 evrem->nxt = ebase.freeq;
968 ebase.freeq = evrem;
969 cfunc(arg);
970 if (ctrl_c) {
971 printf("\bwarning: power-down mode interrupted\n");
972 break;
973 }
974 }
975 sregs.pwdtime += ebase.simtime - endtime;
976 return ebase.simtime - endtime;
977 }
978
979 int
980 check_bpt(sregs)
981 struct pstate *sregs;
982 {
983 int32 i;
984
985 if ((sregs->bphit) || (sregs->annul))
986 return 0;
987 for (i = 0; i < (int32) sregs->bptnum; i++) {
988 if (sregs->pc == sregs->bpts[i])
989 return BPT_HIT;
990 }
991 return 0;
992 }
993
994 void
995 reset_all()
996 {
997 init_event(); /* Clear event queue */
998 init_regs(&sregs);
999 reset();
1000 #ifdef ERRINJ
1001 errinjstart();
1002 #endif
1003 }
1004
1005 void
1006 sys_reset()
1007 {
1008 reset_all();
1009 sregs.trap = 256; /* Force fake reset trap */
1010 }
1011
1012 void
1013 sys_halt()
1014 {
1015 sregs.trap = 257; /* Force fake halt trap */
1016 }
1017
1018 #include "ansidecl.h"
1019
1020 #include <stdarg.h>
1021
1022 #include "libiberty.h"
1023 #include "bfd.h"
1024
1025 #define min(A, B) (((A) < (B)) ? (A) : (B))
1026 #define LOAD_ADDRESS 0
1027
1028 int
1029 bfd_load (const char *fname)
1030 {
1031 asection *section;
1032 bfd *pbfd;
1033 const bfd_arch_info_type *arch;
1034 int i;
1035
1036 pbfd = bfd_openr(fname, 0);
1037
1038 if (pbfd == NULL) {
1039 printf("open of %s failed\n", fname);
1040 return -1;
1041 }
1042 if (!bfd_check_format(pbfd, bfd_object)) {
1043 printf("file %s doesn't seem to be an object file\n", fname);
1044 return -1;
1045 }
1046
1047 arch = bfd_get_arch_info (pbfd);
1048 if (sis_verbose)
1049 printf("loading %s:", fname);
1050 for (section = pbfd->sections; section; section = section->next) {
1051 if (bfd_get_section_flags(pbfd, section) & SEC_ALLOC) {
1052 bfd_vma section_address;
1053 unsigned long section_size;
1054 const char *section_name;
1055
1056 section_name = bfd_get_section_name(pbfd, section);
1057
1058 section_address = bfd_get_section_vma(pbfd, section);
1059 /*
1060 * Adjust sections from a.out files, since they don't carry their
1061 * addresses with.
1062 */
1063 if (bfd_get_flavour(pbfd) == bfd_target_aout_flavour) {
1064 if (strcmp (section_name, ".text") == 0)
1065 section_address = bfd_get_start_address (pbfd);
1066 else if (strcmp (section_name, ".data") == 0) {
1067 /* Read the first 8 bytes of the data section.
1068 There should be the string 'DaTa' followed by
1069 a word containing the actual section address. */
1070 struct data_marker
1071 {
1072 char signature[4]; /* 'DaTa' */
1073 unsigned char sdata[4]; /* &sdata */
1074 } marker;
1075 bfd_get_section_contents (pbfd, section, &marker, 0,
1076 sizeof (marker));
1077 if (strncmp (marker.signature, "DaTa", 4) == 0)
1078 {
1079 section_address = bfd_getb32 (marker.sdata);
1080 }
1081 }
1082 }
1083
1084 section_size = bfd_section_size(pbfd, section);
1085
1086 if (sis_verbose)
1087 printf("\nsection %s at 0x%08lx (0x%lx bytes)",
1088 section_name, section_address, section_size);
1089
1090 /* Text, data or lit */
1091 if (bfd_get_section_flags(pbfd, section) & SEC_LOAD) {
1092 file_ptr fptr;
1093
1094 fptr = 0;
1095
1096 while (section_size > 0) {
1097 char buffer[1024];
1098 int count;
1099
1100 count = min(section_size, 1024);
1101
1102 bfd_get_section_contents(pbfd, section, buffer, fptr, count);
1103
1104 for (i = 0; i < count; i++)
1105 sis_memory_write ((section_address + i) ^ EBT, &buffer[i], 1);
1106
1107 section_address += count;
1108 fptr += count;
1109 section_size -= count;
1110 }
1111 } else /* BSS */
1112 if (sis_verbose)
1113 printf("(not loaded)");
1114 }
1115 }
1116 if (sis_verbose)
1117 printf("\n");
1118
1119 return bfd_get_start_address (pbfd);
1120 }
1121
1122 double get_time (void)
1123 {
1124 double usec;
1125
1126 struct timeval tm;
1127
1128 gettimeofday (&tm, NULL);
1129 usec = ((double) tm.tv_sec) * 1E6 + ((double) tm.tv_usec);
1130 return usec / 1E6;
1131 }
GDB Binutils - Deliverables
This page took 0.123123 seconds and 5 git commands to generate.