home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / sim / h8500 / compile.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-12  |  46.0 KB  |  2,232 lines
  1. /* Simulator for the Hitachi H8/500 architecture.
  2.  
  3.    Written by Steve Chamberlain of Cygnus Support.
  4.    sac@cygnus.com
  5.  
  6.    This file is part of H8/500 sim
  7.  
  8.  
  9.         THIS SOFTWARE IS NOT COPYRIGHTED
  10.  
  11.    Cygnus offers the following for use in the public domain.  Cygnus
  12.    makes no warranty with regard to the software or it's performance
  13.    and the user accepts the software "AS IS" with all faults.
  14.  
  15.    CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO
  16.    THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  17.    MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  18.  
  19. */
  20.  
  21. #include <signal.h>
  22. #include <sys/times.h>
  23. #include <sys/param.h>
  24.  
  25. #define O_RECOMPILE 85
  26. #define DEFINE_TABLE
  27. #define DISASSEMBLER_TABLE
  28.  
  29.  
  30. int debug;
  31.  
  32. /* This code can be compiled with any old C compiler, in which case
  33.    four or five switch statements will be executed for each
  34.    instruction simulated.  It can be compiled with GCC, then the
  35.    simulated instructions thread through the code fragments, and
  36.    everything goes much faster.
  37.  
  38.    These definitions make the code work either way
  39. */
  40. #ifdef __GNUC__
  41. #define DISPATCH(X) goto *(X); do
  42. #define LABEL(X) X##_L
  43. #define LABELN(X,N) X##_L##N
  44. #define LABEL_REF(X) &&X##_L
  45. #define LABEL_REFN(X,N) &&X##_L##N
  46. #define ENDDISPATCH while (0);
  47. #define fastref void *
  48. #define LABEL_DEC(X,Y)
  49. #define DEFAULT ;
  50. #define INLINE __inline__
  51. #else
  52. #define DEFAULT default :
  53. #define DISPATCH(X) switch (X)
  54. #define LABEL(X) case X
  55. #define LABELN(X,N) case X
  56. #define LABEL_REF(X) X
  57. #define LABEL_REFN(X,N) X
  58. #define ENDDISPATCH
  59. #define fastref int
  60. #define LABEL_DEC(X,Y) #define X Y
  61.  
  62.  
  63. #define INLINE 
  64. #define STORE_REG_B     1
  65. #define STORE_REG_W     2
  66. #define STORE_INC_B     3
  67. #define STORE_INC_W     4
  68. #define STORE_DEC_B     5
  69. #define STORE_DEC_W     6
  70. #define STORE_DISP_B     7
  71. #define STORE_DISP_W     8
  72. #define STORE_CRB     9
  73. #define STORE_CRW     10
  74. #define STORE_REG_L     11
  75. #define STORE_NOP     12
  76.  
  77. #define FETCH_NOP     9
  78. #define FETCH_REG_B     10
  79. #define FETCH_REG_W     11
  80. #define FETCH_INC_B     12
  81. #define FETCH_INC_W     13
  82. #define FETCH_DEC_B     14
  83. #define FETCH_DEC_W     15
  84. #define FETCH_DISP_B     16
  85. #define FETCH_DISP_W     17
  86. #define FETCH_IMM     18
  87. #define FETCH_CRB     19
  88. #define FETCH_CRW     20
  89. #define FETCH_LVAL     21
  90. #define FETCH_LVAL24     22
  91. #define FETCH_REG_L     23
  92.  
  93. #define FLAG_m         20
  94. #define FLAG_M         21
  95. #define FLAG_A         22
  96. #define FLAG_NONE     23
  97. #define FLAG_NOSTORE     24
  98. #define FLAG_CLEAR     25
  99. #define FLAG_a         26
  100. #define FLAG_BRANCH     27
  101. #define FLAG_special     28
  102.  
  103. #define FLAG_shiftword     29
  104. #define FLAG_shiftbyte     30
  105.  
  106. #define FLAG_multword     31
  107. #define FLAG_multbyte     32
  108. #endif
  109.  
  110.  
  111. #define h8500_table h8500_compile_table
  112. #include "../opcodes/h8500-opc.h"
  113. #include "../endian.h"
  114.  
  115. #include "inst.h"
  116.  
  117. #define LOW_BYTE(x) ((x) & 0xff)
  118. #define HIGH_BYTE(x) (((x)>>8) & 0xff)
  119. #define NORMAL_CP ((cpu.regs[R_CP].c - cpu.memory)>>16)
  120. #define NORMAL_DP ((cpu.regs[R_DP].c - cpu.memory)>>16)
  121. #define NORMAL_EP ((cpu.regs[R_EP].c - cpu.memory)>>16)
  122. #define NORMAL_TP ((cpu.regs[R_TP].c - cpu.memory)>>16)
  123. #define SET_NORMREG(x,y) ((cpu.regs[x].l = (y)))
  124. #define GET_NORMREG(x) (cpu.regs[x].l)
  125. #define SET_SEGREG(x,y) { cpu.regs[x].c = (y & 0xff0000) + cpu.memory;}
  126. #define SET_NORMAL_CPPC(x) { pc = (x) & 0xffff; SET_SEGREG(R_CP, (x));}
  127. #define NORMAL_SR ((N<<3)|(Z<<2)|(V<<1)|(C))
  128. #define P(X,Y) ((X<<8) | Y)
  129.  
  130. #define BUILDSR()   cpu.regs[R_SR].s[LOW] = (N << 3) | (Z << 2) | (V<<1) | C;
  131.  
  132. #define GETSR()            \
  133.   C = (cpu.regs[R_SR].s[LOW] >> 0) & 1;\
  134.   V = (cpu.regs[R_SR].s[LOW] >> 1) & 1;\
  135.   Z = (cpu.regs[R_SR].s[LOW] >> 2) & 1;\
  136.   N = (cpu.regs[R_SR].s[LOW] >> 3) & 1;
  137.  
  138. #ifdef __CHAR_IS_SIGNED__
  139. #define SEXTCHAR(x) ((char)(x))
  140. #endif
  141.  
  142. #ifndef SEXTCHAR
  143. #define SEXTCHAR(x) ((x & 0x80) ? (x | ~0xff):x)
  144. #endif
  145.  
  146. #define SEXTSHORT(x) ((short)(x))
  147.  
  148. /* Which segment registers go with which pointer registers */
  149. static unsigned char **segmap[R_LAST];
  150. static unsigned char *(regptr[R_LAST][3]);
  151. static unsigned char *(segregptr[R_LAST][3]);
  152. static cpu_state_type cpu;
  153.  
  154. #ifdef BIG_ENDIAN_HOST
  155. #define LOW 1
  156. #define HIGH 0
  157. #else
  158. #define LOW 0
  159. #define HIGH 1
  160. #endif
  161.  
  162. /* routines for getting and storing args */
  163. #define elval(struct, lit) \
  164.  (((*(struct.reg.wptr) + lit) & 0xffff) + (*(struct.r2.segreg)))
  165.  
  166. #define displval(s) elval((s),(s).literal)
  167.  
  168. #define ireglval(struct) elval(struct, 0)
  169. #define wordat(x) (((x)[0] << 8) | (x)[1])
  170. #define longat(x) ((wordat((x))<<16)|(wordat((x)+2)))
  171. #define byteat(x) ((x)[0])
  172.  
  173. #define setwordat(x,y) {x[0] =( y)>>8; x[1] = y;}
  174. #define setbyteat(x,y) {x[0] = y;}
  175.  
  176. /*#define setalignedwordat(x,y) {((short *)x)[0] =y;}*/
  177. /*
  178. statics
  179. */
  180.  
  181. ea_type rd;
  182. ea_type rs;
  183. ea_type imm;
  184. ea_type cr;
  185. ea_type ea;
  186. ea_type nop;
  187. ea_type lval;
  188. ea_type lval24;
  189.  
  190. ea_type eavector[2];
  191.  
  192. int disp;
  193.  
  194. #define JBYTE 0
  195. #define JWORD 1
  196. #define JLONG 2
  197.  
  198. typedef union
  199. {
  200.   struct
  201.     {
  202.       fastref srcabyte;
  203.       fastref srcaword;
  204.       fastref srcalong;
  205.  
  206.       fastref srcbbyte;
  207.       fastref srcbword;
  208.       fastref srcblong;
  209.  
  210.       fastref dstbyte;
  211.       fastref dstword;
  212.       fastref dstlong;
  213.     } s;
  214.   struct
  215.     {
  216.       fastref byte;
  217.       fastref word;
  218.       fastref lon;
  219.     } a[3];
  220.  
  221.   fastref j[9];
  222. } size_ptr;
  223.  
  224. union
  225. {
  226.   struct ea_struct
  227.     {
  228.       size_ptr ea_nop;
  229.       size_ptr ea_reg;
  230.       size_ptr ea_inc;
  231.       size_ptr ea_dec;
  232.       size_ptr ea_disp;
  233.  
  234.       size_ptr ea_imm;
  235.       size_ptr ea_cr;
  236.       size_ptr ea_lval;
  237.       size_ptr ea_lval24;
  238.     } s;
  239. #define N_EATYPES (sizeof(struct ea_struct) / sizeof(size_ptr))
  240.   size_ptr a[N_EATYPES];
  241. } eas;
  242.  
  243. /* This function takes an ea structure filled in for the 1st source
  244.  operand and modifies it to be for either the 1st, 2nd or dst operand */
  245.  
  246. static void
  247. howto_workout (encoded, semiencoded, n)
  248.      ea_type *encoded;
  249.      ea_type *semiencoded;
  250.      int n;
  251. {
  252.   int i;
  253.   *encoded = *semiencoded;
  254.  
  255.   for (i = 0; i < N_EATYPES; i++)
  256.     {
  257.       if (encoded->type == eas.a[i].s.srcabyte)
  258.     {
  259.       encoded->type = eas.a[i].a[n].byte;
  260.       return;
  261.     }
  262.       else if (encoded->type == eas.a[i].s.srcaword)
  263.     {
  264.       encoded->type = eas.a[i].a[n].word;
  265.       return;
  266.     }
  267.       else if (encoded->type == eas.a[i].s.srcalong)
  268.     {
  269.       encoded->type = eas.a[i].a[n].lon;
  270.       return;
  271.     }
  272.     }
  273.  
  274.   abort ();
  275. }
  276.  
  277. fastref flag_shiftword;
  278. fastref flag_shiftbyte;
  279. fastref flag_multword;
  280. fastref flag_multbyte;
  281. fastref flag_mp;
  282. fastref flag_special;
  283. fastref flag_Mp;
  284. fastref flag_ap;
  285. fastref flag_Ap;
  286. fastref flag_nonep;
  287. fastref flag_nostorep;
  288. fastref flag_clearp;
  289. fastref flag_branch;
  290. fastref exec_dispatch[100];
  291.  
  292. static int
  293. get_now ()
  294. {
  295.   struct tms b;
  296.   times (&b);
  297.   return b.tms_utime + b.tms_stime;
  298. }
  299.  
  300. static int
  301. now_persec ()
  302. {
  303.   return HZ;
  304. }
  305.  
  306. static void
  307. gotcr (ptr, n)
  308.      ea_type *ptr;
  309.      int n;
  310. {
  311.   int size;
  312.   n &= 0x7;
  313.   if (n == 0)
  314.     {
  315.       abort ();
  316.     }
  317.   else
  318.     {
  319.       ptr->type = eas.s.ea_cr.j[JBYTE];
  320.       ptr->reg.bptr = segregptr[n][JLONG];
  321.     }
  322. }
  323. static void
  324. gotreg (ptr, n, size)
  325.      ea_type *ptr;
  326.      int n;
  327.      int size;
  328. {
  329.   n &= 0x7;
  330.   ptr->type = eas.s.ea_reg.j[size];
  331.   ptr->reg.bptr = regptr[n][size];
  332. }
  333.  
  334. static void
  335. gotinc (ptr, n, inc, size)
  336.      ea_type *ptr;
  337.      int n;
  338.      int size;
  339. {
  340.   n &= 0x7;
  341.   if (inc > 0)
  342.     {
  343.       ptr->type = eas.s.ea_inc.j[size];
  344.     }
  345.   else
  346.     {
  347.       ptr->type = eas.s.ea_dec.j[size];
  348.     }
  349.   ptr->reg.bptr = regptr[n][JWORD];
  350.   ptr->r2.segreg = segmap[n];
  351. }
  352.  
  353.  
  354. static void
  355. gotabs (ptr, disp, reg, size)
  356.      ea_type *ptr;
  357.      int disp;
  358.      int reg;
  359.      int size;
  360. {
  361.   ptr->type = eas.s.ea_disp.j[size];
  362.   ptr->reg.bptr = regptr[reg][JWORD];
  363.   ptr->r2.segreg = segmap[reg];
  364.   ptr->literal = disp;
  365. }
  366.  
  367. static void
  368. gotind (ptr, disp, reg, size)
  369.      ea_type *ptr;
  370.      int disp;
  371.      int reg;
  372.      int size;
  373. {
  374.   gotabs (ptr, disp, reg & 0x7, size);
  375. }
  376.  
  377. static void
  378. gotimm (ptr, val)
  379.      ea_type *ptr;
  380.      int val;
  381. {
  382.   ptr->type = eas.s.ea_imm.j[0];
  383.   ptr->literal = val;
  384. }
  385. static void
  386. indoff (ptr)
  387.      ea_type *ptr;
  388. {
  389.   int i;
  390.   for (i = 0; i < 6; i++)
  391.     {
  392.       if (ptr->type == eas.s.ea_disp.j[i])
  393.     {
  394.       ptr->type = eas.s.ea_lval.j[i];
  395.       return;
  396.     }
  397.     }
  398. }
  399.  
  400. thinkabout_shifts (d, bytesized)
  401.      decoded_inst *d;
  402.      int bytesized;
  403. {
  404.   if (bytesized)
  405.     {
  406.       /* Got a byte shift, fake up second arg */
  407.       d->srcb.type = eas.s.ea_imm.s.srcbword;
  408.       d->srcb.literal = 8;
  409.     }
  410.   {
  411.     /* got a word shift, fake up second arg */
  412.     d->srcb.type = eas.s.ea_imm.s.srcbword;
  413.     d->srcb.literal = 16;
  414.   }
  415. }
  416.  
  417. /* Calculate the number of cycles required to run this 
  418.    instruction
  419. */
  420. static void
  421. compcycles(dst, opcode)
  422. decoded_inst *dst;
  423. h8500_opcode_info *opcode;
  424. {
  425.   int cycles = 0;
  426.   /* Guess for the time being - 1 cycle for the first two bytes in the 
  427.      opcode - to fecth the operand, and 3 cycles for all the rest of 
  428.      the bytes, since they mean that there is probably an operand to 
  429.      fetch */
  430.  
  431.   switch (opcode->length)
  432.     {
  433.     case 1:
  434.     case 2:
  435.       cycles += opcode->length;
  436.       break;
  437.     default:
  438.       cycles += opcode->length * 3;
  439.       break;
  440.     }
  441.  
  442.   dst->cycles = cycles;
  443. }
  444. static void
  445. find (pc, buffer, dst)
  446.      int pc;
  447.      unsigned char *buffer;
  448.      decoded_inst *dst;
  449. {
  450.   h8500_opcode_info *opcode;
  451.   int i;
  452.   int idx;
  453.   int hadimm = 0;
  454.  
  455.  
  456.   /* Run down the table to find the one which matches */
  457.   for (opcode = h8500_table; opcode->name; opcode++)
  458.     {
  459.       int byte;
  460.       int rn;
  461.       int rd;
  462.       int rs;
  463.       int disp;
  464.       int abs;
  465.       int imm;
  466.       int pcrel;
  467.       int qim;
  468.       int i;
  469.       int cr;
  470.  
  471.  
  472.       dst->opcode = exec_dispatch[opcode->flavor & 0x7f];
  473.  
  474.       for (byte = 0; byte < opcode->length; byte++)
  475.     {
  476.       if ((buffer[byte] & opcode->bytes[byte].mask)
  477.           != (opcode->bytes[byte].contents))
  478.         {
  479.           goto next;
  480.         }
  481.       else
  482.         {
  483.           /* extract any info parts */
  484.           switch (opcode->bytes[byte].insert)
  485.         {
  486.         case 0:
  487.         case FP:
  488.           break;
  489.         default:
  490.           abort ();
  491.           break;
  492.         case RN:
  493.           rn = buffer[byte] & 0x7;
  494.           break;
  495.         case RS:
  496.           rs = buffer[byte] & 0x7;
  497.           break;
  498.         case CRB:
  499.           cr = buffer[byte] & 0x7;
  500.           if (cr == 0)
  501.             goto next;
  502.           break;
  503.         case CRW:
  504.           cr = buffer[byte] & 0x7;
  505.           if (cr != 0)
  506.             goto next;
  507.           break;
  508.         case DISP16:
  509.           disp = (buffer[byte] << 8) | (buffer[byte + 1]);
  510.           break;
  511.         case FPIND_D8:
  512.         case DISP8:
  513.           disp = ((char) (buffer[byte]));
  514.           break;
  515.         case RD:
  516.         case RDIND:
  517.           rd = buffer[byte] & 0x7;
  518.           break;
  519.         case ABS24:
  520.           abs =
  521.             (buffer[byte] << 16)
  522.             | (buffer[byte + 1] << 8)
  523.             | (buffer[byte + 2]);
  524.           break;
  525.         case ABS16:
  526.           abs = (buffer[byte] << 8) | (buffer[byte + 1]);
  527.           break;
  528.         case ABS8:
  529.           abs = (buffer[byte]);
  530.           break;
  531.         case IMM16:
  532.           imm = (buffer[byte] << 8) | (buffer[byte + 1]);
  533.           break;
  534.         case IMM4:
  535.           imm = (buffer[byte]) & 0xf;
  536.           break;
  537.         case IMM8:
  538.         case RLIST:
  539.           imm = SEXTCHAR (buffer[byte]);
  540.           break;
  541.         case PCREL16:
  542.           pcrel = SEXTSHORT ((buffer[byte] << 8) | (buffer[byte + 1]));
  543.           break;
  544.         case PCREL8:
  545.           pcrel = SEXTCHAR ((buffer[byte]));
  546.           break;
  547.         case QIM:
  548.           switch (buffer[byte] & 0x7)
  549.             {
  550.             case 0:
  551.               imm = 1;
  552.               break;
  553.             case 1:
  554.               imm = 2;
  555.               break;
  556.             case 4:
  557.               imm = -1;
  558.               break;
  559.             case 5:
  560.               imm = -2;
  561.               break;
  562.             }
  563.           break;
  564.  
  565.         }
  566.         }
  567.     }
  568.       if (opcode->flavor & O_BYTE)
  569.     {
  570.       idx = 0;
  571.       switch (opcode->flags)
  572.         {
  573.         case 'h':
  574.           dst->flags = flag_shiftbyte;
  575.           break;
  576.         case 'p':
  577.           dst->flags = flag_multbyte;
  578.           break;
  579.         case 'B':
  580.           dst->flags = flag_branch;
  581.           break;
  582.         case 'm':
  583.           dst->flags = flag_mp;
  584.           break;
  585.         case 'a':
  586.           dst->flags = flag_ap;
  587.           break;
  588.         case '-':
  589.           dst->flags = flag_nonep;
  590.           break;
  591.         case 0:
  592.           dst->flags = flag_nostorep;
  593.           break;
  594.         case 'c':
  595.           dst->flags = flag_clearp;
  596.           break;
  597.         case 's':
  598.           /* special */
  599.           dst->flags = flag_special;
  600.         }
  601.     }
  602.       else
  603.     {
  604.       idx = 1;
  605.       switch (opcode->flags)
  606.         {
  607.         case 'h':
  608.           dst->flags = flag_shiftword;
  609.           break;
  610.         case 'p':
  611.           dst->flags = flag_multword;
  612.           break;
  613.         case 'B':
  614.           dst->flags = flag_branch;
  615.           break;
  616.         case 'm':
  617.           dst->flags = flag_Mp;
  618.           break;
  619.         case 'a':
  620.           dst->flags = flag_Ap;
  621.           break;
  622.         case '-':
  623.           dst->flags = flag_nonep;
  624.           break;
  625.         case 0:
  626.           dst->flags = flag_nostorep;
  627.           break;
  628.         case 'c':
  629.           dst->flags = flag_clearp;
  630.           break;
  631.         case 's':
  632.           /* special */
  633.           dst->flags = flag_special;
  634.           break;
  635.         }
  636.     }
  637.  
  638.       for (i = 0; i < opcode->nargs; i++)
  639.     {
  640.       ea_type *p = eavector + i;
  641.  
  642.       switch (opcode->arg_type[i])
  643.         {
  644.         default:
  645.           abort();
  646.  
  647.         case FP:
  648.           gotreg (p, 6, idx);
  649.           break;
  650.         case RNIND:
  651.           disp =0;
  652.         case RNIND_D16:
  653.         case RNIND_D8:
  654.           gotind (p, disp, rn, idx);
  655.           break;
  656.           break;
  657.         case RDIND:
  658.           disp = 0;
  659.         case RDIND_D16:
  660.         case RDIND_D8:
  661.           gotind (p, disp, rd, idx);
  662.           break;
  663.         case FPIND_D8:
  664.           gotind (p, disp, 6, idx);
  665.           break;
  666.         case CRB:
  667.         case CRW:
  668.           gotcr (p, cr);
  669.           break;
  670.         case RN:
  671.           gotreg (p, rn, idx);
  672.           break;
  673.         case RD:
  674.           gotreg (p, rd, idx);
  675.           break;
  676.         case RS:
  677.           gotreg (p, rs, idx);
  678.           break;
  679.         case RNDEC:
  680.           gotinc (p, rn, -1, idx);
  681.           break;
  682.         case RNINC:
  683.           gotinc (p, rn, 1, idx);
  684.           break;
  685.         case SPINC:
  686.           gotinc (p, 7, 1, idx);
  687.           break;
  688.         case SPDEC:
  689.           gotinc (p, 7, -1, idx);
  690.           break;
  691.         case ABS24:
  692.         case ABS16:
  693.           gotabs (p, abs, R_HARD_0, idx);
  694.           break;
  695.         case ABS8:
  696.           gotabs (p, abs, R_HARD8_0, idx);
  697.           break;
  698.         case IMM16:
  699.         case RLIST:
  700.         case QIM:
  701.         case IMM4:
  702.         case IMM8:
  703.           gotimm (p, imm);
  704.           break;
  705.         case PCREL16:
  706.         case PCREL8:
  707.           gotimm (p,
  708.          ((pcrel + pc + opcode->length) & 0xffff) | (pc & 0xff0000),
  709.               R_HARD_0, JLONG);
  710.  
  711.         }
  712.     }
  713.  
  714.       /* Finished and done - turn from two operand stuff into three */
  715.  
  716.       dst->srca.type = eas.s.ea_nop.s.srcabyte;
  717.       dst->srcb.type = eas.s.ea_nop.s.srcbbyte;
  718.       dst->dst.type = eas.s.ea_nop.s.dstbyte;
  719.  
  720.       if (opcode->nargs)
  721.     {
  722.       switch (opcode->nargs)
  723.         {
  724.         case 1:
  725.           howto_workout (&dst->srca, &eavector[0], 0);
  726.           if (opcode->dst != '!')
  727.         howto_workout (&dst->dst, &eavector[0], 2);
  728.           break;
  729.         case 2:
  730.           if (opcode->src2 == '!')
  731.         {
  732.           howto_workout (&dst->srca, &eavector[0], 0);
  733.           howto_workout (&dst->dst, &eavector[1], 2);
  734.         }
  735.           else
  736.         {
  737.           howto_workout (&dst->srca, &eavector[0], 0);
  738.           howto_workout (&dst->srcb, &eavector[1], 1);
  739.           if (opcode->dst != '!')
  740.             {
  741.               howto_workout (&dst->dst, &eavector[1], 2);
  742.             }
  743.         }
  744.           break;
  745.         }
  746.  
  747.  
  748.  
  749.       /* Some extra stuff with pre inc and post dec,
  750.        make sure that if the same ea is there twice, only one of the
  751.        ops is auto inc/dec */
  752.  
  753.  
  754.       if (dst->dst.type == eas.s.ea_inc.s.dstbyte
  755.           && (dst->srca.type == eas.s.ea_inc.s.srcabyte
  756.           || dst->srcb.type == eas.s.ea_inc.s.srcbbyte))
  757.         {
  758.           dst->dst.type = eas.s.ea_disp.s.dstbyte;
  759.         }
  760.  
  761.       if (dst->dst.type == eas.s.ea_inc.s.dstword
  762.           && (dst->srca.type == eas.s.ea_inc.s.srcaword
  763.           || dst->srcb.type == eas.s.ea_inc.s.srcbword))
  764.         {
  765.           dst->dst.type = eas.s.ea_disp.s.dstword;
  766.         }
  767.  
  768.       if (dst->dst.type == eas.s.ea_dec.s.dstbyte
  769.           || dst->dst.type == eas.s.ea_dec.s.dstword)
  770.         {
  771.           if (dst->srca.type == eas.s.ea_dec.s.srcabyte)
  772.         {
  773.           dst->srca.type = eas.s.ea_disp.s.srcabyte;
  774.         }
  775.           else if (dst->srca.type == eas.s.ea_dec.s.srcaword)
  776.         {
  777.           dst->srca.type = eas.s.ea_disp.s.srcaword;
  778.         }
  779.           else if (dst->srcb.type == eas.s.ea_dec.s.srcbbyte)
  780.         {
  781.           dst->srcb.type = eas.s.ea_disp.s.srcbbyte;
  782.         }
  783.           else if (dst->srcb.type == eas.s.ea_dec.s.srcbword)
  784.         {
  785.           dst->srcb.type = eas.s.ea_disp.s.srcbword;
  786.         }
  787.         }
  788.  
  789.       /* Some special cases */
  790.       if (dst->opcode == exec_dispatch[O_PJSR]
  791.           || dst->opcode == exec_dispatch[O_JSR])
  792.         {
  793.           /* For [P]JSR, keep return address precomputed */
  794.           dst->srcb.literal = pc + opcode->length;
  795.           dst->srcb.type = eas.s.ea_imm.s.srcbword;
  796.         }
  797.  
  798.       if (dst->opcode == exec_dispatch[O_MULXU])
  799.         {
  800.           /* This is a multiply -fix the destination op */
  801.           if (dst->dst.type == eas.s.ea_reg.s.dstword)
  802.         {
  803.           dst->dst.type = eas.s.ea_reg.s.dstlong;
  804.         }
  805.           else
  806.         {
  807.           dst->dst.type = eas.s.ea_reg.s.dstword;
  808.         }
  809.           dst->dst.reg.bptr = regptr[rd][JWORD];
  810.         }
  811.       if (dst->opcode == exec_dispatch[O_DIVXU])
  812.         {
  813.           /* This is a wider than normal, fix the source operand */
  814.           dst->srcb.type
  815.         = (dst->srcb.type == eas.s.ea_reg.s.srcbword)
  816.         ? eas.s.ea_reg.s.srcblong
  817.         : eas.s.ea_reg.s.srcbword;
  818.  
  819.           dst->dst.type
  820.         = (dst->dst.type == eas.s.ea_reg.s.dstword)
  821.         ? eas.s.ea_reg.s.dstlong
  822.         : eas.s.ea_reg.s.dstword;
  823.  
  824.         }
  825.  
  826.       if (dst->opcode == exec_dispatch[O_LDM]) {
  827.         /* Turn of the stack ref */
  828.         dst->srca.type = eas.s.ea_nop.s.srcabyte;
  829.       }
  830.       if (dst->opcode == exec_dispatch[O_STM]) {
  831.         /* Turn of the stack ref */
  832.         dst->srcb.type = eas.s.ea_nop.s.srcbbyte;
  833.       }
  834.  
  835.  
  836.           /* extends read one size and write another */
  837.       if (dst->opcode == exec_dispatch[O_EXTS]
  838.           || dst->opcode == exec_dispatch[O_EXTU])
  839.         {
  840.           dst->dst.type = eas.s.ea_reg.s.dstword;
  841.           dst->dst.reg.bptr = regptr[rd][JWORD];
  842.           dst->flags = flag_Ap;
  843.         }
  844.  
  845.  
  846.       if (opcode->flags == 'h')
  847.         thinkabout_shifts (dst, opcode->flavor & O_BYTE);
  848.  
  849.  
  850.       /* For a branch, turn off one level of indirection */
  851.       if (opcode->src1 == 'B')
  852.         {
  853.           indoff (&dst->srca);
  854.         }
  855.  
  856.     }
  857.       dst->next_pc = pc + opcode->length;
  858.  
  859.       compcycles(dst, opcode);
  860.  
  861.       return;
  862.  
  863.  
  864.     next:;
  865.     }
  866.  
  867.   /* Couldn't understand anything */
  868.   dst->opcode = exec_dispatch[O_TRAPA];
  869.   dst->next_pc = pc + 1;
  870.  
  871. }
  872.  
  873. compile (pc)
  874. {
  875.   int idx;
  876.  
  877.   /* find the next cache entry to use */
  878.  
  879.   idx = cpu.cache_top + 1;
  880.   cpu.compiles++;
  881.   if (idx >= cpu.csize)
  882.     {
  883.       idx = 1;
  884.     }
  885.   cpu.cache_top = idx;
  886.  
  887.   /* Throw away its old meaning */
  888.   cpu.cache_idx[cpu.cache[idx].oldpc] = 0;
  889.  
  890.   /* set to new address */
  891.   cpu.cache[idx].oldpc = pc;
  892.  
  893.   /* fill in instruction info */
  894.   find (pc, cpu.memory + pc, cpu.cache + idx);
  895.  
  896.   /* point to new cache entry */
  897.   cpu.cache_idx[pc] = idx;
  898. }
  899.  
  900. baddefault (x)
  901. {
  902.   printf ("bad default %d\n", x);
  903. }
  904.  
  905. #define FETCH(dst, arg, n)  \
  906. { \
  907.  int r; unsigned char*lval; \
  908.  DISPATCH((arg).type) \
  909.  { LABELN(FETCH_NOP,n): \
  910.  dst= 0; \
  911.  break; \
  912.  DEFAULT baddefault((arg).type); break; \
  913.  LABELN(FETCH_LVAL,n):  \
  914.  dst = (*(((arg).reg.wptr)) + (arg.literal)) ; \
  915.  break; \
  916.  LABELN(FETCH_LVAL24,n):  \
  917.  dst = (*(((arg).reg.wptr)) + *(((arg).r2.wptr)) + (arg.literal)) &0xffffff; \
  918.  break; \
  919.  LABELN(FETCH_CRB,n):  \
  920.  dst = (*((arg).reg.segptr) - cpu.memory)>>16; \
  921.  break; \
  922.  LABELN(FETCH_CRW,n):  \
  923.   dst = BUILDSR();\
  924.  break; \
  925.  LABELN(FETCH_REG_B,n): \
  926.  dst = *((arg).reg.bptr); \
  927.  break; \
  928.  LABELN(FETCH_REG_W,n): \
  929.  dst = *((arg).reg.wptr); \
  930.  break; \
  931.  LABELN(FETCH_REG_L,n): \
  932.  dst = (*((arg).reg.wptr) << 16) | (*((arg).reg.wptr + 2)); \
  933.  break; \
  934.  LABELN(FETCH_INC_B,n): \
  935.  lval = elval ((arg), 0); \
  936.  dst = byteat (lval); \
  937.  (*((arg).reg.wptr))++; \
  938.  break; \
  939.  LABELN(FETCH_INC_W,n): \
  940.  lval = elval ((arg), 0); \
  941.  dst = wordat (lval); \
  942.  (*(((arg).reg.wptr))) += 2; \
  943.  break; \
  944.  LABELN(FETCH_DEC_B, n): \
  945.  lval = elval ((arg), 0); \
  946.  r = byteat (lval); \
  947.  (*(arg).reg.wptr)--; \
  948.  dst = r; \
  949.  break; \
  950.  LABELN(FETCH_DEC_W, n): \
  951.  lval = elval ((arg), 0); \
  952.  r = wordat (lval); \
  953.  (*((arg).reg.wptr)) -= 2; \
  954.  dst = r; \
  955.  break; \
  956.  LABELN(FETCH_DISP_B,n): \
  957.  lval = displval ((arg)); \
  958.  dst = byteat (lval); \
  959.  break; \
  960.  LABELN(FETCH_DISP_W,n): \
  961.  lval = displval ((arg)); \
  962.  dst = wordat (lval); \
  963.  break; \
  964.  LABELN(FETCH_IMM, n): \
  965.  dst = (arg).literal; \
  966.  break; \
  967.  } \
  968.  ENDDISPATCH; \
  969. }
  970.  
  971. static union
  972. {
  973.   short int i;
  974.   struct
  975.     {
  976.       char low;
  977.       char high;
  978.     }
  979.   u;
  980. }
  981.  
  982. littleendian;
  983.  
  984. static
  985. void
  986. init_pointers ()
  987. {
  988.   static int init;
  989.  
  990.   if (!init)
  991.     {
  992.       int i;
  993.  
  994.       init = 1;
  995.       littleendian.i = 1;
  996.  
  997.       for (i = 0; i < (int) R_LAST; i++)
  998.     {
  999.       if (littleendian.u.high)
  1000.         {
  1001.           /* big endian host */
  1002.           regptr[i][0] = ((unsigned char *) (cpu.regs + i)) + 3;
  1003.           regptr[i][1] = ((unsigned char *) (cpu.regs + i)) + 2;
  1004.         }
  1005.       else
  1006.         {
  1007.           regptr[i][0] = (unsigned char *) &(cpu.regs[i]);
  1008.           regptr[i][1] = (unsigned char *) (&(cpu.regs[i]));
  1009.         }
  1010.  
  1011.       regptr[i][2] = (unsigned char *) &(cpu.regs[i]);
  1012.     }
  1013.  
  1014.       memcpy (segregptr + 0, regptr + R_SR, sizeof (segregptr[0]));
  1015.       memcpy (segregptr + 1, regptr + R_TP, sizeof (segregptr[1]));
  1016.       memcpy (segregptr + 3, regptr + R_BR, sizeof (segregptr[3]));
  1017.       memcpy (segregptr + 4, regptr + R_EP, sizeof (segregptr[4]));
  1018.       memcpy (segregptr + 5, regptr + R_DP, sizeof (segregptr[5]));
  1019.       memcpy (segregptr + 6, regptr + R_CP, sizeof (segregptr[6]));
  1020.       memcpy (segregptr + 7, regptr + R_TP, sizeof (segregptr[7]));
  1021.  
  1022.       /* Pointers to into the cpu state for the seg registers */
  1023.  
  1024.       segmap[R0] = &cpu.regs[R_DP].c;
  1025.       segmap[R1] = &cpu.regs[R_DP].c;
  1026.       segmap[R2] = &cpu.regs[R_DP].c;
  1027.       segmap[R3] = &cpu.regs[R_DP].c;
  1028.       segmap[R4] = &cpu.regs[R_EP].c;
  1029.       segmap[R5] = &cpu.regs[R_EP].c;
  1030.       segmap[R6] = &cpu.regs[R_TP].c;
  1031.       segmap[R7] = &cpu.regs[R_TP].c;
  1032.       segmap[R_HARD_0] = &cpu.regs[R_DP].c;
  1033.       segmap[R_HARD8_0] = &cpu.regs[R_BP].c;
  1034.  
  1035.       cpu.memory = (unsigned char *) calloc (sizeof (char), MSIZE);
  1036.       cpu.cache_idx = (unsigned short *) calloc (sizeof (short), MSIZE);
  1037.  
  1038.       /* initialize the seg registers */
  1039.  
  1040.       cpu.regs[R_DP].c = cpu.memory;
  1041.       cpu.regs[R_TP].c = cpu.memory;
  1042.       cpu.regs[R_CP].c = cpu.memory;
  1043.       cpu.regs[R_BP].c = cpu.memory;
  1044.       cpu.regs[R_EP].c = cpu.memory;
  1045.       cpu.regs[R7].s[LOW] = 0xfffe;
  1046.       cpu.regs[R6].s[LOW] = 0xfffe;
  1047.       if (!cpu.cache)
  1048.     sim_csize (CSIZE);
  1049.     }
  1050. }
  1051.  
  1052. #define PUSHWORD(x)                \
  1053. {                        \
  1054.   int sp = cpu.regs[R7].s[LOW];            \
  1055.   unsigned char *p;                \
  1056.                         \
  1057.   sp -= 2;                    \
  1058.   p = (sp & 0xffff) + (cpu.regs[R_TP].c);    \
  1059.   cpu.regs[R7].s[LOW] = sp;            \
  1060.   setwordat (p, x);                \
  1061. }                        \
  1062.                          
  1063. #define POPWORD(d)                \
  1064. {                        \
  1065.   int spx= cpu.regs[R7].s[LOW];            \
  1066.   unsigned char *p;                \
  1067.                             \
  1068.   p = (spx& 0xffff) + (cpu.regs[R_TP].c);    \
  1069.   spx+= 2;                    \
  1070.   cpu.regs[R7].s[LOW] = spx;                    \
  1071.   d = wordat (p);                \
  1072. }                        \
  1073.  
  1074. /* simulate a monitor trap */
  1075. trap ()
  1076. {
  1077.   switch (cpu.regs[R3].s[LOW] & 0xff)
  1078.     {
  1079.     case 33:
  1080.       /* exit */
  1081.       cpu.exception = SIGQUIT;
  1082.       break;
  1083.     case 6:
  1084.       /* print char in r0 */
  1085.       printf ("%c", cpu.regs[R0].s[LOW]);
  1086.       break;
  1087.     }
  1088. }
  1089. void
  1090. control_c (sig, code, scp, addr)
  1091.      int sig;
  1092.      int code;
  1093.      char *scp;
  1094.      char *addr;
  1095. {
  1096.   cpu.exception = SIGINT;
  1097. }
  1098.  
  1099. int
  1100. sim_resume (step)
  1101. {
  1102.   static int init1;
  1103.   int res;
  1104.   int tmp;
  1105.   int arga;
  1106.   int argb;
  1107.   int bit;
  1108.   int pc;
  1109.   int C, Z, V, N;
  1110.   int cycles = 0;
  1111.   int insts  = 0;
  1112.   int tick_start = get_now();
  1113.   void (*prev) ();
  1114.  
  1115.   if (!init1)
  1116.     {
  1117.       int i;
  1118.  
  1119.       init1 = 1;
  1120.       init_pointers ();
  1121.  
  1122.       for (i = 0; i < N_EATYPES; i++)
  1123.     {
  1124.       eas.a[i].s.srcabyte = LABEL_REFN (FETCH_NOP, 0);
  1125.       eas.a[i].s.srcaword = LABEL_REFN (FETCH_NOP, 0);
  1126.       eas.a[i].s.srcalong = LABEL_REFN (FETCH_NOP, 0);
  1127.  
  1128.       eas.a[i].s.srcbbyte = LABEL_REFN (FETCH_NOP, 1);
  1129.       eas.a[i].s.srcbword = LABEL_REFN (FETCH_NOP, 1);
  1130.       eas.a[i].s.srcblong = LABEL_REFN (FETCH_NOP, 1);
  1131.  
  1132.       eas.a[i].s.dstbyte = LABEL_REF (STORE_NOP);
  1133.       eas.a[i].s.dstword = LABEL_REF (STORE_NOP);
  1134.       eas.a[i].s.dstlong = LABEL_REF (STORE_NOP);
  1135.     }
  1136.  
  1137.       eas.s.ea_lval.s.srcabyte = LABEL_REFN (FETCH_LVAL, 0);
  1138.       eas.s.ea_lval.s.srcaword = LABEL_REFN (FETCH_LVAL, 0);
  1139.       eas.s.ea_lval24.s.srcabyte = LABEL_REFN (FETCH_LVAL24, 0);
  1140.       eas.s.ea_lval24.s.srcaword = LABEL_REFN (FETCH_LVAL24, 0);
  1141.  
  1142.       eas.s.ea_nop.s.srcabyte = LABEL_REFN (FETCH_NOP, 0);
  1143.       eas.s.ea_nop.s.srcaword = LABEL_REFN (FETCH_NOP, 0);
  1144.       eas.s.ea_nop.s.srcbbyte = LABEL_REFN (FETCH_NOP, 1);
  1145.       eas.s.ea_nop.s.srcbword = LABEL_REFN (FETCH_NOP, 1);
  1146.       eas.s.ea_nop.s.dstbyte = LABEL_REF (STORE_NOP);
  1147.       eas.s.ea_nop.s.dstword = LABEL_REF (STORE_NOP);
  1148.  
  1149.       eas.s.ea_cr.s.srcabyte = LABEL_REFN (FETCH_CRB, 0);
  1150.       eas.s.ea_cr.s.srcaword = LABEL_REFN (FETCH_CRW, 0);
  1151.  
  1152.       eas.s.ea_cr.s.srcbbyte = LABEL_REFN (FETCH_CRB, 1);
  1153.       eas.s.ea_cr.s.srcbword = LABEL_REFN (FETCH_CRW, 1);
  1154.  
  1155.       eas.s.ea_cr.s.dstbyte = LABEL_REF (STORE_CRB);
  1156.       eas.s.ea_cr.s.dstword = LABEL_REF (STORE_CRW);
  1157.  
  1158.       eas.s.ea_reg.s.srcabyte = LABEL_REFN (FETCH_REG_B, 0);
  1159.       eas.s.ea_reg.s.srcaword = LABEL_REFN (FETCH_REG_W, 0);
  1160.       eas.s.ea_reg.s.srcalong = LABEL_REFN (FETCH_REG_L, 0);
  1161.  
  1162.       eas.s.ea_reg.s.srcbbyte = LABEL_REFN (FETCH_REG_B, 1);
  1163.       eas.s.ea_reg.s.srcbword = LABEL_REFN (FETCH_REG_W, 1);
  1164.       eas.s.ea_reg.s.srcblong = LABEL_REFN (FETCH_REG_L, 1);
  1165.  
  1166.       eas.s.ea_reg.s.dstbyte = LABEL_REF (STORE_REG_B);
  1167.       eas.s.ea_reg.s.dstword = LABEL_REF (STORE_REG_W);
  1168.       eas.s.ea_reg.s.dstlong = LABEL_REF (STORE_REG_L);
  1169.  
  1170.       eas.s.ea_inc.s.srcabyte = LABEL_REFN (FETCH_INC_B, 0);
  1171.       eas.s.ea_inc.s.srcaword = LABEL_REFN (FETCH_INC_W, 0);
  1172.       eas.s.ea_inc.s.srcbbyte = LABEL_REFN (FETCH_INC_B, 1);
  1173.       eas.s.ea_inc.s.srcbword = LABEL_REFN (FETCH_INC_W, 1);
  1174.       eas.s.ea_inc.s.dstbyte = LABEL_REF (STORE_INC_B);
  1175.       eas.s.ea_inc.s.dstword = LABEL_REF (STORE_INC_W);
  1176.  
  1177.       eas.s.ea_dec.s.srcabyte = LABEL_REFN (FETCH_DEC_B, 0);
  1178.       eas.s.ea_dec.s.srcaword = LABEL_REFN (FETCH_DEC_W, 0);
  1179.       eas.s.ea_dec.s.srcbbyte = LABEL_REFN (FETCH_DEC_B, 1);
  1180.       eas.s.ea_dec.s.srcbword = LABEL_REFN (FETCH_DEC_W, 1);
  1181.       eas.s.ea_dec.s.dstbyte = LABEL_REF (STORE_DEC_B);
  1182.       eas.s.ea_dec.s.dstword = LABEL_REF (STORE_DEC_W);
  1183.  
  1184.       eas.s.ea_disp.s.srcabyte = LABEL_REFN (FETCH_DISP_B, 0);
  1185.       eas.s.ea_disp.s.srcaword = LABEL_REFN (FETCH_DISP_W, 0);
  1186.       eas.s.ea_disp.s.srcbbyte = LABEL_REFN (FETCH_DISP_B, 1);
  1187.       eas.s.ea_disp.s.srcbword = LABEL_REFN (FETCH_DISP_W, 1);
  1188.       eas.s.ea_disp.s.dstbyte = LABEL_REF (STORE_DISP_B);
  1189.       eas.s.ea_disp.s.dstword = LABEL_REF (STORE_DISP_W);
  1190.  
  1191.       eas.s.ea_imm.s.srcabyte = LABEL_REFN (FETCH_IMM, 0);
  1192.       eas.s.ea_imm.s.srcaword = LABEL_REFN (FETCH_IMM, 0);
  1193.       eas.s.ea_imm.s.srcbbyte = LABEL_REFN (FETCH_IMM, 1);
  1194.       eas.s.ea_imm.s.srcbword = LABEL_REFN (FETCH_IMM, 1);
  1195.  
  1196.       flag_special = LABEL_REF (FLAG_special);
  1197.       flag_mp = LABEL_REF (FLAG_m);
  1198.       flag_Mp = LABEL_REF (FLAG_M);
  1199.       flag_ap = LABEL_REF (FLAG_a);
  1200.       flag_Ap = LABEL_REF (FLAG_A);
  1201.       flag_nonep = LABEL_REF (FLAG_NONE);
  1202.       flag_nostorep = LABEL_REF (FLAG_NOSTORE);
  1203.       flag_clearp = LABEL_REF (FLAG_CLEAR);
  1204.       flag_shiftbyte = LABEL_REF (FLAG_shiftbyte);
  1205.       flag_shiftword = LABEL_REF (FLAG_shiftword);
  1206.       flag_multbyte = LABEL_REF (FLAG_multbyte);
  1207.       flag_multword = LABEL_REF (FLAG_multword);
  1208.  
  1209.  
  1210.       exec_dispatch[O_ADDS] = LABEL_REF (O_ADDS);
  1211.       exec_dispatch[O_ADDX] = LABEL_REF (O_ADDX);
  1212.       exec_dispatch[O_ADD] = LABEL_REF (O_ADD);
  1213.       exec_dispatch[O_ANDC] = LABEL_REF (O_ANDC);
  1214.       exec_dispatch[O_AND] = LABEL_REF (O_AND);
  1215.       exec_dispatch[O_BCC] = LABEL_REF (O_BCC);
  1216.       exec_dispatch[O_BCLR] = LABEL_REF (O_BCLR);
  1217.       exec_dispatch[O_BCS] = LABEL_REF (O_BCS);
  1218.       exec_dispatch[O_BEQ] = LABEL_REF (O_BEQ);
  1219.       exec_dispatch[O_BF] = LABEL_REF (O_BF);
  1220.       exec_dispatch[O_BGE] = LABEL_REF (O_BGE);
  1221.       exec_dispatch[O_BGT] = LABEL_REF (O_BGT);
  1222.       exec_dispatch[O_BHI] = LABEL_REF (O_BHI);
  1223.       exec_dispatch[O_BHS] = LABEL_REF (O_BHS);
  1224.       exec_dispatch[O_BLE] = LABEL_REF (O_BLE);
  1225.       exec_dispatch[O_BLO] = LABEL_REF (O_BLO);
  1226.       exec_dispatch[O_BLS] = LABEL_REF (O_BLS);
  1227.       exec_dispatch[O_BLT] = LABEL_REF (O_BLT);
  1228.       exec_dispatch[O_BMI] = LABEL_REF (O_BMI);
  1229.       exec_dispatch[O_BNE] = LABEL_REF (O_BNE);
  1230.       exec_dispatch[O_BNOT] = LABEL_REF (O_BNOT);
  1231.       exec_dispatch[O_BPL] = LABEL_REF (O_BPL);
  1232.       exec_dispatch[O_BPT] = LABEL_REF (O_BPT);
  1233.       exec_dispatch[O_BRA] = LABEL_REF (O_BRA);
  1234.       exec_dispatch[O_BRN] = LABEL_REF (O_BRN);
  1235.       exec_dispatch[O_BSET] = LABEL_REF (O_BSET);
  1236.       exec_dispatch[O_BSR] = LABEL_REF (O_BSR);
  1237.       exec_dispatch[O_BTST] = LABEL_REF (O_BTST);
  1238.       exec_dispatch[O_BT] = LABEL_REF (O_BT);
  1239.       exec_dispatch[O_BVC] = LABEL_REF (O_BVC);
  1240.       exec_dispatch[O_BVS] = LABEL_REF (O_BVS);
  1241.       exec_dispatch[O_CLR] = LABEL_REF (O_CLR);
  1242.       exec_dispatch[O_CMP] = LABEL_REF (O_CMP);
  1243.       exec_dispatch[O_DADD] = LABEL_REF (O_DADD);
  1244.       exec_dispatch[O_DIVXU] = LABEL_REF (O_DIVXU);
  1245.       exec_dispatch[O_DSUB] = LABEL_REF (O_DSUB);
  1246.       exec_dispatch[O_EXTS] = LABEL_REF (O_EXTS);
  1247.       exec_dispatch[O_EXTU] = LABEL_REF (O_EXTU);
  1248.       exec_dispatch[O_JMP] = LABEL_REF (O_JMP);
  1249.       exec_dispatch[O_JSR] = LABEL_REF (O_JSR);
  1250.       exec_dispatch[O_LDC] = LABEL_REF (O_LDC);
  1251.       exec_dispatch[O_LDM] = LABEL_REF (O_LDM);
  1252.       exec_dispatch[O_LINK] = LABEL_REF (O_LINK);
  1253.       exec_dispatch[O_MOVFPE] = LABEL_REF (O_MOVFPE);
  1254.       exec_dispatch[O_MOVTPE] = LABEL_REF (O_MOVTPE);
  1255.       exec_dispatch[O_MOV] = LABEL_REF (O_MOV);
  1256.       exec_dispatch[O_MULXU] = LABEL_REF (O_MULXU);
  1257.       exec_dispatch[O_NEG] = LABEL_REF (O_NEG);
  1258.       exec_dispatch[O_NOP] = LABEL_REF (O_NOP);
  1259.       exec_dispatch[O_NOT] = LABEL_REF (O_NOT);
  1260.       exec_dispatch[O_ORC] = LABEL_REF (O_ORC);
  1261.       exec_dispatch[O_OR] = LABEL_REF (O_OR);
  1262.       exec_dispatch[O_PJMP] = LABEL_REF (O_PJMP);
  1263.       exec_dispatch[O_PJSR] = LABEL_REF (O_PJSR);
  1264.       exec_dispatch[O_PRTD] = LABEL_REF (O_PRTD);
  1265.       exec_dispatch[O_PRTS] = LABEL_REF (O_PRTS);
  1266.       exec_dispatch[O_RECOMPILE] = LABEL_REF (O_RECOMPILE);
  1267.  
  1268.       exec_dispatch[O_ROTL] = LABEL_REF (O_ROTL);
  1269.       exec_dispatch[O_ROTR] = LABEL_REF (O_ROTR);
  1270.       exec_dispatch[O_ROTXL] = LABEL_REF (O_ROTXL);
  1271.       exec_dispatch[O_ROTXR] = LABEL_REF (O_ROTXR);
  1272.  
  1273.       exec_dispatch[O_RTD] = LABEL_REF (O_RTD);
  1274.       exec_dispatch[O_RTS] = LABEL_REF (O_RTS);
  1275.       exec_dispatch[O_SCB_EQ] = LABEL_REF (O_SCB_EQ);
  1276.       exec_dispatch[O_SCB_F] = LABEL_REF (O_SCB_F);
  1277.       exec_dispatch[O_SCB_NE] = LABEL_REF (O_SCB_NE);
  1278.       exec_dispatch[O_SHAL] = LABEL_REF (O_SHAL);
  1279.       exec_dispatch[O_SHAR] = LABEL_REF (O_SHAR);
  1280.       exec_dispatch[O_SHLL] = LABEL_REF (O_SHLL);
  1281.       exec_dispatch[O_SHLR] = LABEL_REF (O_SHLR);
  1282.  
  1283.       exec_dispatch[O_SLEEP] = LABEL_REF (O_SLEEP);
  1284.       exec_dispatch[O_STC] = LABEL_REF (O_STC);
  1285.       exec_dispatch[O_STM] = LABEL_REF (O_STM);
  1286.       exec_dispatch[O_SUBS] = LABEL_REF (O_SUBS);
  1287.       exec_dispatch[O_SUBX] = LABEL_REF (O_SUBX);
  1288.       exec_dispatch[O_SUB] = LABEL_REF (O_SUB);
  1289.       exec_dispatch[O_SWAP] = LABEL_REF (O_SWAP);
  1290.       exec_dispatch[O_TAS] = LABEL_REF (O_TAS);
  1291.       exec_dispatch[O_TRAPA] = LABEL_REF (O_TRAPA);
  1292.       exec_dispatch[O_TRAP_VS] = LABEL_REF (O_TRAP_VS);
  1293.       exec_dispatch[O_TST] = LABEL_REF (O_TST);
  1294.       exec_dispatch[O_UNLK] = LABEL_REF (O_UNLK);
  1295.       exec_dispatch[O_XCH] = LABEL_REF (O_XCH);
  1296.       exec_dispatch[O_XORC] = LABEL_REF (O_XORC);
  1297.       exec_dispatch[O_XOR] = LABEL_REF (O_XOR);
  1298.       nop.type = eas.s.ea_nop.s.srcabyte;
  1299.       cpu.cache[0].opcode = exec_dispatch[O_RECOMPILE];
  1300.       cpu.cache[0].srca.type = eas.s.ea_nop.s.srcabyte;
  1301.       cpu.cache[0].srcb.type = eas.s.ea_nop.s.srcbbyte;
  1302.     }
  1303.  
  1304.   prev = signal (SIGINT, control_c);
  1305.  
  1306.   if (step)
  1307.     {
  1308.       cpu.exception = SIGTRAP;
  1309.     }
  1310.   else
  1311.     {
  1312.       cpu.exception = 0;
  1313.     }
  1314.  
  1315.   pc = cpu.regs[R_PC].s[LOW] + (NORMAL_CP << 16);
  1316.  
  1317.   GETSR ();
  1318.  
  1319.   do
  1320.     {
  1321.       int cidx;
  1322.       decoded_inst *code;
  1323.  
  1324.     top:
  1325.       cidx = cpu.cache_idx[pc];
  1326.       code = cpu.cache + cidx;
  1327.  
  1328.       FETCH (arga, code->srca, 0);
  1329.       FETCH (argb, code->srcb, 1);
  1330.       
  1331. #ifdef DEBUG
  1332.       if (debug)
  1333.     {
  1334.       printf ("%x %d %s\n", pc, code->opcode,
  1335.           code->op ? code->op->name : "**");
  1336.     }
  1337. #endif
  1338.  
  1339.       cycles += code->cycles;
  1340.       insts ++;
  1341.       DISPATCH (code->opcode)
  1342.       {
  1343.       LABEL (O_RECOMPILE):
  1344.     /* This opcode is a fake for when we get to an instruction which
  1345.          hasn't been compiled */
  1346.     compile (pc);
  1347.     goto top;
  1348.     break;
  1349.       LABEL (O_NEG):
  1350.     arga = -arga;
  1351.     argb = 0;
  1352.     res = arga + argb;
  1353.     break;
  1354.       LABEL (O_SUBX):
  1355.     arga += C;
  1356.       LABEL (O_SUB):
  1357.       LABEL (O_SUBS):
  1358.     arga = - arga;
  1359.       LABEL (O_ADD):
  1360.       LABEL (O_ADDS):
  1361.     res = arga + argb;
  1362.     break;
  1363.  
  1364.       LABEL (O_ADDX):
  1365.     res = arga + argb + C;
  1366.     break;
  1367.  
  1368.       LABEL (O_AND):
  1369.       LABEL (O_ANDC):
  1370.     res = arga & argb;
  1371.     break;
  1372.     break;
  1373.  
  1374.       LABEL (O_BCLR):
  1375.     arga &= 0xf;
  1376.     bit = (argb & (1 << arga));
  1377.     res = argb & ~(1 << arga);
  1378.       goto bitop;
  1379.  
  1380.  
  1381.       LABEL (O_BRA):
  1382.       LABEL (O_BT):
  1383.     if (1)
  1384.       goto condtrue;
  1385.  
  1386.       LABEL (O_BRN):
  1387.       LABEL (O_BF):
  1388.     if (0)
  1389.       goto condtrue;
  1390.     break;
  1391.  
  1392.       LABEL (O_BHI):
  1393.     if ((C || Z) == 0)
  1394.       goto condtrue;
  1395.     break;
  1396.  
  1397.       LABEL (O_BLS):
  1398.     if ((C || Z))
  1399.       goto condtrue;
  1400.     break;
  1401.  
  1402.       LABEL (O_BCS):
  1403.       LABEL (O_BLO):
  1404.     if ((C == 1))
  1405.       goto condtrue;
  1406.     break;
  1407.  
  1408.       LABEL (O_BCC):
  1409.       LABEL (O_BHS):
  1410.     if ((C == 0))
  1411.       goto condtrue;
  1412.     break;
  1413.  
  1414.       LABEL (O_BEQ):
  1415.     if (Z)
  1416.       goto condtrue;
  1417.     break;
  1418.       LABEL (O_BGT):
  1419.     if (((Z || (N ^ V)) == 0))
  1420.       goto condtrue;
  1421.     break;
  1422.  
  1423.  
  1424.       LABEL (O_BLE):
  1425.     if (((Z || (N ^ V)) == 1))
  1426.       goto condtrue;
  1427.     break;
  1428.  
  1429.       LABEL (O_BGE):
  1430.     if ((N ^ V) == 0)
  1431.       goto condtrue;
  1432.     break;
  1433.       LABEL (O_BLT):
  1434.     if ((N ^ V))
  1435.       goto condtrue;
  1436.     break;
  1437.       LABEL (O_BMI):
  1438.     if ((N))
  1439.       goto condtrue;
  1440.     break;
  1441.       LABEL (O_BNE):
  1442.     if ((Z == 0))
  1443.       goto condtrue;
  1444.     break;
  1445.       LABEL (O_BPL):
  1446.     if (N == 0)
  1447.       goto condtrue;
  1448.     break;
  1449.     break;
  1450.       LABEL (O_BVC):
  1451.     if ((V == 0))
  1452.       goto condtrue;
  1453.     break;
  1454.       LABEL (O_BVS):
  1455.     if ((V == 1))
  1456.       goto condtrue;
  1457.     break;
  1458.  
  1459.       LABEL (O_BNOT):
  1460.     arga = 1 << (arga & 0xf);
  1461.     bit = (argb & arga);
  1462.     res = (argb & ~arga) | ~(argb & arga);
  1463.     break;
  1464.  
  1465.       LABEL (O_BSET):
  1466.     arga = 1 << (arga & 0xf);
  1467.     bit = argb & arga;
  1468.     res = argb | arga;
  1469.       goto bitop;
  1470.     break;
  1471.  
  1472.       LABEL (O_PJMP):
  1473.     pc = arga;
  1474.     goto next;
  1475.  
  1476.       LABEL (O_UNLK):
  1477.       {
  1478.     int t;
  1479.     SET_NORMREG (R7, GET_NORMREG (R6));
  1480.     POPWORD (t);
  1481.       SET_NORMREG (R6,t);
  1482.     pc = code->next_pc;
  1483.     goto next;
  1484.       }
  1485.  
  1486.       LABEL (O_RTS):
  1487.     {
  1488.       int cp = pc & 0xff0000;
  1489.       POPWORD (pc);
  1490.       pc |= cp;
  1491.       goto next;
  1492.     }
  1493.     break;
  1494.  
  1495.       LABEL (O_PRTS):
  1496.     {
  1497.       int cp;
  1498.       int off;
  1499.       POPWORD (cp);
  1500.       POPWORD (off);
  1501.       cp <<= 16;
  1502.       SET_SEGREG (R_CP, cp);
  1503.       pc = cp + off;
  1504.     }
  1505.     goto next;
  1506.  
  1507.       LABEL (O_PJSR):
  1508.     PUSHWORD (argb & 0xffff);
  1509.     PUSHWORD (argb >> 16);
  1510.     pc = arga;
  1511.     goto next;
  1512.  
  1513.       LABEL (O_BSR):
  1514.       LABEL (O_JSR):
  1515.     PUSHWORD (argb);
  1516.     pc = arga;
  1517.     goto next;
  1518.  
  1519.       LABEL (O_BTST):
  1520.     Z = (((argb >> (arga & 0xf)) &  1)== 0);
  1521.       pc = code->next_pc;
  1522.       goto next;
  1523.  
  1524.       LABEL (O_CLR):
  1525.     res = 0;
  1526.     break;
  1527.  
  1528.       LABEL (O_CMP):
  1529.     arga = -arga;
  1530.     res = arga + argb;
  1531.     break;
  1532.  
  1533.       LABEL (O_DADD):
  1534.     res = arga + argb + C;
  1535.       if (res > 99) {
  1536.     res -= 100;
  1537.     C = 1;
  1538.       }
  1539.       else {
  1540.     C = 0;
  1541.       }
  1542.       Z = Z && (res == 0);
  1543.       break;
  1544.       
  1545.  
  1546.       LABEL (O_DSUB):
  1547.     res = argb  - arga - C;
  1548.       if (res < 0)
  1549.     {
  1550.       res += 100;
  1551.       C = 1;
  1552.     }
  1553.       else {
  1554.     C = 0;
  1555.       }
  1556.       Z = Z && (res == 0);
  1557.       break;
  1558.  
  1559.       LABEL (O_EXTS):
  1560.     res = SEXTCHAR (arga);
  1561.     break;
  1562.  
  1563.       LABEL (O_EXTU):
  1564.     res = (unsigned char) arga;
  1565.     break;
  1566.  
  1567.       LABEL (O_JMP):
  1568.     pc = arga | (pc & 0xff0000);
  1569.     goto next;
  1570.     break;
  1571.  
  1572.       LABEL (O_LDM):
  1573.         
  1574.        for (tmp = 0; tmp < 7; tmp++)
  1575.      {
  1576.        if (argb & (1<<tmp)) {
  1577.          POPWORD (cpu.regs[tmp].s[LOW]);
  1578.        }
  1579.      }
  1580.     if (argb & 0x80)
  1581.         POPWORD (tmp); /* dummy ready for sp */
  1582.       goto nextpc;
  1583.       break;
  1584.  
  1585.       LABEL (O_LINK):
  1586.     PUSHWORD (cpu.regs[R6].s[LOW]);
  1587.     cpu.regs[R6].s[LOW] = cpu.regs[R7].s[LOW];
  1588.     cpu.regs[R7].s[LOW] += argb;
  1589.       goto nextpc;
  1590.  
  1591.       LABEL (O_STC):
  1592.       LABEL (O_LDC):
  1593.       LABEL (O_MOVFPE):
  1594.       LABEL (O_MOVTPE):
  1595.       LABEL (O_MOV):
  1596.       LABEL (O_TST):
  1597.     res = arga;
  1598.     break;
  1599.  
  1600.       LABEL (O_TRAPA):
  1601.     if (arga == 15)
  1602.       {
  1603.         trap ();
  1604.       }
  1605.     else
  1606.       {
  1607.         PUSHWORD (pc & 0xffff);
  1608.         if (cpu.maximum)
  1609.           {
  1610.         PUSHWORD (NORMAL_CP);
  1611.           }
  1612.         PUSHWORD (NORMAL_SR);
  1613.         if (cpu.maximum)
  1614.           {
  1615.         arga = arga * 4 + 0x40;
  1616.         SET_NORMAL_CPPC (longat (cpu.memory + arga));
  1617.           }
  1618.         else
  1619.           {
  1620.         arga = arga * 2 + 0x20;
  1621.         SET_NORMAL_CPPC (wordat (cpu.memory + arga));
  1622.           }
  1623.       }
  1624.     break;
  1625.  
  1626.       LABEL (O_OR):
  1627.       LABEL (O_ORC):
  1628.     res = arga | argb;
  1629.     break;
  1630.  
  1631.       LABEL (O_XOR):
  1632.       LABEL (O_XORC):
  1633.     res = arga ^ argb;
  1634.     break;
  1635.  
  1636.       LABEL (O_SCB_F):
  1637.     {
  1638.     scb_f:
  1639.       res = arga - 1;
  1640.       code->srcb.reg.wptr[0] = res;
  1641.       if (res != -1)
  1642.         {
  1643.           pc = argb;
  1644.           goto next;
  1645.         }
  1646.     }
  1647.     break;
  1648.  
  1649.       LABEL (O_SCB_EQ):
  1650.     if (Z == 1)
  1651.       break;
  1652.     else
  1653.       goto scb_f;
  1654.  
  1655.       LABEL (O_SCB_NE):
  1656.     if (Z == 0)
  1657.       break;
  1658.     else
  1659.       goto scb_f;
  1660.  
  1661.       LABEL (O_NOP):
  1662.     /* If only they were all as simple as this */
  1663.     break;
  1664.  
  1665.       LABEL (O_ROTL):
  1666.     res = arga << 1;
  1667.     C = (res >> argb) & 1;
  1668.     res |= C;
  1669.     break;
  1670.  
  1671.  
  1672.       LABEL (O_ROTR):
  1673.     C = arga & 1;
  1674.     res = arga >> 1;
  1675.     res |= (C << (argb - 1));
  1676.     break;
  1677.  
  1678.       LABEL (O_ROTXL):
  1679.     res = arga << 1;
  1680.     res |= C;
  1681.     C = (res >> argb) & 1;
  1682.     break;
  1683.  
  1684.       LABEL (O_ROTXR):
  1685.     res = arga >> 1;
  1686.     res |= (C << (argb - 1));
  1687.     C = arga & 1;
  1688.     break;
  1689.  
  1690.       LABEL (O_SHAL):
  1691.     res = arga << 1;
  1692.     if (argb == 16)
  1693.       {
  1694.         C = (res >> (16)) & 1;
  1695.         Z = ((res & 0xffff) == 0);
  1696.         N = ((res & 0x8000) != 0);
  1697.       }
  1698.  
  1699.     else
  1700.       {
  1701.         C = (res >> (8)) & 1;
  1702.         Z = ((res & 0xff) == 0);
  1703.         N = ((res & 0x80) != 0);
  1704.  
  1705.       }
  1706.     V = C ^ N;
  1707.     goto none;
  1708.  
  1709.       LABEL (O_SHAR):
  1710.     C = arga & 1;
  1711.     if (argb == 16)
  1712.       {
  1713.         res = ((short) arga) >> 1;
  1714.       }
  1715.     else
  1716.       {
  1717.         res = (SEXTCHAR (arga)) >> 1;
  1718.       }
  1719.     break;
  1720.  
  1721.       LABEL (O_SHLL):
  1722.     res = arga << 1;
  1723.     C = (res >> argb) & 1;
  1724.     break;
  1725.  
  1726.       LABEL (O_SHLR):
  1727.     C = arga & 1;
  1728.     res = arga >> 1;
  1729.     break;
  1730.  
  1731.       LABEL (O_DIVXU):
  1732.     if (arga == 0)
  1733.       {
  1734.         N = V = C = 0;
  1735.         Z = 1;
  1736.         cpu.exception = SIGILL;
  1737.       }
  1738.     else
  1739.       {
  1740.         int d = argb / arga;
  1741.         int m = argb % arga;
  1742.         if (code->dst.type == eas.s.ea_reg.s.dstlong)
  1743.           {
  1744.         res = (m << 16) | (d & 0xffff);
  1745.           }
  1746.         else
  1747.           {
  1748.         res = (m << 8) | (d & 0xff);
  1749.           }
  1750.  
  1751.       }
  1752.     break;
  1753.  
  1754.       LABEL (O_MULXU):
  1755.     res = arga * argb;
  1756.     break;
  1757.  
  1758.       LABEL (O_NOT):
  1759.     res = ~arga;
  1760.     break;
  1761.  
  1762.       LABEL (O_SWAP):
  1763.     res = ((arga >> 8) & 0xff) | ((arga << 8) & 0xff00);
  1764.     break;
  1765.  
  1766.  
  1767.       LABEL (O_STM):
  1768.     for (tmp = 7; tmp >= 0; tmp--)
  1769.       {
  1770.         if (arga & (1<<tmp))
  1771.           {
  1772.         PUSHWORD (cpu.regs[tmp].s[LOW]);
  1773.           }
  1774.       }
  1775.     goto nextpc;
  1776.  
  1777.       LABEL (O_TAS):
  1778.     C = 0;
  1779.     V = 0;
  1780.     Z = arga == 0;
  1781.     N = arga < 0;
  1782.     res = arga | 0x80;
  1783.     goto none;
  1784.  
  1785.       LABEL (O_PRTD):
  1786.       LABEL (O_XCH):
  1787.       LABEL (O_RTD):
  1788.     cpu.exception = SIGILL;
  1789.     goto next;
  1790.  
  1791.       LABEL (O_TRAP_VS):
  1792.       LABEL (O_SLEEP):
  1793.       LABEL (O_BPT):
  1794.     cpu.exception = SIGTRAP;
  1795.     goto next;
  1796.     break;
  1797.       }
  1798.  
  1799.       ENDDISPATCH;
  1800.  
  1801.       DISPATCH (code->flags)
  1802.       {
  1803.       bitop:
  1804.     Z = res == 0;
  1805.     pc = code->next_pc;
  1806.     break;
  1807.       LABEL (FLAG_multword):
  1808.     Z = (res & 0xffff) == 0;
  1809.     N = (res & 0x8000) != 0;
  1810.     V = 0;
  1811.     C = 0;
  1812.     pc = code->next_pc;
  1813.     break;
  1814.  
  1815.       LABEL (FLAG_multbyte):
  1816.     /* 8*8 -> 16 */
  1817.     Z = (res & 0xff) == 0;
  1818.     N = (res & 0x80) != 0;
  1819.     V = 0;
  1820.     C = 0;
  1821.     pc = code->next_pc;
  1822.     break;
  1823.  
  1824.       LABEL (FLAG_shiftword):
  1825.     N = (res & 0x8000) != 0;
  1826.     Z = (res & 0xffff) == 0;
  1827.     V = 0;
  1828.     pc = code->next_pc;
  1829.     break;
  1830.  
  1831.       LABEL (FLAG_shiftbyte):
  1832.     N = (res & 0x80) != 0;
  1833.     Z = (res & 0xff) == 0;
  1834.     V = 0;
  1835.     pc = code->next_pc;
  1836.     break;
  1837.  
  1838.       LABEL (FLAG_special):
  1839.     pc = code->next_pc;
  1840.     break;
  1841.  
  1842.       LABEL (FLAG_m):
  1843.     /* Move byte flags */
  1844.     /* after a logical instruction */
  1845.     N = (res & 0x80) != 0;
  1846.     Z = (res & 0xff) == 0;
  1847.     V = (((~arga & ~argb & res) | (arga & argb & ~res)) & 0x80) != 0;
  1848.     pc = code->next_pc;
  1849.     break;
  1850.  
  1851.       LABEL (FLAG_M):
  1852.     /* Move word flags */
  1853.     /* after a logical instruction */
  1854.     N = (res & 0x8000) != 0;
  1855.     Z = (res & 0xffff) == 0;
  1856.     V = (((~arga & ~argb & res) | (arga & argb & ~res)) & 0x8000) != 0;
  1857.     pc = code->next_pc;
  1858.     break;
  1859.  
  1860.       LABEL (FLAG_a):
  1861.     /* after byte sized arith */
  1862.     C = (res & 0x100) != 0;
  1863.     N = (res & 0x80) != 0;
  1864.     Z = (res & 0xff) == 0;
  1865.     V = (((~arga & ~argb & res) | (arga & argb & ~res)) & 0x80) != 0;
  1866.     pc = code->next_pc;
  1867.     break;
  1868.  
  1869.       LABEL (FLAG_A):
  1870.     /* after word sized arith */
  1871.     C = (res & 0x10000) != 0;
  1872.     N = (res & 0x8000) != 0;
  1873.     Z = (res & 0xffff) == 0;
  1874.     V = (((~arga & ~argb & res) | (arga & argb & ~res)) & 0x8000) != 0;
  1875.     pc = code->next_pc;
  1876.     break;
  1877.  
  1878.       LABEL (FLAG_NONE):
  1879.       none:;
  1880.     /* no flags but store */
  1881.     pc = code->next_pc;
  1882.     break;
  1883.       LABEL (FLAG_NOSTORE):
  1884.     /* no flags and no store */
  1885.     pc = code->next_pc;
  1886.     break;
  1887.       LABEL (FLAG_CLEAR):
  1888.     /* clear flags */
  1889.     N = 0;
  1890.     Z = 1;
  1891.     V = 0;
  1892.     C = 0;
  1893.         pc = code->next_pc;
  1894.     break;
  1895.       condtrue:
  1896.     pc = arga;
  1897.     goto next;
  1898.       }
  1899.       ENDDISPATCH;
  1900.  
  1901.       DISPATCH (code->dst.type)
  1902.       {
  1903.     unsigned char *lval;
  1904.  
  1905.     LABEL (STORE_CRB):
  1906.     (*(code->dst.reg.segptr)) = cpu.memory + (res << 16);
  1907.     break;
  1908.  
  1909.     LABEL (STORE_NOP):
  1910.     break;
  1911.  
  1912.     LABEL (STORE_REG_B):
  1913.     (*(code->dst.reg.bptr)) = res;
  1914.     break;
  1915.  
  1916.     LABEL (STORE_REG_W):
  1917.     (*(code->dst.reg.wptr)) = res;
  1918.     break;
  1919.  
  1920.     LABEL (STORE_REG_L):
  1921.     (*(code->dst.reg.wptr)) = res >> 16;
  1922.     (*(code->dst.reg.wptr + 2)) = res & 0xffff;
  1923.     break;
  1924.  
  1925.     LABEL (STORE_DISP_W):
  1926.     lval = displval (code->dst);
  1927.     setwordat (lval, res);
  1928.     break;
  1929.  
  1930.     LABEL (STORE_DISP_B):
  1931.     lval = displval (code->dst);
  1932.     setbyteat (lval, res);
  1933.     break;
  1934.  
  1935.     LABEL (STORE_INC_B):
  1936.     lval = elval (code->dst, 0);
  1937.     setbyteat (lval, res);
  1938.     (*(code->dst.reg.wptr))++;
  1939.     break;
  1940.  
  1941.     LABEL (STORE_INC_W):
  1942.     lval = elval (code->dst, 0);
  1943.     setwordat (lval, res);
  1944.     (*(code->dst.reg.wptr)) += 2;
  1945.     break;
  1946.  
  1947.     LABEL (STORE_DEC_B):
  1948.     (*(code->dst.reg.wptr))--;
  1949.     lval = elval (code->dst, 0);
  1950.     setbyteat (lval, res);
  1951.     break;
  1952.  
  1953.     LABEL (STORE_CRW):
  1954.     /* Make an up to date sr from the flag state */
  1955.     cpu.regs[R_SR].s[LOW] = res;
  1956.     GETSR ();
  1957.     break;
  1958.  
  1959.     LABEL (STORE_DEC_W):
  1960.     (*(code->dst.reg.wptr)) -= 2;
  1961.     lval = elval (code->dst, 0);
  1962.     setwordat (lval, res);
  1963.  
  1964.     break;
  1965.  
  1966.       nextpc:
  1967.     pc = code->next_pc;
  1968.  
  1969.       }
  1970.       ENDDISPATCH;
  1971.     next:;
  1972.  
  1973.     }
  1974.   while (!cpu.exception);
  1975.   cpu.ticks += get_now() - tick_start;
  1976.   cpu.cycles += cycles;
  1977.   cpu.insts += insts;
  1978.   cpu.regs[R_PC].s[LOW] = pc;
  1979.   BUILDSR ();
  1980.  
  1981.  
  1982.   signal (SIGINT, prev);
  1983. }
  1984.  
  1985.  
  1986.  
  1987.  
  1988. void
  1989. sim_write (addr, buffer, size)
  1990.      long int addr;
  1991.      unsigned char *buffer;
  1992.      int size;
  1993. {
  1994.   int i;
  1995.  
  1996.   init_pointers ();
  1997.   if (addr < 0 || addr + size > MSIZE)
  1998.     return;
  1999.   for (i = 0; i < size; i++)
  2000.     {
  2001.       cpu.memory[addr + i] = buffer[i];
  2002.       cpu.cache_idx[addr + i] = 0;
  2003.     }
  2004. }
  2005.  
  2006. void
  2007. sim_read (addr, buffer, size)
  2008.      long int addr;
  2009.      char *buffer;
  2010.      int size;
  2011. {
  2012.   init_pointers ();
  2013.   if (addr < 0 || addr + size > MSIZE)
  2014.     return;
  2015.   memcpy (buffer, cpu.memory + addr, size);
  2016. }
  2017.  
  2018. /* Ripped off from tm-h8500.h */
  2019.  
  2020. #define R0_REGNUM    0
  2021. #define R1_REGNUM    1
  2022. #define R2_REGNUM    2
  2023. #define R3_REGNUM    3
  2024. #define R4_REGNUM    4
  2025. #define R5_REGNUM    5
  2026. #define R6_REGNUM    6
  2027. #define R7_REGNUM    7
  2028.  
  2029. #define SP_REGNUM       R7_REGNUM    /* Contains address of top of stack */
  2030. #define FP_REGNUM       R6_REGNUM    /* Contains address of executing stack frame */
  2031.  
  2032. #define CCR_REGNUM      8    /* Contains processor status */
  2033. #define PC_REGNUM       9    /* Contains program counter */
  2034.  
  2035. #define SEG_C_REGNUM    10    /* Segment registers */
  2036. #define SEG_D_REGNUM    11
  2037. #define SEG_E_REGNUM    12
  2038. #define SEG_T_REGNUM    13
  2039.  
  2040. #define CYCLE_REGNUM    14
  2041. #define INST_REGNUM     15
  2042. #define TICK_REGNUM     16
  2043.  
  2044. sim_store_register (rn, value)
  2045.      int rn;
  2046.      int value;
  2047. {
  2048.   int seg;
  2049.   int reg = -1;
  2050.  
  2051.   init_pointers ();
  2052.   switch (rn)
  2053.     {
  2054.     case PC_REGNUM:
  2055.       seg = R_CP;
  2056.       reg = R_PC;
  2057.       break;
  2058.     case SEG_C_REGNUM:
  2059.     case SEG_D_REGNUM:
  2060.     case SEG_E_REGNUM:
  2061.     case SEG_T_REGNUM:
  2062.       value <<= 16;
  2063.       seg = rn - SEG_C_REGNUM + R_CP;
  2064.       reg = -1;
  2065.       break;
  2066.     default:
  2067.       abort ();
  2068.     case R0_REGNUM:
  2069.     case R1_REGNUM:
  2070.     case R2_REGNUM:
  2071.     case R3_REGNUM:
  2072.     case R4_REGNUM:
  2073.     case R5_REGNUM:
  2074.     case R6_REGNUM:
  2075.     case R7_REGNUM:
  2076.       seg = 0;
  2077.       reg = rn - GR0 + R0_REGNUM;
  2078.       break;
  2079.     case CCR_REGNUM:
  2080.       seg = 0;
  2081.       reg = R_SR;
  2082.       break;
  2083.     case CYCLE_REGNUM:
  2084.       cpu.cycles = value;
  2085.       return;
  2086.     case INST_REGNUM:
  2087.       cpu.insts = value;
  2088.      return;
  2089.     case TICK_REGNUM:
  2090.       cpu.ticks = value;
  2091.      return;
  2092.     }
  2093.  
  2094.   if (seg)
  2095.     SET_SEGREG (seg, value);
  2096.  
  2097.   if (reg > 0)
  2098.     {
  2099.       cpu.regs[reg].s[LOW] = value & 0xffff;
  2100.     }
  2101. }
  2102.  
  2103. sim_fetch_register (rn, buf)
  2104.      gdbreg_type rn;
  2105.      char *buf;
  2106. {
  2107.   init_pointers ();
  2108.  
  2109.   switch (rn)
  2110.     {
  2111.     default:
  2112.       abort ();
  2113.     case SEG_C_REGNUM:
  2114.     case SEG_D_REGNUM:
  2115.     case SEG_E_REGNUM:
  2116.     case SEG_T_REGNUM:
  2117.       buf[0] = ((cpu.regs[rn - SEG_C_REGNUM + R_CP].c - cpu.memory) >> 16);
  2118.       break;
  2119.     case CCR_REGNUM:
  2120.       buf[0] = cpu.regs[R_SR].s[HIGH];
  2121.       buf[1] = cpu.regs[R_SR].s[LOW];
  2122.       break;
  2123.     case PC_REGNUM:
  2124.       buf[0] = HIGH_BYTE (cpu.regs[R_PC].s[LOW]);
  2125.       buf[1] = LOW_BYTE (cpu.regs[R_PC].s[LOW]);
  2126.       break;
  2127.     case R0_REGNUM:
  2128.     case R1_REGNUM:
  2129.     case R2_REGNUM:
  2130.     case R3_REGNUM:
  2131.     case R4_REGNUM:
  2132.     case R5_REGNUM:
  2133.     case R6_REGNUM:
  2134.     case R7_REGNUM:
  2135.       buf[0] = HIGH_BYTE (cpu.regs[rn].s[LOW]);
  2136.       buf[1] = LOW_BYTE (cpu.regs[rn].s[LOW]);
  2137.       break;
  2138.     case CYCLE_REGNUM:
  2139.       buf[0] = cpu.cycles >> 24;
  2140.       buf[1] = cpu.cycles >> 16;
  2141.       buf[2] = cpu.cycles >> 8;
  2142.       buf[3] = cpu.cycles >> 0;
  2143.       break;
  2144.  
  2145.     case TICK_REGNUM:
  2146.       buf[0] = cpu.ticks >> 24;
  2147.       buf[1] = cpu.ticks >> 16;
  2148.       buf[2] = cpu.ticks >> 8;
  2149.       buf[3] = cpu.ticks >> 0;
  2150.       break;
  2151.  
  2152.     case INST_REGNUM:
  2153.       buf[0] = cpu.insts >> 24;
  2154.       buf[1] = cpu.insts >> 16;
  2155.       buf[2] = cpu.insts >> 8;
  2156.       buf[3] = cpu.insts >> 0;
  2157.       break;
  2158.       
  2159.     }
  2160. }
  2161.  
  2162. int
  2163. sim_trace ()
  2164. {
  2165.  
  2166.   int i;
  2167.  
  2168.   for (i = 0; i < 12; i += 2)
  2169.     {
  2170.       unsigned char *p = cpu.regs[R_TP].c + ((cpu.regs[R6].s[LOW] + i) & 0xffff);
  2171.       unsigned short *j = (unsigned short *) p;
  2172.  
  2173.       printf ("%04x ", *j);
  2174.     }
  2175.   printf ("\n");
  2176.   printf ("%02x %02x %02x %02x:%04x %04x %04x %04x %04x %04x %04x %04x %04x\n",
  2177.       NORMAL_DP,
  2178.       NORMAL_EP,
  2179.       NORMAL_TP,
  2180.       NORMAL_CP,
  2181.       cpu.regs[R_PC].s[LOW],
  2182.       cpu.regs[0].s[LOW],
  2183.       cpu.regs[1].s[LOW],
  2184.       cpu.regs[2].s[LOW],
  2185.       cpu.regs[3].s[LOW],
  2186.       cpu.regs[4].s[LOW],
  2187.       cpu.regs[5].s[LOW],
  2188.       cpu.regs[6].s[LOW],
  2189.       cpu.regs[7].s[LOW]);
  2190.   sim_resume (1);
  2191.   return 0;
  2192. }
  2193.  
  2194. sim_stop_signal ()
  2195. {
  2196.   return cpu.exception;
  2197. }
  2198.  
  2199. sim_set_pc (n)
  2200. {
  2201.   sim_store_register (PC_REGNUM, n);
  2202. }
  2203.  
  2204.  
  2205. sim_csize (n)
  2206. {
  2207.   if (cpu.cache)
  2208.     free (cpu.cache);
  2209.   if (n < 2)
  2210.     n = 2;
  2211.   cpu.cache = (decoded_inst *) malloc (sizeof (decoded_inst) * n);
  2212.   cpu.csize = n;
  2213. }
  2214.  
  2215.  
  2216.  
  2217.  
  2218. sim_info()
  2219. {
  2220.   double timetaken = (double) cpu.ticks / (double) now_persec ();
  2221.   double virttime = cpu.cycles / 10.0e6;
  2222.  
  2223.   printf("\n\ninstructions executed  %10d\n", cpu.insts);
  2224.   printf("cycles (v approximate) %10d\n", cpu.cycles);
  2225.   printf("real time taken        %10.4f\n", timetaken);
  2226.   printf("virtual time taked     %10.4f\n", virttime);
  2227.   printf("simulation ratio       %10.4f\n", virttime/timetaken);
  2228.   printf("compiles               %10d\n", cpu.compiles);
  2229.   printf("cache size             %10d\n", cpu.csize);
  2230. }
  2231.  
  2232.