| 1 | /* Code generator for the Hitachi H8/300 architecture simulator. |
| 2 | |
| 3 | Written by Steve Chamberlain of Cygnus Support. |
| 4 | sac@cygnus.com |
| 5 | |
| 6 | This file is part of H8/300 sim |
| 7 | |
| 8 | |
| 9 | THIS SOFTWARE IS NOT COPYRIGHTED |
| 10 | |
| 11 | Cygnus offers the following for use in the public domain. Cygnus |
| 12 | makes no warranty with regard to the software or it's performance |
| 13 | and the user accepts the software "AS IS" with all faults. |
| 14 | |
| 15 | CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO |
| 16 | THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
| 17 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. |
| 18 | |
| 19 | */ |
| 20 | |
| 21 | /* This program reads the H8/300 opcode table and writes out |
| 22 | a large switch statement to understand the opcodes (with ifs if |
| 23 | there is more than one opcode per case) and code to do the stuff */ |
| 24 | |
| 25 | #include <stdio.h> |
| 26 | |
| 27 | #define DEFINE_TABLE |
| 28 | #define INSIM |
| 29 | #include"opcode/h8300.h" |
| 30 | |
| 31 | #define MAXSAME 140 |
| 32 | |
| 33 | #define PTWO 256 |
| 34 | static struct h8_opcode *h8_opcodes_sorted[PTWO][MAXSAME]; |
| 35 | |
| 36 | char *cs = "/*"; |
| 37 | char *ce = "*/"; |
| 38 | |
| 39 | /* How to get at nibble n from the instruction */ |
| 40 | char *nibs[] = |
| 41 | { |
| 42 | "foo", |
| 43 | "(b0&0xf)", |
| 44 | "((b1>>4)&0xf)", |
| 45 | "((b1)&0xf)", |
| 46 | "((pc[1]>>12)&0xf)", |
| 47 | "((pc[1]>>8)&0xf)", |
| 48 | "((pc[1]>>4)&0xf)", |
| 49 | "((pc[1])&0xf)", |
| 50 | 0, 0}; |
| 51 | |
| 52 | /* how to get at the 3 bit immediate in the instruction */ |
| 53 | char *imm3[] = |
| 54 | {"foo", |
| 55 | "foo", |
| 56 | "((b1>>4)&0x7)", |
| 57 | "foo", |
| 58 | "foo", |
| 59 | "foo", |
| 60 | "(pc[1]>>4)&0x7"}; |
| 61 | |
| 62 | /* How to get at a byte register from an index in the instruction at |
| 63 | nibble n */ |
| 64 | char *breg[] = |
| 65 | {"foo", |
| 66 | "*(blow[b0])", |
| 67 | "*(bhigh[b1])", |
| 68 | "*(blow[b1])", |
| 69 | 0, 0, |
| 70 | "*(bhigh[pc[1]>>8])"}; |
| 71 | |
| 72 | /* How to get at a word register from an index in the instruction at |
| 73 | nibble n */ |
| 74 | |
| 75 | char *wreg[] = |
| 76 | {"foo", |
| 77 | "*(wlow[b0])", |
| 78 | "*(whigh[b1])", |
| 79 | "*(wlow[b1])"}; |
| 80 | |
| 81 | #define sorted_key noperands |
| 82 | |
| 83 | /* sort the opcode table into h8_opcodes_sorted[0..255] */ |
| 84 | static void |
| 85 | init () |
| 86 | { |
| 87 | unsigned int i; |
| 88 | struct h8_opcode *p; |
| 89 | |
| 90 | for (p = h8_opcodes; p->name; p++) |
| 91 | { |
| 92 | int n1 = 0; |
| 93 | int n2 = 0; |
| 94 | int j; |
| 95 | #if 0 |
| 96 | for (j = 0; p->data.nib[j] != E; j++) |
| 97 | { |
| 98 | if ((int) p->data.nib[j] == ABS16ORREL8SRC) |
| 99 | p->data.nib[j] = ABS16SRC; |
| 100 | if ((int) p->data.nib[j] == ABS16OR8SRC) |
| 101 | p->data.nib[j] = ABS16SRC; |
| 102 | if ((int) p->data.nib[j] == ABS16OR8DST) |
| 103 | p->data.nib[j] = ABS16DST; |
| 104 | } |
| 105 | #endif |
| 106 | |
| 107 | if ((int) p->data.nib[0] < 16) |
| 108 | { |
| 109 | n1 = (int) p->data.nib[0]; |
| 110 | } |
| 111 | else |
| 112 | n1 = 0; |
| 113 | if ((int) p->data.nib[1] < 16) |
| 114 | { |
| 115 | n2 = (int) p->data.nib[1]; |
| 116 | } |
| 117 | else |
| 118 | n2 = 0; |
| 119 | for (i = 0; i < MAXSAME; i++) |
| 120 | { |
| 121 | int j = /* ((n3 >> 3) * 512) + ((n4 >> 3) * 256) + */ n1 * 16 + n2; |
| 122 | |
| 123 | if (h8_opcodes_sorted[j][i] == (struct h8_opcode *) NULL) |
| 124 | { |
| 125 | h8_opcodes_sorted[j][i] = p; |
| 126 | p->sorted_key = j; |
| 127 | break; |
| 128 | } |
| 129 | } |
| 130 | |
| 131 | if (i == MAXSAME) |
| 132 | abort (); |
| 133 | |
| 134 | /* Just make sure there are an even number of nibbles in it, and |
| 135 | that the count is the same s the length */ |
| 136 | for (i = 0; p->data.nib[i] != E; i++) |
| 137 | /*EMPTY*/ ; |
| 138 | if (i & 1) |
| 139 | abort (); |
| 140 | p->length = i / 2; |
| 141 | } |
| 142 | for (i = 0; i < PTWO; i++) |
| 143 | { |
| 144 | if (h8_opcodes_sorted[i][0]) |
| 145 | p = h8_opcodes_sorted[i][0]; |
| 146 | else |
| 147 | h8_opcodes_sorted[i][0] = p; |
| 148 | } |
| 149 | } |
| 150 | |
| 151 | /* decode the lvalues, creating a pointer in real space to object - |
| 152 | remember if the thing has to be swapped out of where it is */ |
| 153 | |
| 154 | |
| 155 | int swap[2]; |
| 156 | |
| 157 | lval (p) |
| 158 | struct h8_opcode *p; |
| 159 | { |
| 160 | int i; |
| 161 | |
| 162 | for (i = 0; p->data.nib[i] != E; i++) |
| 163 | { |
| 164 | int x = p->data.nib[i]; |
| 165 | int size; |
| 166 | int op; |
| 167 | op = (x & DST) ? 1 : 0; |
| 168 | |
| 169 | switch (x & SIZE) |
| 170 | { |
| 171 | case L_32: |
| 172 | size = 32; |
| 173 | break; |
| 174 | case L_16: |
| 175 | size = 16; |
| 176 | break; |
| 177 | case L_8: |
| 178 | size = 8; |
| 179 | break; |
| 180 | default: |
| 181 | size = 1234; |
| 182 | } |
| 183 | |
| 184 | if (x & REG) |
| 185 | { |
| 186 | printf ("ir%d = GET_LVAL_%d_REG(%d);\n", op, size, i); |
| 187 | } |
| 188 | else if (x & IMM) |
| 189 | { |
| 190 | printf ("/* Imm has no lvalue */\n"); |
| 191 | } |
| 192 | |
| 193 | } |
| 194 | |
| 195 | |
| 196 | |
| 197 | } |
| 198 | |
| 199 | void |
| 200 | decode (p, fetch, size) |
| 201 | struct h8_opcode *p; |
| 202 | int fetch; |
| 203 | int size; |
| 204 | { |
| 205 | if (fetch) |
| 206 | { |
| 207 | lval (p); |
| 208 | } |
| 209 | |
| 210 | } |
| 211 | |
| 212 | |
| 213 | |
| 214 | static void |
| 215 | esleep () |
| 216 | { |
| 217 | printf ("saved_state.exception = SIGSTOP;\n"); |
| 218 | } |
| 219 | |
| 220 | static void |
| 221 | mov (p, s, sz) |
| 222 | struct h8_opcode *p; |
| 223 | char *s; |
| 224 | int sz; |
| 225 | { |
| 226 | printf ("dst = srca;\n"); |
| 227 | } |
| 228 | |
| 229 | static void |
| 230 | andc (p) |
| 231 | struct h8_opcode *p; |
| 232 | { |
| 233 | printf ("SET_CCR(GET_CCR() & srca);\n"); |
| 234 | } |
| 235 | |
| 236 | static void |
| 237 | addx (p) |
| 238 | struct h8_opcode *p; |
| 239 | { |
| 240 | printf ("dst = srca + srcb+ (c != 0);\n"); |
| 241 | } |
| 242 | |
| 243 | static void |
| 244 | subx (p) |
| 245 | struct h8_opcode *p; |
| 246 | { |
| 247 | printf ("dst = srcb - srca - (c != 0);\n"); |
| 248 | } |
| 249 | |
| 250 | static void |
| 251 | add (p, s, sz) |
| 252 | struct h8_opcode *p; |
| 253 | char *s; |
| 254 | int sz; |
| 255 | { |
| 256 | printf ("%s;\n", s); |
| 257 | } |
| 258 | |
| 259 | static void |
| 260 | adds (p, s) |
| 261 | struct h8_opcode *p; |
| 262 | char *s; |
| 263 | { |
| 264 | printf ("%s;\n", s); |
| 265 | } |
| 266 | |
| 267 | static void |
| 268 | bra (p, a) |
| 269 | struct h8_opcode *p; |
| 270 | char *a; |
| 271 | { |
| 272 | printf ("if (%s) npc += ((char )b1)>>1;\n", a); |
| 273 | } |
| 274 | |
| 275 | static void |
| 276 | bsr (p, a) |
| 277 | struct h8_opcode *p; |
| 278 | char *a; |
| 279 | { |
| 280 | printf ("reg[7]-=2;\n"); |
| 281 | printf ("tmp = reg[7];\n"); |
| 282 | printf ("SET_WORD_MEM(tmp, (npc-saved_state.mem)*2);\n"); |
| 283 | printf ("npc += ((char)b1)>>1;\n"); |
| 284 | } |
| 285 | |
| 286 | static void |
| 287 | cmp (p, a, s) |
| 288 | struct h8_opcode *p; |
| 289 | char *a; |
| 290 | int s; |
| 291 | { |
| 292 | decode (p, 1, s); |
| 293 | printf ("srca = -srca;\n"); |
| 294 | printf ("dst = srca + srcb;\n"); |
| 295 | } |
| 296 | |
| 297 | static |
| 298 | void |
| 299 | jsr (p, a, s) |
| 300 | struct h8_opcode *p; |
| 301 | char *a; |
| 302 | int s; |
| 303 | { |
| 304 | printf ("if (b1 == 0xc4) {\n"); |
| 305 | printf ("printf(\"%%c\", reg[2]);\n"); |
| 306 | printf ("}\n"); |
| 307 | printf ("else {\n"); |
| 308 | printf ("reg[7]-=2;\n"); |
| 309 | printf ("tmp = reg[7];\n"); |
| 310 | printf ("SET_WORD_MEM(tmp, (npc-saved_state.mem)*2);\n"); |
| 311 | printf ("npc = (lval>>1) + saved_state.mem;\n"); |
| 312 | printf ("}"); |
| 313 | } |
| 314 | |
| 315 | static void |
| 316 | jmp (p, a, s) |
| 317 | struct h8_opcode *p; |
| 318 | char *a; |
| 319 | int s; |
| 320 | { |
| 321 | printf ("npc = (lval>>1) + saved_state.mem;\n"); |
| 322 | } |
| 323 | |
| 324 | static void |
| 325 | rts (p, a, s) |
| 326 | struct h8_opcode *p; |
| 327 | char *a; |
| 328 | int s; |
| 329 | { |
| 330 | printf ("tmp = reg[7];\n"); |
| 331 | printf ("reg[7]+=2;\n"); |
| 332 | printf ("npc = saved_state.mem + (WORD_MEM(tmp)>>1);\n"); |
| 333 | } |
| 334 | |
| 335 | static void |
| 336 | rte (p, a, s) |
| 337 | struct h8_opcode *p; |
| 338 | char *a; |
| 339 | int s; |
| 340 | { |
| 341 | printf ("reg[7]+=2;\n"); |
| 342 | printf ("tmp = reg[7];\n"); |
| 343 | printf ("reg[7]+=2;\n"); |
| 344 | printf ("SET_CCR(tmp);\n"); |
| 345 | printf ("npc = saved_state.mem + (WORD_MEM(tmp)>>1);\n"); |
| 346 | } |
| 347 | |
| 348 | static void |
| 349 | setf (p, a, s) |
| 350 | struct h8_opcode *p; |
| 351 | char *a; |
| 352 | int s; |
| 353 | { |
| 354 | printf ("tmp = GET_CCR();\n"); |
| 355 | printf ("tmp %s= srca;\n", a); |
| 356 | } |
| 357 | |
| 358 | static void |
| 359 | bpt (p, a, s) |
| 360 | struct h8_opcode *p; |
| 361 | char *a; |
| 362 | int s; |
| 363 | { |
| 364 | printf ("saved_state.exception = SIGTRAP;\n"); |
| 365 | printf ("npc = pc;\n"); |
| 366 | } |
| 367 | |
| 368 | static void |
| 369 | log (p, a, s) |
| 370 | struct h8_opcode *p; |
| 371 | char *a; |
| 372 | int s; |
| 373 | { |
| 374 | printf ("dst = srcb %s srca;\n", a); |
| 375 | } |
| 376 | |
| 377 | static void |
| 378 | ulog (p, a, s) |
| 379 | struct h8_opcode *p; |
| 380 | char *a; |
| 381 | int s; |
| 382 | { |
| 383 | printf ("dst = %s srcb ;\n", a); |
| 384 | } |
| 385 | |
| 386 | static void |
| 387 | nop () |
| 388 | { |
| 389 | } |
| 390 | |
| 391 | static void |
| 392 | rotl () |
| 393 | { |
| 394 | printf ("c = srcb & 0x80;\n"); |
| 395 | printf ("dst = srcb << 1;\n"); |
| 396 | printf ("if (c) dst|=1;\n"); |
| 397 | } |
| 398 | |
| 399 | static void |
| 400 | rotr () |
| 401 | { |
| 402 | printf ("c = srcb & 1;\n"); |
| 403 | printf ("dst = srcb >> 1;\n"); |
| 404 | printf ("if (c) dst|=0x80;\n"); |
| 405 | } |
| 406 | |
| 407 | static void |
| 408 | rotxl () |
| 409 | { |
| 410 | printf ("tmp = srcb & 0x80;\n"); |
| 411 | printf ("dst = srcb << 1;\n"); |
| 412 | printf ("if (c) dst|=1;\n"); |
| 413 | printf ("c = tmp;\n"); |
| 414 | } |
| 415 | |
| 416 | static void |
| 417 | rotxr () |
| 418 | { |
| 419 | printf ("tmp = srcb & 1;\n"); |
| 420 | printf ("dst = srcb >> 1;\n"); |
| 421 | printf ("if (c) dst|=0x80;\n"); |
| 422 | printf ("c = tmp;\n"); |
| 423 | } |
| 424 | |
| 425 | static void |
| 426 | shal () |
| 427 | { |
| 428 | printf ("c = srcb&0x80;\n"); |
| 429 | printf ("dst = srcb << 1;\n"); |
| 430 | } |
| 431 | |
| 432 | static |
| 433 | void |
| 434 | shar () |
| 435 | { |
| 436 | printf ("c = srcb&0x1;\n"); |
| 437 | printf ("if (srcb&0x80) dst = (srcb>>1) | 0x80;\n"); |
| 438 | printf ("else dst = (srcb>>1) &~ 0x80;\n"); |
| 439 | } |
| 440 | |
| 441 | static |
| 442 | void |
| 443 | shll () |
| 444 | { |
| 445 | printf ("c = srcb&0x80;\n"); |
| 446 | printf ("dst = srcb << 1;\n"); |
| 447 | } |
| 448 | |
| 449 | static |
| 450 | void |
| 451 | shlr () |
| 452 | { |
| 453 | printf ("c = srcb&0x1;\n"); |
| 454 | printf ("dst = (srcb>>1) &~ 0x80;\n"); |
| 455 | } |
| 456 | |
| 457 | static |
| 458 | void |
| 459 | divxu () |
| 460 | { |
| 461 | printf ("srca = %s;\n", breg[2]); |
| 462 | printf ("srcb = %s;\n", wreg[3]); |
| 463 | printf ("n = srca & 0x80;\n"); |
| 464 | printf ("z = !srca;\n"); |
| 465 | printf ("if (srca) dst = srcb / srca;tmp = srcb %% srca;\n"); |
| 466 | printf ("%s = (dst & 0xff) | (tmp << 8);\n", wreg[3]); |
| 467 | } |
| 468 | |
| 469 | static |
| 470 | void |
| 471 | mulxu () |
| 472 | { |
| 473 | printf ("srca = %s;\n", breg[2]); |
| 474 | printf ("srcb = %s;\n", wreg[3]); |
| 475 | |
| 476 | printf ("dst = (srcb&0xff) * srca;\n"); |
| 477 | printf ("%s = dst;\n", wreg[3]); |
| 478 | } |
| 479 | |
| 480 | static |
| 481 | void |
| 482 | inc () |
| 483 | { |
| 484 | printf ("dst = %s;\n", breg[3]); |
| 485 | printf ("v = (dst==0x7f);\n"); |
| 486 | printf ("dst++;\n"); |
| 487 | printf ("%s= dst;\n", breg[3]); |
| 488 | } |
| 489 | |
| 490 | static |
| 491 | void |
| 492 | bit (p, a, s) |
| 493 | struct h8_opcode *p; |
| 494 | char *a; |
| 495 | int s; |
| 496 | { |
| 497 | printf ("%s\n", a); |
| 498 | } |
| 499 | |
| 500 | static |
| 501 | void |
| 502 | dec () |
| 503 | { |
| 504 | printf ("dst = %s;\n", breg[3]); |
| 505 | printf ("v = (dst==0x80);\n"); |
| 506 | printf ("dst--;\n"); |
| 507 | printf ("%s = dst;\n", breg[3]); |
| 508 | } |
| 509 | |
| 510 | char saf[] = "goto setflags;"; |
| 511 | char sf[] = "goto shiftflags;"; |
| 512 | char af8[] = "goto aluflags8;"; |
| 513 | char af16[] = "goto aluflags16;"; |
| 514 | char lf[] = "goto logflags;"; |
| 515 | char icf[] = "goto incflags;"; |
| 516 | char mf8[] = "goto movflags8;"; |
| 517 | char mf16[] = "goto movflags16;"; |
| 518 | char nx[] = "goto next;"; |
| 519 | |
| 520 | struct |
| 521 | { |
| 522 | char *ftype; |
| 523 | int decode; |
| 524 | char *name; |
| 525 | void (*func) (); |
| 526 | char *arg; |
| 527 | int size; |
| 528 | |
| 529 | } |
| 530 | |
| 531 | table[] = |
| 532 | { |
| 533 | { |
| 534 | nx, 1, "bld", bit, "dst = srcb; c = (srcb>>srca)&1;", 8 |
| 535 | } |
| 536 | , |
| 537 | { |
| 538 | nx, 1, "bild", bit, "dst = srcb; c = !((srcb>>srca)&1);", 8 |
| 539 | } |
| 540 | , |
| 541 | { |
| 542 | nx, 1, "band", bit, "dst = srcb; c = C &&((srcb>>srca)&1);", 8 |
| 543 | } |
| 544 | , |
| 545 | { |
| 546 | nx, 1, "biand", bit, "dst = srcb; c = C &&(!((srcb>>srca)&1));", 8 |
| 547 | } |
| 548 | , |
| 549 | { |
| 550 | nx, 1, "bior", bit, "dst = srcb; c = C ||(!((srcb>>srca)&1));", 8 |
| 551 | } |
| 552 | , |
| 553 | { |
| 554 | nx, 1, "bor", bit, "dst = srcb; c = C ||(((srcb>>srca)&1));", 8 |
| 555 | } |
| 556 | , |
| 557 | { |
| 558 | nx, 1, "bixor", bit, "dst = srcb; c = C ^(!((srcb>>srca)&1));", 8 |
| 559 | } |
| 560 | , |
| 561 | { |
| 562 | nx, 1, "bxor", bit, "dst = srcb; c = C ^(((srcb>>srca)&1));", 8 |
| 563 | } |
| 564 | , |
| 565 | { |
| 566 | nx, 1, "bnot", bit, "dst = srcb ^ (1<<srca);", 8 |
| 567 | } |
| 568 | , |
| 569 | { |
| 570 | nx, 1, "bclr", bit, "dst = srcb & ~(1<<srca);", 8 |
| 571 | } |
| 572 | , |
| 573 | { |
| 574 | nx, 1, "bset", bit, "dst = srcb | (1<<srca);", 8 |
| 575 | } |
| 576 | , |
| 577 | { |
| 578 | nx, 1, "bst", bit, "dst = (srcb & ~(1<<srca))| ((C)<<srca);", 8 |
| 579 | } |
| 580 | , |
| 581 | { |
| 582 | nx, 1, "bist", bit, "dst = (srcb & ~(1<<srca))| ((!C)<<srca);", 8 |
| 583 | } |
| 584 | , |
| 585 | { |
| 586 | nx, 1, "btst", bit, "dst = srcb; z = !((srcb>>srca)&1);", 8 |
| 587 | } |
| 588 | , |
| 589 | { |
| 590 | icf, 0, "dec", dec, 0, 0 |
| 591 | } |
| 592 | , |
| 593 | { |
| 594 | icf, 0, "inc", inc, 0, 0 |
| 595 | } |
| 596 | , |
| 597 | { |
| 598 | saf, 1, "orc", setf, "|", 0 |
| 599 | } |
| 600 | , |
| 601 | { |
| 602 | saf, 1, "xorc", setf, "^", 0 |
| 603 | } |
| 604 | , |
| 605 | { |
| 606 | saf, 1, "andc", setf, "&", 0 |
| 607 | } |
| 608 | , |
| 609 | { |
| 610 | nx, 1, "nop", nop, 0, 0 |
| 611 | } |
| 612 | , |
| 613 | { |
| 614 | nx, 1, "bra", bra, "1", 0 |
| 615 | } |
| 616 | , |
| 617 | { |
| 618 | nx, 1, "brn", bra, "0", 0 |
| 619 | } |
| 620 | , |
| 621 | { |
| 622 | nx, 1, "bhi", bra, "(C||Z)==0", 0 |
| 623 | } |
| 624 | , |
| 625 | { |
| 626 | nx, 1, "bls", bra, "(C||Z)==1", 0 |
| 627 | } |
| 628 | , |
| 629 | { |
| 630 | nx, 1, "bcs", bra, "C==1", 0 |
| 631 | } |
| 632 | , |
| 633 | { |
| 634 | nx, 1, "bcc", bra, "C==0", 0 |
| 635 | } |
| 636 | , |
| 637 | { |
| 638 | nx, 1, "bpl", bra, "N==0", 0 |
| 639 | } |
| 640 | , |
| 641 | { |
| 642 | nx, 1, "bmi", bra, "N==1", 0 |
| 643 | } |
| 644 | , |
| 645 | { |
| 646 | nx, 1, "bvs", bra, "V==1", 0 |
| 647 | } |
| 648 | , |
| 649 | { |
| 650 | nx, 1, "bvc", bra, "V==0", 0 |
| 651 | } |
| 652 | , |
| 653 | { |
| 654 | nx, 1, "bge", bra, "(N^V)==0", 0 |
| 655 | } |
| 656 | , |
| 657 | { |
| 658 | nx, 1, "bgt", bra, "(Z|(N^V))==0", 0 |
| 659 | } |
| 660 | , |
| 661 | { |
| 662 | nx, 1, "blt", bra, "(N^V)==1", 0 |
| 663 | } |
| 664 | , |
| 665 | { |
| 666 | nx, 1, "ble", bra, "(Z|(N^V))==1", 0 |
| 667 | } |
| 668 | , |
| 669 | { |
| 670 | nx, 1, "beq", bra, "Z==1", 0 |
| 671 | } |
| 672 | , |
| 673 | { |
| 674 | nx, 1, "bne", bra, "Z==0", 0 |
| 675 | } |
| 676 | , |
| 677 | { |
| 678 | nx, 1, "bsr", bsr, "", 0 |
| 679 | } |
| 680 | , |
| 681 | { |
| 682 | nx, 1, "jsr", jsr, 0, 0 |
| 683 | } |
| 684 | , |
| 685 | { |
| 686 | nx, 1, "jmp", jmp, 0, 0 |
| 687 | } |
| 688 | , |
| 689 | { |
| 690 | nx, 0, "rts", rts, 0, 0 |
| 691 | } |
| 692 | , |
| 693 | { |
| 694 | nx, 0, "rte", rte, 0, 0 |
| 695 | } |
| 696 | , |
| 697 | { |
| 698 | nx, 1, "andc", andc, 0, 0 |
| 699 | } |
| 700 | , |
| 701 | { |
| 702 | sf, 1, "shal", shal, 0, 0 |
| 703 | } |
| 704 | , |
| 705 | { |
| 706 | sf, 1, "shar", shar, 0, 0 |
| 707 | } |
| 708 | , |
| 709 | { |
| 710 | sf, 1, "shll", shll, 0, 0 |
| 711 | } |
| 712 | , |
| 713 | { |
| 714 | sf, 1, "shlr", shlr, 0, 0 |
| 715 | } |
| 716 | , |
| 717 | { |
| 718 | sf, 1, "rotxl", rotxl, 0, 0 |
| 719 | } |
| 720 | , |
| 721 | { |
| 722 | sf, 1, "rotxr", rotxr, 0, 0 |
| 723 | } |
| 724 | , |
| 725 | { |
| 726 | sf, 1, "rotl", rotl, 0, 0 |
| 727 | } |
| 728 | , |
| 729 | { |
| 730 | sf, 1, "rotr", rotr, 0, 0 |
| 731 | } |
| 732 | , |
| 733 | { |
| 734 | lf, 1, "xor", log, "^", 0 |
| 735 | } |
| 736 | , |
| 737 | { |
| 738 | lf, 1, "and", log, "&", 0 |
| 739 | } |
| 740 | , |
| 741 | { |
| 742 | lf, 1, "or", log, "|", 0 |
| 743 | } |
| 744 | , |
| 745 | { |
| 746 | lf, 1, "not", ulog, " ~", 0 |
| 747 | } |
| 748 | , |
| 749 | { |
| 750 | lf, 1, "neg", ulog, " - ", 0 |
| 751 | } |
| 752 | , |
| 753 | { |
| 754 | nx, 1, "adds", adds, "dst = srca + srcb", 0 |
| 755 | } |
| 756 | , |
| 757 | { |
| 758 | nx, 1, "subs", adds, "srca = -srca; dst = srcb + srca", 0 |
| 759 | } |
| 760 | , |
| 761 | { |
| 762 | af8, 1, "add.b", add, "dst = srca + srcb", 8 |
| 763 | } |
| 764 | , |
| 765 | { |
| 766 | af16, 1, "add.w", add, "dst = srca + srcb", 16 |
| 767 | } |
| 768 | , |
| 769 | { |
| 770 | af16, 1, "sub.w", add, "srca = -srca; dst = srcb + srca", 16 |
| 771 | } |
| 772 | , |
| 773 | { |
| 774 | af8, 1, "sub.b", add, "srca = -srca; dst = srcb + srca", 8 |
| 775 | } |
| 776 | , |
| 777 | { |
| 778 | af8, 1, "addx", addx, 0, 8 |
| 779 | } |
| 780 | , |
| 781 | { |
| 782 | af8, 1, "subx", subx, 0, 8 |
| 783 | } |
| 784 | , |
| 785 | { |
| 786 | af8, 0, "cmp.b", cmp, 0, 8 |
| 787 | } |
| 788 | , |
| 789 | { |
| 790 | af16, 0, "cmp.w", cmp, 0, 16 |
| 791 | } |
| 792 | , |
| 793 | { |
| 794 | nx, 1, "sleep", esleep, 0, 0 |
| 795 | } |
| 796 | , |
| 797 | { |
| 798 | nx, 0, "bpt", bpt, 0, 8 |
| 799 | } |
| 800 | , |
| 801 | { |
| 802 | nx, 0, "divxu", divxu, 0, 0 |
| 803 | } |
| 804 | , |
| 805 | { |
| 806 | nx, 0, "mulxu", mulxu, 0, 0 |
| 807 | } |
| 808 | , |
| 809 | { |
| 810 | mf8, 1, "mov.b", mov, 0, 8 |
| 811 | } |
| 812 | , |
| 813 | { |
| 814 | mf8, 1, "movtpe", mov, 0, 8 |
| 815 | } |
| 816 | , |
| 817 | { |
| 818 | mf8, 1, "movfpe", mov, 0, 8 |
| 819 | } |
| 820 | , |
| 821 | { |
| 822 | mf16, 1, "mov.w", mov, 0, 16 |
| 823 | } |
| 824 | , |
| 825 | { |
| 826 | 0 |
| 827 | } |
| 828 | }; |
| 829 | |
| 830 | static |
| 831 | void |
| 832 | edo (p) |
| 833 | struct h8_opcode *p; |
| 834 | { |
| 835 | int i; |
| 836 | |
| 837 | printf ("%s %s %s\n", cs, p->name, ce); |
| 838 | |
| 839 | for (i = 0; table[i].name; i++) |
| 840 | { |
| 841 | if (strcmp (table[i].name, p->name) == 0) |
| 842 | { |
| 843 | printf ("{\n"); |
| 844 | if (table[i].decode) |
| 845 | decode (p, 1, table[i].size); |
| 846 | printf ("cycles += %d;\n", p->time); |
| 847 | printf ("npc = pc + %d;\n", p->length / 2); |
| 848 | table[i].func (p, table[i].arg, table[i].size); |
| 849 | if (table[i].decode) |
| 850 | decode (p, 0, table[i].size); |
| 851 | if (table[i].ftype) |
| 852 | printf (table[i].ftype); |
| 853 | else |
| 854 | printf ("goto next;\n"); |
| 855 | printf ("}\n"); |
| 856 | return; |
| 857 | } |
| 858 | } |
| 859 | printf ("%s not found %s\n", cs, ce); |
| 860 | printf ("saved_state.exception = SIGILL;\n"); |
| 861 | printf ("break;\n"); |
| 862 | } |
| 863 | |
| 864 | static |
| 865 | int |
| 866 | owrite (i) |
| 867 | int i; |
| 868 | { |
| 869 | /* write if statements to select the right opcode */ |
| 870 | struct h8_opcode **p; |
| 871 | int needand = 1; |
| 872 | |
| 873 | p = h8_opcodes_sorted[i]; |
| 874 | printf ("case 0x%03x:\n", i); |
| 875 | |
| 876 | if (p[1] == 0) |
| 877 | { |
| 878 | /* See if the next few also match */ |
| 879 | while (h8_opcodes_sorted[i + 1][0] == *p) |
| 880 | { |
| 881 | i++; |
| 882 | printf ("case 0x%03x:\n", i); |
| 883 | } |
| 884 | |
| 885 | /* Don't need any if's this is the only one */ |
| 886 | edo (*p); |
| 887 | } |
| 888 | else |
| 889 | { |
| 890 | while (*p) |
| 891 | { |
| 892 | /* start two nibbles in since we know we match in the first byte */ |
| 893 | int c; |
| 894 | int nib = 2; |
| 895 | int byte = 1; |
| 896 | int mask1[5]; |
| 897 | int mask0[5]; |
| 898 | int nibshift = 4; |
| 899 | int any = 0; |
| 900 | |
| 901 | for (c = 0; c < 5; c++) |
| 902 | { |
| 903 | mask1[c] = 0; |
| 904 | mask0[c] = 0; |
| 905 | } |
| 906 | printf ("%s %x%x", cs, (*p)->data.nib[0], (*p)->data.nib[1]); |
| 907 | while ((c = (*p)->data.nib[nib]) != E) |
| 908 | { |
| 909 | if (c & B30) |
| 910 | { |
| 911 | /* bit 3 must be zero */ |
| 912 | mask0[byte] |= 0x8 << nibshift; |
| 913 | printf ("0"); |
| 914 | any = 1; |
| 915 | } |
| 916 | else if (c & B31) |
| 917 | { |
| 918 | /* bit 3 must be one */ |
| 919 | mask1[byte] |= 0x8 << nibshift; |
| 920 | printf ("8"); |
| 921 | any = 1; |
| 922 | } |
| 923 | else if (c <= HexF) |
| 924 | { |
| 925 | mask0[byte] |= ((~c) & 0xf) << nibshift; |
| 926 | mask1[byte] |= (c & 0xf) << nibshift; |
| 927 | printf ("%x", c); |
| 928 | any = 1; |
| 929 | } |
| 930 | else |
| 931 | { |
| 932 | printf ("x"); |
| 933 | } |
| 934 | nib++; |
| 935 | if (nibshift == 4) |
| 936 | { |
| 937 | nibshift = 0; |
| 938 | } |
| 939 | else |
| 940 | { |
| 941 | byte++; |
| 942 | nibshift = 4; |
| 943 | } |
| 944 | } |
| 945 | printf ("*/\n"); |
| 946 | if (any) |
| 947 | { |
| 948 | printf ("if ("); |
| 949 | needand = 0; |
| 950 | for (c = 1; c < byte; c++) |
| 951 | { |
| 952 | if (mask0[c] | mask1[c]) |
| 953 | { |
| 954 | int sh; |
| 955 | |
| 956 | if (needand) |
| 957 | printf ("\n&&"); |
| 958 | if (c & 1) |
| 959 | sh = 0; |
| 960 | else |
| 961 | sh = 8; |
| 962 | if (c / 2 == 0 && sh == 0) |
| 963 | printf ("((b1&0x%x)==0x%x)", mask0[c] | mask1[c], |
| 964 | mask1[c]); |
| 965 | else |
| 966 | { |
| 967 | printf ("((pc[%d]&(0x%02x<<%d))==(0x%x<<%d))", |
| 968 | c / 2, mask0[c] | mask1[c], sh, |
| 969 | mask1[c], sh); |
| 970 | } |
| 971 | |
| 972 | needand = 1; |
| 973 | } |
| 974 | } |
| 975 | printf (")\n"); |
| 976 | } |
| 977 | edo (*p); |
| 978 | p++; |
| 979 | |
| 980 | } |
| 981 | } |
| 982 | return i; |
| 983 | } |
| 984 | |
| 985 | static |
| 986 | void |
| 987 | remove_dups () |
| 988 | { |
| 989 | struct h8_opcode *s; |
| 990 | struct h8_opcode *d; |
| 991 | |
| 992 | for (d = s = h8_opcodes; s->name; s++) |
| 993 | { |
| 994 | int doit = 1; |
| 995 | |
| 996 | if (strcmp (s->name, "push") == 0) |
| 997 | doit = 0; |
| 998 | if (strcmp (s->name, "bhs") == 0) |
| 999 | doit = 0; |
| 1000 | if (strcmp (s->name, "blo") == 0) |
| 1001 | doit = 0; |
| 1002 | if (strcmp (s->name, "bt") == 0) |
| 1003 | doit = 0; |
| 1004 | if (strcmp (s->name, "bf") == 0) |
| 1005 | doit = 0; |
| 1006 | if (strcmp (s->name, "pop") == 0) |
| 1007 | doit = 0; |
| 1008 | if (doit) |
| 1009 | { |
| 1010 | *d++ = *s; |
| 1011 | } |
| 1012 | } |
| 1013 | *d++ = *s++; |
| 1014 | } |
| 1015 | |
| 1016 | int |
| 1017 | main () |
| 1018 | { |
| 1019 | int i; |
| 1020 | |
| 1021 | remove_dups (); |
| 1022 | init (); |
| 1023 | |
| 1024 | printf ("%s do the operation %s\n", cs, ce); |
| 1025 | printf ("switch (b0) \n{\n"); |
| 1026 | for (i = 0; i < PTWO; i++) |
| 1027 | { |
| 1028 | i = owrite (i); |
| 1029 | } |
| 1030 | printf ("}\n"); |
| 1031 | |
| 1032 | return 0; |
| 1033 | } |