![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gencomp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Previous NeXT emulator] / previous_trunk / src / cpu / jit|
Return to gencomp.c CVS log | Up to [Previous NeXT emulator] / previous_trunk / src / cpu / jit |
1.1 ! root 1: /* ! 2: * UAE - The Un*x Amiga Emulator ! 3: * ! 4: * MC68000 compilation generator ! 5: * ! 6: * Based on work Copyright 1995, 1996 Bernd Schmidt. Changes Copyright 2000 ! 7: * Bernd Meyer ! 8: */ ! 9: ! 10: #include "sysconfig.h" ! 11: #include "sysdeps.h" ! 12: #include <ctype.h> ! 13: ! 14: #include "readcpu.h" ! 15: ! 16: #include <stdio.h> ! 17: #include <stdarg.h> ! 18: ! 19: #define BOOL_TYPE "int" ! 20: #define failure global_failure=1 ! 21: #define FAILURE global_failure=1 ! 22: #define isjump global_isjump=1 ! 23: #define is_const_jump global_iscjump=1; ! 24: #define isaddx global_isaddx=1 ! 25: #define uses_cmov global_cmov=1 ! 26: #define mayfail global_mayfail=1 ! 27: ! 28: int hack_opcode; ! 29: ! 30: static int global_failure; ! 31: static int global_isjump; ! 32: static int global_iscjump; ! 33: static int global_isaddx; ! 34: static int global_cmov; ! 35: static int long_opcode; ! 36: static int global_mayfail; ! 37: ! 38: static char endstr[1000]; ! 39: static char lines[100000]; ! 40: static int comp_index=0; ! 41: ! 42: static int cond_codes_x86[]={-1,-1,7,6,3,2,5,4,-1,-1,9,8,13,12,15,14}; ! 43: ! 44: static void comprintf(const char* format, ...) ! 45: { ! 46: va_list args; ! 47: ! 48: va_start(args,format); ! 49: comp_index+=vsprintf(lines+comp_index,format,args); ! 50: } ! 51: ! 52: static void com_discard(void) ! 53: { ! 54: comp_index=0; ! 55: } ! 56: ! 57: static void com_flush(void) ! 58: { ! 59: int i; ! 60: for (i=0;i<comp_index;i++) ! 61: putchar(lines[i]); ! 62: com_discard(); ! 63: } ! 64: ! 65: ! 66: static FILE *headerfile; ! 67: static FILE *stblfile; ! 68: ! 69: static int using_prefetch; ! 70: static int using_exception_3; ! 71: static int cpu_level; ! 72: static int noflags; ! 73: ! 74: /* For the current opcode, the next lower level that will have different code. ! 75: * Initialized to -1 for each opcode. If it remains unchanged, indicates we ! 76: * are done with that opcode. */ ! 77: static int next_cpu_level; ! 78: ! 79: static int *opcode_map; ! 80: static int *opcode_next_clev; ! 81: static int *opcode_last_postfix; ! 82: static unsigned long *counts; ! 83: ! 84: static void ! 85: read_counts (void) ! 86: { ! 87: FILE *file; ! 88: unsigned long opcode, count = 0, total; ! 89: char name[20]; ! 90: int nr = 0; ! 91: memset (counts, 0, 65536 * sizeof *counts); ! 92: ! 93: file = fopen ("frequent.68k", "r"); ! 94: if (file) ! 95: { ! 96: fscanf (file, "Total: %lu\n", &total); ! 97: while (fscanf (file, "%lx: %lu %s\n", &opcode, &count, name) == 3) ! 98: { ! 99: opcode_next_clev[nr] = 5; ! 100: opcode_last_postfix[nr] = -1; ! 101: opcode_map[nr++] = opcode; ! 102: counts[opcode] = count; ! 103: } ! 104: fclose (file); ! 105: } ! 106: if (nr == nr_cpuop_funcs) ! 107: return; ! 108: for (opcode = 0; opcode < 0x10000; opcode++) ! 109: { ! 110: if (table68k[opcode].handler == -1 && table68k[opcode].mnemo != i_ILLG ! 111: && counts[opcode] == 0) ! 112: { ! 113: opcode_next_clev[nr] = 5; ! 114: opcode_last_postfix[nr] = -1; ! 115: opcode_map[nr++] = opcode; ! 116: counts[opcode] = count; ! 117: } ! 118: } ! 119: if (nr != nr_cpuop_funcs) ! 120: abort (); ! 121: } ! 122: ! 123: static int n_braces = 0; ! 124: static int insn_n_cycles; ! 125: ! 126: static void ! 127: start_brace (void) ! 128: { ! 129: n_braces++; ! 130: comprintf ("{"); ! 131: } ! 132: ! 133: static void ! 134: close_brace (void) ! 135: { ! 136: assert (n_braces > 0); ! 137: n_braces--; ! 138: comprintf ("}"); ! 139: } ! 140: ! 141: static void ! 142: finish_braces (void) ! 143: { ! 144: while (n_braces > 0) ! 145: close_brace (); ! 146: } ! 147: ! 148: static void ! 149: pop_braces (int to) ! 150: { ! 151: while (n_braces > to) ! 152: close_brace (); ! 153: } ! 154: ! 155: static int ! 156: bit_size (int size) ! 157: { ! 158: switch (size) ! 159: { ! 160: case sz_byte: ! 161: return 8; ! 162: case sz_word: ! 163: return 16; ! 164: case sz_long: ! 165: return 32; ! 166: default: ! 167: abort (); ! 168: } ! 169: return 0; ! 170: } ! 171: ! 172: static const char * ! 173: bit_mask (int size) ! 174: { ! 175: switch (size) ! 176: { ! 177: case sz_byte: ! 178: return "0xff"; ! 179: case sz_word: ! 180: return "0xffff"; ! 181: case sz_long: ! 182: return "0xffffffff"; ! 183: default: ! 184: abort (); ! 185: } ! 186: return 0; ! 187: } ! 188: ! 189: static __inline__ void gen_update_next_handler(void) ! 190: { ! 191: return; /* Can anything clever be done here? */ ! 192: } ! 193: ! 194: static void gen_writebyte (char* address, char* source) ! 195: { ! 196: comprintf("\twritebyte(%s,%s,scratchie);\n",address,source); ! 197: } ! 198: ! 199: static void gen_writeword (char* address, char* source) ! 200: { ! 201: comprintf("\twriteword(%s,%s,scratchie);\n",address,source); ! 202: } ! 203: ! 204: static void gen_writelong (char* address, char* source) ! 205: { ! 206: comprintf("\twritelong(%s,%s,scratchie);\n",address,source); ! 207: } ! 208: ! 209: static void gen_readbyte (char* address, char* dest) ! 210: { ! 211: comprintf("\treadbyte(%s,%s,scratchie);\n",address,dest); ! 212: } ! 213: ! 214: static void gen_readword (char* address, char* dest) ! 215: { ! 216: comprintf("\treadword(%s,%s,scratchie);\n",address,dest); ! 217: } ! 218: ! 219: static void gen_readlong (char* address, char* dest) ! 220: { ! 221: comprintf("\treadlong(%s,%s,scratchie);\n",address,dest); ! 222: } ! 223: ! 224: ! 225: ! 226: static const char * ! 227: gen_nextilong (void) ! 228: { ! 229: static char buffer[80]; ! 230: ! 231: sprintf (buffer, "comp_get_ilong((m68k_pc_offset+=4)-4)"); ! 232: insn_n_cycles += 4; ! 233: ! 234: long_opcode=1; ! 235: return buffer; ! 236: } ! 237: ! 238: static const char * ! 239: gen_nextiword (void) ! 240: { ! 241: static char buffer[80]; ! 242: ! 243: sprintf (buffer, "comp_get_iword((m68k_pc_offset+=2)-2)"); ! 244: insn_n_cycles+=2; ! 245: ! 246: long_opcode=1; ! 247: return buffer; ! 248: } ! 249: ! 250: static const char * ! 251: gen_nextibyte (void) ! 252: { ! 253: static char buffer[80]; ! 254: ! 255: sprintf (buffer, "comp_get_ibyte((m68k_pc_offset+=2)-2)"); ! 256: insn_n_cycles += 2; ! 257: ! 258: long_opcode=1; ! 259: return buffer; ! 260: } ! 261: ! 262: static void ! 263: sync_m68k_pc (void) ! 264: { ! 265: comprintf("\t if (m68k_pc_offset>100) sync_m68k_pc();\n"); ! 266: } ! 267: ! 268: ! 269: /* getv == 1: fetch data; getv != 0: check for odd address. If movem != 0, ! 270: * the calling routine handles Apdi and Aipi modes. */ ! 271: static void ! 272: genamode (amodes mode, char *reg, wordsizes size, char *name, int getv, int movem) ! 273: { ! 274: start_brace (); ! 275: switch (mode) ! 276: { ! 277: case Dreg: /* Do we need to check dodgy here? */ ! 278: if (movem) ! 279: abort (); ! 280: if (getv == 1 || getv==2) { ! 281: /* We generate the variable even for getv==2, so we can use ! 282: it as a destination for MOVE */ ! 283: comprintf ("\tint %s=%s;\n",name,reg); ! 284: } ! 285: return; ! 286: ! 287: case Areg: ! 288: if (movem) ! 289: abort (); ! 290: if (getv == 1 || getv==2) { ! 291: /* see above */ ! 292: comprintf ("\tint %s=dodgy?scratchie++:%s+8;\n",name,reg); ! 293: if (getv==1) { ! 294: comprintf ("\tif (dodgy) \n"); ! 295: comprintf ("\t\tmov_l_rr(%s,%s+8);\n",name, reg); ! 296: } ! 297: } ! 298: return; ! 299: ! 300: case Aind: ! 301: comprintf ("\tint %sa=dodgy?scratchie++:%s+8;\n",name,reg); ! 302: comprintf ("\tif (dodgy) \n"); ! 303: comprintf ("\t\tmov_l_rr(%sa,%s+8);\n",name, reg); ! 304: break; ! 305: case Aipi: ! 306: comprintf ("\tint %sa=scratchie++;\n",name,reg); ! 307: comprintf ("\tmov_l_rr(%sa,%s+8);\n",name, reg); ! 308: break; ! 309: case Apdi: ! 310: switch (size) ! 311: { ! 312: case sz_byte: ! 313: if (movem) { ! 314: comprintf ("\tint %sa=dodgy?scratchie++:%s+8;\n",name,reg); ! 315: comprintf ("\tif (dodgy) \n"); ! 316: comprintf("\tmov_l_rr(%sa,8+%s);\n",name,reg); ! 317: } ! 318: else { ! 319: start_brace(); ! 320: comprintf ("\tint %sa=dodgy?scratchie++:%s+8;\n",name,reg); ! 321: comprintf("\tlea_l_brr(%s+8,%s+8,(uae_s32)-areg_byteinc[%s]);\n",reg,reg,reg); ! 322: comprintf ("\tif (dodgy) \n"); ! 323: comprintf("\tmov_l_rr(%sa,8+%s);\n",name,reg); ! 324: } ! 325: break; ! 326: case sz_word: ! 327: if (movem) { ! 328: comprintf ("\tint %sa=dodgy?scratchie++:%s+8;\n",name,reg); ! 329: comprintf ("\tif (dodgy) \n"); ! 330: comprintf("\tmov_l_rr(%sa,8+%s);\n",name,reg); ! 331: } ! 332: else { ! 333: start_brace(); ! 334: comprintf ("\tint %sa=dodgy?scratchie++:%s+8;\n",name,reg); ! 335: comprintf("\tlea_l_brr(%s+8,%s+8,-2);\n",reg,reg); ! 336: comprintf ("\tif (dodgy) \n"); ! 337: comprintf("\tmov_l_rr(%sa,8+%s);\n",name,reg); ! 338: } ! 339: break; ! 340: case sz_long: ! 341: if (movem) { ! 342: comprintf ("\tint %sa=dodgy?scratchie++:%s+8;\n",name,reg); ! 343: comprintf ("\tif (dodgy) \n"); ! 344: comprintf("\tmov_l_rr(%sa,8+%s);\n",name,reg); ! 345: } ! 346: else { ! 347: start_brace(); ! 348: comprintf ("\tint %sa=dodgy?scratchie++:%s+8;\n",name,reg); ! 349: comprintf("\tlea_l_brr(%s+8,%s+8,-4);\n",reg,reg); ! 350: comprintf ("\tif (dodgy) \n"); ! 351: comprintf("\tmov_l_rr(%sa,8+%s);\n",name,reg); ! 352: } ! 353: break; ! 354: default: ! 355: abort (); ! 356: } ! 357: break; ! 358: case Ad16: ! 359: comprintf("\tint %sa=scratchie++;\n",name); ! 360: comprintf("\tmov_l_rr(%sa,8+%s);\n",name,reg); ! 361: comprintf("\tlea_l_brr(%sa,%sa,(uae_s32)(uae_s16)%s);\n",name,name,gen_nextiword()); ! 362: break; ! 363: case Ad8r: ! 364: comprintf("\tint %sa=scratchie++;\n",name); ! 365: comprintf("\tcalc_disp_ea_020(%s+8,%s,%sa,scratchie);\n", ! 366: reg,gen_nextiword(),name); ! 367: break; ! 368: ! 369: case PC16: ! 370: comprintf("\tint %sa=scratchie++;\n",name); ! 371: comprintf("\tuae_u32 address=start_pc+((char *)comp_pc_p-(char *)start_pc_p)+m68k_pc_offset;\n"); ! 372: comprintf ("\tuae_s32 PC16off = (uae_s32)(uae_s16)%s;\n", gen_nextiword ()); ! 373: comprintf("\tmov_l_ri(%sa,address+PC16off);\n",name); ! 374: break; ! 375: ! 376: case PC8r: ! 377: comprintf("\tint pctmp=scratchie++;\n"); ! 378: comprintf("\tint %sa=scratchie++;\n",name); ! 379: comprintf("\tuae_u32 address=start_pc+((char *)comp_pc_p-(char *)start_pc_p)+m68k_pc_offset;\n"); ! 380: start_brace(); ! 381: comprintf("\tmov_l_ri(pctmp,address);\n"); ! 382: ! 383: comprintf("\tcalc_disp_ea_020(pctmp,%s,%sa,scratchie);\n", ! 384: gen_nextiword(),name); ! 385: break; ! 386: case absw: ! 387: comprintf ("\tint %sa = scratchie++;\n",name); ! 388: comprintf ("\tmov_l_ri(%sa,(uae_s32)(uae_s16)%s);\n", name, gen_nextiword ()); ! 389: break; ! 390: case absl: ! 391: comprintf ("\tint %sa = scratchie++;\n",name); ! 392: comprintf ("\tmov_l_ri(%sa,%s); /* absl */\n", name, gen_nextilong ()); ! 393: break; ! 394: case imm: ! 395: if (getv != 1) ! 396: abort (); ! 397: switch (size) ! 398: { ! 399: case sz_byte: ! 400: comprintf ("\tint %s = scratchie++;\n",name); ! 401: comprintf ("\tmov_l_ri(%s,(uae_s32)(uae_s8)%s);\n", name, gen_nextibyte ()); ! 402: break; ! 403: case sz_word: ! 404: comprintf ("\tint %s = scratchie++;\n",name); ! 405: comprintf ("\tmov_l_ri(%s,(uae_s32)(uae_s16)%s);\n", name, gen_nextiword ()); ! 406: break; ! 407: case sz_long: ! 408: comprintf ("\tint %s = scratchie++;\n",name); ! 409: comprintf ("\tmov_l_ri(%s,%s);\n", name, gen_nextilong ()); ! 410: break; ! 411: default: ! 412: abort (); ! 413: } ! 414: return; ! 415: case imm0: ! 416: if (getv != 1) ! 417: abort (); ! 418: comprintf ("\tint %s = scratchie++;\n",name); ! 419: comprintf ("\tmov_l_ri(%s,(uae_s32)(uae_s8)%s);\n", name, gen_nextibyte ()); ! 420: return; ! 421: case imm1: ! 422: if (getv != 1) ! 423: abort (); ! 424: comprintf ("\tint %s = scratchie++;\n",name); ! 425: comprintf ("\tmov_l_ri(%s,(uae_s32)(uae_s16)%s);\n", name, gen_nextiword ()); ! 426: return; ! 427: case imm2: ! 428: if (getv != 1) ! 429: abort (); ! 430: comprintf ("\tint %s = scratchie++;\n",name); ! 431: comprintf ("\tmov_l_ri(%s,%s);\n", name, gen_nextilong ()); ! 432: return; ! 433: case immi: ! 434: if (getv != 1) ! 435: abort (); ! 436: comprintf ("\tint %s = scratchie++;\n",name); ! 437: comprintf ("\tmov_l_ri(%s,%s);\n", name, reg); ! 438: return; ! 439: default: ! 440: abort (); ! 441: } ! 442: ! 443: /* We get here for all non-reg non-immediate addressing modes to ! 444: * actually fetch the value. */ ! 445: if (getv == 1) ! 446: { ! 447: char astring[80]; ! 448: sprintf(astring,"%sa",name); ! 449: switch (size) ! 450: { ! 451: case sz_byte: ! 452: insn_n_cycles += 2; ! 453: break; ! 454: case sz_word: ! 455: insn_n_cycles += 2; ! 456: break; ! 457: case sz_long: ! 458: insn_n_cycles += 4; ! 459: break; ! 460: default: ! 461: abort (); ! 462: } ! 463: start_brace (); ! 464: comprintf("\tint %s=scratchie++;\n",name); ! 465: switch (size) ! 466: { ! 467: case sz_byte: ! 468: gen_readbyte(astring,name); ! 469: break; ! 470: case sz_word: ! 471: gen_readword(astring,name); ! 472: break; ! 473: case sz_long: ! 474: gen_readlong(astring,name); ! 475: break; ! 476: default: ! 477: abort (); ! 478: } ! 479: } ! 480: ! 481: /* We now might have to fix up the register for pre-dec or post-inc ! 482: * addressing modes. */ ! 483: if (!movem) { ! 484: switch (mode) ! 485: { ! 486: case Aipi: ! 487: switch (size) ! 488: { ! 489: case sz_byte: ! 490: comprintf("\tlea_l_brr(%s+8,%s+8,areg_byteinc[%s]);\n",reg,reg,reg); ! 491: break; ! 492: case sz_word: ! 493: comprintf("\tlea_l_brr(%s+8,%s+8,2);\n",reg,reg,reg); ! 494: break; ! 495: case sz_long: ! 496: comprintf("\tlea_l_brr(%s+8,%s+8,4);\n",reg,reg); ! 497: break; ! 498: default: ! 499: abort (); ! 500: } ! 501: break; ! 502: case Apdi: ! 503: break; ! 504: default: ! 505: break; ! 506: } ! 507: } ! 508: } ! 509: ! 510: static void ! 511: genastore (char *from, amodes mode, char *reg, wordsizes size, char *to) ! 512: { ! 513: switch (mode) ! 514: { ! 515: case Dreg: ! 516: switch (size) ! 517: { ! 518: case sz_byte: ! 519: comprintf("\tif(%s!=%s)\n",reg,from); ! 520: comprintf ("\t\tmov_b_rr(%s,%s);\n", reg, from); ! 521: break; ! 522: case sz_word: ! 523: comprintf("\tif(%s!=%s)\n",reg,from); ! 524: comprintf ("\t\tmov_w_rr(%s,%s);\n", reg, from); ! 525: break; ! 526: case sz_long: ! 527: comprintf("\tif(%s!=%s)\n",reg,from); ! 528: comprintf ("\t\tmov_l_rr(%s,%s);\n", reg, from); ! 529: break; ! 530: default: ! 531: abort (); ! 532: } ! 533: break; ! 534: case Areg: ! 535: switch (size) ! 536: { ! 537: case sz_word: ! 538: comprintf("\tif(%s+8!=%s)\n",reg,from); ! 539: comprintf ("\t\tmov_w_rr(%s+8,%s);\n", reg, from); ! 540: break; ! 541: case sz_long: ! 542: comprintf("\tif(%s+8!=%s)\n",reg,from); ! 543: comprintf ("\t\tmov_l_rr(%s+8,%s);\n", reg, from); ! 544: break; ! 545: default: ! 546: abort (); ! 547: } ! 548: break; ! 549: ! 550: case Apdi: ! 551: case absw: ! 552: case PC16: ! 553: case PC8r: ! 554: case Ad16: ! 555: case Ad8r: ! 556: case Aipi: ! 557: case Aind: ! 558: case absl: ! 559: { ! 560: char astring[80]; ! 561: sprintf(astring,"%sa",to); ! 562: ! 563: switch (size) ! 564: { ! 565: case sz_byte: ! 566: insn_n_cycles += 2; ! 567: gen_writebyte(astring,from); ! 568: break; ! 569: case sz_word: ! 570: insn_n_cycles += 2; ! 571: gen_writeword(astring,from); ! 572: break; ! 573: case sz_long: ! 574: insn_n_cycles += 4; ! 575: gen_writelong(astring,from); ! 576: break; ! 577: default: ! 578: abort (); ! 579: } ! 580: } ! 581: break; ! 582: case imm: ! 583: case imm0: ! 584: case imm1: ! 585: case imm2: ! 586: case immi: ! 587: abort (); ! 588: break; ! 589: default: ! 590: abort (); ! 591: } ! 592: } ! 593: static void genmov16(uae_u32 opcode, struct instr *curi) ! 594: { ! 595: comprintf("\tint src=scratchie++;\n"); ! 596: comprintf("\tint dst=scratchie++;\n"); ! 597: ! 598: if ((opcode & 0xfff8) == 0xf620) { ! 599: /* MOVE16 (Ax)+,(Ay)+ */ ! 600: comprintf("\tuae_u16 dstreg=((%s)>>12)&0x07;\n", gen_nextiword()); ! 601: comprintf("\tmov_l_rr(src,8+srcreg);\n"); ! 602: comprintf("\tmov_l_rr(dst,8+dstreg);\n"); ! 603: } else { ! 604: /* Other variants */ ! 605: genamode (curi->smode, "srcreg", curi->size, "src", 0, 2); ! 606: genamode (curi->dmode, "dstreg", curi->size, "dst", 0, 2); ! 607: comprintf("\tmov_l_rr(src,srca);\n"); ! 608: comprintf("\tmov_l_rr(dst,dsta);\n"); ! 609: } ! 610: ! 611: /* Align on 16-byte boundaries */ ! 612: comprintf("\tand_l_ri(src,~15);\n"); ! 613: comprintf("\tand_l_ri(dst,~15);\n"); ! 614: ! 615: ! 616: if ((opcode & 0xfff8) == 0xf620) { ! 617: comprintf("\tif (srcreg != dstreg)\n"); ! 618: comprintf("\tadd_l_ri(srcreg+8,16);\n"); ! 619: comprintf("\tadd_l_ri(dstreg+8,16);\n"); ! 620: } else if ((opcode & 0xfff8) == 0xf600) ! 621: comprintf("\tadd_l_ri(srcreg+8,16);\n"); ! 622: else if ((opcode & 0xfff8) == 0xf608) ! 623: comprintf("\tadd_l_ri(dstreg+8,16);\n"); ! 624: ! 625: comprintf("\tif (special_mem) {\n"); ! 626: comprintf("\t\tint tmp=scratchie;\n"); ! 627: comprintf("\tscratchie+=4;\n" ! 628: "\treadlong(src,tmp,scratchie);\n" ! 629: "\twritelong_clobber(dst,tmp,scratchie);\n" ! 630: "\tadd_l_ri(src,4);\n" ! 631: "\tadd_l_ri(dst,4);\n" ! 632: "\treadlong(src,tmp,scratchie);\n" ! 633: "\twritelong_clobber(dst,tmp,scratchie);\n" ! 634: "\tadd_l_ri(src,4);\n" ! 635: "\tadd_l_ri(dst,4);\n" ! 636: "\treadlong(src,tmp,scratchie);\n" ! 637: "\twritelong_clobber(dst,tmp,scratchie);\n" ! 638: "\tadd_l_ri(src,4);\n" ! 639: "\tadd_l_ri(dst,4);\n" ! 640: "\treadlong(src,tmp,scratchie);\n" ! 641: "\twritelong_clobber(dst,tmp,scratchie);\n"); ! 642: comprintf("\t} else {\n"); ! 643: comprintf("\t\tint tmp=scratchie;\n"); ! 644: comprintf("\tscratchie+=4;\n"); ! 645: comprintf("\tget_n_addr(src,src,scratchie);\n" ! 646: "\tget_n_addr(dst,dst,scratchie);\n" ! 647: "\tmov_l_rR(tmp+0,src,0);\n" ! 648: "\tmov_l_rR(tmp+1,src,4);\n" ! 649: "\tmov_l_rR(tmp+2,src,8);\n" ! 650: "\tmov_l_rR(tmp+3,src,12);\n" ! 651: "\tmov_l_Rr(dst,tmp+0,0);\n" ! 652: "\tforget_about(tmp+0);\n" ! 653: "\tmov_l_Rr(dst,tmp+1,4);\n" ! 654: "\tforget_about(tmp+1);\n" ! 655: "\tmov_l_Rr(dst,tmp+2,8);\n" ! 656: "\tforget_about(tmp+2);\n" ! 657: "\tmov_l_Rr(dst,tmp+3,12);\t}\n"); ! 658: ! 659: } ! 660: ! 661: #if 0 ! 662: static void genmov16(void) ! 663: { ! 664: comprintf("\tint src=scratchie++;\n" ! 665: "\tuae_u16 dstreg=((%s)>>12)&0x07;\n",gen_nextiword()); ! 666: comprintf("\tint dst=scratchie++;\n" ! 667: "\tint tmp=scratchie;\n" ! 668: "\tscratchie+=4;\n" ! 669: "\tmov_l_rr(src,8+srcreg);\n" ! 670: "\tand_l_ri(src,~15);\n" ! 671: "\tmov_l_rr(dst,8+dstreg);\n" ! 672: "\tand_l_ri(dst,~15);\n" ! 673: "\tadd_l_ri(srcreg+8,16);\n" ! 674: "\tadd_l_ri(dstreg+8,16);\n"); ! 675: ! 676: comprintf("\tif (special_mem) {\n" ! 677: "\treadlong(src,tmp,scratchie);\n" ! 678: "\twritelong_clobber(dst,tmp,scratchie);\n" ! 679: "\tadd_l_ri(src,4);\n" ! 680: "\tadd_l_ri(dst,4);\n" ! 681: "\treadlong(src,tmp,scratchie);\n" ! 682: "\twritelong_clobber(dst,tmp,scratchie);\n" ! 683: "\tadd_l_ri(src,4);\n" ! 684: "\tadd_l_ri(dst,4);\n" ! 685: "\treadlong(src,tmp,scratchie);\n" ! 686: "\twritelong_clobber(dst,tmp,scratchie);\n" ! 687: "\tadd_l_ri(src,4);\n" ! 688: "\tadd_l_ri(dst,4);\n" ! 689: "\treadlong(src,tmp,scratchie);\n" ! 690: "\twritelong_clobber(dst,tmp,scratchie);\n"); ! 691: comprintf("\t} else {\n"); ! 692: comprintf("\tget_n_addr(src,src,scratchie);\n" ! 693: "\tget_n_addr(dst,dst,scratchie);\n" ! 694: "\tmov_l_rR(tmp+0,src,0);\n" ! 695: "\tmov_l_rR(tmp+1,src,4);\n" ! 696: "\tmov_l_rR(tmp+2,src,8);\n" ! 697: "\tmov_l_rR(tmp+3,src,12);\n" ! 698: "\tmov_l_Rr(dst,tmp+0,0);\n" ! 699: "\tforget_about(tmp+0);\n" ! 700: "\tmov_l_Rr(dst,tmp+1,4);\n" ! 701: "\tforget_about(tmp+1);\n" ! 702: "\tmov_l_Rr(dst,tmp+2,8);\n" ! 703: "\tforget_about(tmp+2);\n" ! 704: "\tmov_l_Rr(dst,tmp+3,12);\n" ! 705: "\t}\n"); ! 706: } ! 707: #endif ! 708: ! 709: static void ! 710: genmovemel (uae_u16 opcode) ! 711: { ! 712: comprintf ("\tuae_u16 mask = %s;\n", gen_nextiword ()); ! 713: comprintf ("\tint native=scratchie++;\n"); ! 714: comprintf ("\tint i;\n"); ! 715: comprintf ("\tint offset=0;\n"); ! 716: genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "src", 2, 1); ! 717: comprintf("\tif (1 && !special_mem) {\n"); ! 718: ! 719: /* Fast but unsafe... */ ! 720: comprintf("\tget_n_addr(srca,native,scratchie);\n"); ! 721: ! 722: ! 723: comprintf("\tfor (i=0;i<16;i++) {\n" ! 724: "\t\tif ((mask>>i)&1) {\n"); ! 725: switch(table68k[opcode].size) { ! 726: case sz_long: ! 727: comprintf("\t\t\tmov_l_rR(i,native,offset);\n" ! 728: "\t\t\tgen_bswap_32(i);\n" ! 729: "\t\t\toffset+=4;\n"); ! 730: break; ! 731: case sz_word: ! 732: comprintf("\t\t\tmov_w_rR(i,native,offset);\n" ! 733: "\t\t\tgen_bswap_16(i);\n" ! 734: "\t\t\tsign_extend_16_rr(i,i);\n" ! 735: "\t\t\toffset+=2;\n"); ! 736: break; ! 737: default: abort(); ! 738: } ! 739: comprintf("\t\t}\n" ! 740: "\t}"); ! 741: if (table68k[opcode].dmode == Aipi) { ! 742: comprintf("\t\t\tlea_l_brr(8+dstreg,srca,offset);\n"); ! 743: } ! 744: /* End fast but unsafe. */ ! 745: ! 746: comprintf("\t} else {\n"); ! 747: ! 748: comprintf ("\tint tmp=scratchie++;\n"); ! 749: ! 750: comprintf("\tmov_l_rr(tmp,srca);\n"); ! 751: comprintf("\tfor (i=0;i<16;i++) {\n" ! 752: "\t\tif ((mask>>i)&1) {\n"); ! 753: switch(table68k[opcode].size) { ! 754: case sz_long: ! 755: comprintf("\t\t\treadlong(tmp,i,scratchie);\n" ! 756: "\t\t\tadd_l_ri(tmp,4);\n"); ! 757: break; ! 758: case sz_word: ! 759: comprintf("\t\t\treadword(tmp,i,scratchie);\n" ! 760: "\t\t\tadd_l_ri(tmp,2);\n"); ! 761: break; ! 762: default: abort(); ! 763: } ! 764: ! 765: comprintf("\t\t}\n" ! 766: "\t}"); ! 767: if (table68k[opcode].dmode == Aipi) { ! 768: comprintf("\t\t\tmov_l_rr(8+dstreg,tmp);\n"); ! 769: } ! 770: comprintf("\t}\n"); ! 771: ! 772: } ! 773: ! 774: ! 775: static void ! 776: genmovemle (uae_u16 opcode) ! 777: { ! 778: comprintf ("\tuae_u16 mask = %s;\n", gen_nextiword ()); ! 779: comprintf ("\tint native=scratchie++;\n"); ! 780: comprintf ("\tint i;\n"); ! 781: comprintf ("\tint tmp=scratchie++;\n"); ! 782: comprintf ("\tsigned char offset=0;\n"); ! 783: genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "src", 2, 1); ! 784: ! 785: /* *Sigh* Some clever geek realized that the fastest way to copy a ! 786: buffer from main memory to the gfx card is by using movmle. Good ! 787: on her, but unfortunately, gfx mem isn't "real" mem, and thus that ! 788: act of cleverness means that movmle must pay attention to special_mem, ! 789: or Genetic Species is a rather boring-looking game ;-) */ ! 790: comprintf("\tif (1 && !special_mem) {\n"); ! 791: comprintf("\tget_n_addr(srca,native,scratchie);\n"); ! 792: ! 793: if (table68k[opcode].dmode!=Apdi) { ! 794: comprintf("\tfor (i=0;i<16;i++) {\n" ! 795: "\t\tif ((mask>>i)&1) {\n"); ! 796: switch(table68k[opcode].size) { ! 797: case sz_long: ! 798: comprintf("\t\t\tmov_l_rr(tmp,i);\n" ! 799: "\t\t\tgen_bswap_32(tmp);\n" ! 800: "\t\t\tmov_l_Rr(native,tmp,offset);\n" ! 801: "\t\t\toffset+=4;\n"); ! 802: break; ! 803: case sz_word: ! 804: comprintf("\t\t\tmov_l_rr(tmp,i);\n" ! 805: "\t\t\tgen_bswap_16(tmp);\n" ! 806: "\t\t\tmov_w_Rr(native,tmp,offset);\n" ! 807: "\t\t\toffset+=2;\n"); ! 808: break; ! 809: default: abort(); ! 810: } ! 811: } else { /* Pre-decrement */ ! 812: comprintf("\tfor (i=0;i<16;i++) {\n" ! 813: "\t\tif ((mask>>i)&1) {\n"); ! 814: switch(table68k[opcode].size) { ! 815: case sz_long: ! 816: comprintf("\t\t\toffset-=4;\n" ! 817: "\t\t\tmov_l_rr(tmp,15-i);\n" ! 818: "\t\t\tgen_bswap_32(tmp);\n" ! 819: "\t\t\tmov_l_Rr(native,tmp,offset);\n" ! 820: ); ! 821: break; ! 822: case sz_word: ! 823: comprintf("\t\t\toffset-=2;\n" ! 824: "\t\t\tmov_l_rr(tmp,15-i);\n" ! 825: "\t\t\tgen_bswap_16(tmp);\n" ! 826: "\t\t\tmov_w_Rr(native,tmp,offset);\n" ! 827: ); ! 828: break; ! 829: default: abort(); ! 830: } ! 831: } ! 832: ! 833: comprintf("\t\t}\n" ! 834: "\t}"); ! 835: if (table68k[opcode].dmode == Apdi) { ! 836: comprintf("\t\t\tlea_l_brr(8+dstreg,srca,(uae_s32)offset);\n"); ! 837: } ! 838: comprintf("\t} else {\n"); ! 839: ! 840: if (table68k[opcode].dmode!=Apdi) { ! 841: comprintf("\tmov_l_rr(tmp,srca);\n"); ! 842: comprintf("\tfor (i=0;i<16;i++) {\n" ! 843: "\t\tif ((mask>>i)&1) {\n"); ! 844: switch(table68k[opcode].size) { ! 845: case sz_long: ! 846: comprintf("\t\t\twritelong(tmp,i,scratchie);\n" ! 847: "\t\t\tadd_l_ri(tmp,4);\n"); ! 848: break; ! 849: case sz_word: ! 850: comprintf("\t\t\twriteword(tmp,i,scratchie);\n" ! 851: "\t\t\tadd_l_ri(tmp,2);\n"); ! 852: break; ! 853: default: abort(); ! 854: } ! 855: } ! 856: else { /* Pre-decrement */ ! 857: comprintf("\tfor (i=0;i<16;i++) {\n" ! 858: "\t\tif ((mask>>i)&1) {\n"); ! 859: switch(table68k[opcode].size) { ! 860: case sz_long: ! 861: comprintf("\t\t\tsub_l_ri(srca,4);\n" ! 862: "\t\t\twritelong(srca,15-i,scratchie);\n"); ! 863: break; ! 864: case sz_word: ! 865: comprintf("\t\t\tsub_l_ri(srca,2);\n" ! 866: "\t\t\twriteword(srca,15-i,scratchie);\n"); ! 867: break; ! 868: default: abort(); ! 869: } ! 870: } ! 871: ! 872: ! 873: comprintf("\t\t}\n" ! 874: "\t}"); ! 875: if (table68k[opcode].dmode == Apdi) { ! 876: comprintf("\t\t\tmov_l_rr(8+dstreg,srca);\n"); ! 877: } ! 878: comprintf("\t}\n"); ! 879: } ! 880: ! 881: ! 882: static void ! 883: duplicate_carry (void) ! 884: { ! 885: comprintf ("\tif (needed_flags&FLAG_X) duplicate_carry();\n"); ! 886: } ! 887: ! 888: typedef enum ! 889: { ! 890: flag_logical_noclobber, flag_logical, flag_add, flag_sub, flag_cmp, ! 891: flag_addx, flag_subx, flag_zn, flag_av, flag_sv, flag_and, flag_or, ! 892: flag_eor, flag_mov ! 893: } ! 894: flagtypes; ! 895: ! 896: ! 897: static void ! 898: genflags (flagtypes type, wordsizes size, char *value, char *src, char *dst) ! 899: { ! 900: if (noflags) { ! 901: switch(type) { ! 902: case flag_cmp: ! 903: comprintf("\tdont_care_flags();\n"); ! 904: comprintf("/* Weird --- CMP with noflags ;-) */\n"); ! 905: return; ! 906: case flag_add: ! 907: case flag_sub: ! 908: comprintf("\tdont_care_flags();\n"); ! 909: { ! 910: char* op; ! 911: switch(type) { ! 912: case flag_add: op="add"; break; ! 913: case flag_sub: op="sub"; break; ! 914: default: abort(); ! 915: } ! 916: switch (size) ! 917: { ! 918: case sz_byte: ! 919: comprintf("\t%s_b(%s,%s);\n",op,dst,src); ! 920: break; ! 921: case sz_word: ! 922: comprintf("\t%s_w(%s,%s);\n",op,dst,src); ! 923: break; ! 924: case sz_long: ! 925: comprintf("\t%s_l(%s,%s);\n",op,dst,src); ! 926: break; ! 927: } ! 928: return; ! 929: } ! 930: break; ! 931: ! 932: case flag_and: ! 933: comprintf("\tdont_care_flags();\n"); ! 934: switch (size) ! 935: { ! 936: case sz_byte: ! 937: comprintf("if (kill_rodent(dst)) {\n"); ! 938: comprintf("\tzero_extend_8_rr(scratchie,%s);\n",src); ! 939: comprintf("\tor_l_ri(scratchie,0xffffff00);\n"); ! 940: comprintf("\tand_l(%s,scratchie);\n",dst); ! 941: comprintf("\tforget_about(scratchie);\n"); ! 942: comprintf("\t} else \n" ! 943: "\tand_b(%s,%s);\n",dst,src); ! 944: break; ! 945: case sz_word: ! 946: comprintf("if (kill_rodent(dst)) {\n"); ! 947: comprintf("\tzero_extend_16_rr(scratchie,%s);\n",src); ! 948: comprintf("\tor_l_ri(scratchie,0xffff0000);\n"); ! 949: comprintf("\tand_l(%s,scratchie);\n",dst); ! 950: comprintf("\tforget_about(scratchie);\n"); ! 951: comprintf("\t} else \n" ! 952: "\tand_w(%s,%s);\n",dst,src); ! 953: break; ! 954: case sz_long: ! 955: comprintf("\tand_l(%s,%s);\n",dst,src); ! 956: break; ! 957: } ! 958: return; ! 959: ! 960: case flag_mov: ! 961: comprintf("\tdont_care_flags();\n"); ! 962: switch (size) ! 963: { ! 964: case sz_byte: ! 965: comprintf("if (kill_rodent(dst)) {\n"); ! 966: comprintf("\tzero_extend_8_rr(scratchie,%s);\n",src); ! 967: comprintf("\tand_l_ri(%s,0xffffff00);\n",dst); ! 968: comprintf("\tor_l(%s,scratchie);\n",dst); ! 969: comprintf("\tforget_about(scratchie);\n"); ! 970: comprintf("\t} else \n" ! 971: "\tmov_b_rr(%s,%s);\n",dst,src); ! 972: break; ! 973: case sz_word: ! 974: comprintf("if (kill_rodent(dst)) {\n"); ! 975: comprintf("\tzero_extend_16_rr(scratchie,%s);\n",src); ! 976: comprintf("\tand_l_ri(%s,0xffff0000);\n",dst); ! 977: comprintf("\tor_l(%s,scratchie);\n",dst); ! 978: comprintf("\tforget_about(scratchie);\n"); ! 979: comprintf("\t} else \n" ! 980: "\tmov_w_rr(%s,%s);\n",dst,src); ! 981: break; ! 982: case sz_long: ! 983: comprintf("\tmov_l_rr(%s,%s);\n",dst,src); ! 984: break; ! 985: } ! 986: return; ! 987: ! 988: case flag_or: ! 989: case flag_eor: ! 990: comprintf("\tdont_care_flags();\n"); ! 991: start_brace(); ! 992: { ! 993: char* op; ! 994: switch(type) { ! 995: case flag_or: op="or"; break; ! 996: case flag_eor: op="xor"; break; ! 997: default: abort(); ! 998: } ! 999: switch (size) ! 1000: { ! 1001: case sz_byte: ! 1002: comprintf("if (kill_rodent(dst)) {\n"); ! 1003: comprintf("\tzero_extend_8_rr(scratchie,%s);\n",src); ! 1004: comprintf("\t%s_l(%s,scratchie);\n",op,dst); ! 1005: comprintf("\tforget_about(scratchie);\n"); ! 1006: comprintf("\t} else \n" ! 1007: "\t%s_b(%s,%s);\n",op,dst,src); ! 1008: break; ! 1009: case sz_word: ! 1010: comprintf("if (kill_rodent(dst)) {\n"); ! 1011: comprintf("\tzero_extend_16_rr(scratchie,%s);\n",src); ! 1012: comprintf("\t%s_l(%s,scratchie);\n",op,dst); ! 1013: comprintf("\tforget_about(scratchie);\n"); ! 1014: comprintf("\t} else \n" ! 1015: "\t%s_w(%s,%s);\n",op,dst,src); ! 1016: break; ! 1017: case sz_long: ! 1018: comprintf("\t%s_l(%s,%s);\n",op,dst,src); ! 1019: break; ! 1020: } ! 1021: close_brace(); ! 1022: return; ! 1023: } ! 1024: ! 1025: ! 1026: case flag_addx: ! 1027: case flag_subx: ! 1028: ! 1029: comprintf("\tdont_care_flags();\n"); ! 1030: { ! 1031: char* op; ! 1032: switch(type) { ! 1033: case flag_addx: op="adc"; break; ! 1034: case flag_subx: op="sbb"; break; ! 1035: default: abort(); ! 1036: } ! 1037: comprintf("\trestore_carry();\n"); /* Reload the X flag into C */ ! 1038: switch (size) ! 1039: { ! 1040: case sz_byte: ! 1041: comprintf("\t%s_b(%s,%s);\n",op,dst,src); ! 1042: break; ! 1043: case sz_word: ! 1044: comprintf("\t%s_w(%s,%s);\n",op,dst,src); ! 1045: break; ! 1046: case sz_long: ! 1047: comprintf("\t%s_l(%s,%s);\n",op,dst,src); ! 1048: break; ! 1049: } ! 1050: return; ! 1051: } ! 1052: break; ! 1053: default: return; ! 1054: } ! 1055: } ! 1056: ! 1057: /* Need the flags, but possibly not all of them */ ! 1058: switch (type) ! 1059: { ! 1060: case flag_logical_noclobber: ! 1061: failure; ! 1062: ! 1063: case flag_and: ! 1064: case flag_or: ! 1065: case flag_eor: ! 1066: comprintf("\tdont_care_flags();\n"); ! 1067: start_brace(); ! 1068: { ! 1069: char* op; ! 1070: switch(type) { ! 1071: case flag_and: op="and"; break; ! 1072: case flag_or: op="or"; break; ! 1073: case flag_eor: op="xor"; break; ! 1074: default: abort(); ! 1075: } ! 1076: switch (size) ! 1077: { ! 1078: case sz_byte: ! 1079: comprintf("\tstart_needflags();\n" ! 1080: "\t%s_b(%s,%s);\n",op,dst,src); ! 1081: break; ! 1082: case sz_word: ! 1083: comprintf("\tstart_needflags();\n" ! 1084: "\t%s_w(%s,%s);\n",op,dst,src); ! 1085: break; ! 1086: case sz_long: ! 1087: comprintf("\tstart_needflags();\n" ! 1088: "\t%s_l(%s,%s);\n",op,dst,src); ! 1089: break; ! 1090: } ! 1091: comprintf("\tlive_flags();\n"); ! 1092: comprintf("\tend_needflags();\n"); ! 1093: close_brace(); ! 1094: return; ! 1095: } ! 1096: ! 1097: case flag_mov: ! 1098: comprintf("\tdont_care_flags();\n"); ! 1099: start_brace(); ! 1100: { ! 1101: switch (size) ! 1102: { ! 1103: case sz_byte: ! 1104: comprintf("\tif (%s!=%s) {\n",src,dst); ! 1105: comprintf("\tmov_b_ri(%s,0);\n" ! 1106: "\tstart_needflags();\n",dst); ! 1107: comprintf("\tor_b(%s,%s);\n",dst,src); ! 1108: comprintf("\t} else {\n"); ! 1109: comprintf("\tmov_b_rr(%s,%s);\n",dst,src); ! 1110: comprintf("\ttest_b_rr(%s,%s);\n",dst,dst); ! 1111: comprintf("\t}\n"); ! 1112: break; ! 1113: case sz_word: ! 1114: comprintf("\tif (%s!=%s) {\n",src,dst); ! 1115: comprintf("\tmov_w_ri(%s,0);\n" ! 1116: "\tstart_needflags();\n",dst); ! 1117: comprintf("\tor_w(%s,%s);\n",dst,src); ! 1118: comprintf("\t} else {\n"); ! 1119: comprintf("\tmov_w_rr(%s,%s);\n",dst,src); ! 1120: comprintf("\ttest_w_rr(%s,%s);\n",dst,dst); ! 1121: comprintf("\t}\n"); ! 1122: break; ! 1123: case sz_long: ! 1124: comprintf("\tif (%s!=%s) {\n",src,dst); ! 1125: comprintf("\tmov_l_ri(%s,0);\n" ! 1126: "\tstart_needflags();\n",dst); ! 1127: comprintf("\tor_l(%s,%s);\n",dst,src); ! 1128: comprintf("\t} else {\n"); ! 1129: comprintf("\tmov_l_rr(%s,%s);\n",dst,src); ! 1130: comprintf("\ttest_l_rr(%s,%s);\n",dst,dst); ! 1131: comprintf("\t}\n"); ! 1132: break; ! 1133: } ! 1134: comprintf("\tlive_flags();\n"); ! 1135: comprintf("\tend_needflags();\n"); ! 1136: close_brace(); ! 1137: return; ! 1138: } ! 1139: ! 1140: case flag_logical: ! 1141: comprintf("\tdont_care_flags();\n"); ! 1142: start_brace(); ! 1143: switch (size) ! 1144: { ! 1145: case sz_byte: ! 1146: comprintf("\tstart_needflags();\n" ! 1147: "\ttest_b_rr(%s,%s);\n",value,value); ! 1148: break; ! 1149: case sz_word: ! 1150: comprintf("\tstart_needflags();\n" ! 1151: "\ttest_w_rr(%s,%s);\n",value,value); ! 1152: break; ! 1153: case sz_long: ! 1154: comprintf("\tstart_needflags();\n" ! 1155: "\ttest_l_rr(%s,%s);\n",value,value); ! 1156: break; ! 1157: } ! 1158: comprintf("\tlive_flags();\n"); ! 1159: comprintf("\tend_needflags();\n"); ! 1160: close_brace(); ! 1161: return; ! 1162: ! 1163: ! 1164: case flag_add: ! 1165: case flag_sub: ! 1166: case flag_cmp: ! 1167: comprintf("\tdont_care_flags();\n"); ! 1168: { ! 1169: char* op; ! 1170: switch(type) { ! 1171: case flag_add: op="add"; break; ! 1172: case flag_sub: op="sub"; break; ! 1173: case flag_cmp: op="cmp"; break; ! 1174: default: abort(); ! 1175: } ! 1176: switch (size) ! 1177: { ! 1178: case sz_byte: ! 1179: comprintf("\tstart_needflags();\n" ! 1180: "\t%s_b(%s,%s);\n",op,dst,src); ! 1181: break; ! 1182: case sz_word: ! 1183: comprintf("\tstart_needflags();\n" ! 1184: "\t%s_w(%s,%s);\n",op,dst,src); ! 1185: break; ! 1186: case sz_long: ! 1187: comprintf("\tstart_needflags();\n" ! 1188: "\t%s_l(%s,%s);\n",op,dst,src); ! 1189: break; ! 1190: } ! 1191: comprintf("\tlive_flags();\n"); ! 1192: comprintf("\tend_needflags();\n"); ! 1193: if (type!=flag_cmp) { ! 1194: duplicate_carry(); ! 1195: } ! 1196: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 1197: ! 1198: return; ! 1199: } ! 1200: ! 1201: case flag_addx: ! 1202: case flag_subx: ! 1203: uses_cmov; ! 1204: comprintf("\tdont_care_flags();\n"); ! 1205: { ! 1206: char* op; ! 1207: switch(type) { ! 1208: case flag_addx: op="adc"; break; ! 1209: case flag_subx: op="sbb"; break; ! 1210: default: abort(); ! 1211: } ! 1212: start_brace(); ! 1213: comprintf("\tint zero=scratchie++;\n" ! 1214: "\tint one=scratchie++;\n" ! 1215: "\tif (needed_flags&FLAG_Z) {\n" ! 1216: "\tmov_l_ri(zero,0);\n" ! 1217: "\tmov_l_ri(one,1);\n" ! 1218: "\tmake_flags_live();\n" ! 1219: "\tcmov_l_rr(zero,one,5);\n" ! 1220: "\t}\n"); ! 1221: comprintf("\trestore_carry();\n"); /* Reload the X flag into C */ ! 1222: switch (size) ! 1223: { ! 1224: case sz_byte: ! 1225: comprintf("\tstart_needflags();\n" ! 1226: "\t%s_b(%s,%s);\n",op,dst,src); ! 1227: break; ! 1228: case sz_word: ! 1229: comprintf("\tstart_needflags();\n" ! 1230: "\t%s_w(%s,%s);\n",op,dst,src); ! 1231: break; ! 1232: case sz_long: ! 1233: comprintf("\tstart_needflags();\n" ! 1234: "\t%s_l(%s,%s);\n",op,dst,src); ! 1235: break; ! 1236: } ! 1237: comprintf("\tlive_flags();\n"); ! 1238: comprintf("\tif (needed_flags&FLAG_Z) {\n" ! 1239: "\tcmov_l_rr(zero,one,5);\n" ! 1240: "\tsetzflg_l(zero);\n" ! 1241: "\tlive_flags();\n" ! 1242: "\t}\n"); ! 1243: comprintf("\tend_needflags();\n"); ! 1244: duplicate_carry(); ! 1245: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 1246: return; ! 1247: } ! 1248: default: ! 1249: failure; ! 1250: break; ! 1251: } ! 1252: } ! 1253: ! 1254: static void ! 1255: force_range_for_rox (const char *var, wordsizes size) ! 1256: { ! 1257: /* Could do a modulo operation here... which one is faster? */ ! 1258: switch (size) ! 1259: { ! 1260: case sz_long: ! 1261: comprintf ("\tif (%s >= 33) %s -= 33;\n", var, var); ! 1262: break; ! 1263: case sz_word: ! 1264: comprintf ("\tif (%s >= 34) %s -= 34;\n", var, var); ! 1265: comprintf ("\tif (%s >= 17) %s -= 17;\n", var, var); ! 1266: break; ! 1267: case sz_byte: ! 1268: comprintf ("\tif (%s >= 36) %s -= 36;\n", var, var); ! 1269: comprintf ("\tif (%s >= 18) %s -= 18;\n", var, var); ! 1270: comprintf ("\tif (%s >= 9) %s -= 9;\n", var, var); ! 1271: break; ! 1272: } ! 1273: } ! 1274: ! 1275: static const char * ! 1276: cmask (wordsizes size) ! 1277: { ! 1278: switch (size) ! 1279: { ! 1280: case sz_byte: ! 1281: return "0x80"; ! 1282: case sz_word: ! 1283: return "0x8000"; ! 1284: case sz_long: ! 1285: return "0x80000000"; ! 1286: default: ! 1287: abort (); ! 1288: } ! 1289: } ! 1290: ! 1291: static int ! 1292: source_is_imm1_8 (struct instr *i) ! 1293: { ! 1294: return i->stype == 3; ! 1295: } ! 1296: ! 1297: static int /* returns zero for success, non-zero for failure */ ! 1298: gen_opcode (unsigned long int opcode) ! 1299: { ! 1300: struct instr *curi = table68k + opcode; ! 1301: char* ssize=NULL; ! 1302: ! 1303: insn_n_cycles = 2; ! 1304: global_failure=0; ! 1305: long_opcode=0; ! 1306: global_isjump=0; ! 1307: global_iscjump=0; ! 1308: global_isaddx=0; ! 1309: global_cmov=0; ! 1310: global_mayfail=0; ! 1311: hack_opcode=opcode; ! 1312: endstr[0]=0; ! 1313: ! 1314: start_brace (); ! 1315: comprintf("\tuae_u8 scratchie=S1;\n"); ! 1316: switch (curi->plev) ! 1317: { ! 1318: case 0: /* not privileged */ ! 1319: break; ! 1320: case 1: /* unprivileged only on 68000 */ ! 1321: if (cpu_level == 0) ! 1322: break; ! 1323: if (next_cpu_level < 0) ! 1324: next_cpu_level = 0; ! 1325: ! 1326: /* fall through */ ! 1327: case 2: /* priviledged */ ! 1328: failure; /* Easy ones first */ ! 1329: break; ! 1330: case 3: /* privileged if size == word */ ! 1331: if (curi->size == sz_byte) ! 1332: break; ! 1333: failure; ! 1334: break; ! 1335: } ! 1336: switch (curi->size) { ! 1337: case sz_byte: ssize="b"; break; ! 1338: case sz_word: ssize="w"; break; ! 1339: case sz_long: ssize="l"; break; ! 1340: default: abort(); ! 1341: } ! 1342: ! 1343: switch (curi->mnemo) ! 1344: { ! 1345: case i_OR: ! 1346: case i_AND: ! 1347: case i_EOR: ! 1348: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1349: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1350: switch(curi->mnemo) { ! 1351: case i_OR: genflags (flag_or, curi->size, "", "src", "dst"); break; ! 1352: case i_AND: genflags (flag_and, curi->size, "", "src", "dst"); break; ! 1353: case i_EOR: genflags (flag_eor, curi->size, "", "src", "dst"); break; ! 1354: } ! 1355: genastore ("dst", curi->dmode, "dstreg", curi->size, "dst"); ! 1356: break; ! 1357: ! 1358: case i_ORSR: ! 1359: case i_EORSR: ! 1360: failure; ! 1361: isjump; ! 1362: break; ! 1363: case i_ANDSR: ! 1364: failure; ! 1365: isjump; ! 1366: break; ! 1367: case i_SUB: ! 1368: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1369: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1370: genflags (flag_sub, curi->size, "", "src", "dst"); ! 1371: genastore ("dst", curi->dmode, "dstreg", curi->size, "dst"); ! 1372: break; ! 1373: case i_SUBA: ! 1374: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1375: genamode (curi->dmode, "dstreg", sz_long, "dst", 1, 0); ! 1376: start_brace(); ! 1377: comprintf("\tint tmp=scratchie++;\n"); ! 1378: switch(curi->size) { ! 1379: case sz_byte: comprintf("\tsign_extend_8_rr(tmp,src);\n"); break; ! 1380: case sz_word: comprintf("\tsign_extend_16_rr(tmp,src);\n"); break; ! 1381: case sz_long: comprintf("\ttmp=src;\n"); break; ! 1382: default: abort(); ! 1383: } ! 1384: comprintf("\tsub_l(dst,tmp);\n"); ! 1385: genastore ("dst", curi->dmode, "dstreg", sz_long, "dst"); ! 1386: break; ! 1387: case i_SUBX: ! 1388: isaddx; ! 1389: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1390: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1391: genflags (flag_subx, curi->size, "", "src", "dst"); ! 1392: genastore ("dst", curi->dmode, "dstreg", curi->size, "dst"); ! 1393: break; ! 1394: case i_SBCD: ! 1395: failure; ! 1396: /* I don't think so! */ ! 1397: break; ! 1398: case i_ADD: ! 1399: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1400: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1401: genflags (flag_add, curi->size, "", "src", "dst"); ! 1402: genastore ("dst", curi->dmode, "dstreg", curi->size, "dst"); ! 1403: break; ! 1404: case i_ADDA: ! 1405: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1406: genamode (curi->dmode, "dstreg", sz_long, "dst", 1, 0); ! 1407: start_brace(); ! 1408: comprintf("\tint tmp=scratchie++;\n"); ! 1409: switch(curi->size) { ! 1410: case sz_byte: comprintf("\tsign_extend_8_rr(tmp,src);\n"); break; ! 1411: case sz_word: comprintf("\tsign_extend_16_rr(tmp,src);\n"); break; ! 1412: case sz_long: comprintf("\ttmp=src;\n"); break; ! 1413: default: abort(); ! 1414: } ! 1415: comprintf("\tadd_l(dst,tmp);\n"); ! 1416: genastore ("dst", curi->dmode, "dstreg", sz_long, "dst"); ! 1417: break; ! 1418: case i_ADDX: ! 1419: isaddx; ! 1420: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1421: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1422: start_brace(); ! 1423: genflags (flag_addx, curi->size, "", "src", "dst"); ! 1424: genastore ("dst", curi->dmode, "dstreg", curi->size, "dst"); ! 1425: break; ! 1426: case i_ABCD: ! 1427: failure; ! 1428: /* No BCD maths for me.... */ ! 1429: break; ! 1430: case i_NEG: ! 1431: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1432: start_brace (); ! 1433: comprintf("\tint dst=scratchie++;\n"); ! 1434: comprintf("\tmov_l_ri(dst,0);\n"); ! 1435: genflags (flag_sub, curi->size, "", "src", "dst"); ! 1436: genastore ("dst", curi->smode, "srcreg", curi->size, "src"); ! 1437: break; ! 1438: case i_NEGX: ! 1439: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1440: start_brace (); ! 1441: comprintf("\tint dst=scratchie++;\n"); ! 1442: comprintf("\tmov_l_ri(dst,0);\n"); ! 1443: genflags (flag_subx, curi->size, "", "src", "dst"); ! 1444: genastore ("dst", curi->smode, "srcreg", curi->size, "src"); ! 1445: break; ! 1446: ! 1447: case i_NBCD: ! 1448: failure; ! 1449: /* Nope! */ ! 1450: break; ! 1451: case i_CLR: ! 1452: genamode (curi->smode, "srcreg", curi->size, "src", 2, 0); ! 1453: start_brace(); ! 1454: comprintf("\tint dst=scratchie++;\n"); ! 1455: comprintf("\tmov_l_ri(dst,0);\n"); ! 1456: genflags (flag_logical, curi->size, "dst", "", ""); ! 1457: genastore ("dst", curi->smode, "srcreg", curi->size, "src"); ! 1458: break; ! 1459: case i_NOT: ! 1460: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1461: start_brace (); ! 1462: comprintf("\tint dst=scratchie++;\n"); ! 1463: comprintf("\tmov_l_ri(dst,0xffffffff);\n"); ! 1464: genflags (flag_eor, curi->size, "", "src", "dst"); ! 1465: genastore ("dst", curi->smode, "srcreg", curi->size, "src"); ! 1466: break; ! 1467: case i_TST: ! 1468: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1469: genflags (flag_logical, curi->size, "src", "", ""); ! 1470: break; ! 1471: case i_BCHG: ! 1472: case i_BCLR: ! 1473: case i_BSET: ! 1474: case i_BTST: ! 1475: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1476: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1477: start_brace(); ! 1478: comprintf("\tint s=scratchie++;\n" ! 1479: "\tmov_l_rr(s,src);\n"); ! 1480: if (curi->size == sz_byte) ! 1481: comprintf("\tand_l_ri(s,7);\n"); ! 1482: else ! 1483: comprintf("\tand_l_ri(s,31);\n"); ! 1484: ! 1485: { ! 1486: char* op; ! 1487: int need_write=1; ! 1488: ! 1489: switch(curi->mnemo) { ! 1490: case i_BCHG: op="btc"; break; ! 1491: case i_BCLR: op="btr"; break; ! 1492: case i_BSET: op="bts"; break; ! 1493: case i_BTST: op="bt"; need_write=0; break; ! 1494: } ! 1495: comprintf("\t%s_l_rr(dst,s);\n" /* Answer now in C */ ! 1496: "\tsbb_l(s,s);\n" /* s is 0 if bit was 0, -1 otherwise */ ! 1497: "\tmake_flags_live();\n" /* Get the flags back */ ! 1498: "\tdont_care_flags();\n",op); ! 1499: if (!noflags) { ! 1500: comprintf("\tstart_needflags();\n" ! 1501: "\tsetzflg_l(s);\n" ! 1502: "\tlive_flags();\n" ! 1503: "\tend_needflags();\n"); ! 1504: } ! 1505: if (need_write) ! 1506: genastore ("dst", curi->dmode, "dstreg", curi->size, "dst"); ! 1507: } ! 1508: break; ! 1509: /*if (!noflags) { ! 1510: failure; ! 1511: break; ! 1512: } ! 1513: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1514: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1515: start_brace(); ! 1516: comprintf("\tint s=scratchie++;\n" ! 1517: "\tmov_l_rr(s,src);\n"); ! 1518: if (curi->size == sz_byte) ! 1519: comprintf("\tand_l_ri(s,7);\n"); ! 1520: else ! 1521: comprintf("\tand_l_ri(s,31);\n"); ! 1522: ! 1523: { ! 1524: char* op; ! 1525: int need_write=1; ! 1526: ! 1527: switch(curi->mnemo) { ! 1528: case i_BCHG: op="btc"; break; ! 1529: case i_BCLR: op="btr"; break; ! 1530: case i_BSET: op="bts"; break; ! 1531: case i_BTST: op="bt"; need_write=0; break; ! 1532: } ! 1533: comprintf("\t%s_l_rr(dst,s);\n" // Answer now in C ! 1534: "\tsbb_l(s,s);\n" // s is 0 if bit was 0, -1 otherwise ! 1535: "\tmake_flags_live();\n" // Get the flags back ! 1536: "\tdont_care_flags();\n" ! 1537: "\tstart_needflags();\n" ! 1538: "\tbsf_l_rr(s,s);\n" ! 1539: "\tlive_flags();\n" ! 1540: "\tend_needflags();\n",op); ! 1541: if (need_write) ! 1542: genastore ("dst", curi->dmode, "dstreg", curi->size, "dst"); ! 1543: } ! 1544: break; ! 1545: */ ! 1546: case i_CMPM: ! 1547: case i_CMP: ! 1548: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1549: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1550: start_brace (); ! 1551: genflags (flag_cmp, curi->size, "", "src", "dst"); ! 1552: break; ! 1553: case i_CMPA: ! 1554: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1555: genamode (curi->dmode, "dstreg", sz_long, "dst", 1, 0); ! 1556: start_brace(); ! 1557: comprintf("\tint tmps=scratchie++;\n"); ! 1558: switch(curi->size) { ! 1559: case sz_byte: comprintf("\tsign_extend_8_rr(tmps,src);\n"); break; ! 1560: case sz_word: comprintf("\tsign_extend_16_rr(tmps,src);\n"); break; ! 1561: case sz_long: comprintf("tmps=src;\n"); break; ! 1562: default: abort(); ! 1563: } ! 1564: genflags (flag_cmp, sz_long, "", "tmps", "dst"); ! 1565: break; ! 1566: /* The next two are coded a little unconventional, but they are doing ! 1567: * weird things... */ ! 1568: case i_MVPRM: ! 1569: isjump; ! 1570: failure; ! 1571: break; ! 1572: case i_MVPMR: ! 1573: isjump; ! 1574: failure; ! 1575: break; ! 1576: case i_MOVE: ! 1577: switch(curi->dmode) { ! 1578: case Dreg: ! 1579: case Areg: ! 1580: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1581: genamode (curi->dmode, "dstreg", curi->size, "dst", 2, 0); ! 1582: genflags (flag_mov, curi->size, "", "src", "dst"); ! 1583: genastore ("dst", curi->dmode, "dstreg", curi->size, "dst"); ! 1584: break; ! 1585: default: /* It goes to memory, not a register */ ! 1586: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1587: genamode (curi->dmode, "dstreg", curi->size, "dst", 2, 0); ! 1588: genflags (flag_logical, curi->size, "src", "", ""); ! 1589: genastore ("src", curi->dmode, "dstreg", curi->size, "dst"); ! 1590: break; ! 1591: } ! 1592: break; ! 1593: case i_MOVEA: ! 1594: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1595: genamode (curi->dmode, "dstreg", curi->size, "dst", 2, 0); ! 1596: ! 1597: start_brace(); ! 1598: comprintf("\tint tmps=scratchie++;\n"); ! 1599: switch(curi->size) { ! 1600: case sz_word: comprintf("\tsign_extend_16_rr(dst,src);\n"); break; ! 1601: case sz_long: comprintf("\tmov_l_rr(dst,src);\n"); break; ! 1602: default: abort(); ! 1603: } ! 1604: genastore ("dst", curi->dmode, "dstreg", sz_long, "dst"); ! 1605: break; ! 1606: ! 1607: case i_MVSR2: ! 1608: isjump; ! 1609: failure; ! 1610: break; ! 1611: case i_MV2SR: ! 1612: isjump; ! 1613: failure; ! 1614: break; ! 1615: case i_SWAP: ! 1616: genamode (curi->smode, "srcreg", sz_long, "src", 1, 0); ! 1617: comprintf("\tdont_care_flags();\n"); ! 1618: comprintf("\trol_l_ri(src,16);\n"); ! 1619: genflags (flag_logical, sz_long, "src", "", ""); ! 1620: genastore ("src", curi->smode, "srcreg", sz_long, "src"); ! 1621: break; ! 1622: case i_EXG: ! 1623: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1624: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 1625: start_brace(); ! 1626: comprintf("\tint tmp=scratchie++;\n" ! 1627: "\tmov_l_rr(tmp,src);\n"); ! 1628: genastore ("dst", curi->smode, "srcreg", curi->size, "src"); ! 1629: genastore ("tmp", curi->dmode, "dstreg", curi->size, "dst"); ! 1630: break; ! 1631: case i_EXT: ! 1632: genamode (curi->smode, "srcreg", sz_long, "src", 1, 0); ! 1633: comprintf("\tdont_care_flags();\n"); ! 1634: start_brace (); ! 1635: switch (curi->size) ! 1636: { ! 1637: case sz_byte: ! 1638: comprintf ("\tint dst = src;\n" ! 1639: "\tsign_extend_8_rr(src,src);\n"); ! 1640: break; ! 1641: case sz_word: ! 1642: comprintf ("\tint dst = scratchie++;\n" ! 1643: "\tsign_extend_8_rr(dst,src);\n"); ! 1644: break; ! 1645: case sz_long: ! 1646: comprintf ("\tint dst = src;\n" ! 1647: "\tsign_extend_16_rr(src,src);\n"); ! 1648: break; ! 1649: default: ! 1650: abort (); ! 1651: } ! 1652: genflags (flag_logical, ! 1653: curi->size == sz_word ? sz_word : sz_long, "dst", "", ""); ! 1654: genastore ("dst", curi->smode, "srcreg", ! 1655: curi->size == sz_word ? sz_word : sz_long, "src"); ! 1656: break; ! 1657: case i_MVMEL: ! 1658: genmovemel (opcode); ! 1659: break; ! 1660: case i_MVMLE: ! 1661: genmovemle (opcode); ! 1662: break; ! 1663: case i_TRAP: ! 1664: isjump; ! 1665: failure; ! 1666: break; ! 1667: case i_MVR2USP: ! 1668: isjump; ! 1669: failure; ! 1670: break; ! 1671: case i_MVUSP2R: ! 1672: isjump; ! 1673: failure; ! 1674: break; ! 1675: case i_RESET: ! 1676: isjump; ! 1677: failure; ! 1678: break; ! 1679: case i_NOP: ! 1680: break; ! 1681: case i_STOP: ! 1682: isjump; ! 1683: failure; ! 1684: break; ! 1685: case i_RTE: ! 1686: isjump; ! 1687: failure; ! 1688: break; ! 1689: case i_RTD: ! 1690: genamode (curi->smode, "srcreg", curi->size, "offs", 1, 0); ! 1691: /* offs is constant */ ! 1692: comprintf("\tadd_l_ri(offs,4);\n"); ! 1693: start_brace(); ! 1694: comprintf("\tint newad=scratchie++;\n" ! 1695: "\treadlong(15,newad,scratchie);\n" ! 1696: "\tand_l_ri(newad,~1);\n" ! 1697: "\tmov_l_mr((uae_u32)®s.pc,newad);\n" ! 1698: "\tget_n_addr_jmp(newad,PC_P,scratchie);\n" ! 1699: "\tmov_l_mr((uae_u32)®s.pc_oldp,PC_P);\n" ! 1700: "\tm68k_pc_offset=0;\n" ! 1701: "\tadd_l(15,offs);\n"); ! 1702: gen_update_next_handler(); ! 1703: isjump; ! 1704: break; ! 1705: case i_LINK: ! 1706: genamode (curi->smode, "srcreg", sz_long, "src", 1, 0); ! 1707: genamode (curi->dmode, "dstreg", curi->size, "offs", 1, 0); ! 1708: comprintf("\tsub_l_ri(15,4);\n" ! 1709: "\twritelong_clobber(15,src,scratchie);\n" ! 1710: "\tmov_l_rr(src,15);\n"); ! 1711: if (curi->size==sz_word) ! 1712: comprintf("\tsign_extend_16_rr(offs,offs);\n"); ! 1713: comprintf("\tadd_l(15,offs);\n"); ! 1714: genastore ("src", curi->smode, "srcreg", sz_long, "src"); ! 1715: break; ! 1716: case i_UNLK: ! 1717: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1718: comprintf("\tmov_l_rr(15,src);\n" ! 1719: "\treadlong(15,src,scratchie);\n" ! 1720: "\tadd_l_ri(15,4);\n"); ! 1721: genastore ("src", curi->smode, "srcreg", curi->size, "src"); ! 1722: break; ! 1723: case i_RTS: ! 1724: comprintf("\tint newad=scratchie++;\n" ! 1725: "\treadlong(15,newad,scratchie);\n" ! 1726: "\tand_l_ri(newad,~1);\n" ! 1727: "\tmov_l_mr((uae_u32)®s.pc,newad);\n" ! 1728: "\tget_n_addr_jmp(newad,PC_P,scratchie);\n" ! 1729: "\tmov_l_mr((uae_u32)®s.pc_oldp,PC_P);\n" ! 1730: "\tm68k_pc_offset=0;\n" ! 1731: "\tlea_l_brr(15,15,4);\n"); ! 1732: gen_update_next_handler(); ! 1733: isjump; ! 1734: break; ! 1735: case i_TRAPV: ! 1736: isjump; ! 1737: failure; ! 1738: break; ! 1739: case i_RTR: ! 1740: isjump; ! 1741: failure; ! 1742: break; ! 1743: case i_JSR: ! 1744: isjump; ! 1745: genamode (curi->smode, "srcreg", curi->size, "src", 0, 0); ! 1746: start_brace(); ! 1747: comprintf("\tuae_u32 retadd=start_pc+((char *)comp_pc_p-(char *)start_pc_p)+m68k_pc_offset;\n"); ! 1748: comprintf("\tint ret=scratchie++;\n" ! 1749: "\tmov_l_ri(ret,retadd);\n" ! 1750: "\tsub_l_ri(15,4);\n" ! 1751: "\twritelong_clobber(15,ret,scratchie);\n"); ! 1752: comprintf("\tand_l_ri(srca,~1);\n" ! 1753: "\tmov_l_mr((uae_u32)®s.pc,srca);\n" ! 1754: "\tget_n_addr_jmp(srca,PC_P,scratchie);\n" ! 1755: "\tmov_l_mr((uae_u32)®s.pc_oldp,PC_P);\n" ! 1756: "\tm68k_pc_offset=0;\n"); ! 1757: gen_update_next_handler(); ! 1758: break; ! 1759: case i_JMP: ! 1760: isjump; ! 1761: genamode (curi->smode, "srcreg", curi->size, "src", 0, 0); ! 1762: comprintf("\tand_l_ri(srca,~1);\n" ! 1763: "\tmov_l_mr((uae_u32)®s.pc,srca);\n" ! 1764: "\tget_n_addr_jmp(srca,PC_P,scratchie);\n" ! 1765: "\tmov_l_mr((uae_u32)®s.pc_oldp,PC_P);\n" ! 1766: "\tm68k_pc_offset=0;\n"); ! 1767: gen_update_next_handler(); ! 1768: break; ! 1769: case i_BSR: ! 1770: if (curi->size==sz_long) ! 1771: failure; ! 1772: is_const_jump; ! 1773: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1774: comprintf("\tand_l_ri(src,~1);\n"); ! 1775: start_brace(); ! 1776: comprintf("\tuae_u32 retadd=start_pc+((char *)comp_pc_p-(char *)start_pc_p)+m68k_pc_offset;\n"); ! 1777: comprintf("\tint ret=scratchie++;\n" ! 1778: "\tmov_l_ri(ret,retadd);\n" ! 1779: "\tsub_l_ri(15,4);\n" ! 1780: "\twritelong_clobber(15,ret,scratchie);\n"); ! 1781: comprintf("\tadd_l_ri(src,m68k_pc_offset_thisinst+2);\n"); ! 1782: comprintf("\tm68k_pc_offset=0;\n"); ! 1783: comprintf("\tadd_l(PC_P,src);\n"); ! 1784: ! 1785: comprintf("\tcomp_pc_p=(uae_u8*)get_const(PC_P);\n"); ! 1786: break; ! 1787: case i_Bcc: ! 1788: comprintf("\tuae_u32 v1,v2;\n"); ! 1789: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1790: /* That source is an immediate, so we can clobber it with abandon */ ! 1791: switch(curi->size) { ! 1792: case sz_byte: comprintf("\tsign_extend_8_rr(src,src);\n"); break; ! 1793: case sz_word: comprintf("\tsign_extend_16_rr(src,src);\n"); break; ! 1794: case sz_long: break; ! 1795: } ! 1796: comprintf("\tand_l_ri(src,~1);\n"); ! 1797: comprintf("\tsub_l_ri(src,m68k_pc_offset-m68k_pc_offset_thisinst-2);\n"); ! 1798: /* Leave the following as "add" --- it will allow it to be optimized ! 1799: away due to src being a constant ;-) */ ! 1800: comprintf("\tadd_l_ri(src,(uae_u32)comp_pc_p);\n"); ! 1801: comprintf("\tmov_l_ri(PC_P,(uae_u32)comp_pc_p);\n"); ! 1802: /* Now they are both constant. Might as well fold in m68k_pc_offset */ ! 1803: comprintf("\tadd_l_ri(src,m68k_pc_offset);\n"); ! 1804: comprintf("\tadd_l_ri(PC_P,m68k_pc_offset);\n"); ! 1805: comprintf("\tm68k_pc_offset=0;\n"); ! 1806: ! 1807: if (curi->cc>=2) { ! 1808: comprintf("\tv1=get_const(PC_P);\n" ! 1809: "\tv2=get_const(src);\n" ! 1810: "\tregister_branch(v1,v2,%d);\n", ! 1811: cond_codes_x86[curi->cc]); ! 1812: comprintf("\tmake_flags_live();\n"); /* Load the flags */ ! 1813: isjump; ! 1814: } ! 1815: else { ! 1816: is_const_jump; ! 1817: } ! 1818: ! 1819: switch(curi->cc) { ! 1820: case 0: /* Unconditional jump */ ! 1821: comprintf("\tmov_l_rr(PC_P,src);\n"); ! 1822: comprintf("\tcomp_pc_p=(uae_u8*)get_const(PC_P);\n"); ! 1823: break; ! 1824: case 1: break; /* This is silly! */ ! 1825: case 8: failure; break; /* Work out details! FIXME */ ! 1826: case 9: failure; break; /* Not critical, though! */ ! 1827: ! 1828: case 2: ! 1829: case 3: ! 1830: case 4: ! 1831: case 5: ! 1832: case 6: ! 1833: case 7: ! 1834: case 10: ! 1835: case 11: ! 1836: case 12: ! 1837: case 13: ! 1838: case 14: ! 1839: case 15: ! 1840: break; ! 1841: default: abort(); ! 1842: } ! 1843: break; ! 1844: case i_LEA: ! 1845: genamode (curi->smode, "srcreg", curi->size, "src", 0, 0); ! 1846: genamode (curi->dmode, "dstreg", curi->size, "dst", 2, 0); ! 1847: genastore ("srca", curi->dmode, "dstreg", curi->size, "dst"); ! 1848: break; ! 1849: case i_PEA: ! 1850: if (table68k[opcode].smode==Areg || ! 1851: table68k[opcode].smode==Aind || ! 1852: table68k[opcode].smode==Aipi || ! 1853: table68k[opcode].smode==Apdi || ! 1854: table68k[opcode].smode==Ad16 || ! 1855: table68k[opcode].smode==Ad8r) ! 1856: comprintf("if (srcreg==7) dodgy=1;\n"); ! 1857: ! 1858: genamode (curi->smode, "srcreg", curi->size, "src", 0, 0); ! 1859: genamode (Apdi, "7", sz_long, "dst", 2, 0); ! 1860: genastore ("srca", Apdi, "7", sz_long, "dst"); ! 1861: break; ! 1862: case i_DBcc: ! 1863: isjump; ! 1864: uses_cmov; ! 1865: genamode (curi->smode, "srcreg", curi->size, "src", 1, 0); ! 1866: genamode (curi->dmode, "dstreg", curi->size, "offs", 1, 0); ! 1867: ! 1868: /* That offs is an immediate, so we can clobber it with abandon */ ! 1869: switch(curi->size) { ! 1870: case sz_word: comprintf("\tsign_extend_16_rr(offs,offs);\n"); break; ! 1871: default: abort(); /* Seems this only comes in word flavour */ ! 1872: } ! 1873: comprintf("\tsub_l_ri(offs,m68k_pc_offset-m68k_pc_offset_thisinst-2);\n"); ! 1874: comprintf("\tadd_l_ri(offs,(uae_u32)comp_pc_p);\n"); /* New PC, ! 1875: once the ! 1876: offset_68k is ! 1877: * also added */ ! 1878: /* Let's fold in the m68k_pc_offset at this point */ ! 1879: comprintf("\tadd_l_ri(offs,m68k_pc_offset);\n"); ! 1880: comprintf("\tadd_l_ri(PC_P,m68k_pc_offset);\n"); ! 1881: comprintf("\tm68k_pc_offset=0;\n"); ! 1882: ! 1883: start_brace(); ! 1884: comprintf("\tint nsrc=scratchie++;\n"); ! 1885: ! 1886: if (curi->cc>=2) { ! 1887: comprintf("\tmake_flags_live();\n"); /* Load the flags */ ! 1888: } ! 1889: ! 1890: if (curi->size!=sz_word) ! 1891: abort(); ! 1892: ! 1893: ! 1894: switch(curi->cc) { ! 1895: case 0: /* This is an elaborate nop? */ ! 1896: break; ! 1897: case 1: ! 1898: comprintf("\tstart_needflags();\n"); ! 1899: comprintf("\tsub_w_ri(src,1);\n"); ! 1900: comprintf("\t end_needflags();\n"); ! 1901: start_brace(); ! 1902: comprintf("\tuae_u32 v2;\n" ! 1903: "\tuae_u32 v1=get_const(PC_P);\n"); ! 1904: comprintf("\tv2=get_const(offs);\n" ! 1905: "\tregister_branch(v1,v2,3);\n"); ! 1906: break; ! 1907: ! 1908: case 8: failure; break; /* Work out details! FIXME */ ! 1909: case 9: failure; break; /* Not critical, though! */ ! 1910: ! 1911: case 2: ! 1912: case 3: ! 1913: case 4: ! 1914: case 5: ! 1915: case 6: ! 1916: case 7: ! 1917: case 10: ! 1918: case 11: ! 1919: case 12: ! 1920: case 13: ! 1921: case 14: ! 1922: case 15: ! 1923: comprintf("\tmov_l_rr(nsrc,src);\n"); ! 1924: comprintf("\tlea_l_brr(scratchie,src,(uae_s32)-1);\n" ! 1925: "\tmov_w_rr(src,scratchie);\n"); ! 1926: comprintf("\tcmov_l_rr(offs,PC_P,%d);\n", ! 1927: cond_codes_x86[curi->cc]); ! 1928: comprintf("\tcmov_l_rr(src,nsrc,%d);\n", ! 1929: cond_codes_x86[curi->cc]); ! 1930: /* OK, now for cc=true, we have src==nsrc and offs==PC_P, ! 1931: so whether we move them around doesn't matter. However, ! 1932: if cc=false, we have offs==jump_pc, and src==nsrc-1 */ ! 1933: ! 1934: comprintf("\t start_needflags();\n"); ! 1935: comprintf("\ttest_w_rr(nsrc,nsrc);\n"); ! 1936: comprintf("\t end_needflags();\n"); ! 1937: comprintf("\tcmov_l_rr(PC_P,offs,5);\n"); ! 1938: break; ! 1939: default: abort(); ! 1940: } ! 1941: genastore ("src", curi->smode, "srcreg", curi->size, "src"); ! 1942: gen_update_next_handler(); ! 1943: break; ! 1944: ! 1945: case i_Scc: ! 1946: genamode (curi->smode, "srcreg", curi->size, "src", 2, 0); ! 1947: start_brace (); ! 1948: comprintf ("\tint val = scratchie++;\n"); ! 1949: ! 1950: /* We set val to 0 if we really should use 255, and to 1 for real 0 */ ! 1951: switch(curi->cc) { ! 1952: case 0: /* Unconditional set */ ! 1953: comprintf("\tmov_l_ri(val,0);\n"); ! 1954: break; ! 1955: case 1: ! 1956: /* Unconditional not-set */ ! 1957: comprintf("\tmov_l_ri(val,1);\n"); ! 1958: break; ! 1959: case 8: failure; break; /* Work out details! FIXME */ ! 1960: case 9: failure; break; /* Not critical, though! */ ! 1961: ! 1962: case 2: ! 1963: case 3: ! 1964: case 4: ! 1965: case 5: ! 1966: case 6: ! 1967: case 7: ! 1968: case 10: ! 1969: case 11: ! 1970: case 12: ! 1971: case 13: ! 1972: case 14: ! 1973: case 15: ! 1974: comprintf("\tmake_flags_live();\n"); /* Load the flags */ ! 1975: /* All condition codes can be inverted by changing the LSB */ ! 1976: comprintf("\tsetcc(val,%d);\n", ! 1977: cond_codes_x86[curi->cc]^1); break; ! 1978: default: abort(); ! 1979: } ! 1980: comprintf("\tsub_b_ri(val,1);\n"); ! 1981: genastore ("val", curi->smode, "srcreg", curi->size, "src"); ! 1982: break; ! 1983: case i_DIVU: ! 1984: isjump; ! 1985: failure; ! 1986: break; ! 1987: case i_DIVS: ! 1988: isjump; ! 1989: failure; ! 1990: break; ! 1991: case i_MULU: ! 1992: comprintf("\tdont_care_flags();\n"); ! 1993: genamode (curi->smode, "srcreg", sz_word, "src", 1, 0); ! 1994: genamode (curi->dmode, "dstreg", sz_word, "dst", 1, 0); ! 1995: /* To do 16x16 unsigned multiplication, we actually use ! 1996: 32x32 signed, and zero-extend the registers first. ! 1997: That solves the problem of MUL needing dedicated registers ! 1998: on the x86 */ ! 1999: comprintf("\tzero_extend_16_rr(scratchie,src);\n" ! 2000: "\tzero_extend_16_rr(dst,dst);\n" ! 2001: "\timul_32_32(dst,scratchie);\n"); ! 2002: genflags (flag_logical, sz_long, "dst", "", ""); ! 2003: genastore ("dst", curi->dmode, "dstreg", sz_long, "dst"); ! 2004: break; ! 2005: case i_MULS: ! 2006: comprintf("\tdont_care_flags();\n"); ! 2007: genamode (curi->smode, "srcreg", sz_word, "src", 1, 0); ! 2008: genamode (curi->dmode, "dstreg", sz_word, "dst", 1, 0); ! 2009: comprintf("\tsign_extend_16_rr(scratchie,src);\n" ! 2010: "\tsign_extend_16_rr(dst,dst);\n" ! 2011: "\timul_32_32(dst,scratchie);\n"); ! 2012: genflags (flag_logical, sz_long, "dst", "", ""); ! 2013: genastore ("dst", curi->dmode, "dstreg", sz_long, "dst"); ! 2014: break; ! 2015: case i_CHK: ! 2016: isjump; ! 2017: failure; ! 2018: break; ! 2019: ! 2020: case i_CHK2: ! 2021: isjump; ! 2022: failure; ! 2023: break; ! 2024: ! 2025: case i_ASR: ! 2026: mayfail; ! 2027: if (curi->smode==Dreg) { ! 2028: comprintf("if ((uae_u32)srcreg==(uae_u32)dstreg) {\n" ! 2029: " FAIL(1);\n" ! 2030: " return 0;\n" ! 2031: "} \n"); ! 2032: start_brace(); ! 2033: } ! 2034: comprintf("\tdont_care_flags();\n"); ! 2035: ! 2036: genamode (curi->smode, "srcreg", curi->size, "cnt", 1, 0); ! 2037: genamode (curi->dmode, "dstreg", curi->size, "data", 1, 0); ! 2038: if (curi->smode!=immi) { ! 2039: if (!noflags) { ! 2040: uses_cmov; ! 2041: start_brace(); ! 2042: comprintf("\tint highmask;\n" ! 2043: "\tint width;\n" ! 2044: "\tint cdata=scratchie++;\n" ! 2045: "\tint tmpcnt=scratchie++;\n" ! 2046: "\tint highshift=scratchie++;\n"); ! 2047: comprintf("\tmov_l_rr(tmpcnt,cnt);\n" ! 2048: "\tand_l_ri(tmpcnt,63);\n" ! 2049: "\tmov_l_ri(cdata,0);\n" ! 2050: "\tcmov_l_rr(cdata,data,5);\n"); ! 2051: /* cdata is now either data (for shift count!=0) or ! 2052: 0 (for shift count==0) */ ! 2053: switch(curi->size) { ! 2054: case sz_byte: comprintf("\tshra_b_rr(data,cnt);\n" ! 2055: "\thighmask=0x38;\n" ! 2056: "\twidth=8;\n"); ! 2057: break; ! 2058: case sz_word: comprintf("\tshra_w_rr(data,cnt);\n" ! 2059: "\thighmask=0x30;\n" ! 2060: "\twidth=16;\n"); ! 2061: break; ! 2062: case sz_long: comprintf("\tshra_l_rr(data,cnt);\n" ! 2063: "\thighmask=0x20;\n" ! 2064: "\twidth=32;\n"); ! 2065: break; ! 2066: default: abort(); ! 2067: } ! 2068: comprintf("test_l_ri(cnt,highmask);\n" ! 2069: "mov_l_ri(highshift,0);\n" ! 2070: "mov_l_ri(scratchie,width/2);\n" ! 2071: "cmov_l_rr(highshift,scratchie,5);\n"); ! 2072: /* The x86 masks out bits, so we now make sure that things ! 2073: really get shifted as much as planned */ ! 2074: switch(curi->size) { ! 2075: case sz_byte: comprintf("\tshra_b_rr(data,highshift);\n");break; ! 2076: case sz_word: comprintf("\tshra_w_rr(data,highshift);\n");break; ! 2077: case sz_long: comprintf("\tshra_l_rr(data,highshift);\n");break; ! 2078: default: abort(); ! 2079: } ! 2080: /* And again */ ! 2081: switch(curi->size) { ! 2082: case sz_byte: comprintf("\tshra_b_rr(data,highshift);\n");break; ! 2083: case sz_word: comprintf("\tshra_w_rr(data,highshift);\n");break; ! 2084: case sz_long: comprintf("\tshra_l_rr(data,highshift);\n");break; ! 2085: default: abort(); ! 2086: } ! 2087: ! 2088: /* Result of shift is now in data. Now we need to determine ! 2089: the carry by shifting cdata one less */ ! 2090: comprintf("\tsub_l_ri(tmpcnt,1);\n"); ! 2091: switch(curi->size) { ! 2092: case sz_byte: comprintf("\tshra_b_rr(cdata,tmpcnt);\n");break; ! 2093: case sz_word: comprintf("\tshra_w_rr(cdata,tmpcnt);\n");break; ! 2094: case sz_long: comprintf("\tshra_l_rr(cdata,tmpcnt);\n");break; ! 2095: default: abort(); ! 2096: } ! 2097: /* If the shift count was higher than the width, we need ! 2098: to pick up the sign from data */ ! 2099: comprintf("test_l_ri(tmpcnt,highmask);\n" ! 2100: "cmov_l_rr(cdata,data,5);\n"); ! 2101: /* And create the flags */ ! 2102: comprintf("\tstart_needflags();\n"); ! 2103: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2104: switch(curi->size) { ! 2105: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); break; ! 2106: case sz_word: comprintf("\t test_w_rr(data,data);\n"); break; ! 2107: case sz_long: comprintf("\t test_l_rr(data,data);\n"); break; ! 2108: } ! 2109: comprintf("\t bt_l_ri(cdata,0);\n"); /* Set C */ ! 2110: comprintf("\t live_flags();\n"); ! 2111: comprintf("\t end_needflags();\n"); ! 2112: comprintf("\t duplicate_carry();\n"); ! 2113: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 2114: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2115: } ! 2116: else { ! 2117: uses_cmov; ! 2118: start_brace(); ! 2119: comprintf("\tint highmask;\n" ! 2120: "\tint width;\n" ! 2121: "\tint highshift=scratchie++;\n"); ! 2122: switch(curi->size) { ! 2123: case sz_byte: comprintf("\tshra_b_rr(data,cnt);\n" ! 2124: "\thighmask=0x38;\n" ! 2125: "\twidth=8;\n"); ! 2126: break; ! 2127: case sz_word: comprintf("\tshra_w_rr(data,cnt);\n" ! 2128: "\thighmask=0x30;\n" ! 2129: "\twidth=16;\n"); ! 2130: break; ! 2131: case sz_long: comprintf("\tshra_l_rr(data,cnt);\n" ! 2132: "\thighmask=0x20;\n" ! 2133: "\twidth=32;\n"); ! 2134: break; ! 2135: default: abort(); ! 2136: } ! 2137: comprintf("test_l_ri(cnt,highmask);\n" ! 2138: "mov_l_ri(highshift,0);\n" ! 2139: "mov_l_ri(scratchie,width/2);\n" ! 2140: "cmov_l_rr(highshift,scratchie,5);\n"); ! 2141: /* The x86 masks out bits, so we now make sure that things ! 2142: really get shifted as much as planned */ ! 2143: switch(curi->size) { ! 2144: case sz_byte: comprintf("\tshra_b_rr(data,highshift);\n");break; ! 2145: case sz_word: comprintf("\tshra_w_rr(data,highshift);\n");break; ! 2146: case sz_long: comprintf("\tshra_l_rr(data,highshift);\n");break; ! 2147: default: abort(); ! 2148: } ! 2149: /* And again */ ! 2150: switch(curi->size) { ! 2151: case sz_byte: comprintf("\tshra_b_rr(data,highshift);\n");break; ! 2152: case sz_word: comprintf("\tshra_w_rr(data,highshift);\n");break; ! 2153: case sz_long: comprintf("\tshra_l_rr(data,highshift);\n");break; ! 2154: default: abort(); ! 2155: } ! 2156: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2157: } ! 2158: } ! 2159: else { ! 2160: start_brace(); ! 2161: comprintf("\tint tmp=scratchie++;\n" ! 2162: "\tint bp;\n" ! 2163: "\tmov_l_rr(tmp,data);\n"); ! 2164: switch(curi->size) { ! 2165: case sz_byte: comprintf("\tshra_b_ri(data,srcreg);\n" ! 2166: "\tbp=srcreg-1;\n"); break; ! 2167: case sz_word: comprintf("\tshra_w_ri(data,srcreg);\n" ! 2168: "\tbp=srcreg-1;\n"); break; ! 2169: case sz_long: comprintf("\tshra_l_ri(data,srcreg);\n" ! 2170: "\tbp=srcreg-1;\n"); break; ! 2171: default: abort(); ! 2172: } ! 2173: ! 2174: if (!noflags) { ! 2175: comprintf("\tstart_needflags();\n"); ! 2176: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2177: switch(curi->size) { ! 2178: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); break; ! 2179: case sz_word: comprintf("\t test_w_rr(data,data);\n"); break; ! 2180: case sz_long: comprintf("\t test_l_rr(data,data);\n"); break; ! 2181: } ! 2182: comprintf("\t bt_l_ri(tmp,bp);\n"); /* Set C */ ! 2183: comprintf("\t live_flags();\n"); ! 2184: comprintf("\t end_needflags();\n"); ! 2185: comprintf("\t duplicate_carry();\n"); ! 2186: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 2187: } ! 2188: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2189: } ! 2190: break; ! 2191: ! 2192: case i_ASL: ! 2193: mayfail; ! 2194: if (curi->smode==Dreg) { ! 2195: comprintf("if ((uae_u32)srcreg==(uae_u32)dstreg) {\n" ! 2196: " FAIL(1);\n" ! 2197: " return 0;\n" ! 2198: "} \n"); ! 2199: start_brace(); ! 2200: } ! 2201: comprintf("\tdont_care_flags();\n"); ! 2202: /* Except for the handling of the V flag, this is identical to ! 2203: LSL. The handling of V is, uhm, unpleasant, so if it's needed, ! 2204: let the normal emulation handle it. Shoulders of giants kinda ! 2205: thing ;-) */ ! 2206: comprintf("if (needed_flags & FLAG_V) {\n" ! 2207: " FAIL(1);\n" ! 2208: " return 0;\n" ! 2209: "} \n"); ! 2210: ! 2211: genamode (curi->smode, "srcreg", curi->size, "cnt", 1, 0); ! 2212: genamode (curi->dmode, "dstreg", curi->size, "data", 1, 0); ! 2213: if (curi->smode!=immi) { ! 2214: if (!noflags) { ! 2215: uses_cmov; ! 2216: start_brace(); ! 2217: comprintf("\tint highmask;\n" ! 2218: "\tint cdata=scratchie++;\n" ! 2219: "\tint tmpcnt=scratchie++;\n"); ! 2220: comprintf("\tmov_l_rr(tmpcnt,cnt);\n" ! 2221: "\tand_l_ri(tmpcnt,63);\n" ! 2222: "\tmov_l_ri(cdata,0);\n" ! 2223: "\tcmov_l_rr(cdata,data,5);\n"); ! 2224: /* cdata is now either data (for shift count!=0) or ! 2225: 0 (for shift count==0) */ ! 2226: switch(curi->size) { ! 2227: case sz_byte: comprintf("\tshll_b_rr(data,cnt);\n" ! 2228: "\thighmask=0x38;\n"); ! 2229: break; ! 2230: case sz_word: comprintf("\tshll_w_rr(data,cnt);\n" ! 2231: "\thighmask=0x30;\n"); ! 2232: break; ! 2233: case sz_long: comprintf("\tshll_l_rr(data,cnt);\n" ! 2234: "\thighmask=0x20;\n"); ! 2235: break; ! 2236: default: abort(); ! 2237: } ! 2238: comprintf("test_l_ri(cnt,highmask);\n" ! 2239: "mov_l_ri(scratchie,0);\n" ! 2240: "cmov_l_rr(scratchie,data,4);\n"); ! 2241: switch(curi->size) { ! 2242: case sz_byte: comprintf("\tmov_b_rr(data,scratchie);\n");break; ! 2243: case sz_word: comprintf("\tmov_w_rr(data,scratchie);\n");break; ! 2244: case sz_long: comprintf("\tmov_l_rr(data,scratchie);\n");break; ! 2245: default: abort(); ! 2246: } ! 2247: /* Result of shift is now in data. Now we need to determine ! 2248: the carry by shifting cdata one less */ ! 2249: comprintf("\tsub_l_ri(tmpcnt,1);\n"); ! 2250: switch(curi->size) { ! 2251: case sz_byte: comprintf("\tshll_b_rr(cdata,tmpcnt);\n");break; ! 2252: case sz_word: comprintf("\tshll_w_rr(cdata,tmpcnt);\n");break; ! 2253: case sz_long: comprintf("\tshll_l_rr(cdata,tmpcnt);\n");break; ! 2254: default: abort(); ! 2255: } ! 2256: comprintf("test_l_ri(tmpcnt,highmask);\n" ! 2257: "mov_l_ri(scratchie,0);\n" ! 2258: "cmov_l_rr(cdata,scratchie,5);\n"); ! 2259: /* And create the flags */ ! 2260: comprintf("\tstart_needflags();\n"); ! 2261: ! 2262: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2263: switch(curi->size) { ! 2264: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); ! 2265: comprintf("\t bt_l_ri(cdata,7);\n"); break; ! 2266: case sz_word: comprintf("\t test_w_rr(data,data);\n"); ! 2267: comprintf("\t bt_l_ri(cdata,15);\n"); break; ! 2268: case sz_long: comprintf("\t test_l_rr(data,data);\n"); ! 2269: comprintf("\t bt_l_ri(cdata,31);\n"); break; ! 2270: } ! 2271: comprintf("\t live_flags();\n"); ! 2272: comprintf("\t end_needflags();\n"); ! 2273: comprintf("\t duplicate_carry();\n"); ! 2274: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 2275: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2276: } ! 2277: else { ! 2278: uses_cmov; ! 2279: start_brace(); ! 2280: comprintf("\tint highmask;\n"); ! 2281: switch(curi->size) { ! 2282: case sz_byte: comprintf("\tshll_b_rr(data,cnt);\n" ! 2283: "\thighmask=0x38;\n"); ! 2284: break; ! 2285: case sz_word: comprintf("\tshll_w_rr(data,cnt);\n" ! 2286: "\thighmask=0x30;\n"); ! 2287: break; ! 2288: case sz_long: comprintf("\tshll_l_rr(data,cnt);\n" ! 2289: "\thighmask=0x20;\n"); ! 2290: break; ! 2291: default: abort(); ! 2292: } ! 2293: comprintf("test_l_ri(cnt,highmask);\n" ! 2294: "mov_l_ri(scratchie,0);\n" ! 2295: "cmov_l_rr(scratchie,data,4);\n"); ! 2296: switch(curi->size) { ! 2297: case sz_byte: comprintf("\tmov_b_rr(data,scratchie);\n");break; ! 2298: case sz_word: comprintf("\tmov_w_rr(data,scratchie);\n");break; ! 2299: case sz_long: comprintf("\tmov_l_rr(data,scratchie);\n");break; ! 2300: default: abort(); ! 2301: } ! 2302: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2303: } ! 2304: } ! 2305: else { ! 2306: start_brace(); ! 2307: comprintf("\tint tmp=scratchie++;\n" ! 2308: "\tint bp;\n" ! 2309: "\tmov_l_rr(tmp,data);\n"); ! 2310: switch(curi->size) { ! 2311: case sz_byte: comprintf("\tshll_b_ri(data,srcreg);\n" ! 2312: "\tbp=8-srcreg;\n"); break; ! 2313: case sz_word: comprintf("\tshll_w_ri(data,srcreg);\n" ! 2314: "\tbp=16-srcreg;\n"); break; ! 2315: case sz_long: comprintf("\tshll_l_ri(data,srcreg);\n" ! 2316: "\tbp=32-srcreg;\n"); break; ! 2317: default: abort(); ! 2318: } ! 2319: ! 2320: if (!noflags) { ! 2321: comprintf("\tstart_needflags();\n"); ! 2322: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2323: switch(curi->size) { ! 2324: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); break; ! 2325: case sz_word: comprintf("\t test_w_rr(data,data);\n"); break; ! 2326: case sz_long: comprintf("\t test_l_rr(data,data);\n"); break; ! 2327: } ! 2328: comprintf("\t bt_l_ri(tmp,bp);\n"); /* Set C */ ! 2329: comprintf("\t live_flags();\n"); ! 2330: comprintf("\t end_needflags();\n"); ! 2331: comprintf("\t duplicate_carry();\n"); ! 2332: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 2333: } ! 2334: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2335: } ! 2336: break; ! 2337: ! 2338: case i_LSR: ! 2339: mayfail; ! 2340: if (curi->smode==Dreg) { ! 2341: comprintf("if ((uae_u32)srcreg==(uae_u32)dstreg) {\n" ! 2342: " FAIL(1);\n" ! 2343: " return 0;\n" ! 2344: "} \n"); ! 2345: start_brace(); ! 2346: } ! 2347: comprintf("\tdont_care_flags();\n"); ! 2348: ! 2349: genamode (curi->smode, "srcreg", curi->size, "cnt", 1, 0); ! 2350: genamode (curi->dmode, "dstreg", curi->size, "data", 1, 0); ! 2351: if (curi->smode!=immi) { ! 2352: if (!noflags) { ! 2353: uses_cmov; ! 2354: start_brace(); ! 2355: comprintf("\tint highmask;\n" ! 2356: "\tint cdata=scratchie++;\n" ! 2357: "\tint tmpcnt=scratchie++;\n"); ! 2358: comprintf("\tmov_l_rr(tmpcnt,cnt);\n" ! 2359: "\tand_l_ri(tmpcnt,63);\n" ! 2360: "\tmov_l_ri(cdata,0);\n" ! 2361: "\tcmov_l_rr(cdata,data,5);\n"); ! 2362: /* cdata is now either data (for shift count!=0) or ! 2363: 0 (for shift count==0) */ ! 2364: switch(curi->size) { ! 2365: case sz_byte: comprintf("\tshrl_b_rr(data,cnt);\n" ! 2366: "\thighmask=0x38;\n"); ! 2367: break; ! 2368: case sz_word: comprintf("\tshrl_w_rr(data,cnt);\n" ! 2369: "\thighmask=0x30;\n"); ! 2370: break; ! 2371: case sz_long: comprintf("\tshrl_l_rr(data,cnt);\n" ! 2372: "\thighmask=0x20;\n"); ! 2373: break; ! 2374: default: abort(); ! 2375: } ! 2376: comprintf("test_l_ri(cnt,highmask);\n" ! 2377: "mov_l_ri(scratchie,0);\n" ! 2378: "cmov_l_rr(scratchie,data,4);\n"); ! 2379: switch(curi->size) { ! 2380: case sz_byte: comprintf("\tmov_b_rr(data,scratchie);\n");break; ! 2381: case sz_word: comprintf("\tmov_w_rr(data,scratchie);\n");break; ! 2382: case sz_long: comprintf("\tmov_l_rr(data,scratchie);\n");break; ! 2383: default: abort(); ! 2384: } ! 2385: /* Result of shift is now in data. Now we need to determine ! 2386: the carry by shifting cdata one less */ ! 2387: comprintf("\tsub_l_ri(tmpcnt,1);\n"); ! 2388: switch(curi->size) { ! 2389: case sz_byte: comprintf("\tshrl_b_rr(cdata,tmpcnt);\n");break; ! 2390: case sz_word: comprintf("\tshrl_w_rr(cdata,tmpcnt);\n");break; ! 2391: case sz_long: comprintf("\tshrl_l_rr(cdata,tmpcnt);\n");break; ! 2392: default: abort(); ! 2393: } ! 2394: comprintf("test_l_ri(tmpcnt,highmask);\n" ! 2395: "mov_l_ri(scratchie,0);\n" ! 2396: "cmov_l_rr(cdata,scratchie,5);\n"); ! 2397: /* And create the flags */ ! 2398: comprintf("\tstart_needflags();\n"); ! 2399: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2400: switch(curi->size) { ! 2401: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); break; ! 2402: case sz_word: comprintf("\t test_w_rr(data,data);\n"); break; ! 2403: case sz_long: comprintf("\t test_l_rr(data,data);\n"); break; ! 2404: } ! 2405: comprintf("\t bt_l_ri(cdata,0);\n"); /* Set C */ ! 2406: comprintf("\t live_flags();\n"); ! 2407: comprintf("\t end_needflags();\n"); ! 2408: comprintf("\t duplicate_carry();\n"); ! 2409: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 2410: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2411: } ! 2412: else { ! 2413: uses_cmov; ! 2414: start_brace(); ! 2415: comprintf("\tint highmask;\n"); ! 2416: switch(curi->size) { ! 2417: case sz_byte: comprintf("\tshrl_b_rr(data,cnt);\n" ! 2418: "\thighmask=0x38;\n"); ! 2419: break; ! 2420: case sz_word: comprintf("\tshrl_w_rr(data,cnt);\n" ! 2421: "\thighmask=0x30;\n"); ! 2422: break; ! 2423: case sz_long: comprintf("\tshrl_l_rr(data,cnt);\n" ! 2424: "\thighmask=0x20;\n"); ! 2425: break; ! 2426: default: abort(); ! 2427: } ! 2428: comprintf("test_l_ri(cnt,highmask);\n" ! 2429: "mov_l_ri(scratchie,0);\n" ! 2430: "cmov_l_rr(scratchie,data,4);\n"); ! 2431: switch(curi->size) { ! 2432: case sz_byte: comprintf("\tmov_b_rr(data,scratchie);\n");break; ! 2433: case sz_word: comprintf("\tmov_w_rr(data,scratchie);\n");break; ! 2434: case sz_long: comprintf("\tmov_l_rr(data,scratchie);\n");break; ! 2435: default: abort(); ! 2436: } ! 2437: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2438: } ! 2439: } ! 2440: else { ! 2441: start_brace(); ! 2442: comprintf("\tint tmp=scratchie++;\n" ! 2443: "\tint bp;\n" ! 2444: "\tmov_l_rr(tmp,data);\n"); ! 2445: switch(curi->size) { ! 2446: case sz_byte: comprintf("\tshrl_b_ri(data,srcreg);\n" ! 2447: "\tbp=srcreg-1;\n"); break; ! 2448: case sz_word: comprintf("\tshrl_w_ri(data,srcreg);\n" ! 2449: "\tbp=srcreg-1;\n"); break; ! 2450: case sz_long: comprintf("\tshrl_l_ri(data,srcreg);\n" ! 2451: "\tbp=srcreg-1;\n"); break; ! 2452: default: abort(); ! 2453: } ! 2454: ! 2455: if (!noflags) { ! 2456: comprintf("\tstart_needflags();\n"); ! 2457: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2458: switch(curi->size) { ! 2459: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); break; ! 2460: case sz_word: comprintf("\t test_w_rr(data,data);\n"); break; ! 2461: case sz_long: comprintf("\t test_l_rr(data,data);\n"); break; ! 2462: } ! 2463: comprintf("\t bt_l_ri(tmp,bp);\n"); /* Set C */ ! 2464: comprintf("\t live_flags();\n"); ! 2465: comprintf("\t end_needflags();\n"); ! 2466: comprintf("\t duplicate_carry();\n"); ! 2467: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 2468: } ! 2469: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2470: } ! 2471: break; ! 2472: ! 2473: case i_LSL: ! 2474: comprintf("\tdont_care_flags();\n"); ! 2475: ! 2476: genamode (curi->smode, "srcreg", curi->size, "cnt", 1, 0); ! 2477: genamode (curi->dmode, "dstreg", curi->size, "data", 1, 0); ! 2478: if (curi->smode!=immi) { ! 2479: if (!noflags) { ! 2480: uses_cmov; ! 2481: start_brace(); ! 2482: comprintf("\tint highmask;\n" ! 2483: "\tint cdata=scratchie++;\n" ! 2484: "\tint tmpcnt=scratchie++;\n"); ! 2485: comprintf("\tmov_l_rr(tmpcnt,cnt);\n" ! 2486: "\tand_l_ri(tmpcnt,63);\n" ! 2487: "\tmov_l_ri(cdata,0);\n" ! 2488: "\tcmov_l_rr(cdata,data,5);\n"); ! 2489: /* cdata is now either data (for shift count!=0) or ! 2490: 0 (for shift count==0) */ ! 2491: switch(curi->size) { ! 2492: case sz_byte: comprintf("\tshll_b_rr(data,cnt);\n" ! 2493: "\thighmask=0x38;\n"); ! 2494: break; ! 2495: case sz_word: comprintf("\tshll_w_rr(data,cnt);\n" ! 2496: "\thighmask=0x30;\n"); ! 2497: break; ! 2498: case sz_long: comprintf("\tshll_l_rr(data,cnt);\n" ! 2499: "\thighmask=0x20;\n"); ! 2500: break; ! 2501: default: abort(); ! 2502: } ! 2503: comprintf("test_l_ri(cnt,highmask);\n" ! 2504: "mov_l_ri(scratchie,0);\n" ! 2505: "cmov_l_rr(scratchie,data,4);\n"); ! 2506: switch(curi->size) { ! 2507: case sz_byte: comprintf("\tmov_b_rr(data,scratchie);\n");break; ! 2508: case sz_word: comprintf("\tmov_w_rr(data,scratchie);\n");break; ! 2509: case sz_long: comprintf("\tmov_l_rr(data,scratchie);\n");break; ! 2510: default: abort(); ! 2511: } ! 2512: /* Result of shift is now in data. Now we need to determine ! 2513: the carry by shifting cdata one less */ ! 2514: comprintf("\tsub_l_ri(tmpcnt,1);\n"); ! 2515: switch(curi->size) { ! 2516: case sz_byte: comprintf("\tshll_b_rr(cdata,tmpcnt);\n");break; ! 2517: case sz_word: comprintf("\tshll_w_rr(cdata,tmpcnt);\n");break; ! 2518: case sz_long: comprintf("\tshll_l_rr(cdata,tmpcnt);\n");break; ! 2519: default: abort(); ! 2520: } ! 2521: comprintf("test_l_ri(tmpcnt,highmask);\n" ! 2522: "mov_l_ri(scratchie,0);\n" ! 2523: "cmov_l_rr(cdata,scratchie,5);\n"); ! 2524: /* And create the flags */ ! 2525: comprintf("\tstart_needflags();\n"); ! 2526: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2527: switch(curi->size) { ! 2528: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); ! 2529: comprintf("\t bt_l_ri(cdata,7);\n"); break; ! 2530: case sz_word: comprintf("\t test_w_rr(data,data);\n"); ! 2531: comprintf("\t bt_l_ri(cdata,15);\n"); break; ! 2532: case sz_long: comprintf("\t test_l_rr(data,data);\n"); ! 2533: comprintf("\t bt_l_ri(cdata,31);\n"); break; ! 2534: } ! 2535: comprintf("\t live_flags();\n"); ! 2536: comprintf("\t end_needflags();\n"); ! 2537: comprintf("\t duplicate_carry();\n"); ! 2538: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 2539: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2540: } ! 2541: else { ! 2542: uses_cmov; ! 2543: start_brace(); ! 2544: comprintf("\tint highmask;\n"); ! 2545: switch(curi->size) { ! 2546: case sz_byte: comprintf("\tshll_b_rr(data,cnt);\n" ! 2547: "\thighmask=0x38;\n"); ! 2548: break; ! 2549: case sz_word: comprintf("\tshll_w_rr(data,cnt);\n" ! 2550: "\thighmask=0x30;\n"); ! 2551: break; ! 2552: case sz_long: comprintf("\tshll_l_rr(data,cnt);\n" ! 2553: "\thighmask=0x20;\n"); ! 2554: break; ! 2555: default: abort(); ! 2556: } ! 2557: comprintf("test_l_ri(cnt,highmask);\n" ! 2558: "mov_l_ri(scratchie,0);\n" ! 2559: "cmov_l_rr(scratchie,data,4);\n"); ! 2560: switch(curi->size) { ! 2561: case sz_byte: comprintf("\tmov_b_rr(data,scratchie);\n");break; ! 2562: case sz_word: comprintf("\tmov_w_rr(data,scratchie);\n");break; ! 2563: case sz_long: comprintf("\tmov_l_rr(data,scratchie);\n");break; ! 2564: default: abort(); ! 2565: } ! 2566: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2567: } ! 2568: } ! 2569: else { ! 2570: start_brace(); ! 2571: comprintf("\tint tmp=scratchie++;\n" ! 2572: "\tint bp;\n" ! 2573: "\tmov_l_rr(tmp,data);\n"); ! 2574: switch(curi->size) { ! 2575: case sz_byte: comprintf("\tshll_b_ri(data,srcreg);\n" ! 2576: "\tbp=8-srcreg;\n"); break; ! 2577: case sz_word: comprintf("\tshll_w_ri(data,srcreg);\n" ! 2578: "\tbp=16-srcreg;\n"); break; ! 2579: case sz_long: comprintf("\tshll_l_ri(data,srcreg);\n" ! 2580: "\tbp=32-srcreg;\n"); break; ! 2581: default: abort(); ! 2582: } ! 2583: ! 2584: if (!noflags) { ! 2585: comprintf("\tstart_needflags();\n"); ! 2586: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2587: switch(curi->size) { ! 2588: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); break; ! 2589: case sz_word: comprintf("\t test_w_rr(data,data);\n"); break; ! 2590: case sz_long: comprintf("\t test_l_rr(data,data);\n"); break; ! 2591: } ! 2592: comprintf("\t bt_l_ri(tmp,bp);\n"); /* Set C */ ! 2593: comprintf("\t live_flags();\n"); ! 2594: comprintf("\t end_needflags();\n"); ! 2595: comprintf("\t duplicate_carry();\n"); ! 2596: comprintf("if (!(needed_flags & FLAG_CZNV)) dont_care_flags();\n"); ! 2597: } ! 2598: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2599: } ! 2600: break; ! 2601: ! 2602: case i_ROL: ! 2603: mayfail; ! 2604: if (curi->smode==Dreg) { ! 2605: comprintf("if ((uae_u32)srcreg==(uae_u32)dstreg) {\n" ! 2606: " FAIL(1);\n" ! 2607: " return 0;\n" ! 2608: "} \n"); ! 2609: start_brace(); ! 2610: } ! 2611: comprintf("\tdont_care_flags();\n"); ! 2612: genamode (curi->smode, "srcreg", curi->size, "cnt", 1, 0); ! 2613: genamode (curi->dmode, "dstreg", curi->size, "data", 1, 0); ! 2614: start_brace (); ! 2615: ! 2616: switch(curi->size) { ! 2617: case sz_long: comprintf("\t rol_l_rr(data,cnt);\n"); break; ! 2618: case sz_word: comprintf("\t rol_w_rr(data,cnt);\n"); break; ! 2619: case sz_byte: comprintf("\t rol_b_rr(data,cnt);\n"); break; ! 2620: } ! 2621: ! 2622: if (!noflags) { ! 2623: comprintf("\tstart_needflags();\n"); ! 2624: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2625: switch(curi->size) { ! 2626: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); break; ! 2627: case sz_word: comprintf("\t test_w_rr(data,data);\n"); break; ! 2628: case sz_long: comprintf("\t test_l_rr(data,data);\n"); break; ! 2629: } ! 2630: comprintf("\t bt_l_ri(data,0x00);\n"); /* Set C */ ! 2631: comprintf("\t live_flags();\n"); ! 2632: comprintf("\t end_needflags();\n"); ! 2633: } ! 2634: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2635: break; ! 2636: ! 2637: case i_ROR: ! 2638: mayfail; ! 2639: if (curi->smode==Dreg) { ! 2640: comprintf("if ((uae_u32)srcreg==(uae_u32)dstreg) {\n" ! 2641: " FAIL(1);\n" ! 2642: " return 0;\n" ! 2643: "} \n"); ! 2644: start_brace(); ! 2645: } ! 2646: comprintf("\tdont_care_flags();\n"); ! 2647: genamode (curi->smode, "srcreg", curi->size, "cnt", 1, 0); ! 2648: genamode (curi->dmode, "dstreg", curi->size, "data", 1, 0); ! 2649: start_brace (); ! 2650: ! 2651: switch(curi->size) { ! 2652: case sz_long: comprintf("\t ror_l_rr(data,cnt);\n"); break; ! 2653: case sz_word: comprintf("\t ror_w_rr(data,cnt);\n"); break; ! 2654: case sz_byte: comprintf("\t ror_b_rr(data,cnt);\n"); break; ! 2655: } ! 2656: ! 2657: if (!noflags) { ! 2658: comprintf("\tstart_needflags();\n"); ! 2659: comprintf("\tif (needed_flags & FLAG_ZNV)\n"); ! 2660: switch(curi->size) { ! 2661: case sz_byte: comprintf("\t test_b_rr(data,data);\n"); break; ! 2662: case sz_word: comprintf("\t test_w_rr(data,data);\n"); break; ! 2663: case sz_long: comprintf("\t test_l_rr(data,data);\n"); break; ! 2664: } ! 2665: switch(curi->size) { ! 2666: case sz_byte: comprintf("\t bt_l_ri(data,0x07);\n"); break; ! 2667: case sz_word: comprintf("\t bt_l_ri(data,0x0f);\n"); break; ! 2668: case sz_long: comprintf("\t bt_l_ri(data,0x1f);\n"); break; ! 2669: } ! 2670: comprintf("\t live_flags();\n"); ! 2671: comprintf("\t end_needflags();\n"); ! 2672: } ! 2673: genastore ("data", curi->dmode, "dstreg", curi->size, "data"); ! 2674: break; ! 2675: ! 2676: case i_ROXL: ! 2677: failure; ! 2678: break; ! 2679: case i_ROXR: ! 2680: failure; ! 2681: break; ! 2682: case i_ASRW: ! 2683: failure; ! 2684: break; ! 2685: case i_ASLW: ! 2686: failure; ! 2687: break; ! 2688: case i_LSRW: ! 2689: failure; ! 2690: break; ! 2691: case i_LSLW: ! 2692: failure; ! 2693: break; ! 2694: case i_ROLW: ! 2695: failure; ! 2696: break; ! 2697: case i_RORW: ! 2698: failure; ! 2699: break; ! 2700: case i_ROXLW: ! 2701: failure; ! 2702: break; ! 2703: case i_ROXRW: ! 2704: failure; ! 2705: break; ! 2706: case i_MOVEC2: ! 2707: isjump; ! 2708: failure; ! 2709: break; ! 2710: case i_MOVE2C: ! 2711: isjump; ! 2712: failure; ! 2713: break; ! 2714: case i_CAS: ! 2715: failure; ! 2716: break; ! 2717: case i_CAS2: ! 2718: failure; ! 2719: break; ! 2720: case i_MOVES: /* ignore DFC and SFC because we have no MMU */ ! 2721: isjump; ! 2722: failure; ! 2723: break; ! 2724: case i_BKPT: /* only needed for hardware emulators */ ! 2725: isjump; ! 2726: failure; ! 2727: break; ! 2728: case i_CALLM: /* not present in 68030 */ ! 2729: isjump; ! 2730: failure; ! 2731: break; ! 2732: case i_RTM: /* not present in 68030 */ ! 2733: isjump; ! 2734: failure; ! 2735: break; ! 2736: case i_TRAPcc: ! 2737: isjump; ! 2738: failure; ! 2739: break; ! 2740: case i_DIVL: ! 2741: isjump; ! 2742: failure; ! 2743: break; ! 2744: case i_MULL: ! 2745: if (!noflags) { ! 2746: failure; ! 2747: break; ! 2748: } ! 2749: comprintf("\tuae_u16 extra=%s;\n",gen_nextiword()); ! 2750: comprintf("\tint r2=(extra>>12)&7;\n" ! 2751: "\tint tmp=scratchie++;\n"); ! 2752: ! 2753: genamode (curi->dmode, "dstreg", curi->size, "dst", 1, 0); ! 2754: /* The two operands are in dst and r2 */ ! 2755: comprintf("\tif (extra&0x0400) {\n" /* Need full 64 bit result */ ! 2756: "\tint r3=(extra&7);\n" ! 2757: "\tmov_l_rr(r3,dst);\n"); /* operands now in r3 and r2 */ ! 2758: comprintf("\tif (extra&0x0800) { \n" /* signed */ ! 2759: "\t\timul_64_32(r2,r3);\n" ! 2760: "\t} else { \n" ! 2761: "\t\tmul_64_32(r2,r3);\n" ! 2762: "\t} \n"); ! 2763: /* The result is in r2/tmp, with r2 holding the lower 32 bits */ ! 2764: comprintf("\t} else {\n"); /* Only want 32 bit result */ ! 2765: /* operands in dst and r2, result foes into r2 */ ! 2766: /* shouldn't matter whether it's signed or unsigned?!? */ ! 2767: comprintf("\timul_32_32(r2,dst);\n" ! 2768: "\t}\n"); ! 2769: break; ! 2770: ! 2771: case i_BFTST: ! 2772: case i_BFEXTU: ! 2773: case i_BFCHG: ! 2774: case i_BFEXTS: ! 2775: case i_BFCLR: ! 2776: case i_BFFFO: ! 2777: case i_BFSET: ! 2778: case i_BFINS: ! 2779: failure; ! 2780: break; ! 2781: case i_PACK: ! 2782: failure; ! 2783: break; ! 2784: case i_UNPK: ! 2785: failure; ! 2786: break; ! 2787: case i_TAS: ! 2788: failure; ! 2789: break; ! 2790: case i_FPP: ! 2791: mayfail; ! 2792: comprintf("\tuae_u16 extra=%s;\n",gen_nextiword()); ! 2793: comprintf("\tcomp_fpp_opp(opcode,extra);\n"); ! 2794: break; ! 2795: case i_FBcc: ! 2796: isjump; ! 2797: uses_cmov; ! 2798: mayfail; ! 2799: comprintf("\tcomp_fbcc_opp(opcode);\n"); ! 2800: break; ! 2801: case i_FDBcc: ! 2802: isjump; ! 2803: failure; ! 2804: break; ! 2805: case i_FScc: ! 2806: mayfail; ! 2807: uses_cmov; ! 2808: comprintf("\tuae_u16 extra=%s;\n",gen_nextiword()); ! 2809: comprintf("\tcomp_fscc_opp(opcode,extra);\n"); ! 2810: break; ! 2811: case i_FTRAPcc: ! 2812: isjump; ! 2813: failure; ! 2814: break; ! 2815: case i_FSAVE: ! 2816: failure; ! 2817: break; ! 2818: case i_FRESTORE: ! 2819: failure; ! 2820: break; ! 2821: ! 2822: case i_CINVL: ! 2823: case i_CINVP: ! 2824: case i_CINVA: ! 2825: isjump; /* Not really, but it's probably a good idea to stop ! 2826: translating at this point */ ! 2827: failure; ! 2828: comprintf ("\tflush_icache();\n"); /* Differentiate a bit more? */ ! 2829: break; ! 2830: case i_CPUSHL: ! 2831: case i_CPUSHP: ! 2832: case i_CPUSHA: ! 2833: isjump; /* Not really, but it's probably a good idea to stop ! 2834: translating at this point */ ! 2835: failure; ! 2836: break; ! 2837: case i_MOVE16: ! 2838: //if ((opcode & 0xfff8) == 0xf620) { ! 2839: genmov16(opcode,curi); ! 2840: //} else { ! 2841: // isjump; ! 2842: // failure; ! 2843: //} ! 2844: break; ! 2845: ! 2846: case i_MMUOP030: ! 2847: case i_PFLUSHN: ! 2848: case i_PFLUSH: ! 2849: case i_PFLUSHAN: ! 2850: case i_PFLUSHA: ! 2851: case i_PLPAR: ! 2852: case i_PLPAW: ! 2853: case i_PTESTR: ! 2854: case i_PTESTW: ! 2855: case i_LPSTOP: ! 2856: isjump; ! 2857: failure; ! 2858: break; ! 2859: default: ! 2860: abort (); ! 2861: break; ! 2862: } ! 2863: comprintf("%s",endstr); ! 2864: finish_braces (); ! 2865: sync_m68k_pc (); ! 2866: if (global_mayfail) ! 2867: comprintf("\tif (failure) m68k_pc_offset=m68k_pc_offset_thisinst;\n"); ! 2868: return global_failure; ! 2869: } ! 2870: ! 2871: static void ! 2872: generate_includes (FILE * f, int bigger) ! 2873: { ! 2874: fprintf (f, "#include \"sysconfig.h\"\n"); ! 2875: fprintf (f, "#if defined(JIT)\n"); ! 2876: fprintf (f, "#include \"sysdeps.h\"\n"); ! 2877: if (bigger) ! 2878: fprintf (f, "#include \"options.h\"\n"); ! 2879: fprintf (f, "#include \"memory.h\"\n"); ! 2880: fprintf (f, "#include \"newcpu.h\"\n"); ! 2881: fprintf (f, "#include \"comptbl.h\"\n"); ! 2882: } ! 2883: ! 2884: static int postfix; ! 2885: ! 2886: static void ! 2887: generate_one_opcode (int rp, int noflags) ! 2888: { ! 2889: int i; ! 2890: uae_u16 smsk, dmsk; ! 2891: long int opcode = opcode_map[rp]; ! 2892: int aborted=0; ! 2893: int have_srcreg=0; ! 2894: int have_dstreg=0; ! 2895: ! 2896: if (table68k[opcode].mnemo == i_ILLG ! 2897: || table68k[opcode].clev > cpu_level) ! 2898: return; ! 2899: ! 2900: for (i = 0; lookuptab[i].name[0]; i++) ! 2901: { ! 2902: if (table68k[opcode].mnemo == lookuptab[i].mnemo) ! 2903: break; ! 2904: } ! 2905: ! 2906: if (table68k[opcode].handler != -1) ! 2907: return; ! 2908: ! 2909: switch (table68k[opcode].stype) ! 2910: { ! 2911: case 0: smsk = 7; break; ! 2912: case 1: smsk = 255; break; ! 2913: case 2: smsk = 15; break; ! 2914: case 3: smsk = 7; break; ! 2915: case 4: smsk = 7; break; ! 2916: case 5: smsk = 63; break; ! 2917: case 7: smsk = 3; break; ! 2918: default: abort (); ! 2919: } ! 2920: dmsk = 7; ! 2921: ! 2922: next_cpu_level = -1; ! 2923: if (table68k[opcode].suse ! 2924: && table68k[opcode].smode != imm && table68k[opcode].smode != imm0 ! 2925: && table68k[opcode].smode != imm1 && table68k[opcode].smode != imm2 ! 2926: && table68k[opcode].smode != absw && table68k[opcode].smode != absl ! 2927: && table68k[opcode].smode != PC8r && table68k[opcode].smode != PC16) ! 2928: { ! 2929: have_srcreg=1; ! 2930: if (table68k[opcode].spos == -1) ! 2931: { ! 2932: if (((int) table68k[opcode].sreg) >= 128) ! 2933: comprintf ("\tuae_s32 srcreg = (uae_s32)(uae_s8)%d;\n", (int) table68k[opcode].sreg); ! 2934: else ! 2935: comprintf ("\tuae_s32 srcreg = %d;\n", (int) table68k[opcode].sreg); ! 2936: } ! 2937: else ! 2938: { ! 2939: char source[100]; ! 2940: int pos = table68k[opcode].spos; ! 2941: ! 2942: if (pos) ! 2943: sprintf (source, "((opcode >> %d) & %d)", pos, smsk); ! 2944: else ! 2945: sprintf (source, "(opcode & %d)", smsk); ! 2946: ! 2947: if (table68k[opcode].stype == 3) ! 2948: comprintf ("\tuae_s32 srcreg = imm8_table[%s];\n", source); ! 2949: else if (table68k[opcode].stype == 1) ! 2950: comprintf ("\tuae_s32 srcreg = (uae_s32)(uae_s8)%s;\n", source); ! 2951: else ! 2952: comprintf ("\tuae_s32 srcreg = %s;\n", source); ! 2953: } ! 2954: } ! 2955: if (table68k[opcode].duse ! 2956: /* Yes, the dmode can be imm, in case of LINK or DBcc */ ! 2957: && table68k[opcode].dmode != imm && table68k[opcode].dmode != imm0 ! 2958: && table68k[opcode].dmode != imm1 && table68k[opcode].dmode != imm2 ! 2959: && table68k[opcode].dmode != absw && table68k[opcode].dmode != absl) ! 2960: { ! 2961: have_dstreg=1; ! 2962: if (table68k[opcode].dpos == -1) ! 2963: { ! 2964: if (((int) table68k[opcode].dreg) >= 128) ! 2965: comprintf ("\tuae_s32 dstreg = (uae_s32)(uae_s8)%d;\n", (int) table68k[opcode].dreg); ! 2966: else ! 2967: comprintf ("\tuae_s32 dstreg = %d;\n", (int) table68k[opcode].dreg); ! 2968: } ! 2969: else ! 2970: { ! 2971: int pos = table68k[opcode].dpos; ! 2972: ! 2973: if (pos) ! 2974: comprintf ("\tuae_u32 dstreg = (opcode >> %d) & %d;\n", ! 2975: pos, dmsk); ! 2976: else ! 2977: comprintf ("\tuae_u32 dstreg = opcode & %d;\n", dmsk); ! 2978: } ! 2979: } ! 2980: ! 2981: if (have_srcreg && have_dstreg && ! 2982: (table68k[opcode].dmode==Areg || ! 2983: table68k[opcode].dmode==Aind || ! 2984: table68k[opcode].dmode==Aipi || ! 2985: table68k[opcode].dmode==Apdi || ! 2986: table68k[opcode].dmode==Ad16 || ! 2987: table68k[opcode].dmode==Ad8r) && ! 2988: (table68k[opcode].smode==Areg || ! 2989: table68k[opcode].smode==Aind || ! 2990: table68k[opcode].smode==Aipi || ! 2991: table68k[opcode].smode==Apdi || ! 2992: table68k[opcode].smode==Ad16 || ! 2993: table68k[opcode].smode==Ad8r) ! 2994: ) { ! 2995: comprintf("\tuae_u32 dodgy=(srcreg==(uae_s32)dstreg);\n"); ! 2996: } ! 2997: else { ! 2998: comprintf("\tuae_u32 dodgy=0;\n"); ! 2999: } ! 3000: comprintf("\tuae_u32 m68k_pc_offset_thisinst=m68k_pc_offset;\n"); ! 3001: comprintf("\tm68k_pc_offset+=2;\n"); ! 3002: ! 3003: aborted=gen_opcode (opcode); ! 3004: { ! 3005: int flags=0; ! 3006: if (global_isjump) flags|=1; ! 3007: if (long_opcode) flags|=2; ! 3008: if (global_cmov) flags|=4; ! 3009: if (global_isaddx) flags|=8; ! 3010: if (global_iscjump) flags|=16; ! 3011: comprintf ("return 0;\n"); ! 3012: comprintf ("}\n"); ! 3013: ! 3014: char name[100] = { 0 }; ! 3015: for (int k = 0; lookuptab[i].name[k]; k++) ! 3016: name[k] = lookuptab[i].name[k]; ! 3017: ! 3018: if (aborted) { ! 3019: fprintf (stblfile, "{ NULL, %ld, 0x%08x }, /* %s */\n", opcode, flags, name); ! 3020: com_discard(); ! 3021: } else { ! 3022: if (noflags) { ! 3023: fprintf (stblfile, "{ op_%lx_%d_comp_nf, %ld, 0x%08x }, /* %s */\n", opcode, postfix, opcode, flags, name); ! 3024: fprintf (headerfile, "extern compop_func op_%lx_%d_comp_nf;\n", opcode, postfix); ! 3025: printf ("unsigned long REGPARAM2 op_%lx_%d_comp_nf(uae_u32 opcode) /* %s */\n{\n", opcode, postfix, name); ! 3026: } else { ! 3027: fprintf (stblfile, "{ op_%lx_%d_comp_ff, %ld, 0x%08x }, /* %s */\n", opcode, postfix, opcode, flags, name); ! 3028: fprintf (headerfile, "extern compop_func op_%lx_%d_comp_ff;\n", opcode, postfix); ! 3029: printf ("unsigned long REGPARAM2 op_%lx_%d_comp_ff(uae_u32 opcode) /* %s */\n{\n", opcode, postfix, name); ! 3030: } ! 3031: com_flush(); ! 3032: } ! 3033: } ! 3034: opcode_next_clev[rp] = next_cpu_level; ! 3035: opcode_last_postfix[rp] = postfix; ! 3036: } ! 3037: ! 3038: static void ! 3039: generate_func (int noflags) ! 3040: { ! 3041: int i, j, rp; ! 3042: ! 3043: using_prefetch = 0; ! 3044: using_exception_3 = 0; ! 3045: for (i = 0; i < 1; i++) /* We only do one level! */ ! 3046: { ! 3047: cpu_level = 5 - i; ! 3048: postfix = i; ! 3049: ! 3050: if (noflags) ! 3051: fprintf (stblfile, "const struct comptbl op_smalltbl_%d_comp_nf[] = {\n", postfix); ! 3052: else ! 3053: fprintf (stblfile, "const struct comptbl op_smalltbl_%d_comp_ff[] = {\n", postfix); ! 3054: ! 3055: ! 3056: /* sam: this is for people with low memory (eg. me :)) */ ! 3057: printf ("\n" ! 3058: "#if !defined(PART_1) && !defined(PART_2) && " ! 3059: "!defined(PART_3) && !defined(PART_4) && " ! 3060: "!defined(PART_5) && !defined(PART_6) && " ! 3061: "!defined(PART_7) && !defined(PART_8)" ! 3062: "\n" ! 3063: "#define PART_1 1\n" ! 3064: "#define PART_2 1\n" ! 3065: "#define PART_3 1\n" ! 3066: "#define PART_4 1\n" ! 3067: "#define PART_5 1\n" ! 3068: "#define PART_6 1\n" ! 3069: "#define PART_7 1\n" ! 3070: "#define PART_8 1\n" ! 3071: "#endif\n\n" ! 3072: "void setzflg_l(uae_u32);\n" ! 3073: "void comp_fpp_opp(void);\n" ! 3074: "void comp_fscc_opp(void);\n" ! 3075: "void comp_fbcc_opp(void);\n\n"); ! 3076: ! 3077: rp = 0; ! 3078: for (j = 1; j <= 8; ++j) ! 3079: { ! 3080: int k = (j * nr_cpuop_funcs) / 8; ! 3081: printf ("#ifdef PART_%d\n", j); ! 3082: for (; rp < k; rp++) ! 3083: generate_one_opcode (rp,noflags); ! 3084: printf ("#endif\n\n"); ! 3085: } ! 3086: ! 3087: fprintf (stblfile, "{ 0, 65536, 0 }};\n"); ! 3088: } ! 3089: ! 3090: } ! 3091: ! 3092: int ! 3093: main (int argc, char **argv) ! 3094: { ! 3095: read_table68k (); ! 3096: do_merges (); ! 3097: ! 3098: opcode_map = xmalloc (int, nr_cpuop_funcs); ! 3099: opcode_last_postfix = xmalloc (int, nr_cpuop_funcs); ! 3100: opcode_next_clev = xmalloc (int, nr_cpuop_funcs); ! 3101: counts = xmalloc (unsigned long, 65536); ! 3102: read_counts (); ! 3103: ! 3104: /* It would be a lot nicer to put all in one file (we'd also get rid of ! 3105: * cputbl.h that way), but cpuopti can't cope. That could be fixed, but ! 3106: * I don't dare to touch the 68k version. */ ! 3107: ! 3108: headerfile = fopen ("jit/comptbl.h", "wb"); ! 3109: ! 3110: fprintf (headerfile, "" \ ! 3111: "#ifdef NOFLAGS_SUPPORT\n" \ ! 3112: "/* 68040 */\n" \ ! 3113: "extern const struct comptbl op_smalltbl_0_nf[];\n" \ ! 3114: "#endif\n" \ ! 3115: "extern const struct comptbl op_smalltbl_0_comp_nf[];\n" \ ! 3116: "extern const struct comptbl op_smalltbl_0_comp_ff[];\n" \ ! 3117: ""); ! 3118: ! 3119: stblfile = fopen ("jit/compstbl.cpp", "wb"); ! 3120: freopen ("jit/compemu.cpp", "wb", stdout); ! 3121: ! 3122: generate_includes (stdout, 1); ! 3123: generate_includes (stblfile, 1); ! 3124: ! 3125: printf("#include \"compemu.h\"\n"); ! 3126: ! 3127: noflags=0; ! 3128: generate_func (noflags); ! 3129: ! 3130: ! 3131: opcode_map = xmalloc (int, nr_cpuop_funcs); ! 3132: opcode_last_postfix = xmalloc (int, nr_cpuop_funcs); ! 3133: opcode_next_clev = xmalloc (int, nr_cpuop_funcs); ! 3134: counts = xmalloc (unsigned long, 65536); ! 3135: read_counts (); ! 3136: noflags=1; ! 3137: generate_func (noflags); ! 3138: ! 3139: printf ("#endif\n"); ! 3140: fprintf (stblfile, "#endif\n"); ! 3141: ! 3142: free (table68k); ! 3143: return 0; ! 3144: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.