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