home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD1.iso / Emulatoren / UAE061.LZH / uae-0.6.1 / gencpu.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-28  |  69.9 KB  |  2,110 lines
  1. /* 
  2.  * UAE - The Un*x Amiga Emulator
  3.  *
  4.  * MC68000 emulation generator
  5.  *
  6.  * This is a fairly stupid program that generates a lot of case labels that 
  7.  * can be #included in a switch statement.
  8.  * As an alternative, it can generate functions that handle specific
  9.  * MC68000 instructions, plus a prototype header file and a function pointer
  10.  * array to look up the function for an opcode.
  11.  * Error checking is bad, an illegal table68k file will cause the program to
  12.  * call abort().
  13.  * The generated code is sometimes sub-optimal, an optimizing compiler should 
  14.  * take care of this.
  15.  * 
  16.  * (c) 1995 Bernd Schmidt
  17.  * 
  18.  */
  19.  
  20. #include "sysconfig.h"
  21. #include "sysdeps.h"
  22. #include <ctype.h>
  23.  
  24. #include "config.h"
  25. #include "options.h"
  26. #include "readcpu.h"
  27.  
  28. #define BOOL_TYPE "int"
  29.  
  30. long int counts[65536];
  31.  
  32. static int isspecific(int opcode)
  33. {
  34.     return counts[opcode]>5;
  35. }
  36.  
  37. static void read_counts(void)
  38. {
  39.     FILE *file;
  40.     unsigned long opcode,count, total;
  41.     int trapcount=0;
  42.     int trap=0;
  43.     memset(counts, 0, sizeof counts);
  44.  
  45.     file=fopen("insncount","r");
  46.     if(file)
  47.     {
  48.     fscanf(file,"Total: %d",&total);
  49.     while(fscanf(file,"%x: %d\n",&opcode,&count)==2)
  50.     {
  51.         counts[opcode]=10000.0*count/total;
  52.         if(isspecific(opcode))
  53.         {
  54.         trapcount+=count;
  55.         trap++;
  56.         }
  57.     }
  58. #if 0
  59.     fprintf(stderr,"trap %d function: %f%\n",trap,100.0*trapcount/total);
  60. #endif
  61.     }
  62. }
  63.  
  64.  
  65. static int n_braces = 0;
  66.  
  67. static void start_brace(void)
  68. {
  69.     n_braces++;
  70.     printf("{");
  71. }
  72.  
  73. static void close_brace(void)
  74. {
  75.     assert (n_braces > 0);
  76.     n_braces--;
  77.     printf("}");
  78. }
  79.  
  80. static void finish_braces(void)
  81. {
  82.     while (n_braces > 0)
  83.     close_brace();
  84. }
  85.  
  86. static void pop_braces(int to)
  87. {
  88.     while (n_braces > to)
  89.     close_brace();
  90. }
  91.  
  92. static void genamode(amodes mode, char *reg, wordsizes size, char *name, int getv, int movem)
  93. {
  94.     start_brace ();
  95.     switch(mode) {
  96.      case Dreg:
  97.     if (movem)
  98.         abort();
  99.     if (getv)
  100.         switch(size) {      
  101.          case sz_byte:
  102.         printf("\tBYTE %s = regs.d[%s];\n", name, reg);
  103.         break;
  104.          case sz_word:
  105.         printf("\tWORD %s = regs.d[%s];\n", name, reg);
  106.         break;
  107.          case sz_long:
  108.         printf("\tLONG %s = regs.d[%s];\n", name, reg);
  109.         break;
  110.          default: abort();
  111.         }
  112.     break;
  113.      case Areg:
  114.     if (movem)
  115.         abort();
  116.     if (getv)
  117.         switch(size) {      
  118.          case sz_word:
  119.         printf("\tWORD %s = regs.a[%s];\n", name, reg);
  120.         break;
  121.          case sz_long:
  122.         printf("\tLONG %s = regs.a[%s];\n", name, reg);
  123.         break;
  124.          default: abort();
  125.         }
  126.     break;
  127.      case Aind:
  128.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  129.     if (getv)
  130.         switch(size) {      
  131.          case sz_byte:
  132.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  133.         break;
  134.          case sz_word:
  135.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  136.         break;
  137.          case sz_long:
  138.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  139.         break;
  140.          default: abort();
  141.         }
  142.     break;
  143.      case Aipi:
  144.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  145.     switch(size) {
  146.      case sz_byte:        
  147.         if (getv) printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  148.         if (!movem) {
  149.         start_brace();
  150.         printf("\tregs.a[%s] += areg_byteinc[%s];\n", reg, reg);
  151.         }
  152.         break;
  153.      case sz_word:
  154.         if (getv) printf("\tWORD %s = get_word(%sa);\n", name, name);
  155.         if (!movem) {
  156.         start_brace();
  157.         printf("\tregs.a[%s] += 2;\n", reg);
  158.         }
  159.         break;
  160.      case sz_long:
  161.         if (getv) printf("\tLONG %s = get_long(%sa);\n", name, name);
  162.         if (!movem) {
  163.         start_brace();
  164.         printf("\tregs.a[%s] += 4;\n", reg);
  165.         }
  166.         break;
  167.      default: abort();
  168.     }
  169.     break;
  170.      case Apdi:
  171.     switch(size) {      
  172.      case sz_byte:
  173.         if (!movem) printf("\tregs.a[%s] -= areg_byteinc[%s];\n", reg, reg);
  174.         start_brace();
  175.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  176.         if (getv) printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  177.         break;
  178.      case sz_word:
  179.         if (!movem) printf("\tregs.a[%s] -= 2;\n", reg);
  180.         start_brace();
  181.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  182.         if (getv) printf("\tWORD %s = get_word(%sa);\n", name, name);
  183.         break;
  184.      case sz_long:
  185.         if (!movem) printf("\tregs.a[%s] -= 4;\n", reg);
  186.         start_brace();
  187.         printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  188.         if (getv) printf("\tLONG %s = get_long(%sa);\n", name, name);
  189.         break;
  190.      default: abort();
  191.     }
  192.     break;
  193.      case Ad16:
  194.     printf("\tCPTR %sa = regs.a[%s] + (LONG)(WORD)nextiword();\n", name, reg);
  195.     if (getv) 
  196.         switch(size) {      
  197.          case sz_byte:
  198.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  199.         break;
  200.          case sz_word:
  201.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  202.         break;
  203.          case sz_long:
  204.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  205.         break;
  206.          default: abort();
  207.         }
  208.     break;
  209.      case Ad8r:
  210.     printf("\tCPTR %sa = regs.a[%s];\n", name, reg);
  211. #if 0
  212.     printf("\tUWORD %sdp = nextiword();\n", name);
  213.     printf("\t%sa += (LONG)(BYTE)(%sdp & 0xFF);\n", name, name);
  214.     start_brace();
  215.     printf("\tULONG %sdpr = %sdp & 0x8000 ? regs.a[(%sdp & 0x7000) >> 12] : regs.d[(%sdp & 0x7000) >> 12];\n", name, name, name, name);
  216.     printf("\tif (!(%sdp & 0x800)) %sdpr = (LONG)(WORD)%sdpr;\n", name, name, name);
  217.     printf("\t%sa += %sdpr;\n", name, name);
  218. #endif
  219.     printf("\t%sa = get_disp_ea (%sa, nextiword());\n", name, name);
  220.     if (getv) {
  221.         start_brace();
  222.         switch(size) {      
  223.          case sz_byte:
  224.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  225.         break;
  226.          case sz_word:
  227.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  228.         break;
  229.          case sz_long:
  230.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  231.         break;
  232.          default: abort();
  233.         }
  234.     }
  235.     break;
  236.      case PC16:
  237.     printf("\tCPTR %sa = m68k_getpc();\n", name);
  238.     printf("\t%sa += (LONG)(WORD)nextiword();\n", name);
  239.     if (getv) {
  240.         start_brace();
  241.         switch(size) {      
  242.          case sz_byte:
  243.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  244.         break;
  245.          case sz_word:
  246.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  247.         break;
  248.          case sz_long:
  249.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  250.         break;
  251.          default: abort();
  252.         }
  253.     }
  254.     break;
  255.      case PC8r:
  256.     printf("\tCPTR %sa = m68k_getpc();\n", name);
  257. #if 0
  258.     printf("\tUWORD %sdp = nextiword();\n", name);
  259.     printf("\t%sa += (LONG)(BYTE)(%sdp & 0xFF);\n", name, name);
  260.     start_brace();
  261.     printf("\tULONG %sdpr = %sdp & 0x8000 ? regs.a[(%sdp & 0x7000) >> 12] : regs.d[(%sdp & 0x7000) >> 12];\n", name, name, name, name);
  262.     printf("\tif (!(%sdp & 0x800)) %sdpr = (LONG)(WORD)%sdpr;\n", name, name, name);
  263.     printf("\t%sa += %sdpr;\n", name, name);
  264. #endif
  265.     printf("\t%sa = get_disp_ea (%sa, nextiword());\n", name, name);
  266.     if (getv) {
  267.         start_brace();
  268.         switch(size) {      
  269.          case sz_byte:
  270.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  271.         break;
  272.          case sz_word:
  273.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  274.         break;
  275.          case sz_long:
  276.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  277.         break;
  278.          default: abort();
  279.         }
  280.     }
  281.     break;
  282.      case absw:
  283.     printf("\tCPTR %sa = (LONG)(WORD)nextiword();\n", name);
  284.     if (getv) 
  285.         switch(size) {      
  286.          case sz_byte:
  287.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  288.         break;
  289.          case sz_word:
  290.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  291.         break;
  292.          case sz_long:
  293.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  294.         break;
  295.          default: abort();
  296.         }
  297.     break;
  298.      case absl:
  299.     printf("\tCPTR %sa = nextilong();\n", name);
  300.     if (getv) 
  301.         switch(size) {      
  302.          case sz_byte:
  303.         printf("\tBYTE %s = get_byte(%sa);\n", name, name);
  304.         break;
  305.          case sz_word:
  306.         printf("\tWORD %s = get_word(%sa);\n", name, name);
  307.         break;
  308.          case sz_long:
  309.         printf("\tLONG %s = get_long(%sa);\n", name, name);
  310.         break;
  311.          default: abort();
  312.         }
  313.     break;
  314.      case imm:
  315.     if (getv) 
  316.         switch(size) {
  317.          case sz_byte:
  318.         printf("\tBYTE %s = nextiword();\n", name);
  319.         break;
  320.          case sz_word:
  321.         printf("\tWORD %s = nextiword();\n", name);
  322.         break;
  323.          case sz_long:
  324.         printf("\tLONG %s = nextilong();\n", name);
  325.         break;
  326.          default: abort();
  327.         }
  328.     break;
  329.      case imm0:
  330.     if (!getv) abort();
  331.     printf("\tBYTE %s = nextiword();\n", name);
  332.     break;
  333.      case imm1:
  334.     if (!getv) abort();
  335.     printf("\tWORD %s = nextiword();\n", name);
  336.     break;
  337.      case imm2:
  338.     if (!getv) abort();
  339.         printf("\tLONG %s = nextilong();\n", name);
  340.     break;
  341.      case immi:
  342.     if (!getv) abort();
  343.     printf("\tULONG %s = %s;\n", name, reg);
  344.     break;
  345.      default: 
  346.     abort();
  347.     }
  348. }
  349.  
  350. static void genastore(char *from, amodes mode, char *reg, wordsizes size, char *to)
  351. {
  352.     switch(mode) {
  353.      case Dreg:
  354.     switch(size) {      
  355.      case sz_byte:
  356.         printf("\tregs.d[%s] &= ~0xff; regs.d[%s] |= (%s) & 0xff;\n", reg, reg, from);
  357.         break;
  358.      case sz_word:
  359.         printf("\tregs.d[%s] &= ~0xffff; regs.d[%s] |= (%s) & 0xffff;\n", reg, reg, from);
  360.         break;
  361.      case sz_long:
  362.         printf("\tregs.d[%s] = (%s);\n", reg, from);
  363.         break;
  364.      default: abort();
  365.     }
  366.     break;
  367.      case Areg:
  368.     switch(size) {      
  369.      case sz_word:
  370.         printf("\tregs.a[%s] = (LONG)(WORD)(%s);\n", reg, from);
  371.         break;
  372.      case sz_long:
  373.         printf("\tregs.a[%s] = (%s);\n", reg, from);
  374.         break;
  375.      default: abort();
  376.     }
  377.     break;
  378.      case Aind:
  379.      case Aipi:
  380.      case Apdi:
  381.      case Ad16:
  382.      case Ad8r:
  383.      case absw:
  384.      case absl:
  385.     switch(size) {
  386.      case sz_byte:
  387.         printf("\tput_byte(%sa,%s);\n", to, from);
  388.         break;
  389.      case sz_word:
  390.         printf("\tput_word(%sa,%s);\n", to, from);
  391.         break;
  392.      case sz_long:
  393.         printf("\tput_long(%sa,%s);\n", to, from);
  394.         break;
  395.      default: abort();
  396.     }
  397.     break;
  398.      case PC16:
  399.      case PC8r:
  400.     switch(size) {
  401.      case sz_byte:
  402.         printf("\tput_byte(%sa,%s);\n", to, from);
  403.         break;
  404.      case sz_word:
  405.         if (CPU_LEVEL < 2)
  406.         abort();
  407.         printf("\tput_word(%sa,%s);\n", to, from);
  408.         break;
  409.      case sz_long:
  410.         if (CPU_LEVEL < 2)
  411.         abort();
  412.         printf("\tput_long(%sa,%s);\n", to, from);
  413.         break;
  414.      default: abort();
  415.     }
  416.     break;
  417.      case imm:
  418.      case imm0:
  419.      case imm1:
  420.      case imm2:
  421.      case immi:
  422.     abort();
  423.     break;
  424.      default: 
  425.     abort();
  426.     }
  427. }
  428.  
  429. static void genmovemel(UWORD opcode)
  430. {
  431.     char getcode[100];
  432.     int size = table68k[opcode].size == sz_long ? 4 : 2;
  433.     
  434.     if (table68k[opcode].size == sz_long) {    
  435.         strcpy(getcode, "get_long(srca)");
  436.     } else {        
  437.         strcpy(getcode, "(LONG)(WORD)get_word(srca)");
  438.     }
  439.     
  440.     printf("\tUWORD mask = nextiword(), bitmask = mask;\n");
  441.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 1);
  442.     start_brace();
  443.     printf("\tint i, bitcnt = 0;\n");
  444.     printf("\tfor(i=0;i<16;i++) { bitcnt += bitmask & 1; bitmask >>= 1; }\n");
  445.     
  446.     printf("\tfor(i=0;i<8;i++) { if (mask & 1) { regs.d[i] = %s; srca += %d; } mask >>= 1; }\n", getcode, size);
  447.     printf("\tfor(i=0;i<8;i++) { if (mask & 1) { regs.a[i] = %s; srca += %d; } mask >>= 1; }\n", getcode, size);
  448.     
  449.     if (table68k[opcode].smode == Aipi)
  450.         printf("\tregs.a[srcreg] = srca;\n");
  451. }
  452.  
  453. static void genmovemle(UWORD opcode)
  454. {
  455.     char putcode[100], shiftcode[] = ">>";
  456.     int size = table68k[opcode].size == sz_long ? 4 : 2;
  457.     int mask = 1;
  458.     if (table68k[opcode].size == sz_long) {
  459.         strcpy(putcode, "put_long(srca,");
  460.     } else {        
  461.         strcpy(putcode, "put_word(srca,");
  462.     }
  463.     
  464.     printf("\tUWORD mask = nextiword(), bitmask = mask;\n");
  465.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 1);
  466.     start_brace();
  467.     printf("\tint i, bitcnt = 0;\n");
  468.     printf("\tULONG rd[8], ra[8];\n");
  469.     printf("\tfor(i=0;i<16;i++) { bitcnt += bitmask & 1; bitmask >>= 1; }\n");
  470.     printf("\tfor(i=0;i<8;i++) { rd[i] = regs.d[i]; ra[i] = regs.a[i]; }\n");
  471.     if (table68k[opcode].smode == Apdi) {
  472.     printf("\tsrca -= %d*bitcnt;\n", size);
  473.     printf("\tregs.a[srcreg] = srca;\n");
  474.     strcpy(shiftcode, "<<");
  475.     mask = 0x8000;
  476.     }
  477.  
  478.     printf("\tfor(i=0;i<8;i++) { if (mask & %d) { %s rd[i]); srca += %d; } mask %s= 1; }\n", 
  479.        mask, putcode, size, shiftcode);
  480.     printf("\tfor(i=0;i<8;i++) { if (mask & %d) { %s ra[i]); srca += %d; } mask %s= 1; }\n",
  481.        mask, putcode, size, shiftcode);    
  482. }
  483.  
  484. typedef enum {
  485.     flag_logical, flag_add, flag_sub, flag_cmp, flag_addx, flag_subx, flag_zn,
  486.     flag_av, flag_sv
  487. } flagtypes;
  488.  
  489. static void genflags_normal(flagtypes type, wordsizes size, char *value, char *src, char *dst)
  490. {
  491.     char vstr[100],sstr[100],dstr[100];
  492.     char usstr[100],udstr[100];
  493.     char unsstr[100],undstr[100];
  494.  
  495.     switch(size) {        
  496.      case sz_byte:
  497.     strcpy(vstr, "((BYTE)(");
  498.     strcpy(usstr, "((UBYTE)(");
  499.     break;
  500.      case sz_word:
  501.     strcpy(vstr, "((WORD)(");
  502.     strcpy(usstr, "((UWORD)(");
  503.     break;
  504.      case sz_long:
  505.     strcpy(vstr, "((LONG)(");
  506.     strcpy(usstr, "((ULONG)(");
  507.     break;
  508.      default:
  509.     abort();
  510.     }
  511.     strcpy(unsstr, usstr); 
  512.  
  513.     strcpy(sstr, vstr);
  514.     strcpy(dstr, vstr);
  515.     strcat(vstr, value); strcat(vstr,"))");
  516.     strcat(dstr, dst); strcat(dstr,"))");
  517.     strcat(sstr, src); strcat(sstr,"))");
  518.     
  519.     strcpy(udstr, usstr);
  520.     strcat(udstr, dst); strcat(udstr,"))");
  521.     strcat(usstr, src); strcat(usstr,"))");
  522.     
  523.     strcpy(undstr, unsstr);
  524.     strcat(unsstr, "-");
  525.     strcat(undstr, "~");
  526.     strcat(undstr, dst); strcat(undstr,"))");
  527.     strcat(unsstr, src); strcat(unsstr,"))");
  528.  
  529.     switch (type) {
  530.      case flag_logical:
  531.      case flag_zn:
  532.      case flag_av:
  533.      case flag_sv:
  534.      case flag_addx:
  535.      case flag_subx:
  536.     break;
  537.     
  538.      case flag_add:
  539.     start_brace();
  540.     printf("ULONG %s = %s + %s;\n", value, dstr, sstr);
  541.     break;
  542.      case flag_sub:
  543.      case flag_cmp:
  544.     start_brace();
  545.     printf("ULONG %s = %s - %s;\n", value, dstr, sstr);
  546.     break;
  547.     }
  548.  
  549.  
  550.     switch (type) {
  551.      case flag_logical:
  552.      case flag_zn:
  553.     break;
  554.     
  555.      case flag_add:
  556.      case flag_sub:
  557.      case flag_addx:
  558.      case flag_subx:
  559.      case flag_cmp:
  560.      case flag_av:
  561.      case flag_sv:
  562.     start_brace();
  563.     printf("\t"BOOL_TYPE" flgs = %s < 0;\n", sstr);
  564.     printf("\t"BOOL_TYPE" flgo = %s < 0;\n", dstr);
  565.     printf("\t"BOOL_TYPE" flgn = %s < 0;\n", vstr);
  566.     break;
  567.     }
  568.     
  569.     switch(type) {
  570.      case flag_logical:
  571. #ifdef GNU_FLAG_OPT
  572.     {
  573.     int max;
  574.         switch(size) {        
  575.            case sz_byte: max = 0x7f; break;
  576.            case sz_word: max = 0x7fff; break;
  577.            case sz_long: max = 0x7fffffff; break;
  578.         }
  579.         printf("\tswitch(%s) {\n",vstr);
  580.     printf("\t   case -%dL-1L ... -1L: regflags.longflags = VCNZ(0,0,1,0);\n",max);
  581.     printf("\t   case 0L:              regflags.longflags = VCNZ(0,0,0,1);\n");
  582.     printf("\t   case 1L ... %dL:      regflags.longflags = VCNZ(0,0,0,0);\n",max);
  583.     printf("\t}\n");
  584.     }
  585. #else
  586.     printf("\tVFLG = CFLG = 0;\n");
  587.     printf("\tZFLG = %s == 0;\n", vstr);
  588.     printf("\tNFLG = %s < 0;\n", vstr);
  589. #endif
  590.     break;
  591.      case flag_av:
  592.     printf("\tVFLG = (flgs == flgo) && (flgn != flgo);\n");
  593.     break;
  594.      case flag_sv:
  595.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  596.     break;
  597.      case flag_zn:
  598.     printf("\tif (%s != 0) ZFLG = 0;\n", vstr);
  599.     printf("\tNFLG = %s < 0;\n", vstr);
  600.     break;
  601.      case flag_add:
  602. #ifdef GNU_FLAG_OPT
  603.     {
  604.     int max;
  605.         switch(size) {        
  606.            case sz_byte: max = 0x7f; break;
  607.            case sz_word: max = 0x7fff; break;
  608.            case sz_long: max = 0x7fffffff; break;
  609.         }
  610.         printf("\tswitch(%s) {\n",vstr);
  611.     printf("\t   case -%dL-1L ... -1L:\n",max);
  612.     printf("\t      if((%s|%s)>=0) {regflags.longflags = VCNZ(1,0,1,0);return;}\n",sstr,dstr);
  613.     printf("\t      else           {regflags.longflags = VCNZ(0,0,1,0);}\n");
  614.     printf("\t      break;\n");
  615.     printf("\t   case 0L:\n");
  616.     printf("\t      if((%s&%s)<0)  {regflags.longflags = VCNZ(1,0,0,1);return;}\n",sstr,dstr);
  617.     printf("\t      else           {regflags.longflags = VCNZ(0,0,0,1);}\n");
  618.     printf("\t      break;\n");
  619.     printf("\t   case 1L ... %dL:\n",max);
  620.     printf("\t      if((%s&%s)<0)  {regflags.longflags = VCNZ(1,0,0,0);return;}\n",sstr,dstr);
  621.     printf("\t      else           {regflags.longflags = VCNZ(0,0,0,0);}\n");
  622.     printf("\t      break;\n");
  623.     printf("\t}\n");
  624.     printf("\tif(%s < %s) regflags.longflags += VCNZ(0,1,0,0);\n", undstr, usstr);
  625.     }
  626. #else
  627.     printf("\tZFLG = %s == 0;\n", vstr);
  628.     printf("\tVFLG = (flgs == flgo) && (flgn != flgo);\n");
  629.     printf("\tCFLG = regs.x = %s < %s;\n", undstr, usstr);
  630.     printf("\tNFLG = flgn != 0;\n");
  631. #endif
  632.     break;
  633.      case flag_sub:
  634.     printf("\tZFLG = %s == 0;\n", vstr);
  635.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  636.     printf("\tCFLG = regs.x = %s > %s;\n", usstr, udstr);
  637.     printf("\tNFLG = flgn != 0;\n");
  638.     break;
  639.      case flag_addx:
  640.     printf("\tVFLG = (flgs && flgo && !flgn) || (!flgs && !flgo && flgn);\n");
  641.     printf("\tregs.x = CFLG = (flgs && flgo) || (!flgn && (flgo || flgs));\n");
  642.     break;
  643.      case flag_subx:
  644.     printf("\tVFLG = (!flgs && flgo && !flgn) || (flgs && !flgo && flgn);\n");
  645.     printf("\tregs.x = CFLG = (flgs && !flgo) || (flgn && (!flgo || flgs));\n");
  646.     break;
  647.      case flag_cmp:
  648.     printf("\tZFLG = %s == 0;\n", vstr);
  649.     printf("\tVFLG = (flgs != flgo) && (flgn != flgo);\n");
  650.     printf("\tCFLG = %s > %s;\n", usstr, udstr);
  651.     printf("\tNFLG = flgn != 0;\n");
  652.     break;
  653.     }
  654. }
  655.  
  656. static void genflags(flagtypes type, wordsizes size, char *value, char *src, char *dst)
  657. {
  658. #ifdef INTEL_FLAG_OPT
  659.     
  660.     switch (type) {
  661.      case flag_logical:
  662.      case flag_av:
  663.      case flag_sv:
  664.      case flag_zn:
  665.      case flag_addx:
  666.      case flag_subx:
  667.     break;
  668.  
  669.      case flag_add:
  670.      case flag_sub:
  671.      case flag_cmp:
  672.     start_brace();
  673.     printf("\tULONG %s;\n", value);
  674.     break;
  675.     }
  676.  
  677.     switch(type) {
  678.      case flag_av:
  679.      case flag_sv:
  680.      case flag_zn:
  681.      case flag_addx:
  682.      case flag_subx:
  683.     break;
  684.  
  685.      case flag_logical:
  686.     if (strcmp(value, "0") == 0) {
  687.         /* GCC doesn't want to load the constant into a register. 
  688.          * intel_flag_lookup[64] is just the zero flag set. */
  689.         printf("\tregflags = intel_flag_lookup[64];\n");
  690.     } else {
  691.         switch(size) {
  692.          case sz_byte:
  693.         printf("\t__asm__(\"testb %%0,%%0; lahf; movzbl %%%%ah,%%%%eax; movl intel_flag_lookup(,%%%%eax,4),%%%%eax; movl %%%%eax,regflags\""
  694.                ": : \"r\" (%s) : \"%%eax\", \"cc\");", value);
  695.         break;
  696.          case sz_word:
  697.         printf("\t__asm__(\"testw %%0,%%0; lahf; movzbl %%%%ah,%%%%eax; movl intel_flag_lookup(,%%%%eax,4),%%%%eax; movl %%%%eax,regflags\""
  698.                ": : \"r\" (%s) : \"%%eax\", \"cc\");", value);
  699.         break;
  700.          case sz_long:
  701.         printf("\t__asm__(\"testl %%0,%%0; lahf; movzbl %%%%ah,%%%%eax; movl intel_flag_lookup(,%%%%eax,4),%%%%eax; movl %%%%eax,regflags\""
  702.                ": : \"r\" (%s) : \"%%eax\", \"cc\");", value);
  703.         
  704.         break;
  705.          case sz_unknown:
  706.         abort();
  707.         }
  708.     }
  709.     return;
  710.  
  711.      case flag_add:
  712.     switch (size) {
  713.     /* Of course it would be better to let GCC find a proper register to 
  714.      * compute newv in, but it does not seem to like reloading the 8 bit
  715.      * regs. */
  716.      case sz_byte:
  717.         printf("\t__asm__(\"addb %%b3,%%b0; lahf; movzbl %%%%ah,%%%%eax;"
  718.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  719.            ": \"=&q\" (%s), \"=m\" (regs.x) "
  720.            ": \"0\" ((BYTE)(%s)), \"qm\" ((BYTE)(%s)) : \"cc\", \"%%eax\");",
  721.            value, src, dst);
  722.         break;
  723.      case sz_word:
  724.         printf("\t__asm__(\"addw %%w3,%%w0; lahf; movzbl %%%%ah,%%%%eax;"
  725.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  726.            ": \"=&r\" (%s), \"=m\" (regs.x) "
  727.            ": \"0\" ((WORD)(%s)), \"rmi\" ((WORD)(%s)) : \"cc\", \"%%eax\");",
  728.            value, src, dst);
  729.         break;
  730.      case sz_long:
  731.         printf("\t__asm__(\"addl %%3,%%0; lahf; movzbl %%%%ah,%%%%eax;"
  732.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  733.            ": \"=&r\" (%s), \"=m\" (regs.x) "
  734.            ": \"0\" ((LONG)(%s)), \"rmi\" ((LONG)(%s)) : \"cc\", \"%%eax\");",
  735.            value, src, dst);
  736.         break;
  737.      case sz_unknown:
  738.         abort();
  739.     }
  740.     return;
  741.  
  742.      case flag_sub:
  743.     switch (size) {
  744.      case sz_byte:
  745.         printf("\t__asm__(\"subb %%b2,%%b0; lahf; movzbl %%%%ah,%%%%eax;"
  746.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  747.            ": \"=&q\" (%s), \"=m\" (regs.x) "
  748.            ": \"qmi\" ((BYTE)(%s)), \"0\" ((BYTE)(%s)) : \"cc\", \"%%eax\");",
  749.            value, src, dst);
  750.         break;
  751.      case sz_word:
  752.         printf("\t__asm__(\"subw %%w2,%%w0; lahf; movzbl %%%%ah,%%%%eax;"
  753.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  754.            ": \"=&r\" (%s), \"=m\" (regs.x) "
  755.            ": \"rmi\" ((WORD)(%s)), \"0\" ((WORD)(%s)) : \"cc\", \"%%eax\");",
  756.            value, src, dst);
  757.         break;
  758.      case sz_long:
  759.         printf("\t__asm__(\"subl %%2,%%0; lahf; movzbl %%%%ah,%%%%eax;"
  760.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al; movb %%%%ah,%%1; movl %%%%eax,regflags \""
  761.            ": \"=&r\" (%s), \"=m\" (regs.x) "
  762.            ": \"rmi\" ((LONG)(%s)), \"0\" ((LONG)(%s)) : \"cc\", \"%%eax\");",
  763.            value, src, dst);
  764.         break;
  765.      case sz_unknown:
  766.         abort();
  767.     }
  768.     return;
  769.  
  770.      case flag_cmp:
  771.     switch (size) {
  772.      case sz_byte:
  773.         printf("\t__asm__(\"movb %%3,%%%%cl; subb %%2,%%%%cl; lahf; movzbl %%%%ah,%%%%eax;"
  774.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al \""
  775.            ": \"=a\" (regflags.longflags), \"=&c\" (%s) "
  776.            ": \"rm\" ((BYTE)(%s)), \"rmi\" ((BYTE)(%s)) : \"cc\");",
  777.            value, src, dst);
  778.         break;
  779.      case sz_word:
  780.         printf("\t__asm__(\"movw %%3,%%%%cx; subw %%2,%%%%cx; lahf; movzbl %%%%ah,%%%%eax;"
  781.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al \""
  782.            ": \"=a\" (regflags.longflags), \"=&c\" (%s) "
  783.            ": \"rm\" ((WORD)(%s)), \"rmi\" ((WORD)(%s)) : \"cc\");",
  784.            value, src, dst);
  785.         break;
  786.      case sz_long:
  787.         printf("\t__asm__(\"movl %%3,%%%%ecx; subl %%2,%%%%ecx; lahf; movzbl %%%%ah,%%%%eax;"
  788.            " movl intel_flag_lookup(,%%%%eax,4),%%%%eax; seto %%%%al \""
  789.            ": \"=a\" (regflags.longflags), \"=&c\" (%s) "
  790.            ": \"rm\" ((LONG)(%s)), \"rmi\" ((LONG)(%s)) : \"cc\");",
  791.            value, src, dst);
  792.         break;
  793.      case sz_unknown:
  794.         abort();
  795.     }
  796.     return;
  797.     }
  798. #elif defined(M68K_FLAG_OPT)
  799. /*
  800.  * sam: This is my first try. There might be a lot of bugs :)
  801.  */
  802.     switch (type) {
  803.      case flag_logical:
  804.      case flag_av:
  805.      case flag_sv:
  806.      case flag_zn:
  807.      case flag_addx:
  808.      case flag_subx:
  809.     break;
  810.  
  811.      case flag_add:
  812.      case flag_sub:
  813.      case flag_cmp:
  814.     start_brace();
  815.     printf("\tULONG %s;\n", value);
  816.     break;
  817.     }
  818.  
  819.     switch(type) {
  820.      case flag_av:
  821.      case flag_sv:
  822.      case flag_zn:
  823.      case flag_addx:
  824.      case flag_subx:
  825.         /* normal code: genflags_normal() */
  826.     break;
  827.  
  828.      case flag_logical:
  829.     if (strcmp(value, "0") == 0) {
  830.         /* v=c=n=0 z=1 */
  831.         printf("\t*(ULONG*)®flags.flags = 1;\n");
  832.     } else {
  833.             printf("\t{ WORD ccr;\n");
  834.         switch(size) {
  835.          case sz_byte:
  836.         printf("\t__asm__(\"tstb %%1; movw ccr,%%0\": \"=d\" (ccr) : \"dm\" ((BYTE)(%s)) : \"cc\");\n",value);
  837.         break;
  838.          case sz_word:
  839.         printf("\t__asm__(\"tstw %%1; movw ccr,%%0\": \"=d\" (ccr) : \"dm\" ((WORD)(%s)) : \"cc\");\n",value);
  840.         break;
  841.          case sz_long:
  842.         printf("\t__asm__(\"tstl %%1; movw ccr,%%0\": \"=d\" (ccr) : \"dm\" ((LONG)(%s)) : \"cc\");\n",value);
  843.         break;
  844.          case sz_unknown:
  845.         abort();
  846.         }
  847.         printf("\tregflags = m68k_flag_lookup[ccr&15]; }\n");
  848.     }
  849.     return;
  850.  
  851.      case flag_add:
  852.         printf("\t{ WORD ccr;\n");
  853.     switch (size) {
  854.      case sz_byte:
  855.          printf("\t__asm__(\" movb %%3,%%1; addb %%2,%%1; movw ccr,%%0\""
  856.                ": \"=d\" (ccr), \"=&d\" ((BYTE)(%s)) : \"dmi\" ((BYTE)(%s)), \"dmi\" ((BYTE)(%s)) : \"cc\");\n",
  857.                value, src, dst);
  858.         break;
  859.      case sz_word:
  860.          printf("\t__asm__(\" movw %%3,%%1; addw %%2,%%1; movw ccr,%%0\""
  861.                ": \"=d\" (ccr), \"=&d\" ((WORD)(%s)) : \"dmi\" ((WORD)(%s)), \"dmi\" ((WORD)(%s)) : \"cc\");\n",
  862.                value, src, dst);
  863.         break;
  864.      case sz_long:
  865.          printf("\t__asm__(\" movl %%3,%%1; addl %%2,%%1; movw ccr,%%0\""
  866.                ": \"=d\" (ccr), \"=&d\" ((LONG)(%s)) : \"dmi\" ((LONG)(%s)), \"dmi\" ((LONG)(%s)) : \"cc\");\n",
  867.                value, src, dst);
  868.         break;
  869.      case sz_unknown:
  870.         abort();
  871.     }
  872.     printf("\tregflags = m68k_flag_lookup[ccr&15];\n");
  873.     printf("\tregs.x = CFLG; }\n");
  874.     return;
  875.  
  876.      case flag_sub:
  877.         printf("\t{ WORD ccr;\n");
  878.     switch (size) {
  879.      case sz_byte:
  880.         if(strcmp(dst,"0")!=0)
  881.          printf("\t__asm__(\" movb %%3,%%1; subb %%2,%%1; movw ccr,%%0\""
  882.                ": \"=d\" (ccr), \"=&d\" ((BYTE)(%s)) : \"dmi\" ((BYTE)(%s)), \"dmi\" ((BYTE)(%s)) : \"cc\");\n",
  883.                value, src, dst);
  884.         else
  885.          printf("\t__asm__(\" movb %%2,%%1; negb %%1; movw ccr,%%0\""
  886.                ": \"=d\" (ccr), \"=&d\" ((BYTE)(%s)) : \"dmi\" ((BYTE)(%s)) : \"cc\");\n",
  887.                value, src);
  888.         break;
  889.      case sz_word:
  890.         if(strcmp(dst,"0")!=0)
  891.          printf("\t__asm__(\" movw %%3,%%1; subw %%2,%%1; movw ccr,%%0\""
  892.                ": \"=d\" (ccr), \"=&d\" ((WORD)(%s)) : \"dmi\" ((WORD)(%s)), \"dmi\" ((WORD)(%s)) : \"cc\");\n",
  893.                value, src, dst);
  894.         else
  895.          printf("\t__asm__(\" movw %%2,%%1; negw %%1; movw ccr,%%0\""
  896.                ": \"=d\" (ccr), \"=&d\" ((WORD)(%s)) : \"dmi\" ((WORD)(%s)) : \"cc\");\n",
  897.                value, src);
  898.         break;
  899.      case sz_long:
  900.         if(strcmp(dst,"0")!=0)
  901.          printf("\t__asm__(\" movl %%3,%%1; subl %%2,%%1; movw ccr,%%0\""
  902.                ": \"=d\" (ccr), \"=&d\" ((LONG)(%s)) : \"dmi\" ((LONG)(%s)), \"dmi\" ((LONG)(%s)) : \"cc\");\n",
  903.                value, src, dst);
  904.         else
  905.          printf("\t__asm__(\" movl %%2,%%1; negl %%1; movw ccr,%%0\""
  906.                ": \"=d\" (ccr), \"=&d\" ((LONG)(%s)) : \"dmi\" ((LONG)(%s)) : \"cc\");\n",
  907.                value, src);
  908.         break;
  909.      case sz_unknown:
  910.         abort();
  911.     }
  912.     printf("\tregflags = m68k_flag_lookup[ccr&15];\n");
  913.     printf("\tregs.x = CFLG; }\n");
  914.     return;
  915.  
  916.      case flag_cmp:
  917.         printf("\t{ WORD ccr;\n");
  918.     switch (size) {
  919.      case sz_byte:
  920.         if(strcmp(dst,"0")!=0)
  921.          printf("\t__asm__(\" movb %%3,%%1; subb %%2,%%1; movw ccr,%%0\""
  922.                ": \"=d\" (ccr), \"=&d\" ((BYTE)(%s)) : \"dmi\" ((BYTE)(%s)), \"dmi\" ((BYTE)(%s)) : \"cc\");\n",
  923.                value, src, dst);
  924.         else
  925.          printf("\t__asm__(\" movb %%2,%%1; negb %%1; movw ccr,%%0\""
  926.                ": \"=d\" (ccr), \"=&d\" ((BYTE)(%s)) : \"dmi\" ((BYTE)(%s)) : \"cc\");\n",
  927.                value, src);
  928.         break;
  929.      case sz_word:
  930.         if(strcmp(dst,"0")!=0)
  931.          printf("\t__asm__(\" movw %%3,%%1; subw %%2,%%1; movw ccr,%%0\""
  932.                ": \"=d\" (ccr), \"=&d\" ((WORD)(%s)) : \"dmi\" ((WORD)(%s)), \"dmi\" ((WORD)(%s)) : \"cc\");\n",
  933.                value, src, dst);
  934.         else
  935.          printf("\t__asm__(\" movw %%2,%%1; negw %%1; movw ccr,%%0\""
  936.                ": \"=d\" (ccr), \"=&d\" ((WORD)(%s)) : \"dmi\" ((WORD)(%s)) : \"cc\");\n",
  937.                value, src);
  938.         break;
  939.      case sz_long:
  940.         if(strcmp(dst,"0")!=0)
  941.          printf("\t__asm__(\" movl %%3,%%1; subl %%2,%%1; movw ccr,%%0\""
  942.                ": \"=d\" (ccr), \"=&d\" ((LONG)(%s)) : \"dmi\" ((LONG)(%s)), \"dmi\" ((LONG)(%s)) : \"cc\");\n",
  943.                value, src, dst);
  944.         else
  945.          printf("\t__asm__(\" movl %%2,%%1; negl %%1; movw ccr,%%0\""
  946.                ": \"=d\" (ccr), \"=&d\" ((LONG)(%s)) : \"dmi\" ((LONG)(%s)) : \"cc\");\n",
  947.                value, src);
  948.         break;
  949.      case sz_unknown:
  950.         abort();
  951.     }
  952.     printf("\tregflags = m68k_flag_lookup[ccr&15]; }\n");
  953.     return;
  954.     }
  955. #endif
  956.     genflags_normal(type, size, value, src, dst);
  957. }
  958. static void gen_opcode(unsigned long int opcode) 
  959. {
  960.     start_brace ();
  961.     switch (table68k[opcode].plev) {
  962.      case 0: /* not priviledged */
  963.     break;
  964.      case 1: /* unpriviledged only on 68000 */
  965.     if (CPU_LEVEL == 0)
  966.         break;
  967.      case 2: /* priviledged */
  968.     printf("if (!regs.s) { regs.pc_p--; Exception(8); } else\n");
  969.     start_brace();
  970.     break;
  971.      case 3: /* priviledged if size == word */
  972.     if (table68k[opcode].size == sz_byte)
  973.         break;
  974.     printf("if (!regs.s) { regs.pc_p--; Exception(8); } else\n");
  975.     start_brace();
  976.     break;
  977.     }
  978.     switch(table68k[opcode].mnemo) {
  979.      case i_OR:
  980.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  981.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  982.     printf("\tsrc |= dst;\n");
  983.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  984.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  985.     break;
  986.      case i_AND:
  987.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  988.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  989.     printf("\tsrc &= dst;\n");
  990.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  991.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  992.     break;
  993.      case i_EOR:
  994.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  995.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  996.     printf("\tsrc ^= dst;\n");
  997.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  998.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  999.     break;
  1000.      case i_ORSR:
  1001.     printf("\tMakeSR();\n");
  1002.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1003.     if (table68k[opcode].size == sz_byte) {
  1004.         printf("\tsrc &= 0xFF;\n");
  1005.     }
  1006.     printf("\tregs.sr |= src;\n");
  1007.     printf("\tMakeFromSR();\n");
  1008.     break;
  1009.      case i_ANDSR:     
  1010.     printf("\tMakeSR();\n");
  1011.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1012.     if (table68k[opcode].size == sz_byte) {
  1013.         printf("\tsrc |= 0xFF00;\n");
  1014.     }
  1015.     printf("\tregs.sr &= src;\n");
  1016.     printf("\tMakeFromSR();\n");
  1017.     break;
  1018.      case i_EORSR:
  1019.     printf("\tMakeSR();\n");
  1020.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1021.     if (table68k[opcode].size == sz_byte) {
  1022.         printf("\tsrc &= 0xFF;\n");
  1023.     }
  1024.     printf("\tregs.sr ^= src;\n");
  1025.     printf("\tMakeFromSR();\n");
  1026.     break;
  1027.      case i_SUB: 
  1028.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1029.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1030.     start_brace ();
  1031.     genflags(flag_sub, table68k[opcode].size, "newv", "src", "dst");
  1032.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1033.     break;
  1034.      case i_SUBA:
  1035.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1036.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1037.     start_brace ();
  1038.     printf("\tULONG newv = dst - src;\n");
  1039.     genastore("newv", table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1040.     break;
  1041.      case i_SUBX:
  1042.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1043.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1044.     start_brace ();
  1045.     printf("\tULONG newv = dst - src - (regs.x ? 1 : 0);\n");
  1046.     genflags(flag_subx, table68k[opcode].size, "newv", "src", "dst");
  1047.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1048.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1049.     break;
  1050.      case i_SBCD:
  1051.     /* Let's hope this works... */
  1052.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1053.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1054.     start_brace ();
  1055.     printf("\tUWORD newv_lo = (dst & 0xF) - (src & 0xF) - regs.x;\n");
  1056.     printf("\tUWORD newv_hi = (dst & 0xF0) - (src & 0xF0);\n");
  1057.     printf("\tUWORD newv;\n");
  1058.     printf("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
  1059.     printf("\tnewv = newv_hi + (newv_lo & 0xF);");
  1060.     printf("\tCFLG = regs.x = (newv_hi & 0x1F0) > 0x90;\n");
  1061.     printf("\tif (CFLG) newv -= 0x60;\n");
  1062.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");    
  1063.     genflags(flag_sv, table68k[opcode].size, "newv", "src", "dst");        
  1064.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1065.     break;
  1066.      case i_ADD:
  1067.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1068.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1069.     start_brace ();
  1070.     genflags(flag_add, table68k[opcode].size, "newv", "src", "dst");
  1071.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1072.     break;
  1073.      case i_ADDA: 
  1074.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1075.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1076.     start_brace ();
  1077.     printf("\tULONG newv = dst + src;\n");
  1078.     genastore("newv", table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1079.     break;
  1080.      case i_ADDX:
  1081.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1082.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1083.     start_brace ();
  1084.     printf("\tULONG newv = dst + src + (regs.x ? 1 : 0);\n");
  1085.     genflags(flag_addx, table68k[opcode].size, "newv", "src", "dst");
  1086.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1087.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1088.     break;
  1089.      case i_ABCD:
  1090.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1091.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1092.     start_brace ();
  1093.     printf("\tUWORD newv_lo = (src & 0xF) + (dst & 0xF) + regs.x;\n");
  1094.     printf("\tUWORD newv_hi = (src & 0xF0) + (dst & 0xF0);\n");
  1095.     printf("\tUWORD newv;\n");
  1096.     printf("\tif (newv_lo > 9) { newv_lo +=6; }\n");
  1097.     printf("\tnewv = newv_hi + newv_lo;");
  1098.     printf("\tCFLG = regs.x = (newv & 0x1F0) > 0x90;\n");
  1099.     printf("\tif (CFLG) newv += 0x60;\n");
  1100.     genflags(flag_zn, table68k[opcode].size, "newv", "", "");
  1101.     genflags(flag_sv, table68k[opcode].size, "newv", "src", "dst");    
  1102.     genastore("newv", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1103.     break;
  1104.      case i_NEG:
  1105.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1106.     start_brace ();
  1107.     genflags(flag_sub, table68k[opcode].size, "dst", "src", "0");
  1108.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1109.     break;
  1110.      case i_NEGX:
  1111.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1112.     start_brace ();
  1113.     printf("\tsrc += regs.x;\n");
  1114.     genflags(flag_sub, table68k[opcode].size, "dst", "src", "0");
  1115.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1116.     break;
  1117.      case i_NBCD: 
  1118.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1119.     start_brace ();
  1120.     printf("\tUWORD newv_lo = - (src & 0xF) - regs.x;\n");
  1121.     printf("\tUWORD newv_hi = - (src & 0xF0);\n");
  1122.     printf("\tUWORD newv;\n");
  1123.     printf("\tif (newv_lo > 9) { newv_lo-=6; newv_hi-=0x10; }\n");
  1124.     printf("\tnewv = newv_hi + (newv_lo & 0xF);");
  1125.     printf("\tCFLG = regs.x = (newv_hi & 0x1F0) > 0x90;\n");
  1126.     printf("\tif (CFLG) newv -= 0x60;\n");
  1127.     printf("\tif (newv != 0) ZFLG = 0;\n");
  1128.     genastore("newv", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1129.     break;
  1130.      case i_CLR: 
  1131.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1132.     genflags(flag_logical, table68k[opcode].size, "0", "", "");
  1133.     genastore("0",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1134.     break;
  1135.      case i_NOT: 
  1136.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1137.     start_brace ();
  1138.     printf("\tULONG dst = ~src;\n");
  1139.     genflags(flag_logical, table68k[opcode].size, "dst", "", "");
  1140.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1141.     break;
  1142.      case i_TST:
  1143.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1144.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  1145.     break;
  1146.      case i_BTST:
  1147.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1148.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1149.     if (table68k[opcode].size == sz_byte)
  1150.         printf("\tsrc &= 7;\n");
  1151.     else
  1152.         printf("\tsrc &= 31;\n");
  1153.     printf("\tZFLG = !(dst & (1 << src));\n");
  1154.     break;
  1155.      case i_BCHG:
  1156.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1157.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1158.     if (table68k[opcode].size == sz_byte)
  1159.         printf("\tsrc &= 7;\n");
  1160.     else
  1161.         printf("\tsrc &= 31;\n");
  1162.     printf("\tZFLG = !(dst & (1 << src));\n");
  1163.     printf("\tdst ^= (1 << src);\n");
  1164.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1165.     break;
  1166.      case i_BCLR:
  1167.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1168.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1169.     if (table68k[opcode].size == sz_byte)
  1170.         printf("\tsrc &= 7;\n");
  1171.     else
  1172.         printf("\tsrc &= 31;\n");
  1173.     printf("\tZFLG = !(dst & (1 << src));\n");
  1174.     printf("\tdst &= ~(1 << src);\n");
  1175.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1176.     break;
  1177.      case i_BSET:
  1178.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1179.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1180.     if (table68k[opcode].size == sz_byte)
  1181.         printf("\tsrc &= 7;\n");
  1182.     else
  1183.         printf("\tsrc &= 31;\n");
  1184.     printf("\tZFLG = !(dst & (1 << src));\n");
  1185.     printf("\tdst |= (1 << src);\n");
  1186.     genastore("dst", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1187.     break;
  1188.      case i_CMPM:
  1189.      case i_CMP:
  1190.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1191.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1192.     start_brace ();
  1193.     genflags(flag_cmp, table68k[opcode].size, "newv", "src", "dst");
  1194.     break;
  1195.      case i_CMPA: 
  1196.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1197.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1198.     start_brace ();
  1199.     genflags(flag_cmp, sz_long, "newv", "src", "dst");
  1200.     break;
  1201.     /* The next two are coded a little unconventional, but they are doing
  1202.      * weird things... */
  1203.      case i_MVPRM:
  1204.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1205.     printf("\tCPTR memp = regs.a[dstreg] + nextiword();\n");
  1206.     if (table68k[opcode].size == sz_word) {
  1207.         printf("\tput_byte(memp, src >> 8); put_byte(memp + 2, src);\n");
  1208.     } else {
  1209.         printf("\tput_byte(memp, src >> 24); put_byte(memp + 2, src >> 16);\n");
  1210.         printf("\tput_byte(memp + 4, src >> 8); put_byte(memp + 6, src);\n");
  1211.     }
  1212.     break;
  1213.      case i_MVPMR: 
  1214.     printf("\tCPTR memp = regs.a[srcreg] + nextiword();\n");
  1215.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
  1216.     if (table68k[opcode].size == sz_word) {
  1217.         printf("\tUWORD val = (get_byte(memp) << 8) + get_byte(memp + 2);\n");
  1218.     } else {
  1219.         printf("\tULONG val = (get_byte(memp) << 24) + (get_byte(memp + 2) << 16)\n");
  1220.         printf("              + (get_byte(memp + 4) << 8) + get_byte(memp + 6);\n");
  1221.     }
  1222.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1223.     break;
  1224.      case i_MOVE:
  1225.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1226.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
  1227.     genflags(flag_logical, table68k[opcode].size, "src", "", "");
  1228.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1229.     break;
  1230.      case i_MOVEA:
  1231.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1232.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
  1233.     genastore("src", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1234.     break;
  1235.      case i_MVSR2: 
  1236.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1237.     printf("\tMakeSR();\n");
  1238.     genastore("regs.sr", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1239.     break;
  1240.      case i_MV2SR:
  1241.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1242.     if (table68k[opcode].size == sz_byte)
  1243.         printf("\tMakeSR();\n\tregs.sr &= 0xFF00;\n\tregs.sr |= src & 0xFF;\n");
  1244.     else {            
  1245.         printf("\tregs.sr = src;\n");
  1246.     }
  1247.     printf("\tMakeFromSR();\n");
  1248.     break;
  1249.      case i_SWAP: 
  1250.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1251.     start_brace ();
  1252.     printf("\tULONG dst = ((src >> 16)&0xFFFF) | ((src&0xFFFF)<<16);\n");
  1253.     genflags(flag_logical, table68k[opcode].size, "dst", "", "");
  1254.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1255.     break;
  1256.      case i_EXG:
  1257.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1258.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1259.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1260.     genastore("src",table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1261.     break;
  1262.      case i_EXT:
  1263.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1264.     start_brace ();
  1265.     switch(table68k[opcode].size) {
  1266.      case sz_word: printf("\tULONG dst = (LONG)(BYTE)src;\n"); break;
  1267.      case sz_long: printf("\tULONG dst = (LONG)(WORD)src;\n"); break;
  1268.      default: abort();
  1269.     }
  1270.     genflags(flag_logical, table68k[opcode].size, "dst", "", "");
  1271.     genastore("dst",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1272.     break;
  1273.      case i_MVMEL:
  1274.     genmovemel(opcode);
  1275.     break;
  1276.      case i_MVMLE:
  1277.     genmovemle(opcode);
  1278.     break;
  1279.      case i_TRAP:
  1280.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1281.     printf("\tException(src+32);\n");
  1282.     break;
  1283.      case i_MVR2USP:
  1284.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1285.     printf("\tregs.usp = src;\n");
  1286.     break;
  1287.      case i_MVUSP2R: 
  1288.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1289.     genastore("regs.usp", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1290.     break;
  1291.      case i_RESET:
  1292.     printf("\tcustomreset();\n");
  1293.     break;
  1294.      case i_NOP:
  1295.     break;
  1296.      case i_STOP:
  1297.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1298.     printf("\tregs.sr = src;\n");
  1299.     printf("\tMakeFromSR();\n");
  1300.     printf("\tm68k_setstopped(1);\n");
  1301.     break;
  1302.      case i_RTE:
  1303.     genamode(Aipi, "7", sz_word, "sr", 1, 0);
  1304.     genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1305.     if (CPU_LEVEL > 0) {
  1306.         genamode(Aipi, "7", sz_word, "format", 1, 0);
  1307.     }
  1308.     printf("\tregs.sr = sr; m68k_setpc(pc);\n");
  1309.     if (CPU_LEVEL > 0) {
  1310.         printf("\tif ((format & 0xF000) == 0x8000) regs.a[7] += 50;\n");
  1311.     }
  1312.     printf("\tMakeFromSR();\n");
  1313.     break;
  1314.      case i_RTD:
  1315.     break;
  1316.      case i_LINK:
  1317.     genamode(Apdi, "7", sz_long, "old", 0, 0);
  1318.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1319.     genastore("src", Apdi, "7", sz_long, "old");
  1320.     genastore("regs.a[7]", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1321.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "offs", 1, 0);
  1322.     printf("\tregs.a[7] += offs;\n");
  1323.     break;
  1324.      case i_UNLK:
  1325.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1326.     printf("\tregs.a[7] = src;\n");
  1327.     genamode(Aipi, "7", sz_long, "old", 1, 0);
  1328.     genastore("old", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1329.     break;
  1330.      case i_RTS:
  1331.     genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1332.     printf("\tm68k_setpc(pc);\n");
  1333.     break;
  1334.      case i_TRAPV:
  1335.     printf("\tif(VFLG) Exception(7);\n");
  1336.     break;
  1337.      case i_RTR: 
  1338.     printf("\tMakeSR();\n");
  1339.     genamode(Aipi, "7", sz_word, "sr", 1, 0);
  1340.     genamode(Aipi, "7", sz_long, "pc", 1, 0);
  1341.     printf("\tregs.sr &= 0xFF00; sr &= 0xFF;\n");
  1342.     printf("\tregs.sr |= sr; m68k_setpc(pc);\n");
  1343.     printf("\tMakeFromSR();\n");
  1344.     break;
  1345.      case i_JSR:
  1346.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1347.     genamode(Apdi, "7", sz_long, "sp", 0, 0);
  1348.     genastore("m68k_getpc()", Apdi, "7", sz_long, "sp");
  1349.     printf("\tm68k_setpc(srca);\n");
  1350.     break;
  1351.      case i_JMP: 
  1352.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1353.     printf("\tm68k_setpc(srca);\n");
  1354.     break;
  1355.      case i_BSR:
  1356.     printf("\tchar *oldpcp = (char *)regs.pc_p;\n");
  1357.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1358.     genamode(Apdi, "7", sz_long, "sp", 0, 0);
  1359.     genastore("m68k_getpc()", Apdi, "7", sz_long, "sp");
  1360. #ifndef NO_EXCEPTION_3
  1361.     printf("\tif (src & 1) Exception(3); else\n");
  1362. #endif
  1363.     printf("\tregs.pc_p = (UWORD *)(oldpcp + (LONG)src);\n");
  1364.     break;
  1365.      case i_Bcc:
  1366.     printf("\tchar *oldpcp = (char *)regs.pc_p;\n");
  1367.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1368.     printf("\tif (cctrue(%d)) {\n", table68k[opcode].cc);
  1369. #ifndef NO_EXCEPTION_3
  1370.     printf("\t\tif (src & 1) Exception(3); else\n");
  1371. #endif
  1372.     printf("\t\tregs.pc_p = (UWORD *)(oldpcp + (LONG)src);\n");
  1373.     printf("\t}\n");
  1374.     break;
  1375.      case i_LEA:
  1376.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1377.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 0, 0);
  1378.     genastore("srca", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1379.     break;
  1380.      case i_PEA:
  1381.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1382.     genamode(Apdi, "7", sz_long, "dst", 0, 0);
  1383.     genastore("srca", Apdi, "7", sz_long, "dst");
  1384.     break;
  1385.      case i_DBcc:
  1386.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1387.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "offs", 1, 0);
  1388.     printf("\tif (!cctrue(%d)) {\n", table68k[opcode].cc);
  1389.     printf("\tif (src--) regs.pc_p = (UWORD *)((char *)regs.pc_p + (LONG)offs - 2);\n");
  1390.     genastore("src", table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1391.     printf("\t}\n");
  1392.     break;
  1393.      case i_Scc: 
  1394.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 0, 0);
  1395.     start_brace ();
  1396.     printf("\tint val = cctrue(%d) ? 0xff : 0;\n", table68k[opcode].cc);
  1397.     genastore("val",table68k[opcode].smode, "srcreg", table68k[opcode].size, "src");
  1398.     break;
  1399.      case i_DIVU:
  1400.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1401.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1402.     printf("\tif(src != 0){\n");
  1403.     printf("\tULONG newv = (ULONG)dst / (UWORD)src;\n");
  1404.     printf("\tULONG rem = (ULONG)dst %% (UWORD)src;\n");
  1405.     /* The N flag appears to be set each time there is an overflow.
  1406.      * Weird. */
  1407.     printf("\tif (newv > 0xffff) { VFLG = NFLG = 1; } else\n\t{\n");
  1408.     genflags(flag_logical, sz_word, "newv", "", "");
  1409.     printf("\tnewv = (newv & 0xffff) | ((ULONG)rem << 16);\n");
  1410.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1411.     printf("\t}\n");
  1412.     printf("\t}\n");
  1413.     break;
  1414.      case i_DIVS: 
  1415.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1416.     genamode(table68k[opcode].dmode, "dstreg", sz_long, "dst", 1, 0);
  1417.     printf("\tif(src != 0){\n");
  1418.     printf("\tLONG newv = (LONG)dst / (WORD)src;\n");
  1419.     printf("\tUWORD rem = (LONG)dst %% (WORD)src;\n");
  1420.     printf("\tif ((newv & 0xffff0000) && (newv & 0xffff0000) != 0xffff0000) { VFLG = NFLG = 1; } else\n\t{\n");
  1421.     printf("\tif (((WORD)rem < 0) != ((LONG)dst < 0)) rem = -rem;\n");
  1422.     genflags(flag_logical, sz_word, "newv", "", "");
  1423.     printf("\tnewv = (newv & 0xffff) | ((ULONG)rem << 16);\n");
  1424.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1425.     printf("\t}\n");
  1426.     printf("\t}\n");
  1427.     break;
  1428.      case i_MULU: 
  1429.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1430.     genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
  1431.     start_brace ();
  1432.     printf("\tULONG newv = (ULONG)(UWORD)dst * (ULONG)(UWORD)src;\n");
  1433.     genflags(flag_logical, sz_long, "newv", "", "");
  1434.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1435. #ifdef WANT_SLOW_MULTIPLY
  1436.     printf("\tspecialflags |= SPCFLAG_EXTRA_CYCLES;\n");
  1437. #endif
  1438.     break;
  1439.      case i_MULS:
  1440.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1441.     genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
  1442.     start_brace ();
  1443.     printf("\tULONG newv = (LONG)(WORD)dst * (LONG)(WORD)src;\n");
  1444.     genflags(flag_logical, sz_long, "newv", "", "");
  1445.     genastore("newv",table68k[opcode].dmode, "dstreg", sz_long, "dst");
  1446. #ifdef WANT_SLOW_MULTIPLY
  1447.     printf("\tspecialflags |= SPCFLAG_EXTRA_CYCLES;\n");
  1448. #endif
  1449.     break;
  1450.      case i_CHK:
  1451.     genamode(table68k[opcode].smode, "srcreg", sz_word, "src", 1, 0);
  1452.     genamode(table68k[opcode].dmode, "dstreg", sz_word, "dst", 1, 0);
  1453.     printf("\tif ((WORD)dst < 0) { NFLG=1; Exception(6); }\n");
  1454.     printf("\telse if ((WORD)dst > (WORD)src) { NFLG=0; Exception(6); }\n");
  1455.     break;
  1456.     
  1457.      case i_ASR: 
  1458.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1459.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1460.     start_brace ();
  1461.     switch(table68k[opcode].size) {
  1462.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1463.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1464.      case sz_long: printf("\tULONG val = data;\n"); break;
  1465.      default: abort();
  1466.     }
  1467.     switch(table68k[opcode].size) {
  1468.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1469.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1470.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1471.      default: abort();
  1472.     }
  1473.     printf("\tULONG sign = cmask & val;\n");
  1474.     printf("\tcnt &= 63;\n");
  1475.     printf("\tVFLG = 0;\n");
  1476.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1477.     printf("\tfor(;cnt;--cnt){\n");
  1478.     printf("\tCFLG=regs.x=val&1; val = ((ULONG)val >> 1) | sign;\n");
  1479.     printf("\t}}\n\tNFLG = sign != 0;\n");
  1480.     printf("\tZFLG = val == 0;\n");
  1481.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1482.     break;
  1483.      case i_ASL:
  1484.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1485.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1486.     start_brace ();
  1487.     switch(table68k[opcode].size) {
  1488.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1489.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1490.      case sz_long: printf("\tULONG val = data;\n"); break;
  1491.      default: abort();
  1492.     }
  1493.     switch(table68k[opcode].size) {
  1494.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1495.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1496.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1497.      default: abort();
  1498.     }
  1499.     printf("\tULONG sign = cmask & val;\n");
  1500.     printf("\tcnt &= 63;\n");
  1501.     printf("\tVFLG = 0;\n");
  1502.     printf("\tif (!cnt) { CFLG = 0; } else { ");
  1503.     printf("\tfor(;cnt;--cnt){\n");
  1504.     printf("\tCFLG=regs.x=(val&cmask)!=0; val <<= 1;\n");
  1505.     printf("\tif ((val&cmask)!=sign)VFLG=1;\n");
  1506.     printf("\t}}\n\tNFLG = (val&cmask) != 0;\n");
  1507.     printf("\tZFLG = val == 0;\n");
  1508.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1509.     break;
  1510.      case i_LSR:
  1511.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1512.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1513.     start_brace ();
  1514.     switch(table68k[opcode].size) {
  1515.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1516.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1517.      case sz_long: printf("\tULONG val = data;\n"); break;
  1518.      default: abort();
  1519.     }
  1520.     switch(table68k[opcode].size) {
  1521.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1522.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1523.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1524.      default: abort();
  1525.     }
  1526.     printf("\tcnt &= 63;\n");
  1527.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1528.     printf("\tint carry = 0;\n");
  1529.     printf("\tfor(;cnt;--cnt){\n");
  1530.     printf("\tcarry=val&1; val >>= 1;\n");
  1531.     printf("\t}\n");
  1532.     printf("\tCFLG = regs.x = carry!=0;\n}\n");
  1533.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1534.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");    
  1535.     break;
  1536.      case i_LSL:
  1537.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1538.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1539.     start_brace ();
  1540.     switch(table68k[opcode].size) {
  1541.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1542.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1543.      case sz_long: printf("\tULONG val = data;\n"); break;
  1544.      default: abort();
  1545.     }
  1546.     switch(table68k[opcode].size) {
  1547.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1548.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1549.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1550.      default: abort();
  1551.     }
  1552.     printf("\tint carry = 0;\n");
  1553.     printf("\tcnt &= 63;\n");
  1554.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1555.     printf("\tfor(;cnt;--cnt){\n");
  1556.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1557.     printf("\t}\n");
  1558.     printf("\tCFLG = regs.x = carry!=0;\n}\n");
  1559.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1560.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1561.     break;
  1562.      case i_ROL:
  1563.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1564.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1565.     start_brace ();
  1566.     switch(table68k[opcode].size) {
  1567.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1568.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1569.      case sz_long: printf("\tULONG val = data;\n"); break;
  1570.      default: abort();
  1571.     }
  1572.     switch(table68k[opcode].size) {
  1573.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1574.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1575.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1576.      default: abort();
  1577.     }
  1578.     printf("\tint carry = 0;\n");
  1579.     printf("\tcnt &= 63;\n");    
  1580.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1581.     printf("\tfor(;cnt;--cnt){\n");
  1582.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1583.     printf("\tif(carry)  val |= 1;\n");
  1584.     printf("\t}\n");
  1585.     printf("\tCFLG = carry!=0;\n}\n");
  1586.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1587.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1588.     break;
  1589.      case i_ROR:
  1590.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1591.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1592.     start_brace ();
  1593.     switch(table68k[opcode].size) {
  1594.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1595.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1596.      case sz_long: printf("\tULONG val = data;\n"); break;
  1597.      default: abort();
  1598.     }
  1599.     switch(table68k[opcode].size) {
  1600.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1601.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1602.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1603.      default: abort();
  1604.     }
  1605.     printf("\tint carry = 0;\n");    
  1606.     printf("\tcnt &= 63;\n");
  1607.     printf("\tif (!cnt) { CFLG = 0; } else {");
  1608.     printf("\tfor(;cnt;--cnt){\n");
  1609.     printf("\tcarry=val&1; val = (ULONG)val >> 1;\n");
  1610.     printf("\tif(carry) val |= cmask;\n");
  1611.     printf("\t}\n");
  1612.     printf("\tCFLG = carry!=0;\n}\n");
  1613.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1614.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1615.     break;
  1616.      case i_ROXL: 
  1617.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1618.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1619.     start_brace ();
  1620.     switch(table68k[opcode].size) {
  1621.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1622.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1623.      case sz_long: printf("\tULONG val = data;\n"); break;
  1624.      default: abort();
  1625.     }
  1626.     switch(table68k[opcode].size) {
  1627.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1628.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1629.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1630.      default: abort();
  1631.     }
  1632.     printf("\tint carry = 0;\n");
  1633.     printf("\tcnt &= 63;\n");
  1634.     printf("\tfor(;cnt;--cnt){\n");
  1635.     printf("\tcarry=val&cmask; val <<= 1;\n");
  1636.     printf("\tif(regs.x) val |= 1;\n");    
  1637.     printf("\tregs.x = carry != 0;\n");
  1638.     printf("\t}\n");
  1639.     printf("\tCFLG = regs.x;\n");
  1640.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1641.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1642.     break;
  1643.      case i_ROXR:
  1644.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "cnt", 1, 0);
  1645.     genamode(table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data", 1, 0);
  1646.     start_brace ();
  1647.     switch(table68k[opcode].size) {
  1648.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1649.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1650.      case sz_long: printf("\tULONG val = data;\n"); break;
  1651.      default: abort();
  1652.     }
  1653.     switch(table68k[opcode].size) {
  1654.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1655.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1656.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1657.      default: abort();
  1658.     }
  1659.     printf("\tint carry = 0;\n");
  1660.     printf("\tcnt &= 63;\n");
  1661.     printf("\tfor(;cnt;--cnt){\n");
  1662.     printf("\tcarry=val&1; val >>= 1;\n");
  1663.     printf("\tif(regs.x) val |= cmask;\n");
  1664.     printf("\tregs.x = carry != 0;\n");
  1665.     printf("\t}\n");
  1666.     printf("\tCFLG = regs.x;\n");
  1667.     printf("\tNFLG = (val & cmask) != 0; ZFLG = val == 0; VFLG = 0;\n");
  1668.     genastore("val", table68k[opcode].dmode, "dstreg", table68k[opcode].size, "data");
  1669.     break;
  1670.      case i_ASRW:
  1671.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1672.     printf("\tVFLG = 0;\n");
  1673.     start_brace ();
  1674.     switch(table68k[opcode].size) {
  1675.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1676.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1677.      case sz_long: printf("\tULONG val = data;\n"); break;
  1678.      default: abort();
  1679.     }
  1680.     switch(table68k[opcode].size) {
  1681.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1682.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1683.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1684.      default: abort();
  1685.     }
  1686.     printf("\tULONG sign = cmask & val;\n");
  1687.     printf("\tCFLG=regs.x=val&1; val = (val >> 1) | sign;\n");
  1688.     printf("\tNFLG = sign != 0;\n");
  1689.     printf("\tZFLG = val == 0;\n");
  1690.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1691.     break;
  1692.      case i_ASLW:
  1693.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1694.     printf("\tVFLG = 0;\n");
  1695.     start_brace ();
  1696.     switch(table68k[opcode].size) {
  1697.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1698.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1699.      case sz_long: printf("\tULONG val = data;\n"); break;
  1700.      default: abort();
  1701.     }
  1702.     switch(table68k[opcode].size) {
  1703.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1704.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1705.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1706.      default: abort();
  1707.     }
  1708.     printf("\tULONG sign = cmask & val;\n");
  1709.     printf("\tCFLG=regs.x=(val&cmask)!=0; val <<= 1;\n");
  1710.     printf("\tif ((val&cmask)!=sign) VFLG=1;\n");
  1711.     printf("\tNFLG = (val&cmask) != 0;\n");
  1712.     printf("\tZFLG = val == 0;\n");
  1713.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1714.     break;
  1715.      case i_LSRW:
  1716.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1717.     start_brace ();
  1718.     switch(table68k[opcode].size) {
  1719.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1720.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1721.      case sz_long: printf("\tULONG val = data;\n"); break;
  1722.      default: abort();
  1723.     }
  1724.     printf("\tint carry = val&1;\n");
  1725.     printf("\tcarry=val&1; val >>= 1;\n");
  1726.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1727.     printf("CFLG = regs.x = carry!=0;\n");
  1728.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1729.     break;
  1730.      case i_LSLW:
  1731.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1732.     start_brace ();
  1733.     switch(table68k[opcode].size) {
  1734.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1735.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1736.      case sz_long: printf("\tULONG val = data;\n"); break;
  1737.      default: abort();
  1738.     }
  1739.     switch(table68k[opcode].size) {
  1740.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1741.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1742.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1743.      default: abort();
  1744.     }
  1745.     printf("\tint carry = val&cmask;\n");
  1746.     printf("\tval <<= 1;\n");
  1747.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1748.     printf("CFLG = regs.x = carry!=0;\n");
  1749.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1750.     break;
  1751.      case i_ROLW:
  1752.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1753.     start_brace ();
  1754.     switch(table68k[opcode].size) {
  1755.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1756.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1757.      case sz_long: printf("\tULONG val = data;\n"); break;
  1758.      default: abort();
  1759.     }
  1760.     switch(table68k[opcode].size) {
  1761.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1762.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1763.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1764.      default: abort();
  1765.     }
  1766.     printf("\tint carry = val&cmask;\n");
  1767.     printf("\tval <<= 1;\n");
  1768.     printf("\tif(carry)  val |= 1;\n");
  1769.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1770.     printf("CFLG = carry!=0;\n");
  1771.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1772.     break;
  1773.      case i_RORW:
  1774.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1775.     start_brace ();
  1776.     switch(table68k[opcode].size) {
  1777.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1778.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1779.      case sz_long: printf("\tULONG val = data;\n"); break;
  1780.      default: abort();
  1781.     }
  1782.     printf("\tint carry = val&1;\n");
  1783.     switch(table68k[opcode].size) {
  1784.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1785.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1786.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1787.      default: abort();
  1788.     }
  1789.     printf("\tval >>= 1;\n");
  1790.     printf("\tif(carry) val |= cmask;\n");
  1791.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1792.     printf("CFLG = carry!=0;\n");
  1793.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1794.     break;
  1795.      case i_ROXLW:
  1796.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1797.     start_brace ();
  1798.     switch(table68k[opcode].size) {
  1799.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1800.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1801.      case sz_long: printf("\tULONG val = data;\n"); break;
  1802.      default: abort();
  1803.     }
  1804.     switch(table68k[opcode].size) {
  1805.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1806.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1807.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1808.      default: abort();
  1809.     }
  1810.     printf("\tint carry = val&cmask;\n");
  1811.     printf("\tval <<= 1;\n");
  1812.     printf("\tif(regs.x) val |= 1;\n");
  1813.     printf("\tregs.x = carry != 0;\n");
  1814.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1815.     printf("regs.x = CFLG = carry!=0;\n");
  1816.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1817.     break;
  1818.      case i_ROXRW:
  1819.     genamode(table68k[opcode].smode, "srcreg", table68k[opcode].size, "data", 1, 0);
  1820.     start_brace ();
  1821.     switch(table68k[opcode].size) {
  1822.      case sz_byte: printf("\tUBYTE val = data;\n"); break;
  1823.      case sz_word: printf("\tUWORD val = data;\n"); break;
  1824.      case sz_long: printf("\tULONG val = data;\n"); break;
  1825.      default: abort();
  1826.     }
  1827.     printf("\tint carry = val&1;\n");
  1828.     switch(table68k[opcode].size) {
  1829.      case sz_byte: printf("\tULONG cmask = 0x80;\n"); break;
  1830.      case sz_word: printf("\tULONG cmask = 0x8000;\n"); break;
  1831.      case sz_long: printf("\tULONG cmask = 0x80000000;\n"); break;
  1832.      default: abort();
  1833.     }
  1834.     printf("\tval >>= 1;\n");
  1835.     printf("\tif(regs.x) val |= cmask;\n");
  1836.     printf("\tregs.x = carry != 0;\n");
  1837.     genflags(flag_logical, table68k[opcode].size, "val", "", "");
  1838.     printf("regs.x = CFLG = carry!=0;\n");
  1839.     genastore("val", table68k[opcode].smode, "srcreg", table68k[opcode].size, "data");
  1840.     break;
  1841.      case i_MOVEC2:
  1842.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1843.     start_brace();
  1844.     printf("\tint regno = (src >> 12) & 7;\n");
  1845.     printf("\tULONG *regp = src & 0x8000 ? regs.a + regno : regs.d + regno;\n");
  1846.     printf("\tm68k_movec2(src & 0xFFF, regp);\n");
  1847.     break;
  1848.      case i_MOVE2C:
  1849.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1850.     start_brace();
  1851.     printf("\tint regno = (src >> 12) & 7;\n");
  1852.     printf("\tULONG *regp = src & 0x8000 ? regs.a + regno : regs.d + regno;\n");
  1853.     printf("\tm68k_move2c(src & 0xFFF, regp);\n");
  1854.     break;
  1855.      case i_CAS:
  1856.     {
  1857.         int old_brace_level;
  1858.         genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "src", 1, 0);
  1859.         genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1860.         start_brace();
  1861.         printf("\tint ru = (src >> 6) & 7;\n");
  1862.         printf("\tint rc = src & 7;\n");
  1863.         printf("\tif ((LONG)regs.d[rc] == (LONG)dst)");
  1864.         old_brace_level = n_braces;
  1865.         start_brace ();
  1866.         genastore("(regs.d[ru])",table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst");
  1867.         pop_braces (old_brace_level);
  1868.         printf("else");
  1869.         start_brace ();
  1870.         printf("regs.d[rc] = dst;\n");
  1871.         pop_braces (old_brace_level);
  1872.     }
  1873.     break;
  1874.      case i_DIVL:
  1875.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  1876.     genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1877.     printf("\tm68k_divl(opcode, dst, extra);\n");
  1878.     break;
  1879.      case i_MULL:
  1880.     genamode (table68k[opcode].smode, "srcreg", table68k[opcode].size, "extra", 1, 0);
  1881.     genamode (table68k[opcode].dmode, "dstreg", table68k[opcode].size, "dst", 1, 0);
  1882.     printf("\tm68k_mull(opcode, dst, extra);\n");
  1883.     break;
  1884.      default:
  1885.     abort();
  1886.     break;
  1887.     };
  1888.     finish_braces ();
  1889. }
  1890.  
  1891. static void generate_func(long int from, long int to)
  1892. {
  1893.     int illg = 0;
  1894.     long int opcode;
  1895.     UWORD smsk; 
  1896.     UWORD dmsk;    
  1897.  
  1898.     printf("#include \"sysconfig.h\"\n");
  1899.     printf("#include \"sysdeps.h\"\n");
  1900.     printf("#include \"config.h\"\n");
  1901.     printf("#include \"options.h\"\n");
  1902.     printf("#include \"memory.h\"\n");
  1903.     printf("#include \"custom.h\"\n");    
  1904.     printf("#include \"newcpu.h\"\n");
  1905.     printf("#include \"cputbl.h\"\n");
  1906.     for(opcode=from; opcode < to; opcode++) {
  1907.     if (table68k[opcode].mnemo == i_ILLG) {
  1908.         illg++;
  1909.         continue;
  1910.     }
  1911.  
  1912.     if (isspecific(opcode)) {
  1913.         printf("void op_%lx_s(ULONG opcode)\n{\n", opcode);
  1914.         if (table68k[opcode].suse
  1915.         && table68k[opcode].smode != imm  && table68k[opcode].smode != imm0
  1916.         && table68k[opcode].smode != imm1 && table68k[opcode].smode != imm2
  1917.         && table68k[opcode].smode != absw && table68k[opcode].smode != absl
  1918.         && table68k[opcode].smode != PC8r && table68k[opcode].smode != PC16)
  1919.         {
  1920.         printf("\tULONG srcreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].sreg);
  1921.         }
  1922.         if (table68k[opcode].duse
  1923.         /* Yes, the dmode can be imm, in case of LINK or DBcc */
  1924.         && table68k[opcode].dmode != imm  && table68k[opcode].dmode != imm0
  1925.         && table68k[opcode].dmode != imm1 && table68k[opcode].dmode != imm2
  1926.         && table68k[opcode].dmode != absw && table68k[opcode].dmode != absl) {
  1927.         printf("\tULONG dstreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].dreg);
  1928.         }
  1929.         gen_opcode(opcode);
  1930.         printf("}\n");
  1931.     }
  1932.         
  1933.     if (table68k[opcode].handler != -1)
  1934.         continue;
  1935.  
  1936.  
  1937.     switch (table68k[opcode].stype) {
  1938.      case 0:
  1939.         smsk = 7; break;
  1940.      case 1:
  1941.         smsk = 255; break;
  1942.      case 2:
  1943.         smsk = 15; break;
  1944.      case 3:
  1945.         smsk = 7; break;
  1946.      default:
  1947.         abort();
  1948.     }
  1949.     smsk <<= table68k[opcode].spos;
  1950.     dmsk = 7 << table68k[opcode].dpos;
  1951.     
  1952.     printf("void op_%lx(ULONG opcode)\n{\n", opcode);
  1953.     if (table68k[opcode].suse
  1954.         && table68k[opcode].smode != imm  && table68k[opcode].smode != imm0
  1955.         && table68k[opcode].smode != imm1 && table68k[opcode].smode != imm2
  1956.         && table68k[opcode].smode != absw && table68k[opcode].smode != absl
  1957.         && table68k[opcode].smode != PC8r && table68k[opcode].smode != PC16)
  1958.     {
  1959.         if (table68k[opcode].spos == -1) {
  1960.         printf("\tULONG srcreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].sreg);
  1961.         } else {
  1962.         if (table68k[opcode].stype == 3)
  1963.             printf("\tULONG srcreg = imm8_table[(opcode & %d) >> %d];\n",
  1964.                smsk, (int)table68k[opcode].spos);
  1965.         else
  1966.             printf("\tULONG srcreg = (LONG)(BYTE)((opcode & %d) >> %d);\n", 
  1967.                smsk, (int)table68k[opcode].spos);
  1968.         }
  1969.     }
  1970.     if (table68k[opcode].duse
  1971.         /* Yes, the dmode can be imm, in case of LINK or DBcc */
  1972.         && table68k[opcode].dmode != imm  && table68k[opcode].dmode != imm0
  1973.         && table68k[opcode].dmode != imm1 && table68k[opcode].dmode != imm2
  1974.         && table68k[opcode].dmode != absw && table68k[opcode].dmode != absl) {
  1975.         if (table68k[opcode].dpos == -1) {        
  1976.         printf("\tULONG dstreg = (LONG)(BYTE)%d;\n", (int)table68k[opcode].dreg);
  1977.         } else {
  1978.         printf("\tULONG dstreg = (opcode & %d) >> %d;\n", dmsk, (int)table68k[opcode].dpos);
  1979.         }
  1980.     }
  1981.     gen_opcode(opcode);
  1982.         printf("}\n");
  1983.     }
  1984.  
  1985.     fprintf (stderr, "%d illegals generated.\n", illg);
  1986. }
  1987.  
  1988. static void generate_table(void)
  1989. {
  1990.     int illg = 0;
  1991.     long int opcode;
  1992.     
  1993.     printf("#include \"sysconfig.h\"\n");
  1994.     printf("#include \"sysdeps.h\"\n");
  1995.     printf("#include \"config.h\"\n");
  1996.     printf("#include \"options.h\"\n");
  1997.     printf("#include \"memory.h\"\n");
  1998.     printf("#include \"custom.h\"\n");
  1999.     printf("#include \"newcpu.h\"\n");
  2000.     printf("#include \"cputbl.h\"\n");
  2001.     
  2002.     printf("cpuop_func *cpufunctbl[65536] = {\n");
  2003.     for(opcode=0; opcode < 65536; opcode++) {
  2004.     if (table68k[opcode].mnemo == i_ILLG) {
  2005.         printf("op_illg");
  2006.         illg++;
  2007.     } else if (isspecific(opcode))
  2008.         printf("op_%lx_s", opcode);
  2009.     else if (table68k[opcode].handler != -1)
  2010.         printf("op_%lx", table68k[opcode].handler);
  2011.     else
  2012.         printf("op_%lx", opcode);
  2013.     
  2014.     if (opcode < 65535) printf(",");
  2015.     if ((opcode & 7) == 7) printf("\n");
  2016.     }
  2017.     printf("\n};\n");
  2018.     fprintf (stderr, "%d illegals generated.\n", illg);
  2019.     if (get_no_mismatches())
  2020.     fprintf(stderr, "%d mismatches.\n", get_no_mismatches());
  2021. }
  2022.  
  2023. static void generate_smalltable(void)
  2024. {
  2025.     long int opcode;
  2026.     
  2027.     printf("#include \"sysconfig.h\"\n");
  2028.     printf("#include \"sysdeps.h\"\n");
  2029.     printf("#include \"config.h\"\n");
  2030.     printf("#include \"options.h\"\n");
  2031.     printf("#include \"memory.h\"\n");
  2032.     printf("#include \"custom.h\"\n");
  2033.     printf("#include \"newcpu.h\"\n");
  2034.     printf("#include \"cputbl.h\"\n");
  2035.     
  2036.     printf("struct cputbl smallcputbl[] = {\n");
  2037.     for(opcode=0; opcode < 65536; opcode++) {
  2038.     if ((isspecific(opcode) || table68k[opcode].handler == -1)
  2039.         && table68k[opcode].mnemo != i_ILLG) 
  2040.     {
  2041.         if (isspecific(opcode))
  2042.         printf("{ op_%x_s, 1, %d },\n", opcode, opcode);
  2043.         if (table68k[opcode].handler == -1)
  2044.         printf("{ op_%x, 0, %d },\n", opcode, opcode);
  2045.     }
  2046.     }
  2047.     printf("{ 0, 0, 0 }};\n");
  2048. }
  2049.  
  2050. static void generate_header(void)
  2051. {
  2052.     int illg = 0;
  2053.     long int opcode;
  2054.     
  2055.     for(opcode=0; opcode < 65536; opcode++) {
  2056.     if (table68k[opcode].mnemo == i_ILLG) {
  2057.         illg++;
  2058.         continue;
  2059.     }
  2060.     if (isspecific(opcode))
  2061.         printf("extern cpuop_func op_%lx_s;\n", opcode);
  2062.     if (table68k[opcode].handler != -1)
  2063.         continue;
  2064.     
  2065.     printf("extern cpuop_func op_%lx;\n", opcode);
  2066.     }
  2067.     
  2068.     fprintf (stderr, "%d illegals generated.\n", illg);
  2069.     if (get_no_mismatches())
  2070.     fprintf(stderr, "%d mismatches.\n", get_no_mismatches());
  2071. }
  2072.  
  2073. int main(int argc, char **argv)
  2074. {
  2075.     long int range = -1;
  2076.     char mode = 'n';
  2077.     int i;
  2078.     
  2079.     if (argc == 2)
  2080.         mode = *argv[1];
  2081.  
  2082.     if (argc == 3) {
  2083.     range = atoi(argv[2]);
  2084.     mode = *argv[1];
  2085.     }
  2086.     
  2087.     read_table68k ();
  2088.     read_counts();
  2089.     do_merges ();
  2090.     
  2091.     switch(mode) {
  2092.      case 'f':
  2093.         generate_func(range * 0x1000, (range + 1) * 0x1000);
  2094.     break;
  2095.      case 'h':
  2096.         generate_header();
  2097.     break;
  2098.      case 't':
  2099.     generate_table();
  2100.     break;
  2101.      case 's':
  2102.     generate_smalltable();
  2103.     break;
  2104.      default:
  2105.     abort();
  2106.     }
  2107.     free(table68k);
  2108.     return 0;
  2109. }
  2110.