Mercurial > hg > Members > kono > os9 > sbc09
annotate src/trace.c @ 138:6f7276831219
TL/1 use x and y register
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Mon, 07 Jan 2019 19:32:10 +0900 |
parents | 9b661787d5ed |
children | f524c0c95559 |
rev | line source |
---|---|
9 | 1 /* 6808 Simulator V092 |
20 | 2 * |
59 | 3 * 2018 Shinji KONO |
20 | 4 * tracer |
59 | 5 * |
0 | 6 */ |
7 | |
8 #include<stdio.h> | |
9 #include<stdlib.h> | |
10 #include<ctype.h> | |
11 #include<signal.h> | |
12 #include<sys/time.h> | |
13 | |
14 #include <unistd.h> | |
15 #include <fcntl.h> | |
16 #include <string.h> | |
1 | 17 #include <time.h> |
0 | 18 |
19 #ifdef USE_TERMIOS | |
20 #include <termios.h> | |
21 #endif | |
22 | |
23 #define engine extern | |
24 #include "v09.h" | |
25 | |
26 struct termios termsetting; | |
27 | |
28 int xmstat; /* 0= no XMODEM transfer, 1=send, 2=receiver */ | |
29 unsigned char xmbuf[132]; | |
30 int xidx; | |
31 int acknak; | |
32 int rcvdnak; | |
33 int blocknum; | |
34 | |
20 | 35 extern FILE *logfile; |
36 extern FILE *infile; | |
37 extern FILE *xfile; | |
38 extern FILE *disk[]; | |
0 | 39 |
40 extern void hexadump( unsigned char *b, int l, int loc, int w); | |
12
111e5defb8ab
boot is called, rti failed
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
11
diff
changeset
|
41 extern int disasm(int,int); |
20 | 42 extern void restore_term(void) ; |
43 | |
9 | 44 #ifdef USE_MMU |
45 extern char *prog ; // for disass | |
11 | 46 extern Byte * mem0(Byte *iphymem, Word adr, Byte *immu) ; |
21 | 47 extern int paddr(Word adr, Byte *immu) ; |
48 #else | |
49 #define paddr(a,m) (a) | |
9 | 50 #endif |
51 | |
0 | 52 void do_exit(void) { |
53 restore_term(); | |
54 exit(0); | |
55 } | |
56 | |
4 | 57 |
0 | 58 typedef struct bp { |
21 | 59 int address; // physical address |
60 int laddr; | |
0 | 61 int count; |
35 | 62 int watch; // watch point |
0 | 63 struct bp *next; |
64 } BP, *BPTR; | |
65 | |
66 BPTR breakpoint = 0; | |
67 int bpskip = 0; | |
68 int trskip = 0; | |
69 int stkskip = 0; | |
70 | |
64 | 71 int getterm(char *buf, char** next) { |
72 int value = 0; | |
73 while (*buf==' ') buf++; | |
74 if (*buf=='x') { value = xreg; buf++; *next = buf ; | |
75 } else if (*buf=='y') { value = yreg; buf++; *next = buf; | |
76 } else if (*buf=='u') { value = ureg; buf++; *next = buf; | |
77 } else if (*buf=='s') { value = sreg; buf++; *next = buf; | |
78 } else if (*buf=='p') { value = pcreg; buf++; *next = buf; | |
79 } else if (*buf=='d') { value = (*areg<<8)+*breg; buf++; *next = buf; | |
80 } else if (*buf=='a') { value = *areg; buf++; *next = buf; | |
81 } else if (*buf=='b') { value = *breg; buf++; *next = buf; | |
82 } else value = strtol(buf,next,0); | |
83 return value; | |
84 } | |
85 | |
0 | 86 int getarg(char *buf, char** next) { |
64 | 87 int value = 0; |
88 char *b = buf; | |
89 if (next==0) next = &b; | |
71 | 90 *next = buf; |
64 | 91 value=getterm(*next,next); |
92 for(;**next;) { | |
35 | 93 if ( **next == '+' ) { |
64 | 94 value += getterm(*next+1,next); |
35 | 95 } else if ( **next == '*' ) { |
64 | 96 value *= getterm(*next+1,next); |
35 | 97 } else if ( **next == '/' ) { |
64 | 98 value /= getterm(*next+1,next); |
35 | 99 } else if ( **next == '-' ) { |
64 | 100 value -= getterm(*next+1,next); |
35 | 101 } else if ( **next == '&' ) { |
64 | 102 value &= getterm(*next+1,next); |
35 | 103 } else if ( **next == '|' ) { |
64 | 104 value |= getterm(*next+1,next); |
105 } else if ( **next == '(' ) { | |
106 value = getarg(*next+1,next); | |
107 if(**next==')') *next=*next+1; | |
35 | 108 } else break; |
109 } | |
110 return value; | |
0 | 111 } |
112 | |
113 void printhelp(void) | |
114 { | |
115 printf( | |
64 | 116 "use 0x for hex inputs\n" |
0 | 117 " s [count] one step trace\n" |
118 " n step over\n" | |
119 " f finish this call (until stack pop)\n" | |
28 | 120 " b [adr] set break point (on current physical addreaa)\n" |
33 | 121 " B break point list\n" |
0 | 122 " d [n] delte break point list\n" |
123 " c [count] continue;\n" | |
64 | 124 " p data print\n" |
33 | 125 " x [adr] [count] dump\n" |
64 | 126 " xi [adr] [count] disassemble\n" |
9 | 127 #ifdef USE_MMU |
64 | 128 " x [p page] [offset] [count] dump physical memory\n" |
129 " xi [p page] [offset] [count] disassemble\n" | |
9 | 130 #endif |
1 | 131 " 0 file disk drive 0 image\n" |
132 " 1 file disk drive 1 image\n" | |
0 | 133 " L file start log to file\n" |
134 " S file set input file\n" | |
135 " X exit\n" | |
136 " q exit\n" | |
137 " U file upload from srecord file \n" | |
138 " D file download to srecord file \n" | |
139 " R do reset\n" | |
140 " h,? print this\n" | |
141 ); | |
142 } | |
143 | |
21 | 144 |
84 | 145 void setbreak(int adr,int count, int page) ; |
22 | 146 int nexti(void); |
21 | 147 |
0 | 148 void do_escape(void) { |
149 char s[80]; | |
28 | 150 int adr,page; |
38 | 151 int ppc = paddr(pcreg,mmu); |
0 | 152 if (bpskip) { // skip unbreak instruction |
153 bpskip--; | |
21 | 154 BPTR *prev = &breakpoint; |
22 | 155 for(BPTR b = breakpoint; b ; prev=&b->next, b=b->next ) { |
35 | 156 #ifdef USE_MMU |
157 int watch = phymem[b->address]; | |
158 #else | |
159 int watch = mem[b->address]; | |
160 #endif | |
161 if (ppc==b->address || b->watch != watch ) { | |
138
6f7276831219
TL/1 use x and y register
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
84
diff
changeset
|
162 if (b->watch != watch) |
6f7276831219
TL/1 use x and y register
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
84
diff
changeset
|
163 printf("%04x : %02x -> %02x ",b->address, b->watch ,watch); |
35 | 164 b->watch = watch; |
21 | 165 if (b->count==-1) { // temporaly break point |
166 BPTR next = b->next; | |
167 free(b); | |
22 | 168 *prev = next; |
21 | 169 goto restart0; |
170 } | |
0 | 171 if (b->count) b->count--; |
172 if (b->count==0) { | |
173 goto restart0; | |
174 } | |
175 } | |
176 } | |
177 return; | |
178 } | |
179 if (stkskip) { // skip until return | |
38 | 180 #ifdef USE_MMU |
181 if (phymem[ppc]==0x3b||(phymem[ppc]==0x10&&phymem[ppc+1]==0x3f)) | |
182 goto restart0; | |
183 #else | |
184 if (mem[ppc]==0x3b||(mem[ppc]==0x10&&mem[ppc+1]==0x3f)) | |
185 goto restart0; | |
186 #endif | |
0 | 187 if (sreg < stkskip ) return; |
188 } | |
189 restart0: | |
190 stkskip = 0; | |
191 restore_term(); | |
9 | 192 #ifdef USE_MMU |
38 | 193 Byte *phyadr = phymem + ppc; |
9 | 194 prog = (char*)phyadr - pcreg; |
195 #endif | |
0 | 196 do_trace(stdout); |
197 if (trskip>1) { // show trace and step | |
198 trskip--; | |
35 | 199 int watch; // watch point |
0 | 200 set_term(escchar); |
201 return; | |
202 } | |
203 restart: | |
204 printf("v09>"); | |
28 | 205 fgets(s, sizeof(s)-1, stdin); |
206 s[strlen(s)-1] = 0; // chop | |
0 | 207 switch (s[0]) { |
64 | 208 case 'p': { |
209 int d = getarg(s+1,0); | |
210 printf("0x%x %d '%c'\n",d,d,(d<' '||d>0x7f)?' ':d); | |
211 goto restart; | |
212 } | |
21 | 213 case 'n': // step over |
214 if (nexti()) { | |
215 bpskip = -1; | |
216 break; | |
217 } | |
0 | 218 case 's': // one step trace |
219 trskip = 1; | |
220 if (s[1]) { | |
221 trskip = getarg(s+1,0); | |
222 } | |
223 bpskip = 0; | |
224 attention = escape = 1; | |
225 break; | |
226 case 'f': // finish this call (until stack pop) | |
227 stkskip = sreg + 2; | |
228 attention = escape = 1; | |
229 break; | |
84 | 230 case 'b': { // set break point |
231 char *next = s; | |
232 int page = -1; | |
233 if (next[1]=='p') { | |
234 next++; | |
235 if (next[1]) | |
236 page = getarg(next+1,&next); | |
237 } | |
238 if (next[1]) { | |
21 | 239 int count = 0; |
84 | 240 int adr = getarg(next+1,&next); |
21 | 241 if (next[0]) { |
242 count = getarg(next,&next); | |
243 } | |
84 | 244 setbreak(adr,count,page); |
21 | 245 } else { |
84 | 246 setbreak(pcreg,0,page); |
0 | 247 } |
248 bpskip = -1; | |
249 goto restart; | |
84 | 250 } |
28 | 251 case 'B': // break point list |
0 | 252 for(BPTR bp = breakpoint; bp ; bp = bp->next) { |
21 | 253 #ifdef USE_MMU |
35 | 254 printf("0x%x p=0x%x c=%d w=0x%x\n", bp->laddr, bp->address, bp->count, bp->watch); |
21 | 255 #else |
35 | 256 printf("0x%x c=%d w=0x%x\n", bp->address, bp->count,bp->watch); |
21 | 257 #endif |
0 | 258 } |
259 goto restart; | |
260 case 'd': // delte break point list | |
261 if (s[1]) { | |
262 int trskip = getarg(s+1,0); | |
263 BPTR *prev = &breakpoint; | |
22 | 264 for(BPTR bp = breakpoint; bp ; prev=&bp->next, bp = bp->next) { |
0 | 265 if (trskip-- == 0) { |
22 | 266 BPTR next = bp->next; |
21 | 267 free(bp); |
22 | 268 *prev = next; |
0 | 269 break; |
270 } | |
271 prev = &bp->next; | |
272 } | |
273 } | |
274 goto restart; | |
275 case 'c': // continue; | |
276 bpskip = -1; | |
277 attention = escape = 1; | |
278 if (s[1]) { | |
279 bpskip = getarg(s+1,0); | |
280 } | |
281 break; | |
59 | 282 /* |
283 * we should have disassembler for a mmu page | |
284 */ | |
28 | 285 case 'x': // dump |
64 | 286 { char d = 0; |
287 char p = 0; | |
288 char *next = s+1; | |
289 int len = 32; | |
290 int adr = pcreg; | |
291 if (*next=='i') { next++; d='i'; | |
292 } | |
293 if (*next=='p') { | |
294 p = 'p'; | |
295 next++; | |
28 | 296 if (next[0]) { |
297 page = getarg(next,&next); | |
298 } | |
299 } | |
300 if (next[0]) { | |
64 | 301 adr = getarg(next,&next); |
9 | 302 #ifdef USE_MMU |
84 | 303 if (d!='i') // disassembler may fail on page boundary |
304 adr -= adr &0xf; | |
9 | 305 #endif |
64 | 306 if (next[0]) { |
307 len = getarg(next,&next); | |
308 } | |
309 } | |
310 for(; len > 0 ; len-=16,adr+=16) { | |
311 Byte *phyadr = 0; | |
9 | 312 #ifdef USE_MMU |
64 | 313 if (p=='p') { |
314 phyadr = phymem + (page * 0x2000 + adr); | |
315 prog = (char*)phyadr - adr ; | |
316 } else { | |
317 phyadr = mem0(phymem,adr,mmu); | |
318 prog = (char*)phyadr - adr ; | |
319 } | |
320 if (phyadr > phymem+memsize) goto restart; | |
9 | 321 #else |
64 | 322 phyadr = mem+adr; |
323 if (phyadr > mem+0xffff) goto restart; | |
9 | 324 #endif |
64 | 325 if (d=='i') { |
79 | 326 adr = disasm(adr,adr+(len>16?16:len))-16; |
64 | 327 } else { |
328 hexadump(phyadr,len>16?16:len,adr,16); | |
329 } | |
330 } | |
0 | 331 goto restart; |
28 | 332 } |
0 | 333 case 'L': |
334 if (logfile) | |
335 fclose(logfile); | |
336 logfile = 0; | |
337 if (s[1]) { | |
1 | 338 int i=1; while(s[i]==' ') i++; |
339 logfile = fopen(s + i, "w"); | |
0 | 340 } |
64 | 341 goto restart; |
0 | 342 break; |
343 case 'S': | |
344 if (infile) | |
345 fclose(infile); | |
346 infile = 0; | |
347 if (s[1]) { | |
1 | 348 int i=1; while(s[i]==' ') i++; |
349 infile = fopen(s + i, "r"); | |
0 | 350 } |
64 | 351 goto restart; |
0 | 352 break; |
353 case 'h': | |
354 case '?': | |
355 printhelp(); | |
356 goto restart; | |
357 case 'X': | |
358 case 'q': | |
359 if (!xmstat) | |
360 do_exit(); | |
361 else { | |
362 xmstat = 0; | |
363 fclose(xfile); | |
364 xfile = 0; | |
365 } | |
64 | 366 goto restart; |
0 | 367 break; |
1 | 368 case '0': |
369 case '1': | |
370 { FILE **drv = &disk[ s[0]-'0'] ; | |
371 if (*drv) | |
372 fclose(*drv); | |
373 *drv = 0; | |
374 if (s[1]) { | |
375 int i=1; while(s[i]==' ') i++; | |
376 *drv = fopen(s + i, "r+b"); | |
377 if ( *drv == 0 ) { printf("can't open %s\n", &s[i]); } | |
378 } | |
379 } | |
64 | 380 goto restart; |
1 | 381 break; |
0 | 382 case 'U': |
383 if (xfile) | |
384 fclose(xfile); | |
385 xfile = 0; | |
386 if (s[1]) { | |
1 | 387 int i=1; while(s[i]==' ') i++; |
388 xfile = fopen(s + i, "rb"); | |
389 if ( xfile == 0 ) { printf("can't open %s\n", &s[i]); } | |
0 | 390 } |
391 if (xfile) | |
392 xmstat = 1; | |
393 else | |
394 xmstat = 0; | |
395 xidx = 0; | |
396 acknak = 21; | |
397 rcvdnak = EOF; | |
398 blocknum = 1; | |
64 | 399 goto restart; |
0 | 400 break; |
401 case 'D': | |
402 if (xfile) | |
403 fclose(xfile); | |
404 xfile = 0; | |
405 if (s[1]) { | |
1 | 406 int i=1; while(s[i]==' ') i++; |
407 xfile = fopen(s + i, "wb"); | |
408 if ( xfile == 0 ) { printf("can't open %s\n", &s[i]); } | |
0 | 409 } |
410 if (xfile) | |
411 xmstat = 2; | |
412 else | |
413 xmstat = 0; | |
414 xidx = 0; | |
415 acknak = 21; | |
416 blocknum = 1; | |
64 | 417 goto restart; |
0 | 418 break; |
419 case 'R': | |
420 pcreg = (mem[0xfffe] << 8) + mem[0xffff]; | |
13 | 421 bpskip = 0; |
24 | 422 #ifdef USE_MMU |
423 mmu = &mem[0xffa0]; | |
28 | 424 mem[0xffa7]=0x3f; |
24 | 425 #endif |
13 | 426 attention = escape = 1; |
59 | 427 // we have to reload romfile |
428 // readimage(); | |
64 | 429 goto restart; |
0 | 430 break; |
52
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
431 default: // one step trace |
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
432 trskip = 1; |
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
433 bpskip = 0; |
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
434 attention = escape = 1; |
0 | 435 } |
436 if (tracing||breakpoint||trskip||bpskip||stkskip) { attention = escape = 1; } | |
437 else attention = 0; | |
438 set_term(escchar); | |
439 } | |
440 | |
59 | 441 /* |
442 * keep break point / watch point in a list | |
443 */ | |
84 | 444 void setbreak(int adr, int count, int page) { |
21 | 445 BPTR bp = calloc(1,sizeof(BP)); |
446 bp->count = count; | |
22 | 447 bp->laddr = adr; |
448 bp->address = paddr(adr,mmu); | |
35 | 449 #ifdef USE_MMU |
84 | 450 if (page!=-1) { |
451 bp->address = page*0x2000 + adr; | |
452 } | |
52
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
453 if (bp->address >= memsize) { free(bp); return; } |
84 | 454 bp->watch = phymem[bp->address]; |
35 | 455 #else |
456 bp->watch = mem[adr]; | |
457 #endif | |
52
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
458 bp->next = breakpoint; |
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
459 breakpoint = bp; |
21 | 460 } |
461 | |
59 | 462 /* |
64 | 463 * length of call instruction |
59 | 464 * |
64 | 465 * if next instruction is call or swi, put temporary break after the call instruction |
59 | 466 * (ignoring page boundary, sorry) |
467 */ | |
21 | 468 int nexti(void) { |
22 | 469 #ifdef USE_MMU |
470 int op1 = *mem0(phymem,pcreg,mmu); | |
471 int op2 = *mem0(phymem,pcreg+1,mmu); | |
472 #else | |
473 int op1 = mem[pcreg]; | |
474 int op2 = mem[pcreg+1]; | |
475 #endif | |
21 | 476 int ofs = 0; |
477 switch(op1) { | |
478 case 0x17: // LBSR | |
479 case 0xbd: // JSR extended | |
22 | 480 ofs=3; break; |
21 | 481 case 0x10: // page2 |
482 { | |
483 if (op2==0x3f) { // os9 system call | |
22 | 484 ofs=3; break; |
21 | 485 } |
486 } | |
29
3c14d647bb51
assembler and emulator fix
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
28
diff
changeset
|
487 break; |
21 | 488 case 0x11: // page3 |
489 { | |
490 if (op2==0x3f) { // SWI3 | |
22 | 491 ofs=2; break; |
21 | 492 } |
493 } | |
29
3c14d647bb51
assembler and emulator fix
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
28
diff
changeset
|
494 break; |
21 | 495 case 0x3f: // SWI |
22 | 496 ofs=1; break; |
21 | 497 case 0x3c: // CWAI |
498 case 0x8d: // BSR | |
499 case 0x9d: // JSR direct | |
22 | 500 ofs=2; break; |
21 | 501 case 0xad: // JSR index |
502 { | |
503 if (op2<0x80) ofs = 2; // 5bit ofs | |
504 else switch (op2&0xf) { | |
505 case 8: case 0xc: | |
506 ofs = 3; break; | |
507 case 9: case 0xd: case 0xf: | |
508 ofs = 4; break; | |
509 default: | |
510 ofs = 2; break; | |
511 } | |
512 } | |
513 break; | |
514 } | |
84 | 515 if (ofs) setbreak(pcreg+ofs,-1,-1); |
22 | 516 return ofs; |
21 | 517 } |
518 | |
59 | 519 /* end */ |