sim/h8300/compile.c

   1 /*
   2  * Simulator for the Hitachi H8/300 architecture.
   3  *
   4  * Written by Steve Chamberlain of Cygnus Support. sac@cygnus.com
   5  *
   6  * This file is part of H8/300 sim
   7  *
   8  *
   9  * THIS SOFTWARE IS NOT COPYRIGHTED
  10  *
  11  * Cygnus offers the following for use in the public domain.  Cygnus makes no
  12  * warranty with regard to the software or its performance and the user
  13  * accepts the software "AS IS" with all faults.
  14  *
  15  * CYGNUS DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD TO THIS
  16  * SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY
  17  * AND FITNESS FOR A PARTICULAR PURPOSE.
  18  */
  19
  20 #include "config.h"
  21
  22 #include <stdio.h>
  23 #include <signal.h>
  24 #ifdef HAVE_TIME_H
  25 #include <time.h>
  26 #endif
  27 #ifdef HAVE_STDLIB_H
  28 #include <stdlib.h>
  29 #endif
  30 #ifdef HAVE_SYS_PARAM_H
  31 #include <sys/param.h>
  32 #endif
  33 #include "ansidecl.h"
  34 #include "bfd.h"
  35 #include "callback.h"
  36 #include "remote-sim.h"
  37
  38 #ifndef SIGTRAP
  39 # define SIGTRAP 5
  40 #endif
  41
  42 int debug;
  43
  44 host_callback *sim_callback;
  45
  46 static SIM_OPEN_KIND sim_kind;
  47 static char *myname;
  48
  49 /* FIXME: Needs to live in header file.
  50    This header should also include the things in remote-sim.h.
  51    One could move this to remote-sim.h but this function isn't needed
  52    by gdb.  */
  53 void sim_set_simcache_size PARAMS ((int));
  54
  55 #define X(op, size)  op*4+size
  56
  57 #define SP (h8300hmode ? SL:SW)
  58 #define SB 0
  59 #define SW 1
  60 #define SL 2
  61 #define OP_REG 1
  62 #define OP_DEC 2
  63 #define OP_DISP 3
  64 #define OP_INC 4
  65 #define OP_PCREL 5
  66 #define OP_MEM 6
  67 #define OP_CCR 7
  68 #define OP_IMM 8
  69 #define OP_ABS 10
  70 #define h8_opcodes ops
  71 #define DEFINE_TABLE
  72 #include "opcode/h8300.h"
  73
  74 #include "inst.h"
  75
  76 /* The rate at which to call the host's poll_quit callback.  */
  77
  78 #define POLL_QUIT_INTERVAL 0x80000
  79
  80 #define LOW_BYTE(x) ((x) & 0xff)
  81 #define HIGH_BYTE(x) (((x)>>8) & 0xff)
  82 #define P(X,Y) ((X<<8) | Y)
  83
  84 #define BUILDSR()   cpu.ccr = (N << 3) | (Z << 2) | (V<<1) | C;
  85
  86 #define GETSR()             \
  87   c = (cpu.ccr >> 0) & 1;\
  88   v = (cpu.ccr >> 1) & 1;\
  89   nz = !((cpu.ccr >> 2) & 1);\
  90   n = (cpu.ccr >> 3) & 1;
  91
  92 #ifdef __CHAR_IS_SIGNED__
  93 #define SEXTCHAR(x) ((char)(x))
  94 #endif
  95
  96 #ifndef SEXTCHAR
  97 #define SEXTCHAR(x) ((x & 0x80) ? (x | ~0xff): x & 0xff)
  98 #endif
  99
 100 #define UEXTCHAR(x) ((x) & 0xff)
 101 #define UEXTSHORT(x) ((x) & 0xffff)
 102 #define SEXTSHORT(x) ((short)(x))
 103
 104 static cpu_state_type cpu;
 105
 106 int h8300hmode = 0;
 107 int h8300smode = 0;
 108
 109 static int memory_size;
 110
 111 static int
 112 get_now ()
 113 {
 114 #ifndef WIN32
 115   return time (0);
 116 #endif
 117   return 0;
 118 }
 119
 120 static int
 121 now_persec ()
 122 {
 123   return 1;
 124 }
 125
 126 static int
 127 bitfrom (x)
 128 {
 129   switch (x & SIZE)
 130     {
 131     case L_8:
 132       return SB;
 133     case L_16:
 134       return SW;
 135     case L_32:
 136       return SL;
 137     case L_P:
 138       return h8300hmode ? SL : SW;
 139     }
 140 }
 141
 142 static unsigned int
 143 lvalue (x, rn)
 144 {
 145   switch (x / 4)
 146     {
 147     case OP_DISP:
 148       if (rn == 8)
 149         {
 150           return X (OP_IMM, SP);
 151         }
 152       return X (OP_REG, SP);
 153
 154     case OP_MEM:
 155       return X (OP_MEM, SP);
 156
 157     default:
 158       abort ();
 159     }
 160 }
 161
 162 static unsigned int
 163 decode (addr, data, dst)
 164      int addr;
 165      unsigned char *data;
 166      decoded_inst *dst;
 167
 168 {
 169   int rs = 0;
 170   int rd = 0;
 171   int rdisp = 0;
 172   int abs = 0;
 173   int bit = 0;
 174   int plen = 0;
 175   struct h8_opcode *q = h8_opcodes;
 176   int size = 0;
 177
 178   dst->dst.type = -1;
 179   dst->src.type = -1;
 180
 181   /* Find the exact opcode/arg combo.  */
 182   while (q->name)
 183     {
 184       op_type *nib;
 185       unsigned int len = 0;
 186
 187       nib = q->data.nib;
 188
 189       while (1)
 190         {
 191           op_type looking_for = *nib;
 192           int thisnib = data[len >> 1];
 193
 194           thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf);
 195
 196           if (looking_for < 16 && looking_for >= 0)
 197             {
 198               if (looking_for != thisnib)
 199                 goto fail;
 200             }
 201           else
 202             {
 203               if ((int) looking_for & (int) B31)
 204                 {
 205                   if (!(((int) thisnib & 0x8) != 0))
 206                     goto fail;
 207
 208                   looking_for = (op_type) ((int) looking_for & ~(int) B31);
 209                   thisnib &= 0x7;
 210                 }
 211
 212               if ((int) looking_for & (int) B30)
 213                 {
 214                   if (!(((int) thisnib & 0x8) == 0))
 215                     goto fail;
 216
 217                   looking_for = (op_type) ((int) looking_for & ~(int) B30);
 218                 }
 219
 220               if (looking_for & DBIT)
 221                 {
 222                   /* Exclude adds/subs by looking at bit 0 and 2, and
 223                      make sure the operand size, either w or l,
 224                      matches by looking at bit 1.  */
 225                   if ((looking_for & 7) != (thisnib & 7))
 226                     goto fail;
 227
 228                   abs = (thisnib & 0x8) ? 2 : 1;
 229                 }
 230               else if (looking_for & (REG | IND | INC | DEC))
 231                 {
 232                   if (looking_for & REG)
 233                     {
 234                       /* Can work out size from the register.  */
 235                       size = bitfrom (looking_for);
 236                     }
 237                   if (looking_for & SRC)
 238                     rs = thisnib;
 239                   else
 240                     rd = thisnib;
 241                 }
 242               else if (looking_for & L_16)
 243                 {
 244                   abs = (data[len >> 1]) * 256 + data[(len + 2) >> 1];
 245                   plen = 16;
 246                   if (looking_for & (PCREL | DISP))
 247                     {
 248                       abs = (short) (abs);
 249                     }
 250                 }
 251               else if (looking_for & ABSJMP)
 252                 {
 253                   abs = (data[1] << 16) | (data[2] << 8) | (data[3]);
 254                 }
 255               else if (looking_for & MEMIND)
 256                 {
 257                   abs = data[1];
 258                 }
 259               else if (looking_for & L_32)
 260                 {
 261                   int i = len >> 1;
 262
 263                   abs = (data[i] << 24)
 264                     | (data[i + 1] << 16)
 265                     | (data[i + 2] << 8)
 266                     | (data[i + 3]);
 267
 268                   plen = 32;
 269                 }
 270               else if (looking_for & L_24)
 271                 {
 272                   int i = len >> 1;
 273
 274                   abs = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
 275                   plen = 24;
 276                 }
 277               else if (looking_for & IGNORE)
 278                 {
 279                   ;
 280                 }
 281               else if (looking_for & DISPREG)
 282                 {
 283                   rdisp = thisnib & 0x7;
 284                 }
 285               else if (looking_for & KBIT)
 286                 {
 287                   switch (thisnib)
 288                     {
 289                     case 9:
 290                       abs = 4;
 291                       break;
 292                     case 8:
 293                       abs = 2;
 294                       break;
 295                     case 0:
 296                       abs = 1;
 297                       break;
 298                     default:
 299                       goto fail;
 300                     }
 301                 }
 302               else if (looking_for & L_8)
 303                 {
 304                   plen = 8;
 305
 306                   if (looking_for & PCREL)
 307                     {
 308                       abs = SEXTCHAR (data[len >> 1]);
 309                     }
 310                   else if (looking_for & ABS8MEM)
 311                     {
 312                       plen = 8;
 313                       abs = h8300hmode ? ~0xff0000ff : ~0xffff00ff;
 314                       abs |= data[len >> 1] & 0xff;
 315                     }
 316                   else
 317                     {
 318                       abs = data[len >> 1] & 0xff;
 319                     }
 320                 }
 321               else if (looking_for & L_3)
 322                 {
 323                   plen = 3;
 324
 325                   bit = thisnib;
 326                 }
 327               else if (looking_for == E)
 328                 {
 329                   dst->op = q;
 330
 331                   /* Fill in the args.  */
 332                   {
 333                     op_type *args = q->args.nib;
 334                     int hadone = 0;
 335
 336                     while (*args != E)
 337                       {
 338                         int x = *args;
 339                         int rn = (x & DST) ? rd : rs;
 340                         ea_type *p;
 341
 342                         if (x & DST)
 343                           p = &(dst->dst);
 344                         else
 345                           p = &(dst->src);
 346
 347                         if (x & L_3)
 348                           {
 349                             p->type = X (OP_IMM, size);
 350                             p->literal = bit;
 351                           }
 352                         else if (x & (IMM | KBIT | DBIT))
 353                           {
 354                             p->type = X (OP_IMM, size);
 355                             p->literal = abs;
 356                           }
 357                         else if (x & REG)
 358                           {
 359                             /* Reset the size, some
 360                                ops (like mul) have two sizes */
 361
 362                             size = bitfrom (x);
 363                             p->type = X (OP_REG, size);
 364                             p->reg = rn;
 365                           }
 366                         else if (x & INC)
 367                           {
 368                             p->type = X (OP_INC, size);
 369                             p->reg = rn & 0x7;
 370                           }
 371                         else if (x & DEC)
 372                           {
 373                             p->type = X (OP_DEC, size);
 374                             p->reg = rn & 0x7;
 375                           }
 376                         else if (x & IND)
 377                           {
 378                             p->type = X (OP_DISP, size);
 379                             p->reg = rn & 0x7;
 380                             p->literal = 0;
 381                           }
 382                         else if (x & (ABS | ABSJMP | ABS8MEM))
 383                           {
 384                             p->type = X (OP_DISP, size);
 385                             p->literal = abs;
 386                             p->reg = 8;
 387                           }
 388                         else if (x & MEMIND)
 389                           {
 390                             p->type = X (OP_MEM, size);
 391                             p->literal = abs;
 392                           }
 393                         else if (x & PCREL)
 394                           {
 395                             p->type = X (OP_PCREL, size);
 396                             p->literal = abs + addr + 2;
 397                             if (x & L_16)
 398                               p->literal += 2;
 399                           }
 400                         else if (x & ABSJMP)
 401                           {
 402                             p->type = X (OP_IMM, SP);
 403                             p->literal = abs;
 404                           }
 405                         else if (x & DISP)
 406                           {
 407                             p->type = X (OP_DISP, size);
 408                             p->literal = abs;
 409                             p->reg = rdisp & 0x7;
 410                           }
 411                         else if (x & CCR)
 412                           {
 413                             p->type = OP_CCR;
 414                           }
 415                         else
 416                           printf ("Hmmmm %x", x);
 417
 418                         args++;
 419                       }
 420                   }
 421
 422                   /* But a jmp or a jsr gets automagically lvalued,
 423                      since we branch to their address not their
 424                      contents.  */
 425                   if (q->how == O (O_JSR, SB)
 426                       || q->how == O (O_JMP, SB))
 427                     {
 428                       dst->src.type = lvalue (dst->src.type, dst->src.reg);
 429                     }
 430
 431                   if (dst->dst.type == -1)
 432                     dst->dst = dst->src;
 433
 434                   dst->opcode = q->how;
 435                   dst->cycles = q->time;
 436
 437                   /* And a jsr to 0xc4 is turned into a magic trap.  */
 438
 439                   if (dst->opcode == O (O_JSR, SB))
 440                     {
 441                       if (dst->src.literal == 0xc4)
 442                         {
 443                           dst->opcode = O (O_SYSCALL, SB);
 444                         }
 445                     }
 446
 447                   dst->next_pc = addr + len / 2;
 448                   return;
 449                 }
 450               else
 451                 printf ("Don't understand %x \n", looking_for);
 452             }
 453
 454           len++;
 455           nib++;
 456         }
 457
 458     fail:
 459       q++;
 460     }
 461
 462   /* Fell off the end.  */
 463   dst->opcode = O (O_ILL, SB);
 464 }
 465
 466 static void
 467 compile (pc)
 468 {
 469   int idx;
 470
 471   /* find the next cache entry to use */
 472
 473   idx = cpu.cache_top + 1;
 474   cpu.compiles++;
 475   if (idx >= cpu.csize)
 476     {
 477       idx = 1;
 478     }
 479   cpu.cache_top = idx;
 480
 481   /* Throw away its old meaning */
 482   cpu.cache_idx[cpu.cache[idx].oldpc] = 0;
 483
 484   /* set to new address */
 485   cpu.cache[idx].oldpc = pc;
 486
 487   /* fill in instruction info */
 488   decode (pc, cpu.memory + pc, cpu.cache + idx);
 489
 490   /* point to new cache entry */
 491   cpu.cache_idx[pc] = idx;
 492 }
 493
 494
 495 static unsigned char *breg[18];
 496 static unsigned short *wreg[18];
 497 static unsigned int *lreg[18];
 498
 499 #define GET_B_REG(x) *(breg[x])
 500 #define SET_B_REG(x,y) (*(breg[x])) = (y)
 501 #define GET_W_REG(x) *(wreg[x])
 502 #define SET_W_REG(x,y) (*(wreg[x])) = (y)
 503
 504 #define GET_L_REG(x) *(lreg[x])
 505 #define SET_L_REG(x,y) (*(lreg[x])) = (y)
 506
 507 #define GET_MEMORY_L(x) \
 508   (x < memory_size \
 509    ? ((cpu.memory[x+0] << 24) | (cpu.memory[x+1] << 16) \
 510       | (cpu.memory[x+2] << 8) | cpu.memory[x+3]) \
 511    : ((cpu.eightbit[(x+0) & 0xff] << 24) | (cpu.eightbit[(x+1) & 0xff] << 16) \
 512       | (cpu.eightbit[(x+2) & 0xff] << 8) | cpu.eightbit[(x+3) & 0xff]))
 513
 514 #define GET_MEMORY_W(x) \
 515   (x < memory_size \
 516    ? ((cpu.memory[x+0] << 8) | (cpu.memory[x+1] << 0)) \
 517    : ((cpu.eightbit[(x+0) & 0xff] << 8) | (cpu.eightbit[(x+1) & 0xff] << 0)))
 518
 519
 520 #define GET_MEMORY_B(x) \
 521   (x < memory_size ? (cpu.memory[x]) : (cpu.eightbit[x & 0xff]))
 522
 523 #define SET_MEMORY_L(x,y)  \
 524 {  register unsigned char *_p; register int __y = y; \
 525    _p = (x < memory_size ? cpu.memory+x : cpu.eightbit + (x & 0xff)); \
 526    _p[0] = (__y)>>24; _p[1] = (__y)>>16; \
 527    _p[2] = (__y)>>8; _p[3] = (__y)>>0;}
 528
 529 #define SET_MEMORY_W(x,y) \
 530 {  register unsigned char *_p; register int __y = y; \
 531    _p = (x < memory_size ? cpu.memory+x : cpu.eightbit + (x & 0xff)); \
 532    _p[0] = (__y)>>8; _p[1] =(__y);}
 533
 534 #define SET_MEMORY_B(x,y) \
 535   (x < memory_size ? (cpu.memory[(x)] = y) : (cpu.eightbit[x & 0xff] = y))
 536
 537 int
 538 fetch (arg, n)
 539      ea_type *arg;
 540 {
 541   int rn = arg->reg;
 542   int abs = arg->literal;
 543   int r;
 544   int t;
 545
 546   switch (arg->type)
 547     {
 548     case X (OP_REG, SB):
 549       return GET_B_REG (rn);
 550     case X (OP_REG, SW):
 551       return GET_W_REG (rn);
 552     case X (OP_REG, SL):
 553       return GET_L_REG (rn);
 554     case X (OP_IMM, SB):
 555     case X (OP_IMM, SW):
 556     case X (OP_IMM, SL):
 557       return abs;
 558     case X (OP_DEC, SB):
 559       abort ();
 560
 561     case X (OP_INC, SB):
 562       t = GET_L_REG (rn);
 563       t &= cpu.mask;
 564       r = GET_MEMORY_B (t);
 565       t++;
 566       t = t & cpu.mask;
 567       SET_L_REG (rn, t);
 568       return r;
 569       break;
 570     case X (OP_INC, SW):
 571       t = GET_L_REG (rn);
 572       t &= cpu.mask;
 573       r = GET_MEMORY_W (t);
 574       t += 2;
 575       t = t & cpu.mask;
 576       SET_L_REG (rn, t);
 577       return r;
 578     case X (OP_INC, SL):
 579       t = GET_L_REG (rn);
 580       t &= cpu.mask;
 581       r = GET_MEMORY_L (t);
 582
 583       t += 4;
 584       t = t & cpu.mask;
 585       SET_L_REG (rn, t);
 586       return r;
 587
 588     case X (OP_DISP, SB):
 589       t = GET_L_REG (rn) + abs;
 590       t &= cpu.mask;
 591       return GET_MEMORY_B (t);
 592
 593     case X (OP_DISP, SW):
 594       t = GET_L_REG (rn) + abs;
 595       t &= cpu.mask;
 596       return GET_MEMORY_W (t);
 597
 598     case X (OP_DISP, SL):
 599       t = GET_L_REG (rn) + abs;
 600       t &= cpu.mask;
 601       return GET_MEMORY_L (t);
 602
 603     case X (OP_MEM, SL):
 604       t = GET_MEMORY_L (abs);
 605       t &= cpu.mask;
 606       return t;
 607
 608     case X (OP_MEM, SW):
 609       t = GET_MEMORY_W (abs);
 610       t &= cpu.mask;
 611       return t;
 612
 613     default:
 614       abort ();
 615
 616     }
 617 }
 618
 619
 620 static
 621 void
 622 store (arg, n)
 623      ea_type *arg;
 624      int n;
 625 {
 626   int rn = arg->reg;
 627   int abs = arg->literal;
 628   int t;
 629
 630   switch (arg->type)
 631     {
 632     case X (OP_REG, SB):
 633       SET_B_REG (rn, n);
 634       break;
 635     case X (OP_REG, SW):
 636       SET_W_REG (rn, n);
 637       break;
 638     case X (OP_REG, SL):
 639       SET_L_REG (rn, n);
 640       break;
 641
 642     case X (OP_DEC, SB):
 643       t = GET_L_REG (rn) - 1;
 644       t &= cpu.mask;
 645       SET_L_REG (rn, t);
 646       SET_MEMORY_B (t, n);
 647
 648       break;
 649     case X (OP_DEC, SW):
 650       t = (GET_L_REG (rn) - 2) & cpu.mask;
 651       SET_L_REG (rn, t);
 652       SET_MEMORY_W (t, n);
 653       break;
 654
 655     case X (OP_DEC, SL):
 656       t = (GET_L_REG (rn) - 4) & cpu.mask;
 657       SET_L_REG (rn, t);
 658       SET_MEMORY_L (t, n);
 659       break;
 660
 661     case X (OP_DISP, SB):
 662       t = GET_L_REG (rn) + abs;
 663       t &= cpu.mask;
 664       SET_MEMORY_B (t, n);
 665       break;
 666
 667     case X (OP_DISP, SW):
 668       t = GET_L_REG (rn) + abs;
 669       t &= cpu.mask;
 670       SET_MEMORY_W (t, n);
 671       break;
 672
 673     case X (OP_DISP, SL):
 674       t = GET_L_REG (rn) + abs;
 675       t &= cpu.mask;
 676       SET_MEMORY_L (t, n);
 677       break;
 678     default:
 679       abort ();
 680     }
 681 }
 682
 683
 684 static union
 685 {
 686   short int i;
 687   struct
 688     {
 689       char low;
 690       char high;
 691     }
 692   u;
 693 }
 694
 695 littleendian;
 696
 697 static
 698 void
 699 init_pointers ()
 700 {
 701   static int init;
 702
 703   if (!init)
 704     {
 705       int i;
 706
 707       init = 1;
 708       littleendian.i = 1;
 709
 710       if (h8300hmode)
 711         memory_size = H8300H_MSIZE;
 712       else
 713         memory_size = H8300_MSIZE;
 714       cpu.memory = (unsigned char *) calloc (sizeof (char), memory_size);
 715       cpu.cache_idx = (unsigned short *) calloc (sizeof (short), memory_size);
 716       cpu.eightbit = (unsigned char *) calloc (sizeof (char), 256);
 717
 718       /* `msize' must be a power of two */
 719       if ((memory_size & (memory_size - 1)) != 0)
 720         abort ();
 721       cpu.mask = memory_size - 1;
 722
 723       for (i = 0; i < 9; i++)
 724         {
 725           cpu.regs[i] = 0;
 726         }
 727
 728       for (i = 0; i < 8; i++)
 729         {
 730           unsigned char *p = (unsigned char *) (cpu.regs + i);
 731           unsigned char *e = (unsigned char *) (cpu.regs + i + 1);
 732           unsigned short *q = (unsigned short *) (cpu.regs + i);
 733           unsigned short *u = (unsigned short *) (cpu.regs + i + 1);
 734           cpu.regs[i] = 0x00112233;
 735           while (p < e)
 736             {
 737               if (*p == 0x22)
 738                 {
 739                   breg[i] = p;
 740                 }
 741               if (*p == 0x33)
 742                 {
 743                   breg[i + 8] = p;
 744                 }
 745               p++;
 746             }
 747           while (q < u)
 748             {
 749               if (*q == 0x2233)
 750                 {
 751                   wreg[i] = q;
 752                 }
 753               if (*q == 0x0011)
 754                 {
 755                   wreg[i + 8] = q;
 756                 }
 757               q++;
 758             }
 759           cpu.regs[i] = 0;
 760           lreg[i] = &cpu.regs[i];
 761         }
 762
 763       lreg[8] = &cpu.regs[8];
 764
 765       /* initialize the seg registers */
 766       if (!cpu.cache)
 767         sim_set_simcache_size (CSIZE);
 768     }
 769 }
 770
 771 static void
 772 control_c (sig, code, scp, addr)
 773      int sig;
 774      int code;
 775      char *scp;
 776      char *addr;
 777 {
 778   cpu.state = SIM_STATE_STOPPED;
 779   cpu.exception = SIGINT;
 780 }
 781
 782 #define C (c != 0)
 783 #define Z (nz == 0)
 784 #define V (v != 0)
 785 #define N (n != 0)
 786
 787 static int
 788 mop (code, bsize, sign)
 789      decoded_inst *code;
 790      int bsize;
 791      int sign;
 792 {
 793   int multiplier;
 794   int multiplicand;
 795   int result;
 796   int n, nz;
 797
 798   if (sign)
 799     {
 800       multiplicand =
 801         bsize ? SEXTCHAR (GET_W_REG (code->dst.reg)) :
 802         SEXTSHORT (GET_W_REG (code->dst.reg));
 803       multiplier =
 804         bsize ? SEXTCHAR (GET_B_REG (code->src.reg)) :
 805         SEXTSHORT (GET_W_REG (code->src.reg));
 806     }
 807   else
 808     {
 809       multiplicand = bsize ? UEXTCHAR (GET_W_REG (code->dst.reg)) :
 810         UEXTSHORT (GET_W_REG (code->dst.reg));
 811       multiplier =
 812         bsize ? UEXTCHAR (GET_B_REG (code->src.reg)) :
 813         UEXTSHORT (GET_W_REG (code->src.reg));
 814
 815     }
 816   result = multiplier * multiplicand;
 817
 818   if (sign)
 819     {
 820       n = result & (bsize ? 0x8000 : 0x80000000);
 821       nz = result & (bsize ? 0xffff : 0xffffffff);
 822     }
 823   if (bsize)
 824     {
 825       SET_W_REG (code->dst.reg, result);
 826     }
 827   else
 828     {
 829       SET_L_REG (code->dst.reg, result);
 830     }
 831 /*  return ((n==1) << 1) | (nz==1); */
 832
 833 }
 834
 835 #define ONOT(name, how) \
 836 case O(name, SB):                               \
 837 {                                               \
 838   int t;                                        \
 839   int hm = 0x80;                                \
 840   rd = GET_B_REG (code->src.reg);               \
 841   how;                                          \
 842   goto shift8;                                  \
 843 }                                               \
 844 case O(name, SW):                               \
 845 {                                               \
 846   int t;                                        \
 847   int hm = 0x8000;                              \
 848   rd = GET_W_REG (code->src.reg);               \
 849   how;                                          \
 850   goto shift16;                                 \
 851 }                                               \
 852 case O(name, SL):                               \
 853 {                                               \
 854   int t;                                        \
 855   int hm = 0x80000000;                          \
 856   rd = GET_L_REG (code->src.reg);               \
 857   how;                                          \
 858   goto shift32;                                 \
 859 }
 860
 861 #define OSHIFTS(name, how1, how2) \
 862 case O(name, SB):                               \
 863 {                                               \
 864   int t;                                        \
 865   int hm = 0x80;                                \
 866   rd = GET_B_REG (code->src.reg);               \
 867   if ((GET_MEMORY_B (pc + 1) & 0x40) == 0)      \
 868     {                                           \
 869       how1;                                     \
 870     }                                           \
 871   else                                          \
 872     {                                           \
 873       how2;                                     \
 874     }                                           \
 875   goto shift8;                                  \
 876 }                                               \
 877 case O(name, SW):                               \
 878 {                                               \
 879   int t;                                        \
 880   int hm = 0x8000;                              \
 881   rd = GET_W_REG (code->src.reg);               \
 882   if ((GET_MEMORY_B (pc + 1) & 0x40) == 0)      \
 883     {                                           \
 884       how1;                                     \
 885     }                                           \
 886   else                                          \
 887     {                                           \
 888       how2;                                     \
 889     }                                           \
 890   goto shift16;                                 \
 891 }                                               \
 892 case O(name, SL):                               \
 893 {                                               \
 894   int t;                                        \
 895   int hm = 0x80000000;                          \
 896   rd = GET_L_REG (code->src.reg);               \
 897   if ((GET_MEMORY_B (pc + 1) & 0x40) == 0)      \
 898     {                                           \
 899       how1;                                     \
 900     }                                           \
 901   else                                          \
 902     {                                           \
 903       how2;                                     \
 904     }                                           \
 905   goto shift32;                                 \
 906 }
 907
 908 #define OBITOP(name,f, s, op)                   \
 909 case  O(name, SB):                              \
 910 {                                               \
 911   int m;                                        \
 912   int b;                                        \
 913   if (f) ea = fetch (&code->dst);               \
 914   m=1<< fetch(&code->src);                      \
 915   op;                                           \
 916   if(s) store (&code->dst,ea); goto next;       \
 917 }
 918
 919 int
 920 sim_stop (sd)
 921      SIM_DESC sd;
 922 {
 923   cpu.state = SIM_STATE_STOPPED;
 924   cpu.exception = SIGINT;
 925   return 1;
 926 }
 927
 928 void
 929 sim_resume (sd, step, siggnal)
 930      SIM_DESC sd;
 931 {
 932   static int init1;
 933   int cycles = 0;
 934   int insts = 0;
 935   int tick_start = get_now ();
 936   void (*prev) ();
 937   int poll_count = 0;
 938   int res;
 939   int tmp;
 940   int rd;
 941   int ea;
 942   int bit;
 943   int pc;
 944   int c, nz, v, n;
 945   int oldmask;
 946   init_pointers ();
 947
 948   prev = signal (SIGINT, control_c);
 949
 950   if (step)
 951     {
 952       cpu.state = SIM_STATE_STOPPED;
 953       cpu.exception = SIGTRAP;
 954     }
 955   else
 956     {
 957       cpu.state = SIM_STATE_RUNNING;
 958       cpu.exception = 0;
 959     }
 960
 961   pc = cpu.pc;
 962
 963   /* The PC should never be odd.  */
 964   if (pc & 0x1)
 965     abort ();
 966
 967   GETSR ();
 968   oldmask = cpu.mask;
 969   if (!h8300hmode)
 970     cpu.mask = 0xffff;
 971   do
 972     {
 973       int cidx;
 974       decoded_inst *code;
 975
 976     top:
 977       cidx = cpu.cache_idx[pc];
 978       code = cpu.cache + cidx;
 979
 980
 981 #define ALUOP(STORE, NAME, HOW) \
 982     case O(NAME,SB):  HOW; if(STORE)goto alu8;else goto just_flags_alu8;  \
 983     case O(NAME, SW): HOW; if(STORE)goto alu16;else goto just_flags_alu16; \
 984     case O(NAME,SL):  HOW; if(STORE)goto alu32;else goto just_flags_alu32;
 985
 986
 987 #define LOGOP(NAME, HOW) \
 988     case O(NAME,SB): HOW; goto log8;\
 989     case O(NAME, SW): HOW; goto log16;\
 990     case O(NAME,SL): HOW; goto log32;
 991
 992
 993
 994 #if ADEBUG
 995       if (debug)
 996         {
 997           printf ("%x %d %s\n", pc, code->opcode,
 998                   code->op ? code->op->name : "**");
 999         }
1000       cpu.stats[code->opcode]++;
1001
1002 #endif
1003
1004       cycles += code->cycles;
1005       insts++;
1006       switch (code->opcode)
1007         {
1008         case 0:
1009           /*
1010            * This opcode is a fake for when we get to an
1011            * instruction which hasnt been compiled
1012            */
1013           compile (pc);
1014           goto top;
1015           break;
1016
1017
1018         case O (O_SUBX, SB):
1019           rd = fetch (&code->dst);
1020           ea = fetch (&code->src);
1021           ea = -(ea + C);
1022           res = rd + ea;
1023           goto alu8;
1024
1025         case O (O_ADDX, SB):
1026           rd = fetch (&code->dst);
1027           ea = fetch (&code->src);
1028           ea = C + ea;
1029           res = rd + ea;
1030           goto alu8;
1031
1032 #define EA    ea = fetch(&code->src);
1033 #define RD_EA ea = fetch(&code->src); rd = fetch(&code->dst);
1034
1035           ALUOP (1, O_SUB, RD_EA;
1036                  ea = -ea;
1037                  res = rd + ea);
1038           ALUOP (1, O_NEG, EA;
1039                  ea = -ea;
1040                  rd = 0;
1041                  res = rd + ea);
1042
1043         case O (O_ADD, SB):
1044           rd = GET_B_REG (code->dst.reg);
1045           ea = fetch (&code->src);
1046           res = rd + ea;
1047           goto alu8;
1048         case O (O_ADD, SW):
1049           rd = GET_W_REG (code->dst.reg);
1050           ea = fetch (&code->src);
1051           res = rd + ea;
1052           goto alu16;
1053         case O (O_ADD, SL):
1054           rd = GET_L_REG (code->dst.reg);
1055           ea = fetch (&code->src);
1056           res = rd + ea;
1057           goto alu32;
1058
1059
1060           LOGOP (O_AND, RD_EA;
1061                  res = rd & ea);
1062
1063           LOGOP (O_OR, RD_EA;
1064                  res = rd | ea);
1065
1066           LOGOP (O_XOR, RD_EA;
1067                  res = rd ^ ea);
1068
1069
1070         case O (O_MOV_TO_MEM, SB):
1071           res = GET_B_REG (code->src.reg);
1072           goto log8;
1073         case O (O_MOV_TO_MEM, SW):
1074           res = GET_W_REG (code->src.reg);
1075           goto log16;
1076         case O (O_MOV_TO_MEM, SL):
1077           res = GET_L_REG (code->src.reg);
1078           goto log32;
1079
1080
1081         case O (O_MOV_TO_REG, SB):
1082           res = fetch (&code->src);
1083           SET_B_REG (code->dst.reg, res);
1084           goto just_flags_log8;
1085         case O (O_MOV_TO_REG, SW):
1086           res = fetch (&code->src);
1087           SET_W_REG (code->dst.reg, res);
1088           goto just_flags_log16;
1089         case O (O_MOV_TO_REG, SL):
1090           res = fetch (&code->src);
1091           SET_L_REG (code->dst.reg, res);
1092           goto just_flags_log32;
1093
1094
1095         case O (O_ADDS, SL):
1096           SET_L_REG (code->dst.reg,
1097                      GET_L_REG (code->dst.reg)
1098                      + code->src.literal);
1099
1100           goto next;
1101
1102         case O (O_SUBS, SL):
1103           SET_L_REG (code->dst.reg,
1104                      GET_L_REG (code->dst.reg)
1105                      - code->src.literal);
1106           goto next;
1107
1108         case O (O_CMP, SB):
1109           rd = fetch (&code->dst);
1110           ea = fetch (&code->src);
1111           ea = -ea;
1112           res = rd + ea;
1113           goto just_flags_alu8;
1114
1115         case O (O_CMP, SW):
1116           rd = fetch (&code->dst);
1117           ea = fetch (&code->src);
1118           ea = -ea;
1119           res = rd + ea;
1120           goto just_flags_alu16;
1121
1122         case O (O_CMP, SL):
1123           rd = fetch (&code->dst);
1124           ea = fetch (&code->src);
1125           ea = -ea;
1126           res = rd + ea;
1127           goto just_flags_alu32;
1128
1129
1130         case O (O_DEC, SB):
1131           rd = GET_B_REG (code->src.reg);
1132           ea = -1;
1133           res = rd + ea;
1134           SET_B_REG (code->src.reg, res);
1135           goto just_flags_inc8;
1136
1137         case O (O_DEC, SW):
1138           rd = GET_W_REG (code->dst.reg);
1139           ea = -code->src.literal;
1140           res = rd + ea;
1141           SET_W_REG (code->dst.reg, res);
1142           goto just_flags_inc16;
1143
1144         case O (O_DEC, SL):
1145           rd = GET_L_REG (code->dst.reg);
1146           ea = -code->src.literal;
1147           res = rd + ea;
1148           SET_L_REG (code->dst.reg, res);
1149           goto just_flags_inc32;
1150
1151
1152         case O (O_INC, SB):
1153           rd = GET_B_REG (code->src.reg);
1154           ea = 1;
1155           res = rd + ea;
1156           SET_B_REG (code->src.reg, res);
1157           goto just_flags_inc8;
1158
1159         case O (O_INC, SW):
1160           rd = GET_W_REG (code->dst.reg);
1161           ea = code->src.literal;
1162           res = rd + ea;
1163           SET_W_REG (code->dst.reg, res);
1164           goto just_flags_inc16;
1165
1166         case O (O_INC, SL):
1167           rd = GET_L_REG (code->dst.reg);
1168           ea = code->src.literal;
1169           res = rd + ea;
1170           SET_L_REG (code->dst.reg, res);
1171           goto just_flags_inc32;
1172
1173
1174 #define GET_CCR(x) BUILDSR();x = cpu.ccr
1175
1176         case O (O_ANDC, SB):
1177           GET_CCR (rd);
1178           ea = code->src.literal;
1179           res = rd & ea;
1180           goto setc;
1181
1182         case O (O_ORC, SB):
1183           GET_CCR (rd);
1184           ea = code->src.literal;
1185           res = rd | ea;
1186           goto setc;
1187
1188         case O (O_XORC, SB):
1189           GET_CCR (rd);
1190           ea = code->src.literal;
1191           res = rd ^ ea;
1192           goto setc;
1193
1194
1195         case O (O_BRA, SB):
1196           if (1)
1197             goto condtrue;
1198           goto next;
1199
1200         case O (O_BRN, SB):
1201           if (0)
1202             goto condtrue;
1203           goto next;
1204
1205         case O (O_BHI, SB):
1206           if ((C || Z) == 0)
1207             goto condtrue;
1208           goto next;
1209
1210
1211         case O (O_BLS, SB):
1212           if ((C || Z))
1213             goto condtrue;
1214           goto next;
1215
1216         case O (O_BCS, SB):
1217           if ((C == 1))
1218             goto condtrue;
1219           goto next;
1220
1221         case O (O_BCC, SB):
1222           if ((C == 0))
1223             goto condtrue;
1224           goto next;
1225
1226         case O (O_BEQ, SB):
1227           if (Z)
1228             goto condtrue;
1229           goto next;
1230         case O (O_BGT, SB):
1231           if (((Z || (N ^ V)) == 0))
1232             goto condtrue;
1233           goto next;
1234
1235
1236         case O (O_BLE, SB):
1237           if (((Z || (N ^ V)) == 1))
1238             goto condtrue;
1239           goto next;
1240
1241         case O (O_BGE, SB):
1242           if ((N ^ V) == 0)
1243             goto condtrue;
1244           goto next;
1245         case O (O_BLT, SB):
1246           if ((N ^ V))
1247             goto condtrue;
1248           goto next;
1249         case O (O_BMI, SB):
1250           if ((N))
1251             goto condtrue;
1252           goto next;
1253         case O (O_BNE, SB):
1254           if ((Z == 0))
1255             goto condtrue;
1256           goto next;
1257
1258         case O (O_BPL, SB):
1259           if (N == 0)
1260             goto condtrue;
1261           goto next;
1262         case O (O_BVC, SB):
1263           if ((V == 0))
1264             goto condtrue;
1265           goto next;
1266         case O (O_BVS, SB):
1267           if ((V == 1))
1268             goto condtrue;
1269           goto next;
1270
1271         case O (O_SYSCALL, SB):
1272           {
1273             char c = cpu.regs[2];
1274             sim_callback->write_stdout (sim_callback, &c, 1);
1275           }
1276           goto next;
1277
1278           ONOT (O_NOT, rd = ~rd; v = 0;);
1279           OSHIFTS (O_SHLL,
1280                    c = rd & hm; v = 0; rd <<= 1,
1281                    c = rd & (hm >> 1); v = 0; rd <<= 2);
1282           OSHIFTS (O_SHLR,
1283                    c = rd & 1; v = 0; rd = (unsigned int) rd >> 1,
1284                    c = rd & 2; v = 0; rd = (unsigned int) rd >> 2);
1285           OSHIFTS (O_SHAL,
1286                    c = rd & hm; v = (rd & hm) != ((rd & (hm >> 1)) << 1); rd <<= 1,
1287                    c = rd & (hm >> 1); v = (rd & (hm >> 1)) != ((rd & (hm >> 2)) << 2); rd <<= 2);
1288           OSHIFTS (O_SHAR,
1289                    t = rd & hm; c = rd & 1; v = 0; rd >>= 1; rd |= t,
1290                    t = rd & hm; c = rd & 2; v = 0; rd >>= 2; rd |= t | t >> 1 );
1291           OSHIFTS (O_ROTL,
1292                    c = rd & hm; v = 0; rd <<= 1; rd |= C,
1293                    c = rd & hm; v = 0; rd <<= 1; rd |= C; c = rd & hm; rd <<= 1; rd |= C);
1294           OSHIFTS (O_ROTR,
1295                    c = rd & 1; v = 0; rd = (unsigned int) rd >> 1; if (c) rd |= hm,
1296                    c = rd & 1; v = 0; rd = (unsigned int) rd >> 1; if (c) rd |= hm; c = rd & 1; rd = (unsigned int) rd >> 1; if (c) rd |= hm);
1297           OSHIFTS (O_ROTXL,
1298                    t = rd & hm; rd <<= 1; rd |= C; c = t; v = 0,
1299                    t = rd & hm; rd <<= 1; rd |= C; c = t; v = 0; t = rd & hm; rd <<= 1; rd |= C; c = t);
1300           OSHIFTS (O_ROTXR,
1301                    t = rd & 1; rd = (unsigned int) rd >> 1; if (C) rd |= hm; c = t; v = 0,
1302                    t = rd & 1; rd = (unsigned int) rd >> 1; if (C) rd |= hm; c = t; v = 0; t = rd & 1; rd = (unsigned int) rd >> 1; if (C) rd |= hm; c = t);
1303
1304         case O (O_JMP, SB):
1305           {
1306             pc = fetch (&code->src);
1307             goto end;
1308
1309           }
1310
1311         case O (O_JSR, SB):
1312           {
1313             int tmp;
1314             pc = fetch (&code->src);
1315           call:
1316             tmp = cpu.regs[7];
1317
1318             if (h8300hmode)
1319               {
1320                 tmp -= 4;
1321                 SET_MEMORY_L (tmp, code->next_pc);
1322               }
1323             else
1324               {
1325                 tmp -= 2;
1326                 SET_MEMORY_W (tmp, code->next_pc);
1327               }
1328             cpu.regs[7] = tmp;
1329
1330             goto end;
1331           }
1332         case O (O_BSR, SB):
1333           pc = code->src.literal;
1334           goto call;
1335
1336         case O (O_RTS, SN):
1337           {
1338             int tmp;
1339
1340             tmp = cpu.regs[7];
1341
1342             if (h8300hmode)
1343               {
1344                 pc = GET_MEMORY_L (tmp);
1345                 tmp += 4;
1346               }
1347             else
1348               {
1349                 pc = GET_MEMORY_W (tmp);
1350                 tmp += 2;
1351               }
1352
1353             cpu.regs[7] = tmp;
1354             goto end;
1355           }
1356
1357         case O (O_ILL, SB):
1358           cpu.state = SIM_STATE_STOPPED;
1359           cpu.exception = SIGILL;
1360           goto end;
1361         case O (O_SLEEP, SN):
1362           /* FIXME: Doesn't this break for breakpoints when r0
1363              contains just the right (er, wrong) value?  */
1364           cpu.state = SIM_STATE_STOPPED;
1365           /* The format of r0 is defined by target newlib.  Expand
1366              the macros here instead of looking for .../sys/wait.h.  */
1367 #define SIM_WIFEXITED(v) (((v) & 0xff) == 0)
1368 #define SIM_WIFSIGNALED(v) (((v) & 0x7f) > 0 && (((v) & 0x7f) < 0x7f))
1369           if (! SIM_WIFEXITED (cpu.regs[0]) && SIM_WIFSIGNALED (cpu.regs[0]))
1370             cpu.exception = SIGILL;
1371           else
1372             cpu.exception = SIGTRAP;
1373           goto end;
1374         case O (O_BPT, SN):
1375           cpu.state = SIM_STATE_STOPPED;
1376           cpu.exception = SIGTRAP;
1377           goto end;
1378
1379           OBITOP (O_BNOT, 1, 1, ea ^= m);
1380           OBITOP (O_BTST, 1, 0, nz = ea & m);
1381           OBITOP (O_BCLR, 1, 1, ea &= ~m);
1382           OBITOP (O_BSET, 1, 1, ea |= m);
1383           OBITOP (O_BLD, 1, 0, c = ea & m);
1384           OBITOP (O_BILD, 1, 0, c = !(ea & m));
1385           OBITOP (O_BST, 1, 1, ea &= ~m;
1386                   if (C) ea |= m);
1387           OBITOP (O_BIST, 1, 1, ea &= ~m;
1388                   if (!C) ea |= m);
1389           OBITOP (O_BAND, 1, 0, c = (ea & m) && C);
1390           OBITOP (O_BIAND, 1, 0, c = !(ea & m) && C);
1391           OBITOP (O_BOR, 1, 0, c = (ea & m) || C);
1392           OBITOP (O_BIOR, 1, 0, c = !(ea & m) || C);
1393           OBITOP (O_BXOR, 1, 0, c = (ea & m) != C);
1394           OBITOP (O_BIXOR, 1, 0, c = !(ea & m) != C);
1395
1396
1397 #define MOP(bsize, signed) mop(code, bsize,signed); goto next;
1398
1399         case O (O_MULS, SB):
1400           MOP (1, 1);
1401           break;
1402         case O (O_MULS, SW):
1403           MOP (0, 1);
1404           break;
1405         case O (O_MULU, SB):
1406           MOP (1, 0);
1407           break;
1408         case O (O_MULU, SW):
1409           MOP (0, 0);
1410           break;
1411
1412
1413         case O (O_DIVU, SB):
1414           {
1415             rd = GET_W_REG (code->dst.reg);
1416             ea = GET_B_REG (code->src.reg);
1417             if (ea)
1418               {
1419                 tmp = (unsigned)rd % ea;
1420                 rd = (unsigned)rd / ea;
1421               }
1422             SET_W_REG (code->dst.reg, (rd & 0xff) | (tmp << 8));
1423             n = ea & 0x80;
1424             nz = ea & 0xff;
1425
1426             goto next;
1427           }
1428         case O (O_DIVU, SW):
1429           {
1430             rd = GET_L_REG (code->dst.reg);
1431             ea = GET_W_REG (code->src.reg);
1432             n = ea & 0x8000;
1433             nz = ea & 0xffff;
1434             if (ea)
1435               {
1436                 tmp = (unsigned)rd % ea;
1437                 rd = (unsigned)rd / ea;
1438               }
1439             SET_L_REG (code->dst.reg, (rd & 0xffff) | (tmp << 16));
1440             goto next;
1441           }
1442
1443         case O (O_DIVS, SB):
1444           {
1445
1446             rd = SEXTSHORT (GET_W_REG (code->dst.reg));
1447             ea = SEXTCHAR (GET_B_REG (code->src.reg));
1448             if (ea)
1449               {
1450                 tmp = (int) rd % (int) ea;
1451                 rd = (int) rd / (int) ea;
1452                 n = rd & 0x8000;
1453                 nz = 1;
1454               }
1455             else
1456               nz = 0;
1457             SET_W_REG (code->dst.reg, (rd & 0xff) | (tmp << 8));
1458             goto next;
1459           }
1460         case O (O_DIVS, SW):
1461           {
1462             rd = GET_L_REG (code->dst.reg);
1463             ea = SEXTSHORT (GET_W_REG (code->src.reg));
1464             if (ea)
1465               {
1466                 tmp = (int) rd % (int) ea;
1467                 rd = (int) rd / (int) ea;
1468                 n = rd & 0x80000000;
1469                 nz = 1;
1470               }
1471             else
1472               nz = 0;
1473             SET_L_REG (code->dst.reg, (rd & 0xffff) | (tmp << 16));
1474             goto next;
1475           }
1476         case O (O_EXTS, SW):
1477           rd = GET_B_REG (code->src.reg + 8) & 0xff; /* Yes, src, not dst.  */
1478           ea = rd & 0x80 ? -256 : 0;
1479           res = rd + ea;
1480           goto log16;
1481         case O (O_EXTS, SL):
1482           rd = GET_W_REG (code->src.reg) & 0xffff;
1483           ea = rd & 0x8000 ? -65536 : 0;
1484           res = rd + ea;
1485           goto log32;
1486         case O (O_EXTU, SW):
1487           rd = GET_B_REG (code->src.reg + 8) & 0xff;
1488           ea = 0;
1489           res = rd + ea;
1490           goto log16;
1491         case O (O_EXTU, SL):
1492           rd = GET_W_REG (code->src.reg) & 0xffff;
1493           ea = 0;
1494           res = rd + ea;
1495           goto log32;
1496
1497         case O (O_NOP, SN):
1498           goto next;
1499
1500         case O (O_STM, SL):
1501           {
1502             int nregs, firstreg, i;
1503
1504             nregs = GET_MEMORY_B (pc + 1);
1505             nregs >>= 4;
1506             nregs &= 0xf;
1507             firstreg = GET_MEMORY_B (pc + 3);
1508             firstreg &= 0xf;
1509             for (i = firstreg; i <= firstreg + nregs; i++)
1510               {
1511                 cpu.regs[7] -= 4;
1512                 SET_MEMORY_L (cpu.regs[7], cpu.regs[i]);
1513               }
1514           }
1515           goto next;
1516
1517         case O (O_LDM, SL):
1518           {
1519             int nregs, firstreg, i;
1520
1521             nregs = GET_MEMORY_B (pc + 1);
1522             nregs >>= 4;
1523             nregs &= 0xf;
1524             firstreg = GET_MEMORY_B (pc + 3);
1525             firstreg &= 0xf;
1526             for (i = firstreg; i >= firstreg - nregs; i--)
1527               {
1528                 cpu.regs[i] = GET_MEMORY_L (cpu.regs[7]);
1529                 cpu.regs[7] += 4;
1530               }
1531           }
1532           goto next;
1533
1534         default:
1535           cpu.state = SIM_STATE_STOPPED;
1536           cpu.exception = SIGILL;
1537           goto end;
1538
1539         }
1540       abort ();
1541
1542     setc:
1543       cpu.ccr = res;
1544       GETSR ();
1545       goto next;
1546
1547     condtrue:
1548       /* When a branch works */
1549       pc = code->src.literal;
1550       goto end;
1551
1552       /* Set the cond codes from res */
1553     bitop:
1554
1555       /* Set the flags after an 8 bit inc/dec operation */
1556     just_flags_inc8:
1557       n = res & 0x80;
1558       nz = res & 0xff;
1559       v = (rd & 0x7f) == 0x7f;
1560       goto next;
1561
1562
1563       /* Set the flags after an 16 bit inc/dec operation */
1564     just_flags_inc16:
1565       n = res & 0x8000;
1566       nz = res & 0xffff;
1567       v = (rd & 0x7fff) == 0x7fff;
1568       goto next;
1569
1570
1571       /* Set the flags after an 32 bit inc/dec operation */
1572     just_flags_inc32:
1573       n = res & 0x80000000;
1574       nz = res & 0xffffffff;
1575       v = (rd & 0x7fffffff) == 0x7fffffff;
1576       goto next;
1577
1578
1579     shift8:
1580       /* Set flags after an 8 bit shift op, carry,overflow set in insn */
1581       n = (rd & 0x80);
1582       nz = rd & 0xff;
1583       SET_B_REG (code->src.reg, rd);
1584       goto next;
1585
1586     shift16:
1587       /* Set flags after an 16 bit shift op, carry,overflow set in insn */
1588       n = (rd & 0x8000);
1589       nz = rd & 0xffff;
1590       SET_W_REG (code->src.reg, rd);
1591       goto next;
1592
1593     shift32:
1594       /* Set flags after an 32 bit shift op, carry,overflow set in insn */
1595       n = (rd & 0x80000000);
1596       nz = rd & 0xffffffff;
1597       SET_L_REG (code->src.reg, rd);
1598       goto next;
1599
1600     log32:
1601       store (&code->dst, res);
1602     just_flags_log32:
1603       /* flags after a 32bit logical operation */
1604       n = res & 0x80000000;
1605       nz = res & 0xffffffff;
1606       v = 0;
1607       goto next;
1608
1609     log16:
1610       store (&code->dst, res);
1611     just_flags_log16:
1612       /* flags after a 16bit logical operation */
1613       n = res & 0x8000;
1614       nz = res & 0xffff;
1615       v = 0;
1616       goto next;
1617
1618
1619     log8:
1620       store (&code->dst, res);
1621     just_flags_log8:
1622       n = res & 0x80;
1623       nz = res & 0xff;
1624       v = 0;
1625       goto next;
1626
1627     alu8:
1628       SET_B_REG (code->dst.reg, res);
1629     just_flags_alu8:
1630       n = res & 0x80;
1631       nz = res & 0xff;
1632       c = (res & 0x100);
1633       switch (code->opcode / 4)
1634         {
1635         case O_ADD:
1636           v = ((rd & 0x80) == (ea & 0x80)
1637                && (rd & 0x80) != (res & 0x80));
1638           break;
1639         case O_SUB:
1640         case O_CMP:
1641           v = ((rd & 0x80) != (-ea & 0x80)
1642                && (rd & 0x80) != (res & 0x80));
1643           break;
1644         case O_NEG:
1645           v = (rd == 0x80);
1646           break;
1647         }
1648       goto next;
1649
1650     alu16:
1651       SET_W_REG (code->dst.reg, res);
1652     just_flags_alu16:
1653       n = res & 0x8000;
1654       nz = res & 0xffff;
1655       c = (res & 0x10000);
1656       switch (code->opcode / 4)
1657         {
1658         case O_ADD:
1659           v = ((rd & 0x8000) == (ea & 0x8000)
1660                && (rd & 0x8000) != (res & 0x8000));
1661           break;
1662         case O_SUB:
1663         case O_CMP:
1664           v = ((rd & 0x8000) != (-ea & 0x8000)
1665                && (rd & 0x8000) != (res & 0x8000));
1666           break;
1667         case O_NEG:
1668           v = (rd == 0x8000);
1669           break;
1670         }
1671       goto next;
1672
1673     alu32:
1674       SET_L_REG (code->dst.reg, res);
1675     just_flags_alu32:
1676       n = res & 0x80000000;
1677       nz = res & 0xffffffff;
1678       switch (code->opcode / 4)
1679         {
1680         case O_ADD:
1681           v = ((rd & 0x80000000) == (ea & 0x80000000)
1682                && (rd & 0x80000000) != (res & 0x80000000));
1683           c = ((unsigned) res < (unsigned) rd) || ((unsigned) res < (unsigned) ea);
1684           break;
1685         case O_SUB:
1686         case O_CMP:
1687           v = ((rd & 0x80000000) != (-ea & 0x80000000)
1688                && (rd & 0x80000000) != (res & 0x80000000));
1689           c = (unsigned) rd < (unsigned) -ea;
1690           break;
1691         case O_NEG:
1692           v = (rd == 0x80000000);
1693           c = res != 0;
1694           break;
1695         }
1696       goto next;
1697
1698     next:;
1699       pc = code->next_pc;
1700
1701     end:
1702       ;
1703       /*      if (cpu.regs[8] ) abort(); */
1704
1705       if (--poll_count < 0)
1706         {
1707           poll_count = POLL_QUIT_INTERVAL;
1708           if ((*sim_callback->poll_quit) != NULL
1709               && (*sim_callback->poll_quit) (sim_callback))
1710             sim_stop (sd);
1711         }
1712
1713     }
1714   while (cpu.state == SIM_STATE_RUNNING);
1715   cpu.ticks += get_now () - tick_start;
1716   cpu.cycles += cycles;
1717   cpu.insts += insts;
1718
1719   cpu.pc = pc;
1720   BUILDSR ();
1721   cpu.mask = oldmask;
1722   signal (SIGINT, prev);
1723 }
1724
1725 int
1726 sim_trace (sd)
1727      SIM_DESC sd;
1728 {
1729   /* FIXME: unfinished */
1730   abort ();
1731 }
1732
1733 int
1734 sim_write (sd, addr, buffer, size)
1735      SIM_DESC sd;
1736      SIM_ADDR addr;
1737      unsigned char *buffer;
1738      int size;
1739 {
1740   int i;
1741
1742   init_pointers ();
1743   if (addr < 0)
1744     return 0;
1745   for (i = 0; i < size; i++)
1746     {
1747       if (addr < memory_size)
1748         {
1749           cpu.memory[addr + i] = buffer[i];
1750           cpu.cache_idx[addr + i] = 0;
1751         }
1752       else
1753         cpu.eightbit[(addr + i) & 0xff] = buffer[i];
1754     }
1755   return size;
1756 }
1757
1758 int
1759 sim_read (sd, addr, buffer, size)
1760      SIM_DESC sd;
1761      SIM_ADDR addr;
1762      unsigned char *buffer;
1763      int size;
1764 {
1765   init_pointers ();
1766   if (addr < 0)
1767     return 0;
1768   if (addr < memory_size)
1769     memcpy (buffer, cpu.memory + addr, size);
1770   else
1771     memcpy (buffer, cpu.eightbit + (addr & 0xff), size);
1772   return size;
1773 }
1774
1775
1776 #define R0_REGNUM       0
1777 #define R1_REGNUM       1
1778 #define R2_REGNUM       2
1779 #define R3_REGNUM       3
1780 #define R4_REGNUM       4
1781 #define R5_REGNUM       5
1782 #define R6_REGNUM       6
1783 #define R7_REGNUM       7
1784
1785 #define SP_REGNUM       R7_REGNUM       /* Contains address of top of stack */
1786 #define FP_REGNUM       R6_REGNUM       /* Contains address of executing
1787                                            * stack frame */
1788
1789 #define CCR_REGNUM      8       /* Contains processor status */
1790 #define PC_REGNUM       9       /* Contains program counter */
1791
1792 #define CYCLE_REGNUM    10
1793 #define INST_REGNUM     11
1794 #define TICK_REGNUM     12
1795
1796
1797 int
1798 sim_store_register (sd, rn, value, length)
1799      SIM_DESC sd;
1800      int rn;
1801      unsigned char *value;
1802      int length;
1803 {
1804   int longval;
1805   int shortval;
1806   int intval;
1807   longval = (value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3];
1808   shortval = (value[0] << 8) | (value[1]);
1809   intval = h8300hmode ? longval : shortval;
1810
1811   init_pointers ();
1812   switch (rn)
1813     {
1814     case PC_REGNUM:
1815       cpu.pc = intval;
1816       break;
1817     default:
1818       abort ();
1819     case R0_REGNUM:
1820     case R1_REGNUM:
1821     case R2_REGNUM:
1822     case R3_REGNUM:
1823     case R4_REGNUM:
1824     case R5_REGNUM:
1825     case R6_REGNUM:
1826     case R7_REGNUM:
1827       cpu.regs[rn] = intval;
1828       break;
1829     case CCR_REGNUM:
1830       cpu.ccr = intval;
1831       break;
1832     case CYCLE_REGNUM:
1833       cpu.cycles = longval;
1834       break;
1835
1836     case INST_REGNUM:
1837       cpu.insts = longval;
1838       break;
1839
1840     case TICK_REGNUM:
1841       cpu.ticks = longval;
1842       break;
1843     }
1844   return -1;
1845 }
1846
1847 int
1848 sim_fetch_register (sd, rn, buf, length)
1849      SIM_DESC sd;
1850      int rn;
1851      unsigned char *buf;
1852      int length;
1853 {
1854   int v;
1855   int longreg = 0;
1856
1857   init_pointers ();
1858
1859   switch (rn)
1860     {
1861     default:
1862       abort ();
1863     case 8:
1864       v = cpu.ccr;
1865       break;
1866     case 9:
1867       v = cpu.pc;
1868       break;
1869     case R0_REGNUM:
1870     case R1_REGNUM:
1871     case R2_REGNUM:
1872     case R3_REGNUM:
1873     case R4_REGNUM:
1874     case R5_REGNUM:
1875     case R6_REGNUM:
1876     case R7_REGNUM:
1877       v = cpu.regs[rn];
1878       break;
1879     case 10:
1880       v = cpu.cycles;
1881       longreg = 1;
1882       break;
1883     case 11:
1884       v = cpu.ticks;
1885       longreg = 1;
1886       break;
1887     case 12:
1888       v = cpu.insts;
1889       longreg = 1;
1890       break;
1891     }
1892   if (h8300hmode || longreg)
1893     {
1894       buf[0] = v >> 24;
1895       buf[1] = v >> 16;
1896       buf[2] = v >> 8;
1897       buf[3] = v >> 0;
1898     }
1899   else
1900     {
1901       buf[0] = v >> 8;
1902       buf[1] = v;
1903     }
1904   return -1;
1905 }
1906
1907 void
1908 sim_stop_reason (sd, reason, sigrc)
1909      SIM_DESC sd;
1910      enum sim_stop *reason;
1911      int *sigrc;
1912 {
1913 #if 0 /* FIXME: This should work but we can't use it.
1914          grep for SLEEP above.  */
1915   switch (cpu.state)
1916     {
1917     case SIM_STATE_EXITED : *reason = sim_exited; break;
1918     case SIM_STATE_SIGNALLED : *reason = sim_signalled; break;
1919     case SIM_STATE_STOPPED : *reason = sim_stopped; break;
1920     default : abort ();
1921     }
1922 #else
1923   *reason = sim_stopped;
1924 #endif
1925   *sigrc = cpu.exception;
1926 }
1927
1928 /* FIXME: Rename to sim_set_mem_size.  */
1929
1930 void
1931 sim_size (n)
1932      int n;
1933 {
1934   /* Memory size is fixed.  */
1935 }
1936
1937 void
1938 sim_set_simcache_size (n)
1939 {
1940   if (cpu.cache)
1941     free (cpu.cache);
1942   if (n < 2)
1943     n = 2;
1944   cpu.cache = (decoded_inst *) malloc (sizeof (decoded_inst) * n);
1945   memset (cpu.cache, 0, sizeof (decoded_inst) * n);
1946   cpu.csize = n;
1947 }
1948
1949
1950 void
1951 sim_info (sd, verbose)
1952      SIM_DESC sd;
1953      int verbose;
1954 {
1955   double timetaken = (double) cpu.ticks / (double) now_persec ();
1956   double virttime = cpu.cycles / 10.0e6;
1957
1958   (*sim_callback->printf_filtered) (sim_callback,
1959                                     "\n\n#instructions executed  %10d\n",
1960                                     cpu.insts);
1961   (*sim_callback->printf_filtered) (sim_callback,
1962                                     "#cycles (v approximate) %10d\n",
1963                                     cpu.cycles);
1964   (*sim_callback->printf_filtered) (sim_callback,
1965                                     "#real time taken        %10.4f\n",
1966                                     timetaken);
1967   (*sim_callback->printf_filtered) (sim_callback,
1968                                     "#virtual time taked     %10.4f\n",
1969                                     virttime);
1970   if (timetaken != 0.0)
1971     (*sim_callback->printf_filtered) (sim_callback,
1972                                       "#simulation ratio       %10.4f\n",
1973                                       virttime / timetaken);
1974   (*sim_callback->printf_filtered) (sim_callback,
1975                                     "#compiles               %10d\n",
1976                                     cpu.compiles);
1977   (*sim_callback->printf_filtered) (sim_callback,
1978                                     "#cache size             %10d\n",
1979                                     cpu.csize);
1980
1981 #ifdef ADEBUG
1982   /* This to be conditional on `what' (aka `verbose'),
1983      however it was never passed as non-zero.  */
1984   if (1)
1985     {
1986       int i;
1987       for (i = 0; i < O_LAST; i++)
1988         {
1989           if (cpu.stats[i])
1990             (*sim_callback->printf_filtered) (sim_callback,
1991                                               "%d: %d\n", i, cpu.stats[i]);
1992         }
1993     }
1994 #endif
1995 }
1996
1997 /* Indicate whether the cpu is an h8/300 or h8/300h.
1998    FLAG is non-zero for the h8/300h.  */
1999
2000 void
2001 set_h8300h (flag)
2002      int flag;
2003 {
2004   /* FIXME: Much of the code in sim_load can be moved to sim_open.
2005      This function being replaced by a sim_open:ARGV configuration
2006      option */
2007   h8300hmode = flag;
2008 }
2009
2010 SIM_DESC
2011 sim_open (kind, ptr, abfd, argv)
2012      SIM_OPEN_KIND kind;
2013      struct host_callback_struct *ptr;
2014      struct _bfd *abfd;
2015      char **argv;
2016 {
2017   /* FIXME: Much of the code in sim_load can be moved here */
2018
2019   sim_kind = kind;
2020   myname = argv[0];
2021   sim_callback = ptr;
2022   /* fudge our descriptor */
2023   return (SIM_DESC) 1;
2024 }
2025
2026 void
2027 sim_close (sd, quitting)
2028      SIM_DESC sd;
2029      int quitting;
2030 {
2031   /* nothing to do */
2032 }
2033
2034 /* Called by gdb to load a program into memory.  */
2035
2036 SIM_RC
2037 sim_load (sd, prog, abfd, from_tty)
2038      SIM_DESC sd;
2039      char *prog;
2040      bfd *abfd;
2041      int from_tty;
2042 {
2043   bfd *prog_bfd;
2044
2045   /* FIXME: The code below that sets a specific variant of the h8/300
2046      being simulated should be moved to sim_open(). */
2047
2048   /* See if the file is for the h8/300 or h8/300h.  */
2049   /* ??? This may not be the most efficient way.  The z8k simulator
2050      does this via a different mechanism (INIT_EXTRA_SYMTAB_INFO).  */
2051   if (abfd != NULL)
2052     prog_bfd = abfd;
2053   else
2054     prog_bfd = bfd_openr (prog, "coff-h8300");
2055   if (prog_bfd != NULL)
2056     {
2057       /* Set the cpu type.  We ignore failure from bfd_check_format
2058          and bfd_openr as sim_load_file checks too.  */
2059       if (bfd_check_format (prog_bfd, bfd_object))
2060         {
2061           unsigned long mach = bfd_get_mach (prog_bfd);
2062           set_h8300h (mach == bfd_mach_h8300h
2063                       || mach == bfd_mach_h8300s);
2064         }
2065     }
2066
2067   /* If we're using gdb attached to the simulator, then we have to
2068      reallocate memory for the simulator.
2069
2070      When gdb first starts, it calls fetch_registers (among other
2071      functions), which in turn calls init_pointers, which allocates
2072      simulator memory.
2073
2074      The problem is when we do that, we don't know whether we're
2075      debugging an h8/300 or h8/300h program.
2076
2077      This is the first point at which we can make that determination,
2078      so we just reallocate memory now; this will also allow us to handle
2079      switching between h8/300 and h8/300h programs without exiting
2080      gdb.  */
2081   if (h8300hmode)
2082     memory_size = H8300H_MSIZE;
2083   else
2084     memory_size = H8300_MSIZE;
2085
2086   if (cpu.memory)
2087     free (cpu.memory);
2088   if (cpu.cache_idx)
2089     free (cpu.cache_idx);
2090   if (cpu.eightbit)
2091     free (cpu.eightbit);
2092
2093   cpu.memory = (unsigned char *) calloc (sizeof (char), memory_size);
2094   cpu.cache_idx = (unsigned short *) calloc (sizeof (short), memory_size);
2095   cpu.eightbit = (unsigned char *) calloc (sizeof (char), 256);
2096
2097   /* `msize' must be a power of two */
2098   if ((memory_size & (memory_size - 1)) != 0)
2099     abort ();
2100   cpu.mask = memory_size - 1;
2101
2102   if (sim_load_file (sd, myname, sim_callback, prog, prog_bfd,
2103                      sim_kind == SIM_OPEN_DEBUG,
2104                      0, sim_write)
2105       == NULL)
2106     {
2107       /* Close the bfd if we opened it.  */
2108       if (abfd == NULL && prog_bfd != NULL)
2109         bfd_close (prog_bfd);
2110       return SIM_RC_FAIL;
2111     }
2112
2113   /* Close the bfd if we opened it.  */
2114   if (abfd == NULL && prog_bfd != NULL)
2115     bfd_close (prog_bfd);
2116   return SIM_RC_OK;
2117 }
2118
2119 SIM_RC
2120 sim_create_inferior (sd, abfd, argv, env)
2121      SIM_DESC sd;
2122      struct _bfd *abfd;
2123      char **argv;
2124      char **env;
2125 {
2126   if (abfd != NULL)
2127     cpu.pc = bfd_get_start_address (abfd);
2128   else
2129     cpu.pc = 0;
2130   return SIM_RC_OK;
2131 }
2132
2133 void
2134 sim_do_command (sd, cmd)
2135      SIM_DESC sd;
2136      char *cmd;
2137 {
2138   (*sim_callback->printf_filtered) (sim_callback,
2139                                     "This simulator does not accept any commands.\n");
2140 }
2141
2142 void
2143 sim_set_callbacks (ptr)
2144      struct host_callback_struct *ptr;
2145 {
2146   sim_callback = ptr;
2147 }