![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gen68k.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Generator SEGA Genesis emulator] / generator / src|
Return to gen68k.c CVS log | Up to [Generator SEGA Genesis emulator] / generator / src |
1.1.1.2 ! root 1: /* Generator is (c) James Ponder, 1997-2001 http://www.squish.net/generator/ */ 1.1 root 2: 3: #include <stdio.h> 4: 5: #include "generator.h" 6: 7: #include "out/def68k-iibs.h" 8: 9: /* forward references */ 10: 11: void generate(FILE *output, int topnibble); 12: void generate_ea(FILE *o, t_iib *iib, t_type type, int update); 13: void generate_eaval(FILE *o, t_iib *iib, t_type type); 14: void generate_eastore(FILE *o, t_iib *iib, t_type type); 15: void generate_outdata(FILE *o, t_iib *iib, const char *init); 16: void generate_cc(FILE *o, t_iib *iib); 17: void generate_stdflag_n(FILE *o, t_iib *iib); 18: void generate_stdflag_z(FILE *o, t_iib *iib); 19: void generate_clrflag_v(FILE *o, t_iib *iib); 20: void generate_clrflag_c(FILE *o, t_iib *iib); 21: void generate_clrflag_n(FILE *o, t_iib *iib); 22: void generate_setflag_z(FILE *o, t_iib *iib); 23: void generate_subflag_c(FILE *o, t_iib *iib); 24: void generate_subflag_cx(FILE *o, t_iib *iib); 25: void generate_subxflag_cx(FILE *o, t_iib *iib); 26: void generate_subflag_v(FILE *o, t_iib *iib); 27: void generate_cmpaflag_c(FILE *o, t_iib *iib); 28: void generate_cmpaflag_v(FILE *o, t_iib *iib); 29: void generate_addflag_cx(FILE *o, t_iib *iib); 30: void generate_addflag_v(FILE *o, t_iib *iib); 31: void generate_addxflag_cx(FILE *o, t_iib *iib); 32: void generate_stdxflag_z(FILE *o, t_iib *iib); 33: void generate_negflag_cx(FILE *o, t_iib *iib); 34: void generate_negflag_v(FILE *o, t_iib *iib); 35: void generate_negxflag_cx(FILE *o, t_iib *iib); 36: void generate_negxflag_v(FILE *o, t_iib *iib); 37: void generate_bits(FILE *o, t_iib *iib); 38: 39: /* defines */ 40: 1.1.1.2 ! root 41: #define HEADER "/*****************************************************************************/\n/* Generator - Sega Genesis emulation - (c) James Ponder 1997-2001 */\n/*****************************************************************************/\n/* */\n/* cpu68k-%x.c */\n/* */\n/*****************************************************************************/\n\n" 1.1 root 42: 43: #define OUT(x) fputs(x,output); 44: 45: /* program entry routine */ 46: 47: int main(int argc, char *argv[]) 48: { 49: FILE *output; 50: int i; 51: char tmp[256]; 52: 53: printf("Writing C files... "); 54: fflush(stdout); 55: 56: for (i = 0; i < 16; i++) { 57: 58: printf("%d. ", i); 59: fflush(stdout); 60: 61: /* make filename */ 62: sprintf(tmp, FNAME_GEN68K_CPU_OUT, i); 63: 64: /* open output file */ 65: if ((output = fopen(tmp, "w")) == NULL) { 66: perror("fopen output"); 67: exit(1); 68: } 69: 70: /* output header */ 71: fprintf(output, HEADER, i); 72: fprintf(output, "#include \"generator.h\"\n"); 73: fprintf(output, "#include \"cpu68k.h\"\n"); 74: fprintf(output, "#include \"mem68k.h\"\n"); 75: fprintf(output, "#include \"reg68k.h\"\n\n"); 76: fprintf(output, "#include \"cpu68k-inline.h\"\n\n"); 77: fprintf(output, "#include <stdio.h>\n\n"); 78: 79: generate(output, i); 80: 81: /* close output */ 82: if (fclose(output)) { 83: perror("fclose output"); 84: exit(1); 85: } 86: 87: } 88: 89: printf("done.\n"); 90: fflush(stdout); 91: 92: /* normal program termination */ 93: return(0); 94: } 95: 96: void generate(FILE *output, int topnibble) 97: { 98: t_iib *iib; 99: int i, flags, pcinc; 100: int DEBUG_BRANCH = 0; 101: int DEBUG_SR = 0; 102: int DEBUG_RTE = 0; 103: 104: for (i = 0; i < iibs_num; i++) { 105: iib = &iibs[i]; 106: 107: if ((iib->mask & 0xF000) != 0xF000) { 108: fprintf(stderr, "error: Strange mask %x\n", iib->mask); 109: exit(1); 110: } 111: if (((iib->bits & 0xF000)>>12) != topnibble) { 112: continue; 113: } 114: 115: for (flags = 0; flags < 2; flags++) { 116: 117: if (flags == 1 && iib->flags.set == 0) { 118: /* there is no non-flags version, functable will already go 119: straight to the normal version anyway, so lets just skip it */ 120: continue; 121: } 122: 123: fprintf(output, "void cpu_op_%i%s(t_ipc *ipc) /* %s */ {\n", 124: i, flags ? "b" : "a", mnemonic_table[iib->mnemonic].name); 125: fprintf(output, " /* mask %0.4x, bits %0.4x, mnemonic %d, priv %d, ", 126: iib->mask, iib->bits, iib->mnemonic, iib->flags.priv); 127: fprintf(output, "endblk %d, imm_notzero %d, used %d", 128: iib->flags.endblk, iib->flags.imm_notzero, iib->flags.used); 129: fprintf(output, " set %d, size %d, stype %d, dtype %d, sbitpos %d, ", 130: iib->flags.set, iib->size, iib->stype, iib->dtype, iib->sbitpos); 131: fprintf(output, "dbitpos %d, immvalue %d */\n", iib->dbitpos, 132: iib->immvalue); 133: 134: pcinc = 1; 135: 136: switch(iib->mnemonic) { 137: 138: case i_OR: 139: case i_AND: 140: case i_EOR: 141: generate_ea(output, iib, tp_src, 1); 142: generate_eaval(output, iib, tp_src); 143: generate_ea(output, iib, tp_dst, 1); 144: generate_eaval(output, iib, tp_dst); 145: generate_outdata(output, iib, "dstdata"); 146: OUT("\n"); 147: switch(iib->mnemonic) { 148: case i_OR: 149: OUT(" outdata|= srcdata;\n"); 150: break; 151: case i_AND: 152: OUT(" outdata&= srcdata;\n"); 153: break; 154: case i_EOR: 155: OUT(" outdata^= srcdata;\n"); 156: break; 157: default: 158: OUT("ERROR\n"); 159: break; 160: } 161: generate_eastore(output, iib, tp_dst); 162: if (flags) 163: OUT("\n"); 164: if (flags && iib->flags.set & IIB_FLAG_N) 165: generate_stdflag_n(output, iib); 166: if (flags && iib->flags.set & IIB_FLAG_Z) 167: generate_stdflag_z(output, iib); 168: if (flags && iib->flags.set & IIB_FLAG_V) 169: generate_clrflag_v(output, iib); 170: if (flags && iib->flags.set & IIB_FLAG_C) 171: generate_clrflag_c(output, iib); 172: break; 173: 174: case i_ORSR: 175: case i_ANDSR: 176: case i_EORSR: 177: generate_ea(output, iib, tp_src, 1); 178: generate_eaval(output, iib, tp_src); 179: OUT(" unsigned int sr = reg68k_sr.sr_struct.s;\n"); 180: OUT("\n"); 181: if (DEBUG_SR) 182: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n", 183: output); 184: if (iib->size == sz_word) { 185: OUT(" if (!SFLAG)\n"); 1.1.1.2 ! root 186: fprintf(output, " reg68k_internal_vector(V_PRIVILEGE, PC+%d);\n", 1.1 root 187: (iib->wordlen)*2); 188: OUT("\n"); 189: } 190: switch(iib->mnemonic) { 191: case i_ORSR: 192: OUT(" SR|= srcdata;\n"); 193: break; 194: case i_ANDSR: 195: if (iib->size == sz_byte) { 196: OUT(" SR = (SR & 0xFF00) | (SR & srcdata);\n"); 197: } else { 198: OUT(" SR&= srcdata;\n"); 199: } 200: break; 201: case i_EORSR: 202: OUT(" SR^= srcdata;\n"); 203: break; 204: default: 205: OUT("ERROR\n"); 206: break; 207: } 208: OUT(" if (sr != (uint8)reg68k_sr.sr_struct.s) {\n"); 209: OUT(" /* mode change, swap SP and A7 */\n"); 210: OUT(" ADDRREG(7)^= SP; SP^= ADDRREG(7); ADDRREG(7)^= SP;\n"); 211: OUT(" }\n"); 212: if (DEBUG_SR) 213: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n", 214: output); 215: break; 216: 217: case i_SUB: 218: generate_ea(output, iib, tp_src, 1); 219: generate_eaval(output, iib, tp_src); 220: generate_ea(output, iib, tp_dst, 1); 221: generate_eaval(output, iib, tp_dst); 222: switch (iib->size) { 223: case sz_byte: 224: generate_outdata(output, iib, "(sint8)dstdata - (sint8)srcdata"); 225: break; 226: case sz_word: 227: generate_outdata(output, iib, "(sint16)dstdata - (sint16)srcdata"); 228: break; 229: case sz_long: 230: generate_outdata(output, iib, "(sint32)dstdata - (sint32)srcdata"); 231: break; 232: default: 233: OUT("ERROR size\n"); 234: break; 235: } 236: OUT("\n"); 237: generate_eastore(output, iib, tp_dst); 238: if (flags) 239: OUT("\n"); 240: if (flags && iib->flags.set & IIB_FLAG_V) 241: generate_subflag_v(output, iib); 242: if (flags && ((iib->flags.set & IIB_FLAG_C) || 243: (iib->flags.set & IIB_FLAG_X))) 244: generate_subflag_cx(output, iib); 245: if (flags && iib->flags.set & IIB_FLAG_N) 246: generate_stdflag_n(output, iib); 247: if (flags && iib->flags.set & IIB_FLAG_Z) 248: generate_stdflag_z(output, iib); 249: break; 250: 251: case i_SUBA: 252: if (iib->dtype != dt_Areg) 253: OUT("Error\n"); 254: generate_ea(output, iib, tp_src, 1); 255: generate_eaval(output, iib, tp_src); 256: generate_ea(output, iib, tp_dst, 1); 257: OUT(" uint32 dstdata = ADDRREG(dstreg);\n"); 258: switch (iib->size) { 259: case sz_byte: 260: OUT(" uint32 outdata = (sint32)dstdata - (sint8)srcdata;\n"); 261: break; 262: case sz_word: 263: OUT(" uint32 outdata = (sint32)dstdata - (sint16)srcdata;\n"); 264: break; 265: case sz_long: 266: OUT(" uint32 outdata = (sint32)dstdata - (sint32)srcdata;\n"); 267: break; 268: default: 269: OUT("ERROR size\n"); 270: break; 271: } 272: OUT("\n"); 273: OUT(" ADDRREG(dstreg) = outdata;\n"); 274: break; 275: 276: case i_SUBX: 277: generate_ea(output, iib, tp_src, 1); 278: generate_eaval(output, iib, tp_src); 279: generate_ea(output, iib, tp_dst, 1); 280: generate_eaval(output, iib, tp_dst); 281: switch (iib->size) { 282: case sz_byte: 283: generate_outdata(output, iib, "(sint8)dstdata - (sint8)srcdata " 284: "- XFLAG"); 285: break; 286: case sz_word: 287: generate_outdata(output, iib, "(sint16)dstdata - (sint16)srcdata" 288: "- XFLAG"); 289: break; 290: case sz_long: 291: generate_outdata(output, iib, "(sint32)dstdata - (sint32)srcdata" 292: "- XFLAG"); 293: break; 294: default: 295: OUT("ERROR size\n"); 296: break; 297: } 298: OUT("\n"); 299: generate_eastore(output, iib, tp_dst); 300: if (flags) 301: OUT("\n"); 302: if (flags && iib->flags.set & IIB_FLAG_V) 303: generate_subflag_v(output, iib); 304: if (flags && ((iib->flags.set & IIB_FLAG_C) || 305: (iib->flags.set & IIB_FLAG_X))) 306: generate_subxflag_cx(output, iib); 307: if (flags && iib->flags.set & IIB_FLAG_N) 308: generate_stdflag_n(output, iib); 309: if (flags && iib->flags.set & IIB_FLAG_Z) 310: generate_stdxflag_z(output, iib); 311: break; 312: 313: case i_ADD: 314: generate_ea(output, iib, tp_src, 1); 315: generate_eaval(output, iib, tp_src); 316: generate_ea(output, iib, tp_dst, 1); 317: generate_eaval(output, iib, tp_dst); 318: switch (iib->size) { 319: case sz_byte: 320: generate_outdata(output, iib, "(sint8)dstdata + (sint8)srcdata"); 321: break; 322: case sz_word: 323: generate_outdata(output, iib, "(sint16)dstdata + (sint16)srcdata"); 324: break; 325: case sz_long: 326: generate_outdata(output, iib, "(sint32)dstdata + (sint32)srcdata"); 327: break; 328: default: 329: OUT("ERROR size\n"); 330: break; 331: } 332: OUT("\n"); 333: generate_eastore(output, iib, tp_dst); 334: if (flags) 335: OUT("\n"); 336: if (flags && iib->flags.set & IIB_FLAG_V) 337: generate_addflag_v(output, iib); 338: if (flags && ((iib->flags.set & IIB_FLAG_C) || 339: (iib->flags.set & IIB_FLAG_X))) 340: generate_addflag_cx(output, iib); 341: if (flags && iib->flags.set & IIB_FLAG_N) 342: generate_stdflag_n(output, iib); 343: if (flags && iib->flags.set & IIB_FLAG_Z) 344: generate_stdflag_z(output, iib); 345: break; 346: 347: case i_ADDA: 348: if (iib->dtype != dt_Areg) 349: OUT("Error\n"); 350: generate_ea(output, iib, tp_src, 1); 351: generate_eaval(output, iib, tp_src); 352: generate_ea(output, iib, tp_dst, 1); 353: OUT(" uint32 dstdata = ADDRREG(dstreg);\n"); 354: switch (iib->size) { 355: case sz_byte: 356: OUT(" uint32 outdata = (sint32)dstdata + (sint8)srcdata;\n"); 357: break; 358: case sz_word: 359: OUT(" uint32 outdata = (sint32)dstdata + (sint16)srcdata;\n"); 360: break; 361: case sz_long: 362: OUT(" uint32 outdata = (sint32)dstdata + (sint32)srcdata;\n"); 363: break; 364: default: 365: OUT("ERROR size\n"); 366: break; 367: } 368: OUT("\n"); 369: OUT(" ADDRREG(dstreg) = outdata;\n"); 370: break; 371: 372: case i_ADDX: 373: generate_ea(output, iib, tp_src, 1); 374: generate_eaval(output, iib, tp_src); 375: generate_ea(output, iib, tp_dst, 1); 376: generate_eaval(output, iib, tp_dst); 377: switch (iib->size) { 378: case sz_byte: 379: generate_outdata(output, iib, "(sint8)dstdata + (sint8)srcdata " 380: "+ XFLAG"); 381: break; 382: case sz_word: 383: generate_outdata(output, iib, "(sint16)dstdata + (sint16)srcdata" 384: "+ XFLAG"); 385: break; 386: case sz_long: 387: generate_outdata(output, iib, "(sint32)dstdata + (sint32)srcdata" 388: "+ XFLAG"); 389: break; 390: default: 391: OUT("ERROR size\n"); 392: break; 393: } 394: OUT("\n"); 395: generate_eastore(output, iib, tp_dst); 396: if (flags) 397: OUT("\n"); 398: if (flags && iib->flags.set & IIB_FLAG_V) 399: generate_addflag_v(output, iib); 400: if (flags && ((iib->flags.set & IIB_FLAG_C) || 401: (iib->flags.set & IIB_FLAG_X))) 402: generate_addxflag_cx(output, iib); 403: if (flags && iib->flags.set & IIB_FLAG_N) 404: generate_stdflag_n(output, iib); 405: if (flags && iib->flags.set & IIB_FLAG_Z) 406: generate_stdxflag_z(output, iib); 407: break; 408: 409: case i_MULU: 410: generate_ea(output, iib, tp_src, 1); 411: generate_eaval(output, iib, tp_src); 412: generate_ea(output, iib, tp_dst, 1); 413: generate_eaval(output, iib, tp_dst); 414: OUT("\n"); 415: OUT(" uint32 outdata = (uint32)srcdata * (uint32)dstdata;\n"); 416: if (iib->dtype != dt_Dreg) 417: OUT("ERROR dtype\n"); 418: OUT(" DATAREG(dstreg) = outdata;\n"); 419: if (flags) 420: OUT("\n"); 421: if (flags && iib->flags.set & IIB_FLAG_N) 422: OUT(" NFLAG = ((sint32)outdata) < 0;\n"); 423: if (flags && iib->flags.set & IIB_FLAG_Z) 424: generate_stdflag_z(output, iib); 425: if (flags && iib->flags.set & IIB_FLAG_V) 426: generate_clrflag_v(output, iib); 427: if (flags && iib->flags.set & IIB_FLAG_C) 428: generate_clrflag_c(output, iib); 429: break; 430: 431: case i_MULS: 432: generate_ea(output, iib, tp_src, 1); 433: generate_eaval(output, iib, tp_src); 434: generate_ea(output, iib, tp_dst, 1); 435: generate_eaval(output, iib, tp_dst); 436: OUT("\n"); 437: OUT(" uint32 outdata = (sint32)(sint16)srcdata * " 438: "(sint32)(sint16)dstdata;\n"); 439: if (iib->dtype != dt_Dreg) 440: OUT("ERROR dtype\n"); 441: OUT(" DATAREG(dstreg) = outdata;\n"); 442: if (flags) 443: OUT("\n"); 444: if (flags && iib->flags.set & IIB_FLAG_N) 445: OUT(" NFLAG = ((sint32)outdata) < 0;\n"); 446: if (flags && iib->flags.set & IIB_FLAG_Z) 447: generate_stdflag_z(output, iib); 448: if (flags && iib->flags.set & IIB_FLAG_V) 449: generate_clrflag_v(output, iib); 450: if (flags && iib->flags.set & IIB_FLAG_C) 451: generate_clrflag_c(output, iib); 452: break; 453: 454: case i_CMP: 455: generate_ea(output, iib, tp_src, 1); 456: generate_eaval(output, iib, tp_src); 457: generate_ea(output, iib, tp_dst, 1); 458: generate_eaval(output, iib, tp_dst); 459: switch (iib->size) { 460: case sz_byte: 461: generate_outdata(output, iib, "(sint8)dstdata - (sint8)srcdata"); 462: break; 463: case sz_word: 464: generate_outdata(output, iib, "(sint16)dstdata - (sint16)srcdata"); 465: break; 466: case sz_long: 467: generate_outdata(output, iib, "(sint32)dstdata - (sint32)srcdata"); 468: break; 469: default: 470: OUT("ERROR size\n"); 471: break; 472: } 473: if (flags) 474: OUT("\n"); 475: if (flags && iib->flags.set & IIB_FLAG_V) 476: generate_subflag_v(output, iib); 477: if (flags && iib->flags.set & IIB_FLAG_C) 478: generate_subflag_c(output, iib); 479: if (flags && iib->flags.set & IIB_FLAG_N) 480: generate_stdflag_n(output, iib); 481: if (flags && iib->flags.set & IIB_FLAG_Z) 482: generate_stdflag_z(output, iib); 483: break; 484: 485: case i_CMPA: 486: if (iib->dtype != dt_Areg || iib->size != sz_word) 487: OUT("Error\n"); 488: generate_ea(output, iib, tp_src, 1); 489: generate_eaval(output, iib, tp_src); 490: iib->size = sz_long; 491: generate_ea(output, iib, tp_dst, 1); 492: generate_eaval(output, iib, tp_dst); 493: OUT(" uint32 outdata = (sint32)dstdata - (sint32)(sint16)srcdata;\n"); 494: if (flags) 495: OUT("\n"); 496: if (flags && iib->flags.set & IIB_FLAG_V) 497: generate_cmpaflag_v(output, iib); 498: if (flags && iib->flags.set & IIB_FLAG_C) 499: generate_cmpaflag_c(output, iib); 500: if (flags && iib->flags.set & IIB_FLAG_N) 501: generate_stdflag_n(output, iib); 502: if (flags && iib->flags.set & IIB_FLAG_Z) 503: generate_stdflag_z(output, iib); 504: iib->size = sz_word; 505: break; 506: 507: case i_BTST: 508: case i_BCHG: 509: case i_BCLR: 510: case i_BSET: 511: generate_ea(output, iib, tp_src, 1); 512: generate_eaval(output, iib, tp_src); 513: generate_ea(output, iib, tp_dst, 1); 514: generate_eaval(output, iib, tp_dst); 515: switch (iib->size) { 516: case sz_byte: 517: OUT(" uint32 bitpos = 1<<(srcdata & 7);"); 518: break; 519: case sz_long: 520: OUT(" uint32 bitpos = 1<<(srcdata & 31);"); 521: break; 522: default: 523: OUT("ERROR size\n"); 524: break; 525: } 526: OUT("\n"); 527: switch(iib->mnemonic) { 528: case i_BTST: 529: break; 530: case i_BCHG: 531: generate_outdata(output, iib, "dstdata ^ bitpos"); 532: generate_eastore(output, iib, tp_dst); 533: break; 534: case i_BCLR: 535: generate_outdata(output, iib, "dstdata & ~bitpos"); 536: generate_eastore(output, iib, tp_dst); 537: break; 538: case i_BSET: 539: generate_outdata(output, iib, "dstdata | bitpos"); 540: generate_eastore(output, iib, tp_dst); 541: break; 542: default: 543: OUT("ERROR\n"); 544: break; 545: } 546: OUT("\n"); 547: OUT(" ZFLAG = !(dstdata & bitpos);\n"); 548: break; 549: 550: case i_MOVE: 551: generate_ea(output, iib, tp_src, 1); 552: generate_eaval(output, iib, tp_src); 553: generate_ea(output, iib, tp_dst, 1); 554: generate_outdata(output, iib, "srcdata"); 555: OUT("\n"); 556: generate_eastore(output, iib, tp_dst); 557: if (flags) 558: OUT("\n"); 559: if (flags && iib->flags.set & IIB_FLAG_V) 560: generate_clrflag_v(output, iib); 561: if (flags && iib->flags.set & IIB_FLAG_C) 562: generate_clrflag_c(output, iib); 563: if (flags && iib->flags.set & IIB_FLAG_N) 564: generate_stdflag_n(output, iib); 565: if (flags && iib->flags.set & IIB_FLAG_Z) 566: generate_stdflag_z(output, iib); 567: break; 568: 569: case i_MOVEA: 570: generate_ea(output, iib, tp_src, 1); 571: generate_eaval(output, iib, tp_src); 572: generate_ea(output, iib, tp_dst, 1); 573: if (iib->dtype != dt_Areg || iib->size != sz_word) 574: OUT("Error\n"); 575: OUT("\n"); 576: OUT(" ADDRREG(dstreg) = (sint32)(sint16)srcdata;\n"); 577: break; 578: 579: case i_MOVEPMR: 580: generate_ea(output, iib, tp_src, 1); 581: generate_ea(output, iib, tp_dst, 1); 582: generate_eaval(output, iib, tp_dst); 583: switch(iib->size) { 584: case sz_word: 585: generate_outdata(output, iib, "(fetchbyte(srcaddr) << 8) + " 586: "fetchbyte(srcaddr+2)"); 587: break; 588: case sz_long: 589: generate_outdata(output, iib, "(fetchbyte(srcaddr) << 24) | " 590: "(fetchbyte(srcaddr+2) << 16) | " 591: "\n (fetchbyte(srcaddr+4) << 8) | " 592: "fetchbyte(srcaddr+6)"); 593: break; 594: default: 595: OUT("ERROR size\n"); 596: break; 597: } 598: OUT("\n"); 599: generate_eastore(output, iib, tp_dst); 600: break; 601: 602: case i_MOVEPRM: 603: generate_ea(output, iib, tp_src, 1); 604: generate_eaval(output, iib, tp_src); 605: generate_ea(output, iib, tp_dst, 1); 606: OUT("\n"); 607: switch(iib->size) { 608: case sz_word: 609: OUT(" storebyte(dstaddr, (srcdata >> 8) & 0xFF);\n"); 610: OUT(" storebyte(dstaddr+2, srcdata & 0xFF);\n"); 611: break; 612: case sz_long: 613: OUT(" storebyte(dstaddr, (srcdata >> 24) & 0xFF);\n"); 614: OUT(" storebyte(dstaddr+2, (srcdata >> 16) & 0xFF);\n"); 615: OUT(" storebyte(dstaddr+4, (srcdata >> 8) & 0xFF);\n"); 616: OUT(" storebyte(dstaddr+6, srcdata & 0xFF);\n"); 617: break; 618: default: 619: OUT("ERROR size\n"); 620: break; 621: } 622: break; 623: 624: case i_MOVEFSR: 625: generate_ea(output, iib, tp_src, 1); 626: generate_outdata(output, iib, NULL); 627: OUT("\n"); 628: OUT(" outdata = SR;\n"); 629: generate_eastore(output, iib, tp_src); 630: break; 631: 632: case i_MOVETSR: 633: generate_ea(output, iib, tp_src, 1); 634: generate_eaval(output, iib, tp_src); 635: OUT(" unsigned int sr = reg68k_sr.sr_struct.s;\n"); 636: OUT("\n"); 637: if (DEBUG_SR) 638: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n", 639: output); 640: switch (iib->size) { 641: case sz_byte: 642: OUT(" SR = (SR & ~0xFF) | srcdata;\n"); 643: break; 644: case sz_word: 645: OUT(" if (!SFLAG)\n"); 1.1.1.2 ! root 646: fprintf(output, " reg68k_internal_vector(V_PRIVILEGE, PC+%d);\n", 1.1 root 647: (iib->wordlen)*2); 648: OUT("\n"); 649: OUT(" SR = srcdata;\n"); 650: break; 651: default: 652: OUT("ERROR size\n"); 653: break; 654: } 655: OUT(" if (sr != (uint8)reg68k_sr.sr_struct.s) {\n"); 656: OUT(" /* mode change, swap SP and A7 */\n"); 657: OUT(" ADDRREG(7)^= SP; SP^= ADDRREG(7); ADDRREG(7)^= SP;\n"); 658: OUT(" }\n"); 659: if (DEBUG_SR) 660: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n", 661: output); 662: break; 663: 664: case i_MOVEMRM: 665: generate_ea(output, iib, tp_src, 1); 666: generate_eaval(output, iib, tp_src); 667: generate_ea(output, iib, tp_dst, 0); 668: if (iib->dtype == dt_Adec) { 669: OUT(" uint8 datamask = (srcdata & 0xFF00) >> 8;\n"); 670: OUT(" uint8 addrmask = srcdata & 0xFF;"); 671: OUT("\n"); 672: switch(iib->size) { 673: case sz_word: 674: OUT(" while (addrmask) {\n"); 675: OUT(" dstaddr-= 2;\n"); 676: OUT(" storeword(dstaddr, ADDRREG((7-movem_bit[addrmask])));\n"); 677: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n"); 678: OUT(" }\n"); 679: OUT(" while (datamask) {\n"); 680: OUT(" dstaddr-= 2;\n"); 681: OUT(" storeword(dstaddr, DATAREG((7-movem_bit[datamask])));\n"); 682: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n"); 683: OUT(" }\n"); 684: break; 685: case sz_long: 686: OUT(" while (addrmask) {\n"); 687: OUT(" dstaddr-= 4;\n"); 688: OUT(" storelong(dstaddr, ADDRREG((7-movem_bit[addrmask])));\n"); 689: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n"); 690: OUT(" }\n"); 691: OUT(" while (datamask) {\n"); 692: OUT(" dstaddr-= 4;\n"); 693: OUT(" storelong(dstaddr, "); 694: OUT("DATAREG((7-movem_bit[datamask])));\n"); 695: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n"); 696: OUT(" }\n"); 697: break; 698: default: 699: OUT("ERROR\n"); 700: break; 701: } 702: OUT(" ADDRREG(dstreg) = dstaddr;"); 703: } else { 704: OUT(" uint8 addrmask = (srcdata & 0xFF00) >> 8;\n"); 705: OUT(" uint8 datamask = srcdata & 0xFF;"); 706: OUT("\n"); 707: switch(iib->size) { 708: case sz_word: 709: OUT(" while (datamask) {\n"); 710: OUT(" storeword(dstaddr, DATAREG(movem_bit[datamask]));\n"); 711: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n"); 712: OUT(" dstaddr+= 2;\n"); 713: OUT(" }\n"); 714: OUT(" while (addrmask) {\n"); 715: OUT(" storeword(dstaddr, ADDRREG(movem_bit[addrmask]));\n"); 716: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n"); 717: OUT(" dstaddr+= 2;\n"); 718: OUT(" }\n"); 719: break; 720: case sz_long: 721: OUT(" while (datamask) {\n"); 722: OUT(" storelong(dstaddr, DATAREG(movem_bit[datamask]));\n"); 723: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n"); 724: OUT(" dstaddr+= 4;\n"); 725: OUT(" }\n"); 726: OUT(" while (addrmask) {\n"); 727: OUT(" storelong(dstaddr, ADDRREG(movem_bit[addrmask]));\n"); 728: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n"); 729: OUT(" dstaddr+= 4;\n"); 730: OUT(" }\n"); 731: break; 732: default: 733: OUT("ERROR\n"); 734: break; 735: } 736: if (iib->dtype == dt_Ainc) { 737: /* not supported */ 738: OUT("ERROR\n"); 739: } 740: } 741: break; 742: 743: case i_MOVEMMR: 744: generate_ea(output, iib, tp_src, 1); 745: generate_eaval(output, iib, tp_src); 746: generate_ea(output, iib, tp_dst, 0); 747: OUT(" uint8 addrmask = (srcdata & 0xFF00) >> 8;\n"); 748: OUT(" uint8 datamask = srcdata & 0xFF;"); 749: OUT("\n"); 750: switch(iib->size) { 751: case sz_word: 752: OUT(" while (datamask) {\n"); 753: OUT(" DATAREG(movem_bit[datamask]) = "); 754: OUT("(sint32)(sint16)fetchword(dstaddr);\n"); 755: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n"); 756: OUT(" dstaddr+= 2;\n"); 757: OUT(" }\n"); 758: OUT(" while (addrmask) {\n"); 759: OUT(" ADDRREG(movem_bit[addrmask]) = "); 760: OUT("(sint32)(sint16)fetchword(dstaddr);\n"); 761: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n"); 762: OUT(" dstaddr+= 2;\n"); 763: OUT(" }\n"); 764: break; 765: case sz_long: 766: OUT(" while (datamask) {\n"); 767: OUT(" DATAREG(movem_bit[datamask]) = fetchlong(dstaddr);\n"); 768: OUT(" datamask&= ~(1<<movem_bit[datamask]);\n"); 769: OUT(" dstaddr+= 4;\n"); 770: OUT(" }\n"); 771: OUT(" while (addrmask) {\n"); 772: OUT(" ADDRREG(movem_bit[addrmask]) = fetchlong(dstaddr);\n"); 773: OUT(" addrmask&= ~(1<<movem_bit[addrmask]);\n"); 774: OUT(" dstaddr+= 4;\n"); 775: OUT(" }\n"); 776: break; 777: default: 778: OUT("ERROR\n"); 779: break; 780: } 781: if (iib->dtype == dt_Ainc) { 782: OUT(" ADDRREG(dstreg) = dstaddr;\n"); 783: } else if (iib->dtype == dt_Adec) { 784: /* not supported */ 785: OUT("ERROR\n"); 786: } 787: break; 788: 789: case i_MOVETUSP: 790: generate_ea(output, iib, tp_src, 1); 791: generate_eaval(output, iib, tp_src); 792: OUT("\n"); 793: OUT(" if (!SFLAG)\n"); 1.1.1.2 ! root 794: fprintf(output, " reg68k_internal_vector(V_PRIVILEGE, PC+%d);\n", 1.1 root 795: (iib->wordlen)*2); 796: OUT("\n"); 797: OUT(" SP = srcdata;\n"); 798: break; 799: 800: case i_MOVEFUSP: 801: generate_ea(output, iib, tp_src, 1); 802: OUT(" uint32 outdata;\n"); 803: OUT("\n"); 804: OUT(" if (!SFLAG)\n"); 1.1.1.2 ! root 805: fprintf(output, " reg68k_internal_vector(V_PRIVILEGE, PC+%d);\n", 1.1 root 806: (iib->wordlen)*2); 807: OUT("\n"); 808: OUT(" outdata = SP;\n"); 809: generate_eastore(output, iib, tp_src); 810: break; 811: 812: case i_NEG: 813: generate_ea(output, iib, tp_src, 1); 814: generate_eaval(output, iib, tp_src); 815: switch (iib->size) { 816: case sz_byte: 817: generate_outdata(output, iib, "0 - (sint8)srcdata"); 818: break; 819: case sz_word: 820: generate_outdata(output, iib, "0 - (sint16)srcdata"); 821: break; 822: case sz_long: 823: generate_outdata(output, iib, "0 - (sint32)srcdata"); 824: break; 825: default: 826: OUT("ERROR size\n"); 827: break; 828: } 829: OUT("\n"); 830: generate_eastore(output, iib, tp_src); 831: if (flags) 832: OUT("\n"); 833: if (flags && iib->flags.set & IIB_FLAG_V) 834: generate_negflag_v(output, iib); 835: if (flags && ((iib->flags.set & IIB_FLAG_C) || 836: (iib->flags.set & IIB_FLAG_X))) 837: generate_negflag_cx(output, iib); 838: if (flags && iib->flags.set & IIB_FLAG_N) 839: generate_stdflag_n(output, iib); 840: if (flags && iib->flags.set & IIB_FLAG_Z) 841: generate_stdflag_z(output, iib); 842: break; 843: 844: case i_NEGX: 845: generate_ea(output, iib, tp_src, 1); 846: generate_eaval(output, iib, tp_src); 847: switch (iib->size) { 848: case sz_byte: 849: generate_outdata(output, iib, "0 - (sint8)srcdata - XFLAG"); 850: break; 851: case sz_word: 852: generate_outdata(output, iib, "0 - (sint16)srcdata - XFLAG"); 853: break; 854: case sz_long: 855: generate_outdata(output, iib, "0 - (sint32)srcdata - XFLAG"); 856: break; 857: default: 858: OUT("ERROR size\n"); 859: break; 860: } 861: OUT("\n"); 862: generate_eastore(output, iib, tp_src); 863: if (flags) 864: OUT("\n"); 865: if (flags && iib->flags.set & IIB_FLAG_V) 866: generate_negxflag_v(output, iib); 867: if (flags && ((iib->flags.set & IIB_FLAG_C) || 868: (iib->flags.set & IIB_FLAG_X))) 869: generate_negxflag_cx(output, iib); 870: if (flags && iib->flags.set & IIB_FLAG_N) 871: generate_stdflag_n(output, iib); 872: if (flags && iib->flags.set & IIB_FLAG_Z) 873: generate_stdxflag_z(output, iib); 874: break; 875: 876: case i_CLR: 877: generate_ea(output, iib, tp_src, 1); 878: generate_eaval(output, iib, tp_src); /* read before write */ 879: generate_outdata(output, iib, "0"); 880: OUT("\n"); 881: generate_eastore(output, iib, tp_src); 882: if (flags) 883: OUT("\n"); 884: if (flags && iib->flags.set & IIB_FLAG_V) 885: generate_clrflag_v(output, iib); 886: if (flags && iib->flags.set & IIB_FLAG_C) 887: generate_clrflag_c(output, iib); 888: if (flags && iib->flags.set & IIB_FLAG_N) 889: generate_clrflag_n(output, iib); 890: if (flags && iib->flags.set & IIB_FLAG_Z) 891: generate_setflag_z(output, iib); 892: break; 893: 894: case i_NOT: 895: generate_ea(output, iib, tp_src, 1); 896: generate_eaval(output, iib, tp_src); /* read before write */ 897: generate_outdata(output, iib, "~srcdata"); 898: OUT("\n"); 899: generate_eastore(output, iib, tp_src); 900: if (flags) 901: OUT("\n"); 902: if (flags && iib->flags.set & IIB_FLAG_V) 903: generate_clrflag_v(output, iib); 904: if (flags && iib->flags.set & IIB_FLAG_C) 905: generate_clrflag_c(output, iib); 906: if (flags && iib->flags.set & IIB_FLAG_N) 907: generate_stdflag_n(output, iib); 908: if (flags && iib->flags.set & IIB_FLAG_Z) 909: generate_stdflag_z(output, iib); 910: break; 911: 912: case i_ABCD: 913: generate_ea(output, iib, tp_src, 1); 914: generate_eaval(output, iib, tp_src); 915: generate_ea(output, iib, tp_dst, 1); 916: generate_eaval(output, iib, tp_dst); 917: generate_outdata(output, iib, NULL); 918: OUT("\n"); 919: OUT(" uint8 outdata_low = (dstdata & 0xF) + (srcdata & 0xF) "); 920: OUT("+ XFLAG;\n"); 921: OUT(" uint8 outdata_high = (dstdata>>4) + (srcdata>>4);\n"); 922: OUT("\n"); 923: OUT(" if (outdata_low > 9) {\n"); 924: OUT(" outdata_low-=10; outdata_high++;\n"); 925: OUT(" }\n"); 926: OUT(" if (outdata_high > 9) {\n"); 927: OUT(" outdata_high-=10;\n"); 928: if (flags && iib->flags.set & IIB_FLAG_C) 929: OUT(" CFLAG = 1;\n"); 930: if (flags && iib->flags.set & IIB_FLAG_X) 931: OUT(" XFLAG = 1;\n"); 932: OUT(" } else {\n"); 933: if (flags && iib->flags.set & IIB_FLAG_C) 934: OUT(" CFLAG = 0;\n"); 935: if (flags && iib->flags.set & IIB_FLAG_X) 936: OUT(" XFLAG = 0;\n"); 937: OUT(" }\n"); 938: OUT(" outdata = outdata_low | (outdata_high << 4);\n"); 939: if (flags && iib->flags.set & IIB_FLAG_Z) 940: OUT(" if (outdata) ZFLAG = 0;\n"); 941: generate_eastore(output, iib, tp_dst); 942: break; 943: 944: case i_SBCD: 945: generate_ea(output, iib, tp_src, 1); 946: generate_eaval(output, iib, tp_src); 947: generate_ea(output, iib, tp_dst, 1); 948: generate_eaval(output, iib, tp_dst); 949: generate_outdata(output, iib, NULL); 950: OUT("\n"); 951: OUT(" sint8 outdata_low = (sint8)(dstdata & 0xF) -"); 952: OUT("(sint8)(srcdata & 0xF) - XFLAG;\n"); 953: OUT(" sint8 outdata_high = (sint8)(dstdata>>4) - "); 954: OUT("(sint8)(srcdata>>4);\n"); 955: OUT("\n"); 956: OUT(" if (outdata_low < 0) {\n"); 957: OUT(" outdata_low+=10; outdata_high--;\n"); 958: OUT(" }\n"); 959: OUT(" if (outdata_high < 0) {\n"); 960: OUT(" outdata_high+=10;\n"); 961: if (flags && iib->flags.set & IIB_FLAG_C) 962: OUT(" CFLAG = 1;\n"); 963: if (flags && iib->flags.set & IIB_FLAG_X) 964: OUT(" XFLAG = 1;\n"); 965: OUT(" } else {\n"); 966: if (flags && iib->flags.set & IIB_FLAG_C) 967: OUT(" CFLAG = 0;\n"); 968: if (flags && iib->flags.set & IIB_FLAG_X) 969: OUT(" XFLAG = 0;\n"); 970: OUT(" }\n"); 971: OUT(" outdata = (uint8)outdata_low | "); 972: OUT("((uint8)outdata_high << 4);\n"); 973: if (flags && iib->flags.set & IIB_FLAG_Z) 974: OUT(" if (outdata) ZFLAG = 0;\n"); 975: generate_eastore(output, iib, tp_dst); 976: break; 977: 978: case i_NBCD: 979: generate_ea(output, iib, tp_src, 1); 980: generate_eaval(output, iib, tp_src); 981: generate_outdata(output, iib, NULL); 982: OUT("\n"); 983: OUT(" sint8 outdata_low = 0 - (sint8)(srcdata & 0xF) - XFLAG;\n"); 984: OUT(" sint8 outdata_high = 0 - (sint8)(srcdata>>4);\n"); 985: OUT("\n"); 986: OUT(" if ((sint8)outdata_low < 0) {\n"); 987: OUT(" outdata_low+=10; outdata_high--;\n"); 988: OUT(" }\n"); 989: OUT(" if ((sint8)outdata_high < 0) {\n"); 990: OUT(" outdata_high+=10;\n"); 991: if (flags && iib->flags.set & IIB_FLAG_C) 992: OUT(" CFLAG = 1;\n"); 993: if (flags && iib->flags.set & IIB_FLAG_X) 994: OUT(" XFLAG = 1;\n"); 995: OUT(" } else {\n"); 996: if (flags && iib->flags.set & IIB_FLAG_C) 997: OUT(" CFLAG = 0;\n"); 998: if (flags && iib->flags.set & IIB_FLAG_X) 999: OUT(" XFLAG = 0;\n"); 1000: OUT(" }\n"); 1001: OUT(" outdata = (uint8)outdata_low |"); 1002: OUT("((uint8)outdata_high << 4);\n"); 1003: if (flags && iib->flags.set & IIB_FLAG_Z) 1004: OUT(" if (outdata) ZFLAG = 0;\n"); 1005: generate_eastore(output, iib, tp_src); 1006: break; 1007: 1008: case i_SWAP: 1009: generate_ea(output, iib, tp_src, 1); 1010: generate_eaval(output, iib, tp_src); 1011: generate_outdata(output, iib, "(srcdata>>16) | (srcdata<<16)"); 1012: OUT("\n"); 1013: generate_eastore(output, iib, tp_src); 1014: if (flags) 1015: OUT("\n"); 1016: if (flags && iib->flags.set & IIB_FLAG_V) 1017: generate_clrflag_v(output, iib); 1018: if (flags && iib->flags.set & IIB_FLAG_C) 1019: generate_clrflag_c(output, iib); 1020: if (flags && iib->flags.set & IIB_FLAG_N) 1021: generate_stdflag_n(output, iib); 1022: if (flags && iib->flags.set & IIB_FLAG_Z) 1023: generate_stdflag_z(output, iib); 1024: break; 1025: 1026: case i_PEA: 1027: generate_ea(output, iib, tp_src, 1); 1028: OUT("\n"); 1029: OUT(" ADDRREG(7)-= 4;\n"); 1030: OUT(" storelong(ADDRREG(7), srcaddr);\n"); 1031: break; 1032: 1033: case i_LEA: 1034: generate_ea(output, iib, tp_src, 1); 1035: generate_ea(output, iib, tp_dst, 1); 1036: generate_outdata(output, iib, "srcaddr"); 1037: OUT("\n"); 1038: generate_eastore(output, iib, tp_dst); 1039: break; 1040: 1041: case i_EXT: 1042: generate_ea(output, iib, tp_src, 1); 1043: generate_eaval(output, iib, tp_src); 1044: OUT("\n"); 1045: switch(iib->size) { 1046: case sz_word: 1047: generate_outdata(output, iib, "(sint16)(sint8)(srcdata)"); 1048: break; 1049: case sz_long: 1050: generate_outdata(output, iib, "(sint32)(sint16)(srcdata)"); 1051: break; 1052: default: 1053: fprintf(output, "ERROR size\n"); 1054: break; 1055: } 1056: generate_eastore(output, iib, tp_src); 1057: if (flags) 1058: OUT("\n"); 1059: if (flags && iib->flags.set & IIB_FLAG_V) 1060: generate_clrflag_v(output, iib); 1061: if (flags && iib->flags.set & IIB_FLAG_C) 1062: generate_clrflag_c(output, iib); 1063: if (flags && iib->flags.set & IIB_FLAG_N) 1064: generate_stdflag_n(output, iib); 1065: if (flags && iib->flags.set & IIB_FLAG_Z) 1066: generate_stdflag_z(output, iib); 1067: break; 1068: 1069: case i_EXG: 1070: generate_ea(output, iib, tp_src, 1); 1071: generate_eaval(output, iib, tp_src); 1072: generate_ea(output, iib, tp_dst, 1); 1073: generate_eaval(output, iib, tp_dst); 1074: OUT("\n"); 1075: switch (iib->dtype) { 1076: case dt_Dreg: 1077: OUT(" DATAREG(dstreg) = srcdata;\n"); 1078: break; 1079: case dt_Areg: 1080: OUT(" ADDRREG(dstreg) = srcdata;\n"); 1081: break; 1082: default: 1083: OUT("ERROR size\n"); 1084: break; 1085: } 1086: switch (iib->stype) { 1087: case dt_Dreg: 1088: OUT(" DATAREG(srcreg) = dstdata;\n"); 1089: break; 1090: case dt_Areg: 1091: OUT(" ADDRREG(srcreg) = dstdata;\n"); 1092: break; 1093: default: 1094: OUT("ERROR size\n"); 1095: break; 1096: } 1097: break; 1098: 1099: case i_TST: 1100: generate_ea(output, iib, tp_src, 1); 1101: generate_eaval(output, iib, tp_src); 1102: generate_outdata(output, iib, "srcdata"); 1103: if (flags) 1104: OUT("\n"); 1105: if (flags && iib->flags.set & IIB_FLAG_V) 1106: generate_clrflag_v(output, iib); 1107: if (flags && iib->flags.set & IIB_FLAG_C) 1108: generate_clrflag_c(output, iib); 1109: if (flags && iib->flags.set & IIB_FLAG_N) 1110: generate_stdflag_n(output, iib); 1111: if (flags && iib->flags.set & IIB_FLAG_Z) 1112: generate_stdflag_z(output, iib); 1113: break; 1114: 1115: case i_TAS: 1116: generate_ea(output, iib, tp_src, 1); 1117: generate_eaval(output, iib, tp_src); 1118: generate_outdata(output, iib, "srcdata"); 1119: if (flags) 1120: OUT("\n"); 1121: if (flags && iib->flags.set & IIB_FLAG_V) 1122: generate_clrflag_v(output, iib); 1123: if (flags && iib->flags.set & IIB_FLAG_C) 1124: generate_clrflag_c(output, iib); 1125: if (flags && iib->flags.set & IIB_FLAG_N) 1126: generate_stdflag_n(output, iib); 1127: if (flags && iib->flags.set & IIB_FLAG_Z) 1128: generate_stdflag_z(output, iib); 1129: switch(iib->size) { 1130: case sz_byte: 1131: OUT(" outdata|= 1<<7;\n"); 1132: break; 1133: case sz_word: 1134: OUT(" outdata|= 1<<15;\n"); 1135: break; 1136: case sz_long: 1137: OUT(" outdata|= 1<<31;\n"); 1138: break; 1139: default: 1140: OUT("ERROR size\n"); 1141: break; 1142: } 1143: generate_eastore(output, iib, tp_src); 1144: break; 1145: 1146: case i_CHK: 1147: generate_ea(output, iib, tp_src, 1); 1148: generate_eaval(output, iib, tp_src); 1149: generate_ea(output, iib, tp_dst, 1); 1150: generate_eaval(output, iib, tp_dst); 1151: fprintf(output, "\n"); 1152: if (iib->size != sz_word) 1153: OUT("ERROR size\n"); 1154: fprintf(output, " if ((sint16)srcdata < 0) {\n"); 1155: if (flags) 1156: OUT(" NFLAG = 1;\n"); 1.1.1.2 ! root 1157: fprintf(output, " reg68k_internal_vector(V_CHK, PC+%d);\n", 1.1 root 1158: (iib->wordlen)*2); 1159: OUT(" } else if (dstdata > srcdata) {\n"); 1160: if (flags) 1161: OUT(" NFLAG = 0;\n"); 1.1.1.2 ! root 1162: fprintf(output, " reg68k_internal_vector(V_CHK, PC+%d);\n", 1.1 root 1163: (iib->wordlen)*2); 1164: OUT(" }\n"); 1165: break; 1166: 1167: case i_TRAPV: 1168: OUT(" if (VFLAG) {\n"); 1.1.1.2 ! root 1169: fprintf(output, " reg68k_internal_vector(V_TRAPV, PC+%d);\n", 1.1 root 1170: (iib->wordlen)*2); 1171: OUT(" }\n"); 1172: break; 1173: 1174: case i_TRAP: 1175: generate_ea(output, iib, tp_src, 1); 1176: generate_eaval(output, iib, tp_src); 1177: OUT("\n"); 1.1.1.2 ! root 1178: fprintf(output, " reg68k_internal_vector(V_TRAP+srcdata, PC+%d);\n", 1.1 root 1179: (iib->wordlen)*2); 1180: pcinc = 0; 1181: break; 1182: 1183: case i_RESET: 1184: OUT(" printf(\"RESET @ %x\\n\", PC);\n"); 1185: OUT(" exit(1);\n"); 1186: break; 1187: 1188: case i_NOP: 1189: /* NOP */ 1190: break; 1191: 1192: case i_STOP: 1193: generate_ea(output, iib, tp_src, 1); 1194: generate_eaval(output, iib, tp_src); 1195: OUT("\n"); 1.1.1.2 ! root 1196: OUT(" if (regs.stop)\n"); ! 1197: OUT(" return;\n"); ! 1198: OUT(" if (!(SFLAG && (srcdata & 1<<13))) {\n"); ! 1199: fprintf(output, " reg68k_internal_vector(V_PRIVILEGE, PC+%d);\n", 1.1 root 1200: (iib->wordlen)*2); 1.1.1.2 ! root 1201: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2); ! 1202: OUT(" } else {\n"); 1.1 root 1203: OUT(" SR = srcdata;\n"); 1204: OUT(" STOP = 1;\n"); 1.1.1.2 ! root 1205: OUT(" }\n"); ! 1206: pcinc = 0; 1.1 root 1207: break; 1208: 1209: case i_LINK: 1210: generate_ea(output, iib, tp_src, 1); 1211: generate_eaval(output, iib, tp_src); 1212: generate_ea(output, iib, tp_dst, 1); 1213: generate_eaval(output, iib, tp_dst); 1214: if (iib->stype != dt_ImmW) 1215: OUT("ERROR stype\n"); 1216: OUT("\n"); 1217: OUT(" ADDRREG(7)-= 4;\n"); 1218: OUT(" storelong(ADDRREG(7), dstdata);\n"); 1219: OUT(" ADDRREG(dstreg) = ADDRREG(7);\n"); 1220: OUT(" ADDRREG(7)+= (sint16)srcdata;\n"); 1221: break; 1222: 1223: case i_UNLK: 1224: generate_ea(output, iib, tp_src, 1); 1225: generate_eaval(output, iib, tp_src); 1226: OUT("\n"); 1227: OUT(" ADDRREG(srcreg) = fetchlong(srcdata);\n"); 1228: OUT(" ADDRREG(7) = srcdata+4;\n"); 1229: break; 1230: 1231: case i_RTE: 1232: if (DEBUG_RTE) 1233: fputs(" printf(\"RTE: 0x%X\\n\", PC);\n", output); 1234: if (DEBUG_SR) 1235: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n", 1236: output); 1237: OUT(" if (!SFLAG)\n"); 1.1.1.2 ! root 1238: fprintf(output, " reg68k_internal_vector(V_PRIVILEGE, PC+%d);\n", 1.1 root 1239: (iib->wordlen)*2); 1240: OUT("\n"); 1241: OUT(" SR = fetchword(ADDRREG(7));\n"); 1242: OUT(" PC = fetchlong(ADDRREG(7)+2);\n"); 1243: OUT(" ADDRREG(7)+= 6;\n"); 1244: OUT(" if (!reg68k_sr.sr_struct.s) {\n"); 1245: OUT(" /* mode change, swap SP and A7 */\n"); 1246: OUT(" ADDRREG(7)^= SP; SP^= ADDRREG(7); ADDRREG(7)^= SP;\n"); 1247: OUT(" }\n"); 1248: if (DEBUG_RTE) 1249: fputs(" printf(\"RTE: ->0x%X\\n\", PC);\n", output); 1250: if (DEBUG_SR) 1251: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n", 1252: output); 1253: pcinc = 0; 1254: break; 1255: 1256: case i_RTS: 1257: if (DEBUG_BRANCH) 1258: fputs(" printf(\"RTS: 0x%X\\n\", PC);", output); 1259: OUT(" PC = fetchlong(ADDRREG(7));\n"); 1260: OUT(" ADDRREG(7)+= 4;\n"); 1261: if (DEBUG_BRANCH) 1262: fputs(" printf(\"RTS: ->0x%X\\n\", PC);", output); 1263: pcinc = 0; 1264: break; 1265: 1266: case i_RTR: 1267: if (DEBUG_BRANCH) 1268: fputs(" printf(\"RTR: 0x%X\\n\", PC);\n", output); 1269: if (DEBUG_SR) 1270: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n", 1271: output); 1272: OUT(" SR = (SR & ~0xFF) | (fetchword(ADDRREG(7)) & 0xFF);\n"); 1273: OUT(" PC = fetchlong(ADDRREG(7)+2);\n"); 1274: OUT(" ADDRREG(7)+= 6;\n"); 1275: if (DEBUG_BRANCH) 1276: fputs(" printf(\"RTR: ->0x%X\\n\", PC);\n", output); 1277: if (DEBUG_SR) 1278: fputs(" printf(\"SR: %08X %04X\\n\", PC, reg68k_sr.sr_int);\n", 1279: output); 1280: pcinc = 0; 1281: break; 1282: 1283: case i_JSR: 1284: generate_ea(output, iib, tp_src, 1); 1285: OUT("\n"); 1286: if (DEBUG_BRANCH) 1287: fputs(" printf(\"JSR: 0x%X\\n\", PC);\n", output); 1288: OUT(" ADDRREG(7)-= 4;\n"); 1289: fprintf(output, " storelong(ADDRREG(7), PC+%d);\n", (iib->wordlen)*2); 1290: OUT(" PC = srcaddr;\n"); 1291: if (DEBUG_BRANCH) 1292: fputs(" printf(\"JSR: ->0x%X\\n\", PC);", output); 1293: pcinc = 0; 1294: break; 1295: 1296: case i_JMP: 1297: generate_ea(output, iib, tp_src, 1); 1298: OUT("\n"); 1299: if (DEBUG_BRANCH) 1300: fputs(" printf(\"JMP: 0x%X\\n\", PC);", output); 1301: OUT(" PC = srcaddr;\n"); 1302: if (DEBUG_BRANCH) 1303: fputs(" printf(\"JMP: ->0x%X\\n\", PC);\n", output); 1304: pcinc = 0; 1305: break; 1306: 1307: case i_Scc: 1308: generate_ea(output, iib, tp_src, 1); 1309: generate_cc(output, iib); 1310: generate_outdata(output, iib, "cc ? (uint8)(-1) : 0"); 1311: OUT("\n"); 1312: generate_eastore(output, iib, tp_src); 1313: break; 1314: 1315: case i_SF: 1316: generate_ea(output, iib, tp_src, 1); 1317: generate_outdata(output, iib, "0"); 1318: OUT("\n"); 1319: generate_eastore(output, iib, tp_src); 1320: break; 1321: 1322: case i_DBcc: 1323: /* special case where ipc holds the already PC-relative value */ 1324: fprintf(output, " uint32 srcdata = ipc->src;\n"); 1325: generate_ea(output, iib, tp_dst, 1); 1326: generate_eaval(output, iib, tp_dst); 1327: generate_cc(output, iib); 1328: fprintf(output, "\n"); 1329: if (iib->size != sz_word) { 1330: OUT("ERROR size\n"); 1331: } 1332: OUT(" if (!cc) {\n"); 1333: OUT(" dstdata-= 1;\n"); 1334: OUT(" DATAREG(dstreg) = (DATAREG(dstreg) & ~0xFFFF)\n"); 1335: OUT("| (dstdata & 0xFFFF);\n"); 1336: OUT(" if ((sint16)dstdata != -1)\n"); 1337: OUT(" PC = srcdata;\n"); 1338: OUT(" else\n"); 1339: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2); 1340: OUT(" } else\n"); 1341: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2); 1342: pcinc = 0; 1343: break; 1344: 1345: case i_DBRA: 1346: /* special case where ipc holds the already PC-relative value */ 1347: fprintf(output, " uint32 srcdata = ipc->src;\n"); 1348: generate_ea(output, iib, tp_dst, 1); 1349: generate_eaval(output, iib, tp_dst); 1350: OUT("\n"); 1351: if (iib->size != sz_word) { 1352: OUT("ERROR size\n"); 1353: } 1354: OUT(" dstdata-= 1;\n"); 1355: OUT(" DATAREG(dstreg) = (DATAREG(dstreg) & ~0xFFFF) | "); 1356: OUT("(dstdata & 0xFFFF);\n"); 1357: OUT(" if ((sint16)dstdata != -1)\n"); 1358: OUT(" PC = srcdata;\n"); 1359: OUT(" else\n"); 1360: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2); 1361: pcinc = 0; 1362: break; 1363: 1364: case i_Bcc: 1365: /* special case where ipc holds the already PC-relative value */ 1366: OUT(" uint32 srcdata = ipc->src;\n"); 1367: generate_cc(output, iib); 1368: OUT("\n"); 1369: if (DEBUG_BRANCH) 1370: fputs(" printf(\"Bcc: 0x%X\\n\", PC);\n", output); 1371: OUT(" if (cc)\n"); 1372: OUT(" PC = srcdata;\n"); 1373: OUT(" else\n"); 1374: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2); 1375: if (DEBUG_BRANCH) 1376: fputs(" printf(\"Bcc: ->0x%X\\n\", PC);\n", output); 1377: pcinc = 0; 1378: break; 1379: 1380: case i_BSR: 1381: /* special case where ipc holds the already PC-relative value */ 1382: OUT(" uint32 srcdata = ipc->src;\n"); 1383: OUT("\n"); 1384: if (DEBUG_BRANCH) 1385: fputs(" printf(\"BSR: 0x%X\\n\", PC);\n", output); 1386: OUT(" ADDRREG(7)-= 4;\n"); 1387: fprintf(output, " storelong(ADDRREG(7), PC+%d);\n", (iib->wordlen)*2); 1388: OUT(" PC = srcdata;\n"); 1389: if (DEBUG_BRANCH) 1390: fputs(" printf(\"BSR: ->0x%X\\n\", PC);\n", output); 1391: pcinc = 0; 1392: break; 1393: 1394: case i_DIVU: 1395: /* DIVx is the only instruction that has different sizes for the 1396: source and destination! */ 1397: if (iib->dtype != dt_Dreg) 1398: OUT("ERROR dtype\n"); 1399: generate_ea(output, iib, tp_src, 1); 1400: generate_eaval(output, iib, tp_src); /* 16bit EA */ 1401: generate_ea(output, iib, tp_dst, 1); /* 32bit Dn */ 1402: OUT(" uint32 dstdata = DATAREG(dstreg);\n"); 1403: OUT(" uint32 quotient;\n"); 1404: OUT("\n"); 1405: OUT(" if (srcdata == 0) {\n"); 1.1.1.2 ! root 1406: fprintf(output, " reg68k_internal_vector(V_ZERO, PC+%d);\n", 1.1 root 1407: (iib->wordlen)*2); 1408: OUT(" return;\n"); 1409: OUT(" }\n"); 1410: OUT(" quotient = dstdata / srcdata;\n"); 1411: OUT(" if ((quotient & 0xffff0000) == 0) {\n"); 1412: OUT(" DATAREG(dstreg) = quotient | "); 1413: OUT("(((uint16)(dstdata % srcdata))<<16);\n"); 1414: if (flags && iib->flags.set & IIB_FLAG_V) 1415: OUT(" VFLAG = 0;\n"); 1416: if (flags && iib->flags.set & IIB_FLAG_N) 1417: OUT(" NFLAG = ((sint16)quotient) < 0;\n"); 1418: if (flags && iib->flags.set & IIB_FLAG_Z) 1419: OUT(" ZFLAG = !((uint16)quotient);\n"); 1420: if (flags && (iib->flags.set & IIB_FLAG_V || 1421: iib->flags.set & IIB_FLAG_N)) { 1422: OUT(" } else {\n"); 1423: if (flags && iib->flags.set & IIB_FLAG_V) 1424: OUT(" VFLAG = 1;\n"); 1425: if (flags && iib->flags.set & IIB_FLAG_N) 1426: OUT(" NFLAG = 1;\n"); 1427: } 1428: OUT(" }\n"); 1429: if (flags && iib->flags.set & IIB_FLAG_C) 1430: OUT(" CFLAG = 0;\n"); 1431: break; 1432: 1433: case i_DIVS: 1434: /* DIVx is the only instruction that has different sizes for the 1435: source and destination! */ 1436: if (iib->dtype != dt_Dreg) 1437: OUT("ERROR dtype\n"); 1438: generate_ea(output, iib, tp_src, 1); 1439: generate_eaval(output, iib, tp_src); /* 16bit EA */ 1440: generate_ea(output, iib, tp_dst, 1); /* 32bit Dn */ 1441: OUT(" sint32 dstdata = DATAREG(dstreg);\n"); 1442: OUT(" sint32 quotient;\n"); 1443: OUT(" sint16 remainder;\n"); 1444: OUT("\n"); 1445: OUT(" if (srcdata == 0) {\n"); 1.1.1.2 ! root 1446: fprintf(output, " reg68k_internal_vector(V_ZERO, PC+%d);\n", 1.1 root 1447: (iib->wordlen)*2); 1448: OUT(" return;\n"); 1449: OUT(" }\n"); 1450: OUT(" quotient = dstdata / (sint16)srcdata;\n"); 1451: OUT(" remainder = dstdata % (sint16)srcdata;\n"); 1452: OUT(" if (((quotient & 0xffff8000) == 0) ||\n"); 1453: OUT(" ((quotient & 0xffff8000) == 0xffff8000)) {\n"); 1454: OUT(" if ((quotient < 0) != (remainder < 0))\n"); 1455: OUT(" remainder = -remainder;\n"); 1456: OUT(" DATAREG(dstreg) = ((uint16)quotient) | "); 1457: OUT("(((uint16)(remainder))<<16);\n"); 1458: if (flags && iib->flags.set & IIB_FLAG_V) 1459: OUT(" VFLAG = 0;\n"); 1460: if (flags && iib->flags.set & IIB_FLAG_N) 1461: OUT(" NFLAG = ((sint16)quotient) < 0;\n"); 1462: if (flags && iib->flags.set & IIB_FLAG_Z) 1463: OUT(" ZFLAG = !((uint16)quotient);\n"); 1464: if (flags && (iib->flags.set & IIB_FLAG_V || 1465: iib->flags.set & IIB_FLAG_N)) { 1466: OUT(" } else {\n"); 1467: if (flags && iib->flags.set & IIB_FLAG_V) 1468: OUT(" VFLAG = 1;\n"); 1469: if (flags && iib->flags.set & IIB_FLAG_N) 1470: OUT(" NFLAG = 1;\n"); 1471: } 1472: OUT(" }\n"); 1473: if (flags && iib->flags.set & IIB_FLAG_C) 1474: OUT(" CFLAG = 0;\n"); 1475: break; 1476: 1477: case i_ASR: 1478: generate_ea(output, iib, tp_src, 1); 1479: generate_eaval(output, iib, tp_src); 1480: generate_ea(output, iib, tp_dst, 1); 1481: generate_eaval(output, iib, tp_dst); 1482: generate_bits(output, iib); 1483: OUT(" uint8 count = srcdata & 63;\n"); 1484: switch (iib->size) { 1485: case sz_byte: 1486: generate_outdata(output, iib, "((sint8)dstdata) >> " 1487: "(count > 7 ? 7 : count)"); 1488: break; 1489: case sz_word: 1490: generate_outdata(output, iib, "((sint16)dstdata) >> " 1491: "(count > 15 ? 15 : count)"); 1492: break; 1493: case sz_long: 1494: generate_outdata(output, iib, "((sint32)dstdata) >> " 1495: "(count > 31 ? 31 : count)"); 1496: break; 1497: default: 1498: OUT("ERROR size\n"); 1499: break; 1500: } 1501: OUT("\n"); 1502: generate_eastore(output, iib, tp_dst); 1503: if (flags) { 1504: OUT("\n"); 1505: OUT(" if (!srcdata)\n"); 1506: if (iib->flags.set & IIB_FLAG_C) 1507: OUT(" CFLAG = 0;\n"); 1508: OUT(" else if (srcdata >= bits) {\n"); 1509: if (iib->flags.set & IIB_FLAG_C) 1510: OUT(" CFLAG = dstdata>>(bits-1);\n"); 1511: if (iib->flags.set & IIB_FLAG_X) 1512: OUT(" XFLAG = dstdata>>(bits-1);\n"); 1513: OUT(" } else {\n"); 1514: if (iib->flags.set & IIB_FLAG_C) 1515: OUT(" CFLAG = dstdata>>(count-1) & 1;\n"); 1516: if (iib->flags.set & IIB_FLAG_X) 1517: OUT(" XFLAG = dstdata>>(count-1) & 1;\n"); 1518: OUT(" }\n"); 1519: if (iib->flags.set & IIB_FLAG_V) 1520: generate_clrflag_v(output, iib); 1521: if (iib->flags.set & IIB_FLAG_N) 1522: generate_stdflag_n(output, iib); 1523: if (iib->flags.set & IIB_FLAG_Z) 1524: generate_stdflag_z(output, iib); 1525: } 1526: break; 1527: 1528: case i_LSR: 1529: generate_ea(output, iib, tp_src, 1); 1530: generate_eaval(output, iib, tp_src); 1531: generate_ea(output, iib, tp_dst, 1); 1532: generate_eaval(output, iib, tp_dst); 1533: generate_bits(output, iib); 1534: OUT(" uint8 count = srcdata & 63;\n"); 1535: generate_outdata(output, iib, 1536: "dstdata >> (count > (bits-1) ? (bits-1) : count)"); 1537: OUT("\n"); 1538: generate_eastore(output, iib, tp_dst); 1539: if (flags) { 1540: OUT("\n"); 1541: OUT(" if (!count)\n"); 1542: if (iib->flags.set & IIB_FLAG_C) 1543: OUT(" CFLAG = 0;\n"); 1544: OUT(" else if (count >= bits) {\n"); 1545: if (iib->flags.set & IIB_FLAG_C) 1546: OUT(" CFLAG = (count == bits) ? dstdata>>(bits-1) : 0;\n"); 1547: if (iib->flags.set & IIB_FLAG_X) 1548: OUT(" XFLAG = (count == bits) ? dstdata>>(bits-1) : 0;\n"); 1549: OUT(" } else {\n"); 1550: if (iib->flags.set & IIB_FLAG_C) 1551: OUT(" CFLAG = dstdata>>(count-1) & 1;\n"); 1552: if (iib->flags.set & IIB_FLAG_X) 1553: OUT(" XFLAG = dstdata>>(count-1) & 1;\n"); 1554: OUT(" }\n"); 1555: if (iib->flags.set & IIB_FLAG_V) 1556: generate_clrflag_v(output, iib); 1557: if (iib->flags.set & IIB_FLAG_N) 1558: generate_stdflag_n(output, iib); 1559: if (iib->flags.set & IIB_FLAG_Z) 1560: generate_stdflag_z(output, iib); 1561: } 1562: break; 1563: 1564: case i_ASL: 1565: generate_ea(output, iib, tp_src, 1); 1566: generate_eaval(output, iib, tp_src); 1567: generate_ea(output, iib, tp_dst, 1); 1568: generate_eaval(output, iib, tp_dst); 1569: generate_bits(output, iib); 1570: OUT(" uint8 count = srcdata & 63;\n"); 1571: generate_outdata(output, iib, 1572: "count >= bits ? 0 : (dstdata << count)"); 1573: OUT("\n"); 1574: generate_eastore(output, iib, tp_dst); 1575: if (flags) { 1576: OUT("\n"); 1577: OUT(" if (!count)\n"); 1578: if (iib->flags.set & IIB_FLAG_C) 1579: OUT(" CFLAG = 0;\n"); 1580: OUT(" else if (count >= bits) {\n"); 1581: if (iib->flags.set & IIB_FLAG_C) 1582: OUT(" CFLAG = (count == bits) ? dstdata & 1 : 0;\n"); 1583: if (iib->flags.set & IIB_FLAG_X) 1584: OUT(" XFLAG = (count == bits) ? dstdata & 1 : 0;\n"); 1585: if (iib->flags.set & IIB_FLAG_V) 1586: OUT(" VFLAG = !dstdata;\n"); 1587: OUT(" } else {\n"); 1588: if (iib->flags.set & IIB_FLAG_C) 1589: OUT(" CFLAG = dstdata>>(bits-count) & 1;\n"); 1590: if (iib->flags.set & IIB_FLAG_X) 1591: OUT(" XFLAG = dstdata>>(bits-count) & 1;\n"); 1592: if (iib->flags.set & IIB_FLAG_V) { 1593: OUT(" {\n"); 1594: switch (iib->size) { 1595: case sz_byte: 1596: OUT(" uint8 mask = 0xff << (7-count);\n") 1597: break; 1598: case sz_word: 1599: OUT(" uint16 mask = 0xffff << (15-count);\n"); 1600: break; 1601: case sz_long: 1602: OUT(" uint32 mask = 0xffffffff <<(31-count);\n"); 1603: break; 1604: default: 1605: OUT("ERROR size\n"); 1606: break; 1607: } 1608: OUT(" VFLAG = ((dstdata & mask) != mask) && "); 1609: OUT("((dstdata & mask) != 0);\n"); 1610: OUT(" }\n"); 1611: OUT(" }\n"); 1612: } 1613: if (iib->flags.set & IIB_FLAG_N) 1614: generate_stdflag_n(output, iib); 1615: if (iib->flags.set & IIB_FLAG_Z) 1616: generate_stdflag_z(output, iib); 1617: } 1618: break; 1619: 1620: case i_LSL: 1621: generate_ea(output, iib, tp_src, 1); 1622: generate_eaval(output, iib, tp_src); 1623: generate_ea(output, iib, tp_dst, 1); 1624: generate_eaval(output, iib, tp_dst); 1625: generate_bits(output, iib); 1626: OUT(" uint8 count = srcdata & 63;\n"); 1627: generate_outdata(output, iib, 1628: "count >= bits ? 0 : (dstdata << count)"); 1629: OUT("\n"); 1630: generate_eastore(output, iib, tp_dst); 1631: if (flags) { 1632: OUT("\n"); 1633: OUT(" if (!count)\n"); 1634: if (iib->flags.set & IIB_FLAG_C) 1635: OUT(" CFLAG = 0;\n"); 1636: OUT(" else if (count >= bits) {\n"); 1637: if (iib->flags.set & IIB_FLAG_C) 1638: OUT(" CFLAG = (count == bits) ? dstdata & 1 : 0;\n"); 1639: if (iib->flags.set & IIB_FLAG_X) 1640: OUT(" XFLAG = (count == bits) ? dstdata & 1 : 0;\n"); 1641: OUT(" } else {\n"); 1642: if (iib->flags.set & IIB_FLAG_C) 1643: OUT(" CFLAG = dstdata>>(bits-count) & 1;\n"); 1644: if (iib->flags.set & IIB_FLAG_X) 1645: OUT(" XFLAG = dstdata>>(bits-count) & 1;\n"); 1646: OUT(" }\n"); 1647: if (iib->flags.set & IIB_FLAG_V) 1648: generate_clrflag_v(output, iib); 1649: if (iib->flags.set & IIB_FLAG_N) 1650: generate_stdflag_n(output, iib); 1651: if (iib->flags.set & IIB_FLAG_Z) 1652: generate_stdflag_z(output, iib); 1653: } 1654: break; 1655: 1656: /* 64 */ 1657: 1658: case i_ROXR: 1659: case i_ROXL: 1660: generate_ea(output, iib, tp_src, 1); 1661: generate_eaval(output, iib, tp_src); 1662: generate_ea(output, iib, tp_dst, 1); 1663: generate_eaval(output, iib, tp_dst); 1664: generate_bits(output, iib); 1665: OUT(" uint8 loop = srcdata & 63;\n"); 1666: OUT(" uint8 cflag = CFLAG;\n"); 1667: OUT(" uint8 xflag = XFLAG;\n"); 1668: generate_outdata(output, iib, "dstdata"); 1669: OUT("\n"); 1670: if (iib->mnemonic == i_ROXR) { 1671: OUT(" while(loop) {\n"); 1672: OUT(" cflag = outdata & 1;\n"); 1673: OUT(" outdata>>= 1;\n"); 1674: OUT(" if (xflag)\n"); 1675: OUT(" outdata |= 1<<(bits-1);\n"); 1676: OUT(" xflag = cflag;\n"); 1677: OUT(" loop--;\n"); 1678: OUT(" }\n"); 1679: } else { 1680: OUT(" while(loop) {\n"); 1681: OUT(" cflag = outdata & 1<<(bits-1) ? 1 : 0;\n"); 1682: OUT(" outdata<<= 1;\n"); 1683: OUT(" outdata |= xflag;\n"); 1684: OUT(" xflag = cflag;\n"); 1685: OUT(" loop--;\n"); 1686: OUT(" }\n"); 1687: } 1688: generate_eastore(output, iib, tp_dst); 1689: if (flags) 1690: OUT("\n"); 1691: if (flags && iib->flags.set & IIB_FLAG_X) 1692: OUT(" XFLAG = xflag;\n"); 1693: if (flags && iib->flags.set & IIB_FLAG_C) 1694: OUT(" CFLAG = xflag;\n"); 1695: if (flags && iib->flags.set & IIB_FLAG_N) 1696: generate_stdflag_n(output, iib); 1697: if (flags && iib->flags.set & IIB_FLAG_Z) 1698: generate_stdflag_z(output, iib); 1699: if (flags && iib->flags.set & IIB_FLAG_V) 1700: generate_clrflag_v(output, iib); 1701: break; 1702: 1703: case i_ROR: 1704: case i_ROL: 1705: generate_ea(output, iib, tp_src, 1); 1706: generate_eaval(output, iib, tp_src); 1707: generate_ea(output, iib, tp_dst, 1); 1708: generate_eaval(output, iib, tp_dst); 1709: generate_bits(output, iib); 1710: OUT(" uint8 loop = srcdata & 63;\n"); 1711: OUT(" uint8 cflag = 0;\n"); 1712: generate_outdata(output, iib, "dstdata"); 1713: OUT("\n"); 1714: if (iib->mnemonic == i_ROR) { 1715: OUT(" while(loop) {\n"); 1716: OUT(" cflag = outdata & 1;\n"); 1717: OUT(" outdata>>= 1;\n"); 1718: OUT(" if (cflag)\n"); 1719: OUT(" outdata |= 1<<(bits-1);\n"); 1720: OUT(" loop--;\n"); 1721: OUT(" }\n"); 1722: } else { 1723: OUT(" while(loop) {\n"); 1724: OUT(" cflag = outdata & 1<<(bits-1) ? 1 : 0;\n"); 1725: OUT(" outdata<<= 1;\n"); 1726: OUT(" if (cflag)\n"); 1727: OUT(" outdata |= 1;\n"); 1728: OUT(" loop--;\n"); 1729: OUT(" }\n"); 1730: } 1731: generate_eastore(output, iib, tp_dst); 1732: if (flags) 1733: OUT("\n"); 1734: if (flags && iib->flags.set & IIB_FLAG_C) 1735: OUT(" CFLAG = cflag;\n"); 1736: if (flags && iib->flags.set & IIB_FLAG_N) 1737: generate_stdflag_n(output, iib); 1738: if (flags && iib->flags.set & IIB_FLAG_Z) 1739: generate_stdflag_z(output, iib); 1740: if (flags && iib->flags.set & IIB_FLAG_V) 1741: generate_clrflag_v(output, iib); 1742: break; 1743: 1744: case i_LINE10: 1745: OUT("\n"); 1.1.1.2 ! root 1746: fprintf(output, " reg68k_internal_vector(V_LINE10, PC);\n"); 1.1 root 1747: pcinc = 0; 1748: break; 1749: 1750: case i_LINE15: 1751: OUT("\n"); 1.1.1.2 ! root 1752: fprintf(output, " reg68k_internal_vector(V_LINE15, PC);\n"); 1.1 root 1753: pcinc = 0; 1754: break; 1755: 1756: case i_ILLG: 1757: OUT(" printf(\"Illegal instruction @ %x\\n\", PC);\n"); 1758: OUT(" exit(1);\n"); 1759: break; 1760: 1761: } /* switch */ 1762: 1763: if (pcinc) { 1764: fprintf(output, " PC+= %d;\n", (iib->wordlen)*2); 1765: } 1766: 1767: OUT("}\n\n"); 1768: } 1769: 1770: } 1771: } 1772: 1773: void generate_ea(FILE *o, t_iib *iib, t_type type, int update) 1774: { 1775: t_datatype datatype = type ? iib->dtype : iib->stype; 1776: 1777: /* generate information about EA to be used in calculations */ 1778: 1779: switch(datatype) { 1780: case dt_Dreg: 1781: case dt_Areg: 1782: case dt_Aind: 1783: case dt_Ainc: 1784: case dt_Adec: 1785: case dt_Adis: 1786: case dt_Aidx: 1787: if (type == tp_src) 1788: fprintf(o, " int srcreg = (ipc->opcode >> %d) & 7;\n", iib->sbitpos); 1789: else 1790: fprintf(o, " int dstreg = (ipc->opcode >> %d) & 7;\n", iib->dbitpos); 1791: break; 1792: default: 1793: break; 1794: } 1795: 1796: if (datatype == dt_Ainc && update) { 1797: 1798: /* Ainc and update */ 1799: 1800: switch(iib->size) { 1801: case sz_byte: 1802: if (type == tp_src) { 1803: fprintf(o, " uint32 srcaddr = ADDRREG(srcreg);\n"); 1804: fprintf(o, " uint32 srcaddr_tmp = (ADDRREG(srcreg)+= " 1805: "(srcreg == 7 ? 2 : 1), 0);\n"); 1806: } else { 1807: fprintf(o, " uint32 dstaddr = ADDRREG(dstreg);\n"); 1808: fprintf(o, " uint32 dstaddr_tmp = (ADDRREG(dstreg)+= " 1809: "(dstreg == 7 ? 2 : 1), 0);\n"); 1810: } 1811: break; 1812: case sz_word: 1813: if (type == tp_src) 1814: fprintf(o, " uint32 srcaddr = (ADDRREG(srcreg)+=2, " 1815: "ADDRREG(srcreg)-2);\n"); 1816: else 1817: fprintf(o, " uint32 dstaddr = (ADDRREG(dstreg)+=2, " 1818: "ADDRREG(dstreg)-2);\n"); 1819: break; 1820: case sz_long: 1821: if (type == tp_src) 1822: fprintf(o, " uint32 srcaddr = (ADDRREG(srcreg)+=4, " 1823: "ADDRREG(srcreg)-4);\n"); 1824: else 1825: fprintf(o, " uint32 dstaddr = (ADDRREG(dstreg)+=4, " 1826: "ADDRREG(dstreg)-4);\n"); 1827: break; 1828: default: 1829: fprintf(o, "ERROR size\n"); 1830: break; 1831: } 1832: 1833: } else if (datatype == dt_Adec && update) { 1834: 1835: /* Adec and update */ 1836: 1837: switch(iib->size) { 1838: case sz_byte: 1839: if (type == tp_src) { 1840: fprintf(o, " uint32 srcaddr = (ADDRREG(srcreg)-= " 1841: "(srcreg == 7 ? 2 : 1));\n"); 1842: } else { 1843: fprintf(o, " uint32 dstaddr = (ADDRREG(dstreg)-= " 1844: "(dstreg == 7 ? 2 : 1));\n"); 1845: } 1846: break; 1847: case sz_word: 1848: if (type == tp_src) 1849: fprintf(o, " uint32 srcaddr = ADDRREG(srcreg)-=2;\n"); 1850: else 1851: fprintf(o, " uint32 dstaddr = ADDRREG(dstreg)-=2;\n"); 1852: break; 1853: case sz_long: 1854: if (type == tp_src) 1855: fprintf(o, " uint32 srcaddr = ADDRREG(srcreg)-=4;\n"); 1856: else 1857: fprintf(o, " uint32 dstaddr = ADDRREG(dstreg)-=4;\n"); 1858: break; 1859: default: 1860: fprintf(o, "ERROR size\n"); 1861: break; 1862: } 1863: 1864: } else { 1865: 1866: /* no update required */ 1867: 1868: switch(datatype) { 1869: case dt_Dreg: 1870: case dt_Areg: 1871: break; 1872: case dt_Aind: 1873: case dt_Adec: 1874: case dt_Ainc: 1875: if (type == tp_src) 1876: fprintf(o, " uint32 srcaddr = ADDRREG(srcreg);\n"); 1877: else 1878: fprintf(o, " uint32 dstaddr = ADDRREG(dstreg);\n"); 1879: break; 1880: case dt_Adis: 1881: if (type == tp_src) 1882: fprintf(o, " uint32 srcaddr = (sint32)ADDRREG(srcreg) + " 1883: "(sint32)(sint16)ipc->src;\n"); 1884: else 1885: fprintf(o, " uint32 dstaddr = (sint32)ADDRREG(dstreg) + " 1886: "(sint32)(sint16)ipc->dst;\n"); 1887: break; 1888: case dt_Aidx: 1889: if (type == tp_src) { 1890: fprintf(o, " uint32 srcaddr = (sint32)ADDRREG(srcreg) + " 1891: "idxval_src(ipc);\n"); 1892: } else { 1893: fprintf(o, " uint32 dstaddr = (sint32)ADDRREG(dstreg) + " 1894: "idxval_dst(ipc);\n"); 1895: } 1896: break; 1897: case dt_AbsW: 1898: case dt_AbsL: 1899: case dt_Pdis: 1900: if (type == tp_src) 1901: fprintf(o, " uint32 srcaddr = ipc->src;\n"); 1902: else 1903: fprintf(o, " uint32 dstaddr = ipc->dst;\n"); 1904: break; 1905: case dt_Pidx: 1906: if (type == tp_src) { 1907: fprintf(o, " uint32 srcaddr = idxval_src(ipc);\n"); 1908: } else { 1909: fprintf(o, " uint32 dstaddr = idxval_dst(ipc);\n"); 1910: } 1911: break; 1912: case dt_ImmB: 1913: case dt_ImmW: 1914: case dt_ImmL: 1915: case dt_ImmS: 1916: case dt_Imm3: 1917: case dt_Imm4: 1918: case dt_Imm8: 1919: case dt_Imm8s: 1920: /* no address - it is immediate */ 1921: break; 1922: default: 1923: fprintf(o, "ERROR\n"); 1924: break; 1925: } 1926: } 1927: } 1928: 1929: void generate_eaval(FILE *o, t_iib *iib, t_type type) 1930: { 1931: t_datatype datatype = type ? iib->dtype : iib->stype; 1932: 1933: /* get value in EA */ 1934: 1935: switch(datatype) { 1936: case dt_Dreg: 1937: switch(iib->size) { 1938: case sz_byte: 1939: if (type == tp_src) 1940: fprintf(o, " uint8 srcdata = DATAREG(srcreg);\n"); 1941: else 1942: fprintf(o, " uint8 dstdata = DATAREG(dstreg);\n"); 1943: break; 1944: case sz_word: 1945: if (type == tp_src) 1946: fprintf(o, " uint16 srcdata = DATAREG(srcreg);\n"); 1947: else 1948: fprintf(o, " uint16 dstdata = DATAREG(dstreg);\n"); 1949: break; 1950: case sz_long: 1951: if (type == tp_src) 1952: fprintf(o, " uint32 srcdata = DATAREG(srcreg);\n"); 1953: else 1954: fprintf(o, " uint32 dstdata = DATAREG(dstreg);\n"); 1955: break; 1956: default: 1957: fprintf(o, "ERROR size\n"); 1958: break; 1959: } 1960: break; 1961: case dt_Areg: 1962: switch(iib->size) { 1963: case sz_byte: 1964: if (type == tp_src) 1965: fprintf(o, " uint8 srcdata = ADDRREG(srcreg);\n"); 1966: else 1967: fprintf(o, " uint8 dstdata = ADDRREG(dstreg);\n"); 1968: break; 1969: case sz_word: 1970: if (type == tp_src) 1971: fprintf(o, " uint16 srcdata = ADDRREG(srcreg);\n"); 1972: else 1973: fprintf(o, " uint16 dstdata = ADDRREG(dstreg);\n"); 1974: break; 1975: case sz_long: 1976: if (type == tp_src) 1977: fprintf(o, " uint32 srcdata = ADDRREG(srcreg);\n"); 1978: else 1979: fprintf(o, " uint32 dstdata = ADDRREG(dstreg);\n"); 1980: break; 1981: default: 1982: fprintf(o, "ERROR size\n"); 1983: break; 1984: } 1985: break; 1986: case dt_Aind: 1987: case dt_Adec: 1988: case dt_Ainc: 1989: case dt_Adis: 1990: case dt_Aidx: 1991: case dt_AbsW: 1992: case dt_AbsL: 1993: case dt_Pdis: 1994: case dt_Pidx: 1995: switch(iib->size) { 1996: case sz_byte: 1997: if (type == tp_src) 1998: fprintf(o, " uint8 srcdata = fetchbyte(srcaddr);\n"); 1999: else 2000: fprintf(o, " uint8 dstdata = fetchbyte(dstaddr);\n"); 2001: break; 2002: case sz_word: 2003: if (type == tp_src) 2004: fprintf(o, " uint16 srcdata = fetchword(srcaddr);\n"); 2005: else 2006: fprintf(o, " uint16 dstdata = fetchword(dstaddr);\n"); 2007: break; 2008: case sz_long: 2009: if (type == tp_src) 2010: fprintf(o, " uint32 srcdata = fetchlong(srcaddr);\n"); 2011: else 2012: fprintf(o, " uint32 dstdata = fetchlong(dstaddr);\n"); 2013: break; 2014: default: 2015: fprintf(o, "ERROR size\n"); 2016: break; 2017: } 2018: break; 2019: case dt_ImmB: 2020: if (type == tp_src) 2021: fprintf(o, " uint8 srcdata = ipc->src;\n"); 2022: else 2023: fprintf(o, " uint8 dstdata = ipc->dst;\n"); 2024: break; 2025: case dt_ImmW: 2026: if (type == tp_src) 2027: fprintf(o, " uint16 srcdata = ipc->src;\n"); 2028: else 2029: fprintf(o, " uint16 dstdata = ipc->dst;\n"); 2030: break; 2031: case dt_ImmL: 2032: if (type == tp_src) 2033: fprintf(o, " uint32 srcdata = ipc->src;\n"); 2034: else 2035: fprintf(o, " uint32 dstdata = ipc->dst;\n"); 2036: break; 2037: case dt_ImmS: 2038: if (type == tp_src) 2039: fprintf(o, " unsigned int srcdata = %d;\n", iib->immvalue); 2040: else 2041: fprintf(o, " unsigned int dstdata = %d;\n", iib->immvalue); 2042: break; 2043: case dt_Imm3: 2044: case dt_Imm4: 2045: case dt_Imm8: 2046: if (type == tp_src) 2047: fprintf(o, " unsigned int srcdata = ipc->src;\n"); 2048: else 2049: fprintf(o, " unsigned int dstdata = ipc->dst;\n"); 2050: break; 2051: case dt_Imm8s: 2052: if (type == tp_src) 2053: fprintf(o, " signed int srcdata = ipc->src;\n"); 2054: else 2055: fprintf(o, " signed int dstdata = ipc->dst;\n"); 2056: break; 2057: default: 2058: fprintf(o, "ERROR\n"); 2059: } 2060: } 2061: 2062: void generate_eastore(FILE *o, t_iib *iib, t_type type) 2063: { 2064: /* get value in EA */ 2065: 2066: switch(type == tp_dst ? iib->dtype : iib->stype) { 2067: case dt_Dreg: 2068: switch (iib->size) { 2069: case sz_byte: 2070: if (type == tp_src) 2071: fprintf(o, " DATAREG(srcreg) = (DATAREG(srcreg) & ~0xff) | " 2072: "outdata;\n"); 2073: else 2074: fprintf(o, " DATAREG(dstreg) = (DATAREG(dstreg) & ~0xff) | " 2075: "outdata;\n"); 2076: break; 2077: case sz_word: 2078: if (type == tp_src) 2079: fprintf(o, " DATAREG(srcreg) = (DATAREG(srcreg) & ~0xffff) | " 2080: "outdata;\n"); 2081: else 2082: fprintf(o, " DATAREG(dstreg) = (DATAREG(dstreg) & ~0xffff) | " 2083: "outdata;\n"); 2084: break; 2085: case sz_long: 2086: if (type == tp_src) 2087: fprintf(o, " DATAREG(srcreg) = outdata;\n"); 2088: else 2089: fprintf(o, " DATAREG(dstreg) = outdata;\n"); 2090: break; 2091: default: 2092: fprintf(o, "ERROR size\n"); 2093: break; 2094: } 2095: break; 2096: case dt_Areg: 2097: switch(iib->size) { 2098: case sz_byte: 2099: if (type == tp_src) 2100: fprintf(o, " ADDRREG(srcreg) = (ADDRREG(srcreg) & ~0xff) | " 2101: "outdata;\n"); 2102: else 2103: fprintf(o, " ADDRREG(dstreg) = (ADDRREG(dstreg) & ~0xff) | " 2104: "outdata;\n"); 2105: break; 2106: case sz_word: 2107: if (type == tp_src) 2108: fprintf(o, " ADDRREG(srcreg) = (ADDRREG(srcreg) & ~0xffff) | " 2109: "outdata;\n"); 2110: else 2111: fprintf(o, " ADDRREG(dstreg) = (ADDRREG(dstreg) & ~0xffff) | " 2112: "outdata;\n"); 2113: break; 2114: case sz_long: 2115: if (type == tp_src) 2116: fprintf(o, " ADDRREG(srcreg) = outdata;\n"); 2117: else 2118: fprintf(o, " ADDRREG(dstreg) = outdata;\n"); 2119: break; 2120: default: 2121: fprintf(o, "ERROR size\n"); 2122: break; 2123: } 2124: break; 2125: case dt_Aind: 2126: case dt_Ainc: 2127: case dt_Adec: 2128: case dt_Adis: 2129: case dt_Aidx: 2130: case dt_AbsW: 2131: case dt_AbsL: 2132: case dt_Pdis: 2133: case dt_Pidx: 2134: switch(iib->size) { 2135: case sz_byte: 2136: if (type == tp_src) 2137: fprintf(o, " storebyte(srcaddr, outdata);\n"); 2138: else 2139: fprintf(o, " storebyte(dstaddr, outdata);\n"); 2140: break; 2141: case sz_word: 2142: if (type == tp_src) 2143: fprintf(o, " storeword(srcaddr, outdata);\n"); 2144: else 2145: fprintf(o, " storeword(dstaddr, outdata);\n"); 2146: break; 2147: case sz_long: 2148: if (type == tp_src) 2149: fprintf(o, " storelong(srcaddr, outdata);\n"); 2150: else 2151: fprintf(o, " storelong(dstaddr, outdata);\n"); 2152: break; 2153: default: 2154: fprintf(o, "ERROR size\n"); 2155: } 2156: break; 2157: default: 2158: fprintf(o, "ERROR type\n"); 2159: } 2160: } 2161: 2162: void generate_outdata(FILE *o, t_iib *iib, const char *init) 2163: { 2164: switch(iib->size) { 2165: case sz_byte: 2166: fprintf(o, " uint8 "); 2167: break; 2168: case sz_word: 2169: fprintf(o, " uint16 "); 2170: break; 2171: case sz_long: 2172: fprintf(o, " uint32 "); 2173: break; 2174: default: 2175: fprintf(o, "ERROR size\n"); 2176: break; 2177: } 2178: fprintf(o, "outdata%s%s;\n", (init && init[0]) ? " = " : "", 2179: init ? init : ""); 2180: } 2181: 2182: void generate_cc(FILE *o, t_iib *iib) 2183: { 2184: switch(iib->cc) { 2185: case 0: /* T */ 2186: fprintf(o, " uint8 cc = 1;\n"); 2187: break; 2188: case 1: /* F */ 2189: fprintf(o, " uint8 cc = 0;\n"); 2190: break; 2191: case 2: /* HI */ 2192: fprintf(o, " uint8 cc = !(CFLAG || ZFLAG);\n"); 2193: break; 2194: case 3: /* LS */ 2195: fprintf(o, " uint8 cc = CFLAG || ZFLAG;\n"); 2196: break; 2197: case 4: /* CC */ 2198: fprintf(o, " uint8 cc = !CFLAG;\n"); 2199: break; 2200: case 5: /* CS */ 2201: fprintf(o, " uint8 cc = CFLAG;\n"); 2202: break; 2203: case 6: /* NE */ 2204: fprintf(o, " uint8 cc = !ZFLAG;\n"); 2205: break; 2206: case 7: /* EQ */ 2207: fprintf(o, " uint8 cc = ZFLAG;\n"); 2208: break; 2209: case 8: /* VC */ 2210: fprintf(o, " uint8 cc = !VFLAG;\n"); 2211: break; 2212: case 9: /* VS */ 2213: fprintf(o, " uint8 cc = VFLAG;\n"); 2214: break; 2215: case 10: /* PL */ 2216: fprintf(o, " uint8 cc = !NFLAG;\n"); 2217: break; 2218: case 11: /* MI */ 2219: fprintf(o, " uint8 cc = NFLAG;\n"); 2220: break; 2221: case 12: /* GE */ 2222: fprintf(o, " uint8 cc = (NFLAG == VFLAG);\n"); 2223: break; 2224: case 13: /* LT */ 2225: fprintf(o, " uint8 cc = (NFLAG != VFLAG);\n"); 2226: break; 2227: case 14: /* GT */ 2228: fprintf(o, " uint8 cc = !ZFLAG && (NFLAG == VFLAG);\n"); 2229: break; 2230: case 15: /* LE */ 2231: fprintf(o, " uint8 cc = ZFLAG || (NFLAG != VFLAG);\n"); 2232: break; 2233: default: 2234: fprintf(o, "ERROR cc\n"); 2235: break; 2236: } 2237: } 2238: 2239: void generate_stdflag_n(FILE *o, t_iib *iib) 2240: { 2241: switch(iib->size) { 2242: case sz_byte: 2243: fprintf(o, " NFLAG = ((sint8)outdata) < 0;\n"); 2244: break; 2245: case sz_word: 2246: fprintf(o, " NFLAG = ((sint16)outdata) < 0;\n"); 2247: break; 2248: case sz_long: 2249: fprintf(o, " NFLAG = ((sint32)outdata) < 0;\n"); 2250: break; 2251: default: 2252: fprintf(o, "ERROR size\n"); 2253: break; 2254: } 2255: } 2256: 2257: void generate_stdflag_z(FILE *o, t_iib *iib) 2258: { 2259: fprintf(o, " ZFLAG = !outdata;\n"); 2260: } 2261: 2262: void generate_clrflag_v(FILE *o, t_iib *iib) 2263: { 2264: fprintf(o, " VFLAG = 0;\n"); 2265: } 2266: 2267: void generate_clrflag_c(FILE *o, t_iib *iib) 2268: { 2269: fprintf(o, " CFLAG = 0;\n"); 2270: } 2271: 2272: void generate_clrflag_n(FILE *o, t_iib *iib) 2273: { 2274: fprintf(o, " NFLAG = 0;\n"); 2275: } 2276: 2277: void generate_setflag_z(FILE *o, t_iib *iib) 2278: { 2279: fprintf(o, " ZFLAG = 1;\n"); 2280: } 2281: 2282: void generate_subflag_c(FILE *o, t_iib *iib) 2283: { 2284: /* C = (Sm && !Dm) || (Rm && !Dm) || (Sm && Rm) 2285: carry is performed as if both source and destination are unsigned, 2286: so this is simply if the source is greater than the destination - I 2287: have proven this to be the case using a truth table and the above 2288: motorola definition */ 2289: fprintf(o, " CFLAG = srcdata > dstdata;\n"); 2290: } 2291: 2292: void generate_subflag_cx(FILE *o, t_iib *iib) 2293: { 2294: /* C = (Sm && !Dm) || (Rm && !Dm) || (Sm && Rm) 2295: carry is performed as if both source and destination are unsigned, 2296: so this is simply if the source is greater than the destination - I 2297: have proven this to be the case using a truth table and the above 2298: motorola definition */ 2299: fprintf(o, " XFLAG = CFLAG = srcdata > dstdata;\n"); 2300: } 2301: 2302: void generate_subxflag_cx(FILE *o, t_iib *iib) 2303: { 2304: /* V = (Sm && !Dm) || (Rm && (!Dm || Sm)) */ 2305: fprintf(o, " {\n"); 2306: switch(iib->size) { 2307: case sz_byte: 2308: fprintf(o, " int Sm = (sint8)srcdata < 0;\n"); 2309: fprintf(o, " int Dm = (sint8)dstdata < 0;\n"); 2310: fprintf(o, " int Rm = (sint8)outdata < 0;\n"); 2311: break; 2312: case sz_word: 2313: fprintf(o, " int Sm = (sint16)srcdata < 0;\n"); 2314: fprintf(o, " int Dm = (sint16)dstdata < 0;\n"); 2315: fprintf(o, " int Rm = (sint16)outdata < 0;\n"); 2316: break; 2317: case sz_long: 2318: fprintf(o, " int Sm = (sint32)srcdata < 0;\n"); 2319: fprintf(o, " int Dm = (sint32)dstdata < 0;\n"); 2320: fprintf(o, " int Rm = (sint32)outdata < 0;\n"); 2321: break; 2322: default: 2323: fprintf(o, "ERROR size\n"); 2324: break; 2325: } 2326: fprintf(o, " XFLAG = CFLAG = (Sm && !Dm) || (Rm && (!Dm || Sm));\n"); 2327: fprintf(o, " }\n"); 2328: } 2329: 2330: void generate_cmpaflag_c(FILE *o, t_iib *iib) 2331: { 2332: /* see generate_subflag_c - this is just the same but with a sign extend 2333: on the source */ 2334: fprintf(o, " CFLAG = (uint32)(sint32)(sint16)srcdata > dstdata;\n"); 2335: } 2336: 2337: void generate_subflag_v(FILE *o, t_iib *iib) 2338: { 2339: /* V = (!Sm && Dm && !Rm) || (Sm && !Dm && Rm) 2340: overflow is performed as if both source and destination are signed, 2341: the only two condtions are if we've added too much to a +ve number 2342: or we've subtracted too much from a -ve number - I have proven the 2343: this to be the case using a truth table and the above motorola 2344: definition */ 2345: /* the technique to implement the above formula is to make sure the sign 2346: of Sm != the sign of Dm, and the sign of Dm != the sign of Rm. */ 2347: switch(iib->size) { 2348: case sz_byte: 2349: fprintf(o, " VFLAG = (((sint8)srcdata < 0) != ((sint8)dstdata < 0)) "); 2350: fprintf(o, "&&\n (((sint8)dstdata < 0) != ((sint8)outdata < 0));\n"); 2351: break; 2352: case sz_word: 2353: fprintf(o, " VFLAG = (((sint16)srcdata < 0) != ((sint16)dstdata < 0)) "); 2354: fprintf(o, "&&\n (((sint16)dstdata < 0) != ((sint16)outdata < 0));\n"); 2355: break; 2356: case sz_long: 2357: fprintf(o, " VFLAG = (((sint32)srcdata < 0) != ((sint32)dstdata < 0)) "); 2358: fprintf(o, "&&\n (((sint32)dstdata < 0) != ((sint32)outdata < 0));\n"); 2359: break; 2360: default: 2361: fprintf(o, "ERROR size\n"); 2362: break; 2363: } 2364: } 2365: 2366: void generate_cmpaflag_v(FILE *o, t_iib *iib) 2367: { 2368: /* see generate_subflag_v - this is just the sz_long version with a sign 2369: extend on the source */ 2370: fprintf(o, " VFLAG = (((sint32)(sint16)srcdata < 0) != "); 2371: fprintf(o, "((sint32)dstdata < 0)) "); 2372: fprintf(o, "&&\n (((sint32)dstdata < 0) != ((sint32)outdata < 0));\n"); 2373: } 2374: 2375: void generate_stdxflag_z(FILE *o, t_iib *iib) 2376: { 2377: fprintf(o, " if (outdata) ZFLAG = 0;\n"); 2378: } 2379: 2380: void generate_addflag_cx(FILE *o, t_iib *iib) 2381: { 2382: /* C = (Sm && Dm) || (!Rm && Dm) || (Sm && !Rm) 2383: carry is performed as if both source and destination are unsigned, 2384: so this is simply if the source is bigger than how much can be added 2385: to the destination without wrapping - this is of course just the bit 2386: inverse of the destination. */ 2387: /* 0xFFFF - dstdata is obviously just ~dstdata, but try and get the 2388: compiler to do that without producing a warning, go on... */ 2389: switch (iib->size) { 2390: case sz_byte: 2391: fprintf(o, " XFLAG = CFLAG = srcdata > (0xFFu - (uint8)dstdata);\n"); 2392: break; 2393: case sz_word: 2394: fprintf(o, " XFLAG = CFLAG = srcdata > (0xFFFFu - (uint16)dstdata);\n"); 2395: break; 2396: case sz_long: 2397: fprintf(o, " XFLAG = CFLAG = srcdata > (uint32)~(uint32)dstdata;\n"); 2398: break; 2399: default: 2400: fprintf(o, "ERROR size\n"); 2401: break; 2402: } 2403: /* gcc doesn't like a one's compliment of an unsigned - take out the 2404: casts in the above and it will warn you incorrectly */ 2405: } 2406: 2407: void generate_addxflag_cx(FILE *o, t_iib *iib) 2408: { 2409: /* V = (Sm && Dm) || (!Rm && (Dm || Sm)) */ 2410: fprintf(o, " {\n"); 2411: switch(iib->size) { 2412: case sz_byte: 2413: fprintf(o, " int Sm = (sint8)srcdata < 0;\n"); 2414: fprintf(o, " int Dm = (sint8)dstdata < 0;\n"); 2415: fprintf(o, " int Rm = (sint8)outdata < 0;\n"); 2416: break; 2417: case sz_word: 2418: fprintf(o, " int Sm = (sint16)srcdata < 0;\n"); 2419: fprintf(o, " int Dm = (sint16)dstdata < 0;\n"); 2420: fprintf(o, " int Rm = (sint16)outdata < 0;\n"); 2421: break; 2422: case sz_long: 2423: fprintf(o, " int Sm = (sint32)srcdata < 0;\n"); 2424: fprintf(o, " int Dm = (sint32)dstdata < 0;\n"); 2425: fprintf(o, " int Rm = (sint32)outdata < 0;\n"); 2426: break; 2427: default: 2428: fprintf(o, "ERROR size\n"); 2429: break; 2430: } 2431: fprintf(o, " XFLAG = CFLAG = (Sm && Dm) || (!Rm && (Dm || Sm));\n"); 2432: fprintf(o, " }\n"); 2433: } 2434: 2435: void generate_addflag_v(FILE *o, t_iib *iib) 2436: { 2437: /* V = (Sm && Dm && !Rm) || (!Sm && !Dm && Rm) 2438: overflow is performed as if both source and destination are signed, 2439: the only two condtions are if we've added too much to a +ve number 2440: or we've subtracted too much from a -ve number */ 2441: /* the technique to implement the above formula is to make sure the sign 2442: of Sm == the sign of Dm, and the sign of Dm != the sign of Rm. */ 2443: switch(iib->size) { 2444: case sz_byte: 2445: fprintf(o, " VFLAG = (((sint8)srcdata < 0) == ((sint8)dstdata < 0)) "); 2446: fprintf(o, "&&\n (((sint8)dstdata < 0) != ((sint8)outdata < 0));\n"); 2447: break; 2448: case sz_word: 2449: fprintf(o, " VFLAG = (((sint16)srcdata < 0) == ((sint16)dstdata < 0)) "); 2450: fprintf(o, "&&\n (((sint16)dstdata < 0) != ((sint16)outdata < 0));\n"); 2451: break; 2452: case sz_long: 2453: fprintf(o, " VFLAG = (((sint32)srcdata < 0) == ((sint32)dstdata < 0)) "); 2454: fprintf(o, "&&\n (((sint32)dstdata < 0) != ((sint32)outdata < 0));\n"); 2455: break; 2456: default: 2457: fprintf(o, "ERROR size\n"); 2458: break; 2459: } 2460: } 2461: 2462: void generate_negflag_cx(FILE *o, t_iib *iib) 2463: { 2464: /* C = (Dm || Rm) */ 2465: fprintf(o, " XFLAG = CFLAG = srcdata ? 1 : 0;\n"); 2466: } 2467: 2468: void generate_negflag_v(FILE *o, t_iib *iib) 2469: { 2470: /* V = (Dm && Rm) 2471: which is the same as V = src == 1<<15 as the only case where both the 2472: data and the result are both negative is in the case of the extreme 2473: negative number (1<<15 in the case of 16 bit) since 0 - 1<<15 = 1<<15. */ 2474: switch(iib->size) { 2475: case sz_byte: 2476: fprintf(o, " VFLAG = (srcdata == (1u<<7));\n"); 2477: break; 2478: case sz_word: 2479: fprintf(o, " VFLAG = (srcdata == (1u<<15));\n"); 2480: break; 2481: case sz_long: 2482: fprintf(o, " VFLAG = (srcdata == (1u<<31));\n"); 2483: break; 2484: default: 2485: fprintf(o, "ERROR size\n"); 2486: break; 2487: } 2488: } 2489: 2490: void generate_negxflag_cx(FILE *o, t_iib *iib) 2491: { 2492: /* C = (Dm || Rm) 2493: unlike NEG, NEGX is done properly */ 2494: fprintf(o, " XFLAG = CFLAG "); 2495: switch(iib->size) { 2496: case sz_byte: 2497: fprintf(o, "= ((sint8)srcdata < 0) || ((sint8)outdata < 0);\n"); 2498: break; 2499: case sz_word: 2500: fprintf(o, "= ((sint16)srcdata < 0) || ((sint16)outdata < 0);\n"); 2501: break; 2502: case sz_long: 2503: fprintf(o, "= ((sint32)srcdata < 0) || ((sint32)outdata < 0);\n"); 2504: break; 2505: default: 2506: fprintf(o, "ERROR size\n"); 2507: break; 2508: } 2509: } 2510: 2511: void generate_negxflag_v(FILE *o, t_iib *iib) 2512: { 2513: /* V = (Dm && Rm) 2514: unlike NEG, NEGX is done properly */ 2515: switch(iib->size) { 2516: case sz_byte: 2517: fprintf(o, " VFLAG = ((sint8)srcdata < 0) && ((sint8)outdata < 0);\n"); 2518: break; 2519: case sz_word: 2520: fprintf(o, " VFLAG = ((sint16)srcdata < 0) && ((sint16)outdata < 0);\n"); 2521: break; 2522: case sz_long: 2523: fprintf(o, " VFLAG = ((sint32)srcdata < 0) && ((sint32)outdata < 0);\n"); 2524: break; 2525: default: 2526: fprintf(o, "ERROR size\n"); 2527: break; 2528: } 2529: } 2530: 2531: void generate_bits(FILE *o, t_iib *iib) 2532: { 2533: switch (iib->size) { 2534: case sz_byte: 2535: fprintf(o, " uint8 bits = 8;\n"); 2536: break; 2537: case sz_word: 2538: fprintf(o, " uint8 bits = 16;\n"); 2539: break; 2540: case sz_long: 2541: fprintf(o, " uint8 bits = 32;\n"); 2542: break; 2543: default: 2544: fprintf(o, "ERROR size\n"); 2545: break; 2546: } 2547: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.