Mercurial > hg > Members > kono > os9 > sbc09
annotate src/trace.c @ 86:4967d1acd34a
add sbc09.asm
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Mon, 20 Aug 2018 00:48:11 +0900 |
| parents | 9b661787d5ed |
| children | 6f7276831219 |
| 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 ) { | |
| 162 b->watch = watch; | |
| 21 | 163 if (b->count==-1) { // temporaly break point |
| 164 BPTR next = b->next; | |
| 165 free(b); | |
| 22 | 166 *prev = next; |
| 21 | 167 goto restart0; |
| 168 } | |
| 0 | 169 if (b->count) b->count--; |
| 170 if (b->count==0) { | |
| 171 goto restart0; | |
| 172 } | |
| 173 } | |
| 174 } | |
| 175 return; | |
| 176 } | |
| 177 if (stkskip) { // skip until return | |
| 38 | 178 #ifdef USE_MMU |
| 179 if (phymem[ppc]==0x3b||(phymem[ppc]==0x10&&phymem[ppc+1]==0x3f)) | |
| 180 goto restart0; | |
| 181 #else | |
| 182 if (mem[ppc]==0x3b||(mem[ppc]==0x10&&mem[ppc+1]==0x3f)) | |
| 183 goto restart0; | |
| 184 #endif | |
| 0 | 185 if (sreg < stkskip ) return; |
| 186 } | |
| 187 restart0: | |
| 188 stkskip = 0; | |
| 189 restore_term(); | |
| 9 | 190 #ifdef USE_MMU |
| 38 | 191 Byte *phyadr = phymem + ppc; |
| 9 | 192 prog = (char*)phyadr - pcreg; |
| 193 #endif | |
| 0 | 194 do_trace(stdout); |
| 195 if (trskip>1) { // show trace and step | |
| 196 trskip--; | |
| 35 | 197 int watch; // watch point |
| 0 | 198 set_term(escchar); |
| 199 return; | |
| 200 } | |
| 201 restart: | |
| 202 printf("v09>"); | |
| 28 | 203 fgets(s, sizeof(s)-1, stdin); |
| 204 s[strlen(s)-1] = 0; // chop | |
| 0 | 205 switch (s[0]) { |
| 64 | 206 case 'p': { |
| 207 int d = getarg(s+1,0); | |
| 208 printf("0x%x %d '%c'\n",d,d,(d<' '||d>0x7f)?' ':d); | |
| 209 goto restart; | |
| 210 } | |
| 21 | 211 case 'n': // step over |
| 212 if (nexti()) { | |
| 213 bpskip = -1; | |
| 214 break; | |
| 215 } | |
| 0 | 216 case 's': // one step trace |
| 217 trskip = 1; | |
| 218 if (s[1]) { | |
| 219 trskip = getarg(s+1,0); | |
| 220 } | |
| 221 bpskip = 0; | |
| 222 attention = escape = 1; | |
| 223 break; | |
| 224 case 'f': // finish this call (until stack pop) | |
| 225 stkskip = sreg + 2; | |
| 226 attention = escape = 1; | |
| 227 break; | |
| 84 | 228 case 'b': { // set break point |
| 229 char *next = s; | |
| 230 int page = -1; | |
| 231 if (next[1]=='p') { | |
| 232 next++; | |
| 233 if (next[1]) | |
| 234 page = getarg(next+1,&next); | |
| 235 } | |
| 236 if (next[1]) { | |
| 21 | 237 int count = 0; |
| 84 | 238 int adr = getarg(next+1,&next); |
| 21 | 239 if (next[0]) { |
| 240 count = getarg(next,&next); | |
| 241 } | |
| 84 | 242 setbreak(adr,count,page); |
| 21 | 243 } else { |
| 84 | 244 setbreak(pcreg,0,page); |
| 0 | 245 } |
| 246 bpskip = -1; | |
| 247 goto restart; | |
| 84 | 248 } |
| 28 | 249 case 'B': // break point list |
| 0 | 250 for(BPTR bp = breakpoint; bp ; bp = bp->next) { |
| 21 | 251 #ifdef USE_MMU |
| 35 | 252 printf("0x%x p=0x%x c=%d w=0x%x\n", bp->laddr, bp->address, bp->count, bp->watch); |
| 21 | 253 #else |
| 35 | 254 printf("0x%x c=%d w=0x%x\n", bp->address, bp->count,bp->watch); |
| 21 | 255 #endif |
| 0 | 256 } |
| 257 goto restart; | |
| 258 case 'd': // delte break point list | |
| 259 if (s[1]) { | |
| 260 int trskip = getarg(s+1,0); | |
| 261 BPTR *prev = &breakpoint; | |
| 22 | 262 for(BPTR bp = breakpoint; bp ; prev=&bp->next, bp = bp->next) { |
| 0 | 263 if (trskip-- == 0) { |
| 22 | 264 BPTR next = bp->next; |
| 21 | 265 free(bp); |
| 22 | 266 *prev = next; |
| 0 | 267 break; |
| 268 } | |
| 269 prev = &bp->next; | |
| 270 } | |
| 271 } | |
| 272 goto restart; | |
| 273 case 'c': // continue; | |
| 274 bpskip = -1; | |
| 275 attention = escape = 1; | |
| 276 if (s[1]) { | |
| 277 bpskip = getarg(s+1,0); | |
| 278 } | |
| 279 break; | |
| 59 | 280 /* |
| 281 * we should have disassembler for a mmu page | |
| 282 */ | |
| 28 | 283 case 'x': // dump |
| 64 | 284 { char d = 0; |
| 285 char p = 0; | |
| 286 char *next = s+1; | |
| 287 int len = 32; | |
| 288 int adr = pcreg; | |
| 289 if (*next=='i') { next++; d='i'; | |
| 290 } | |
| 291 if (*next=='p') { | |
| 292 p = 'p'; | |
| 293 next++; | |
| 28 | 294 if (next[0]) { |
| 295 page = getarg(next,&next); | |
| 296 } | |
| 297 } | |
| 298 if (next[0]) { | |
| 64 | 299 adr = getarg(next,&next); |
| 9 | 300 #ifdef USE_MMU |
| 84 | 301 if (d!='i') // disassembler may fail on page boundary |
| 302 adr -= adr &0xf; | |
| 9 | 303 #endif |
| 64 | 304 if (next[0]) { |
| 305 len = getarg(next,&next); | |
| 306 } | |
| 307 } | |
| 308 for(; len > 0 ; len-=16,adr+=16) { | |
| 309 Byte *phyadr = 0; | |
| 9 | 310 #ifdef USE_MMU |
| 64 | 311 if (p=='p') { |
| 312 phyadr = phymem + (page * 0x2000 + adr); | |
| 313 prog = (char*)phyadr - adr ; | |
| 314 } else { | |
| 315 phyadr = mem0(phymem,adr,mmu); | |
| 316 prog = (char*)phyadr - adr ; | |
| 317 } | |
| 318 if (phyadr > phymem+memsize) goto restart; | |
| 9 | 319 #else |
| 64 | 320 phyadr = mem+adr; |
| 321 if (phyadr > mem+0xffff) goto restart; | |
| 9 | 322 #endif |
| 64 | 323 if (d=='i') { |
| 79 | 324 adr = disasm(adr,adr+(len>16?16:len))-16; |
| 64 | 325 } else { |
| 326 hexadump(phyadr,len>16?16:len,adr,16); | |
| 327 } | |
| 328 } | |
| 0 | 329 goto restart; |
| 28 | 330 } |
| 0 | 331 case 'L': |
| 332 if (logfile) | |
| 333 fclose(logfile); | |
| 334 logfile = 0; | |
| 335 if (s[1]) { | |
| 1 | 336 int i=1; while(s[i]==' ') i++; |
| 337 logfile = fopen(s + i, "w"); | |
| 0 | 338 } |
| 64 | 339 goto restart; |
| 0 | 340 break; |
| 341 case 'S': | |
| 342 if (infile) | |
| 343 fclose(infile); | |
| 344 infile = 0; | |
| 345 if (s[1]) { | |
| 1 | 346 int i=1; while(s[i]==' ') i++; |
| 347 infile = fopen(s + i, "r"); | |
| 0 | 348 } |
| 64 | 349 goto restart; |
| 0 | 350 break; |
| 351 case 'h': | |
| 352 case '?': | |
| 353 printhelp(); | |
| 354 goto restart; | |
| 355 case 'X': | |
| 356 case 'q': | |
| 357 if (!xmstat) | |
| 358 do_exit(); | |
| 359 else { | |
| 360 xmstat = 0; | |
| 361 fclose(xfile); | |
| 362 xfile = 0; | |
| 363 } | |
| 64 | 364 goto restart; |
| 0 | 365 break; |
| 1 | 366 case '0': |
| 367 case '1': | |
| 368 { FILE **drv = &disk[ s[0]-'0'] ; | |
| 369 if (*drv) | |
| 370 fclose(*drv); | |
| 371 *drv = 0; | |
| 372 if (s[1]) { | |
| 373 int i=1; while(s[i]==' ') i++; | |
| 374 *drv = fopen(s + i, "r+b"); | |
| 375 if ( *drv == 0 ) { printf("can't open %s\n", &s[i]); } | |
| 376 } | |
| 377 } | |
| 64 | 378 goto restart; |
| 1 | 379 break; |
| 0 | 380 case 'U': |
| 381 if (xfile) | |
| 382 fclose(xfile); | |
| 383 xfile = 0; | |
| 384 if (s[1]) { | |
| 1 | 385 int i=1; while(s[i]==' ') i++; |
| 386 xfile = fopen(s + i, "rb"); | |
| 387 if ( xfile == 0 ) { printf("can't open %s\n", &s[i]); } | |
| 0 | 388 } |
| 389 if (xfile) | |
| 390 xmstat = 1; | |
| 391 else | |
| 392 xmstat = 0; | |
| 393 xidx = 0; | |
| 394 acknak = 21; | |
| 395 rcvdnak = EOF; | |
| 396 blocknum = 1; | |
| 64 | 397 goto restart; |
| 0 | 398 break; |
| 399 case 'D': | |
| 400 if (xfile) | |
| 401 fclose(xfile); | |
| 402 xfile = 0; | |
| 403 if (s[1]) { | |
| 1 | 404 int i=1; while(s[i]==' ') i++; |
| 405 xfile = fopen(s + i, "wb"); | |
| 406 if ( xfile == 0 ) { printf("can't open %s\n", &s[i]); } | |
| 0 | 407 } |
| 408 if (xfile) | |
| 409 xmstat = 2; | |
| 410 else | |
| 411 xmstat = 0; | |
| 412 xidx = 0; | |
| 413 acknak = 21; | |
| 414 blocknum = 1; | |
| 64 | 415 goto restart; |
| 0 | 416 break; |
| 417 case 'R': | |
| 418 pcreg = (mem[0xfffe] << 8) + mem[0xffff]; | |
| 13 | 419 bpskip = 0; |
| 24 | 420 #ifdef USE_MMU |
| 421 mmu = &mem[0xffa0]; | |
| 28 | 422 mem[0xffa7]=0x3f; |
| 24 | 423 #endif |
| 13 | 424 attention = escape = 1; |
| 59 | 425 // we have to reload romfile |
| 426 // readimage(); | |
| 64 | 427 goto restart; |
| 0 | 428 break; |
|
52
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
429 default: // one step trace |
|
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
430 trskip = 1; |
|
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
431 bpskip = 0; |
|
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
432 attention = escape = 1; |
| 0 | 433 } |
| 434 if (tracing||breakpoint||trskip||bpskip||stkskip) { attention = escape = 1; } | |
| 435 else attention = 0; | |
| 436 set_term(escchar); | |
| 437 } | |
| 438 | |
| 59 | 439 /* |
| 440 * keep break point / watch point in a list | |
| 441 */ | |
| 84 | 442 void setbreak(int adr, int count, int page) { |
| 21 | 443 BPTR bp = calloc(1,sizeof(BP)); |
| 444 bp->count = count; | |
| 22 | 445 bp->laddr = adr; |
| 446 bp->address = paddr(adr,mmu); | |
| 35 | 447 #ifdef USE_MMU |
| 84 | 448 if (page!=-1) { |
| 449 bp->address = page*0x2000 + adr; | |
| 450 } | |
|
52
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
451 if (bp->address >= memsize) { free(bp); return; } |
| 84 | 452 bp->watch = phymem[bp->address]; |
| 35 | 453 #else |
| 454 bp->watch = mem[adr]; | |
| 455 #endif | |
|
52
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
456 bp->next = breakpoint; |
|
51b437557f42
boot without disk image
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
38
diff
changeset
|
457 breakpoint = bp; |
| 21 | 458 } |
| 459 | |
| 59 | 460 /* |
| 64 | 461 * length of call instruction |
| 59 | 462 * |
| 64 | 463 * if next instruction is call or swi, put temporary break after the call instruction |
| 59 | 464 * (ignoring page boundary, sorry) |
| 465 */ | |
| 21 | 466 int nexti(void) { |
| 22 | 467 #ifdef USE_MMU |
| 468 int op1 = *mem0(phymem,pcreg,mmu); | |
| 469 int op2 = *mem0(phymem,pcreg+1,mmu); | |
| 470 #else | |
| 471 int op1 = mem[pcreg]; | |
| 472 int op2 = mem[pcreg+1]; | |
| 473 #endif | |
| 21 | 474 int ofs = 0; |
| 475 switch(op1) { | |
| 476 case 0x17: // LBSR | |
| 477 case 0xbd: // JSR extended | |
| 22 | 478 ofs=3; break; |
| 21 | 479 case 0x10: // page2 |
| 480 { | |
| 481 if (op2==0x3f) { // os9 system call | |
| 22 | 482 ofs=3; break; |
| 21 | 483 } |
| 484 } | |
|
29
3c14d647bb51
assembler and emulator fix
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
28
diff
changeset
|
485 break; |
| 21 | 486 case 0x11: // page3 |
| 487 { | |
| 488 if (op2==0x3f) { // SWI3 | |
| 22 | 489 ofs=2; break; |
| 21 | 490 } |
| 491 } | |
|
29
3c14d647bb51
assembler and emulator fix
Shinji KONO <kono@ie.u-ryukyu.ac.jp>
parents:
28
diff
changeset
|
492 break; |
| 21 | 493 case 0x3f: // SWI |
| 22 | 494 ofs=1; break; |
| 21 | 495 case 0x3c: // CWAI |
| 496 case 0x8d: // BSR | |
| 497 case 0x9d: // JSR direct | |
| 22 | 498 ofs=2; break; |
| 21 | 499 case 0xad: // JSR index |
| 500 { | |
| 501 if (op2<0x80) ofs = 2; // 5bit ofs | |
| 502 else switch (op2&0xf) { | |
| 503 case 8: case 0xc: | |
| 504 ofs = 3; break; | |
| 505 case 9: case 0xd: case 0xf: | |
| 506 ofs = 4; break; | |
| 507 default: | |
| 508 ofs = 2; break; | |
| 509 } | |
| 510 } | |
| 511 break; | |
| 512 } | |
| 84 | 513 if (ofs) setbreak(pcreg+ofs,-1,-1); |
| 22 | 514 return ofs; |
| 21 | 515 } |
| 516 | |
| 59 | 517 /* end */ |