sim/frv/interrupts.c

   1 /* frv exception and interrupt support
   2    Copyright (C) 1999-2015 Free Software Foundation, Inc.
   3    Contributed by Red Hat.
   4
   5 This file is part of the GNU simulators.
   6
   7 This program is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 3 of the License, or
  10 (at your option) any later version.
  11
  12 This program is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #define WANT_CPU frvbf
  21 #define WANT_CPU_FRVBF
  22
  23 #include "sim-main.h"
  24 #include "bfd.h"
  25
  26 /* FR-V Interrupt table.
  27    Describes the interrupts supported by the FR-V.
  28    This table *must* be maintained in order of interrupt priority as defined by
  29    frv_interrupt_kind.  */
  30 #define DEFERRED 1
  31 #define PRECISE  1
  32 #define ITABLE_ENTRY(name, class, deferral, precision, offset) \
  33   {FRV_##name, FRV_EC_##name, class, deferral, precision, offset}
  34
  35 struct frv_interrupt frv_interrupt_table[NUM_FRV_INTERRUPT_KINDS] =
  36 {
  37   /* External interrupts */
  38   ITABLE_ENTRY(INTERRUPT_LEVEL_1,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x21),
  39   ITABLE_ENTRY(INTERRUPT_LEVEL_2,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x22),
  40   ITABLE_ENTRY(INTERRUPT_LEVEL_3,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x23),
  41   ITABLE_ENTRY(INTERRUPT_LEVEL_4,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x24),
  42   ITABLE_ENTRY(INTERRUPT_LEVEL_5,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x25),
  43   ITABLE_ENTRY(INTERRUPT_LEVEL_6,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x26),
  44   ITABLE_ENTRY(INTERRUPT_LEVEL_7,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x27),
  45   ITABLE_ENTRY(INTERRUPT_LEVEL_8,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x28),
  46   ITABLE_ENTRY(INTERRUPT_LEVEL_9,            FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x29),
  47   ITABLE_ENTRY(INTERRUPT_LEVEL_10,           FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x2a),
  48   ITABLE_ENTRY(INTERRUPT_LEVEL_11,           FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x2b),
  49   ITABLE_ENTRY(INTERRUPT_LEVEL_12,           FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x2c),
  50   ITABLE_ENTRY(INTERRUPT_LEVEL_13,           FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x2d),
  51   ITABLE_ENTRY(INTERRUPT_LEVEL_14,           FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x2e),
  52   ITABLE_ENTRY(INTERRUPT_LEVEL_15,           FRV_EXTERNAL_INTERRUPT, !DEFERRED, !PRECISE, 0x2f),
  53   /* Software interrupt */
  54   ITABLE_ENTRY(TRAP_INSTRUCTION,             FRV_SOFTWARE_INTERRUPT, !DEFERRED, !PRECISE, 0x80),
  55   /* Program interrupts */
  56   ITABLE_ENTRY(COMMIT_EXCEPTION,             FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x19),
  57   ITABLE_ENTRY(DIVISION_EXCEPTION,           FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x17),
  58   ITABLE_ENTRY(DATA_STORE_ERROR,             FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x14),
  59   ITABLE_ENTRY(DATA_ACCESS_EXCEPTION,        FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x13),
  60   ITABLE_ENTRY(DATA_ACCESS_MMU_MISS,         FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x12),
  61   ITABLE_ENTRY(DATA_ACCESS_ERROR,            FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x11),
  62   ITABLE_ENTRY(MP_EXCEPTION,                 FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x0e),
  63   ITABLE_ENTRY(FP_EXCEPTION,                 FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x0d),
  64   ITABLE_ENTRY(MEM_ADDRESS_NOT_ALIGNED,      FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x10),
  65   ITABLE_ENTRY(REGISTER_EXCEPTION,           FRV_PROGRAM_INTERRUPT,  !DEFERRED,  PRECISE, 0x08),
  66   ITABLE_ENTRY(MP_DISABLED,                  FRV_PROGRAM_INTERRUPT,  !DEFERRED,  PRECISE, 0x0b),
  67   ITABLE_ENTRY(FP_DISABLED,                  FRV_PROGRAM_INTERRUPT,  !DEFERRED,  PRECISE, 0x0a),
  68   ITABLE_ENTRY(PRIVILEGED_INSTRUCTION,       FRV_PROGRAM_INTERRUPT,  !DEFERRED,  PRECISE, 0x06),
  69   ITABLE_ENTRY(ILLEGAL_INSTRUCTION,          FRV_PROGRAM_INTERRUPT,  !DEFERRED,  PRECISE, 0x07),
  70   ITABLE_ENTRY(INSTRUCTION_ACCESS_EXCEPTION, FRV_PROGRAM_INTERRUPT,  !DEFERRED,  PRECISE, 0x03),
  71   ITABLE_ENTRY(INSTRUCTION_ACCESS_ERROR,     FRV_PROGRAM_INTERRUPT,  !DEFERRED,  PRECISE, 0x02),
  72   ITABLE_ENTRY(INSTRUCTION_ACCESS_MMU_MISS,  FRV_PROGRAM_INTERRUPT,  !DEFERRED,  PRECISE, 0x01),
  73   ITABLE_ENTRY(COMPOUND_EXCEPTION,           FRV_PROGRAM_INTERRUPT,  !DEFERRED, !PRECISE, 0x20),
  74   /* Break interrupt */
  75   ITABLE_ENTRY(BREAK_EXCEPTION,              FRV_BREAK_INTERRUPT,    !DEFERRED, !PRECISE, 0xff),
  76   /* Reset interrupt */
  77   ITABLE_ENTRY(RESET,                        FRV_RESET_INTERRUPT,    !DEFERRED, !PRECISE, 0x00)
  78 };
  79
  80 /* The current interrupt state.  */
  81 struct frv_interrupt_state frv_interrupt_state;
  82
  83 /* maintain the address of the start of the previous VLIW insn sequence.  */
  84 IADDR previous_vliw_pc;
  85
  86 /* Add a break interrupt to the interrupt queue.  */
  87 struct frv_interrupt_queue_element *
  88 frv_queue_break_interrupt (SIM_CPU *current_cpu)
  89 {
  90   return frv_queue_interrupt (current_cpu, FRV_BREAK_EXCEPTION);
  91 }
  92
  93 /* Add a software interrupt to the interrupt queue.  */
  94 struct frv_interrupt_queue_element *
  95 frv_queue_software_interrupt (SIM_CPU *current_cpu, SI offset)
  96 {
  97   struct frv_interrupt_queue_element *new_element
  98     = frv_queue_interrupt (current_cpu, FRV_TRAP_INSTRUCTION);
  99
 100   struct frv_interrupt *interrupt = & frv_interrupt_table[new_element->kind];
 101   interrupt->handler_offset = offset;
 102
 103   return new_element;
 104 }
 105
 106 /* Add a program interrupt to the interrupt queue.  */
 107 struct frv_interrupt_queue_element *
 108 frv_queue_program_interrupt (
 109   SIM_CPU *current_cpu, enum frv_interrupt_kind kind
 110 )
 111 {
 112   return frv_queue_interrupt (current_cpu, kind);
 113 }
 114
 115 /* Add an external interrupt to the interrupt queue.  */
 116 struct frv_interrupt_queue_element *
 117 frv_queue_external_interrupt (
 118   SIM_CPU *current_cpu, enum frv_interrupt_kind kind
 119 )
 120 {
 121   if (! GET_H_PSR_ET ()
 122       || (kind != FRV_INTERRUPT_LEVEL_15 && kind < GET_H_PSR_PIL ()))
 123     return NULL; /* Leave it for later.  */
 124
 125   return frv_queue_interrupt (current_cpu, kind);
 126 }
 127
 128 /* Add any interrupt to the interrupt queue. It will be added in reverse
 129    priority order.  This makes it easy to find the highest priority interrupt
 130    at the end of the queue and to remove it after processing.  */
 131 struct frv_interrupt_queue_element *
 132 frv_queue_interrupt (SIM_CPU *current_cpu, enum frv_interrupt_kind kind)
 133 {
 134   int i;
 135   int j;
 136   int limit = frv_interrupt_state.queue_index;
 137   struct frv_interrupt_queue_element *new_element;
 138   enum frv_interrupt_class iclass;
 139
 140   if (limit >= FRV_INTERRUPT_QUEUE_SIZE)
 141     abort (); /* TODO: Make the queue dynamic */
 142
 143   /* Find the right place in the queue.  */
 144   for (i = 0; i < limit; ++i)
 145     {
 146       if (frv_interrupt_state.queue[i].kind >= kind)
 147         break;
 148     }
 149
 150   /* Don't queue two external interrupts of the same priority.  */
 151   iclass = frv_interrupt_table[kind].iclass;
 152   if (i < limit && iclass == FRV_EXTERNAL_INTERRUPT)
 153     {
 154       if (frv_interrupt_state.queue[i].kind == kind)
 155         return & frv_interrupt_state.queue[i];
 156     }
 157
 158   /* Make room for the new interrupt in this spot.  */
 159   for (j = limit - 1; j >= i; --j)
 160     frv_interrupt_state.queue[j + 1] = frv_interrupt_state.queue[j];
 161
 162   /* Add the new interrupt.  */
 163   frv_interrupt_state.queue_index++;
 164   new_element = & frv_interrupt_state.queue[i];
 165   new_element->kind = kind;
 166   new_element->vpc = CPU_PC_GET (current_cpu);
 167   new_element->u.data_written.length = 0;
 168   frv_set_interrupt_queue_slot (current_cpu, new_element);
 169
 170   return new_element;
 171 }
 172
 173 struct frv_interrupt_queue_element *
 174 frv_queue_register_exception_interrupt (SIM_CPU *current_cpu, enum frv_rec rec)
 175 {
 176   struct frv_interrupt_queue_element *new_element =
 177     frv_queue_program_interrupt (current_cpu, FRV_REGISTER_EXCEPTION);
 178
 179   new_element->u.rec = rec;
 180
 181   return new_element;
 182 }
 183
 184 struct frv_interrupt_queue_element *
 185 frv_queue_mem_address_not_aligned_interrupt (SIM_CPU *current_cpu, USI addr)
 186 {
 187   struct frv_interrupt_queue_element *new_element;
 188   USI isr = GET_ISR ();
 189
 190   /* Make sure that this exception is not masked.  */
 191   if (GET_ISR_EMAM (isr))
 192     return NULL;
 193
 194   /* Queue the interrupt.  */
 195   new_element = frv_queue_program_interrupt (current_cpu,
 196                                              FRV_MEM_ADDRESS_NOT_ALIGNED);
 197   new_element->eaddress = addr;
 198   new_element->u.data_written = frv_interrupt_state.data_written;
 199   frv_interrupt_state.data_written.length = 0;
 200
 201   return new_element;
 202 }
 203
 204 struct frv_interrupt_queue_element *
 205 frv_queue_data_access_error_interrupt (SIM_CPU *current_cpu, USI addr)
 206 {
 207   struct frv_interrupt_queue_element *new_element;
 208   new_element = frv_queue_program_interrupt (current_cpu,
 209                                              FRV_DATA_ACCESS_ERROR);
 210   new_element->eaddress = addr;
 211   return new_element;
 212 }
 213
 214 struct frv_interrupt_queue_element *
 215 frv_queue_data_access_exception_interrupt (SIM_CPU *current_cpu)
 216 {
 217   return frv_queue_program_interrupt (current_cpu, FRV_DATA_ACCESS_EXCEPTION);
 218 }
 219
 220 struct frv_interrupt_queue_element *
 221 frv_queue_instruction_access_error_interrupt (SIM_CPU *current_cpu)
 222 {
 223   return frv_queue_program_interrupt (current_cpu, FRV_INSTRUCTION_ACCESS_ERROR);
 224 }
 225
 226 struct frv_interrupt_queue_element *
 227 frv_queue_instruction_access_exception_interrupt (SIM_CPU *current_cpu)
 228 {
 229   return frv_queue_program_interrupt (current_cpu, FRV_INSTRUCTION_ACCESS_EXCEPTION);
 230 }
 231
 232 struct frv_interrupt_queue_element *
 233 frv_queue_illegal_instruction_interrupt (
 234   SIM_CPU *current_cpu, const CGEN_INSN *insn
 235 )
 236 {
 237   SIM_DESC sd = CPU_STATE (current_cpu);
 238   switch (STATE_ARCHITECTURE (sd)->mach)
 239     {
 240     case bfd_mach_fr400:
 241     case bfd_mach_fr450:
 242     case bfd_mach_fr550:
 243       break;
 244     default:
 245       /* Some machines generate fp_exception for this case.  */
 246       if (frv_is_float_insn (insn) || frv_is_media_insn (insn))
 247         {
 248           struct frv_fp_exception_info fp_info = {
 249             FSR_NO_EXCEPTION, FTT_SEQUENCE_ERROR
 250           };
 251           return frv_queue_fp_exception_interrupt (current_cpu, & fp_info);
 252         }
 253       break;
 254     }
 255
 256   return frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 257 }
 258
 259 struct frv_interrupt_queue_element *
 260 frv_queue_privileged_instruction_interrupt (SIM_CPU *current_cpu, const CGEN_INSN *insn)
 261 {
 262   /* The fr550 has no privileged instruction interrupt. It uses
 263      illegal_instruction.  */
 264   SIM_DESC sd = CPU_STATE (current_cpu);
 265   if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550)
 266     return frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 267
 268   return frv_queue_program_interrupt (current_cpu, FRV_PRIVILEGED_INSTRUCTION);
 269 }
 270
 271 struct frv_interrupt_queue_element *
 272 frv_queue_float_disabled_interrupt (SIM_CPU *current_cpu)
 273 {
 274   /* The fr550 has no fp_disabled interrupt. It uses illegal_instruction.  */
 275   SIM_DESC sd = CPU_STATE (current_cpu);
 276   if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550)
 277     return frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 278
 279   return frv_queue_program_interrupt (current_cpu, FRV_FP_DISABLED);
 280 }
 281
 282 struct frv_interrupt_queue_element *
 283 frv_queue_media_disabled_interrupt (SIM_CPU *current_cpu)
 284 {
 285   /* The fr550 has no mp_disabled interrupt. It uses illegal_instruction.  */
 286   SIM_DESC sd = CPU_STATE (current_cpu);
 287   if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550)
 288     return frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 289
 290   return frv_queue_program_interrupt (current_cpu, FRV_MP_DISABLED);
 291 }
 292
 293 struct frv_interrupt_queue_element *
 294 frv_queue_non_implemented_instruction_interrupt (
 295   SIM_CPU *current_cpu, const CGEN_INSN *insn
 296 )
 297 {
 298   SIM_DESC sd = CPU_STATE (current_cpu);
 299   switch (STATE_ARCHITECTURE (sd)->mach)
 300     {
 301     case bfd_mach_fr400:
 302     case bfd_mach_fr450:
 303     case bfd_mach_fr550:
 304       break;
 305     default:
 306       /* Some machines generate fp_exception or mp_exception for this case.  */
 307       if (frv_is_float_insn (insn))
 308         {
 309           struct frv_fp_exception_info fp_info = {
 310             FSR_NO_EXCEPTION, FTT_UNIMPLEMENTED_FPOP
 311           };
 312           return frv_queue_fp_exception_interrupt (current_cpu, & fp_info);
 313         }
 314       if (frv_is_media_insn (insn))
 315         {
 316           frv_set_mp_exception_registers (current_cpu, MTT_UNIMPLEMENTED_MPOP,
 317                                           0);
 318           return NULL; /* no interrupt queued at this time.  */
 319         }
 320       break;
 321     }
 322
 323   return frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 324 }
 325
 326 /* Queue the given fp_exception interrupt. Also update fp_info by removing
 327    masked interrupts and updating the 'slot' flield.  */
 328 struct frv_interrupt_queue_element *
 329 frv_queue_fp_exception_interrupt (
 330   SIM_CPU *current_cpu, struct frv_fp_exception_info *fp_info
 331 )
 332 {
 333   SI fsr0 = GET_FSR (0);
 334   int tem = GET_FSR_TEM (fsr0);
 335   int aexc = GET_FSR_AEXC (fsr0);
 336   struct frv_interrupt_queue_element *new_element = NULL;
 337
 338   /* Update AEXC with the interrupts that are masked.  */
 339   aexc |= fp_info->fsr_mask & ~tem;
 340   SET_FSR_AEXC (fsr0, aexc);
 341   SET_FSR (0, fsr0);
 342
 343   /* update fsr_mask with the exceptions that are enabled.  */
 344   fp_info->fsr_mask &= tem;
 345
 346   /* If there is an unmasked interrupt then queue it, unless
 347      this was a non-excepting insn, in which case simply set the NE
 348      status registers.  */
 349   if (frv_interrupt_state.ne_index != NE_NOFLAG
 350       && fp_info->fsr_mask != FSR_NO_EXCEPTION)
 351     {
 352       SET_NE_FLAG (frv_interrupt_state.f_ne_flags,
 353                    frv_interrupt_state.ne_index);
 354       /* TODO -- Set NESR for chips which support it.  */
 355       new_element = NULL;
 356     }
 357   else if (fp_info->fsr_mask != FSR_NO_EXCEPTION
 358            || fp_info->ftt == FTT_UNIMPLEMENTED_FPOP
 359            || fp_info->ftt == FTT_SEQUENCE_ERROR
 360            || fp_info->ftt == FTT_INVALID_FR)
 361     {
 362       new_element = frv_queue_program_interrupt (current_cpu, FRV_FP_EXCEPTION);
 363       new_element->u.fp_info = *fp_info;
 364     }
 365
 366   return new_element;
 367 }
 368
 369 struct frv_interrupt_queue_element *
 370 frv_queue_division_exception_interrupt (SIM_CPU *current_cpu, enum frv_dtt dtt)
 371 {
 372   struct frv_interrupt_queue_element *new_element =
 373     frv_queue_program_interrupt (current_cpu, FRV_DIVISION_EXCEPTION);
 374
 375   new_element->u.dtt = dtt;
 376
 377   return new_element;
 378 }
 379
 380 /* Check for interrupts caused by illegal insn access.  These conditions are
 381    checked in the order specified by the fr400 and fr500 LSI specs.  */
 382 void
 383 frv_detect_insn_access_interrupts (SIM_CPU *current_cpu, SCACHE *sc)
 384 {
 385
 386   const CGEN_INSN *insn = sc->argbuf.idesc->idata;
 387   SIM_DESC sd = CPU_STATE (current_cpu);
 388   FRV_VLIW *vliw = CPU_VLIW (current_cpu);
 389
 390   /* Check for vliw constraints.  */
 391   if (vliw->constraint_violation)
 392     frv_queue_illegal_instruction_interrupt (current_cpu, insn);
 393   /* Check for non-excepting insns.  */
 394   else if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_NON_EXCEPTING)
 395       && ! GET_H_PSR_NEM ())
 396     frv_queue_non_implemented_instruction_interrupt (current_cpu, insn);
 397   /* Check for conditional insns.  */
 398   else if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_CONDITIONAL)
 399       && ! GET_H_PSR_CM ())
 400     frv_queue_non_implemented_instruction_interrupt (current_cpu, insn);
 401   /* Make sure floating point support is enabled.  */
 402   else if (! GET_H_PSR_EF ())
 403     {
 404       /* Generate fp_disabled if it is a floating point insn or if PSR.EM is
 405          off and the insns accesses a fp register.  */
 406       if (frv_is_float_insn (insn)
 407           || (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR_ACCESS)
 408               && ! GET_H_PSR_EM ()))
 409         frv_queue_float_disabled_interrupt (current_cpu);
 410     }
 411   /* Make sure media support is enabled.  */
 412   else if (! GET_H_PSR_EM ())
 413     {
 414       /* Generate mp_disabled if it is a media insn.  */
 415       if (frv_is_media_insn (insn) || CGEN_INSN_NUM (insn) == FRV_INSN_MTRAP)
 416         frv_queue_media_disabled_interrupt (current_cpu);
 417     }
 418   /* Check for privileged insns.  */
 419   else if (CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_PRIVILEGED) &&
 420            ! GET_H_PSR_S ())
 421     frv_queue_privileged_instruction_interrupt (current_cpu, insn);
 422 #if 0 /* disable for now until we find out how FSR0.QNE gets reset.  */
 423   else
 424     {
 425       /* Enter the halt state if FSR0.QNE is set and we are executing a
 426          floating point insn, a media insn or an insn which access a FR
 427          register.  */
 428       SI fsr0 = GET_FSR (0);
 429       if (GET_FSR_QNE (fsr0)
 430           && (frv_is_float_insn (insn) || frv_is_media_insn (insn)
 431               || CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_FR_ACCESS)))
 432         {
 433           sim_engine_halt (sd, current_cpu, NULL, GET_H_PC (), sim_stopped,
 434                            SIM_SIGINT);
 435         }
 436     }
 437 #endif
 438 }
 439
 440 /* Record the current VLIW slot in the given interrupt queue element.  */
 441 void
 442 frv_set_interrupt_queue_slot (
 443   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item
 444 )
 445 {
 446   FRV_VLIW *vliw = CPU_VLIW (current_cpu);
 447   int slot = vliw->next_slot - 1;
 448   item->slot = (*vliw->current_vliw)[slot];
 449 }
 450
 451 /* Handle an individual interrupt.  */
 452 static void
 453 handle_interrupt (SIM_CPU *current_cpu, IADDR pc)
 454 {
 455   struct frv_interrupt *interrupt;
 456   int writeback_done = 0;
 457   while (1)
 458     {
 459       /* Interrupts are queued in priority order with the highest priority
 460          last.  */
 461       int index = frv_interrupt_state.queue_index - 1;
 462       struct frv_interrupt_queue_element *item
 463         = & frv_interrupt_state.queue[index];
 464       interrupt = & frv_interrupt_table[item->kind];
 465
 466       switch (interrupt->iclass)
 467         {
 468         case FRV_EXTERNAL_INTERRUPT:
 469           /* Perform writeback first. This may cause a higher priority
 470              interrupt.  */
 471           if (! writeback_done)
 472             {
 473               frvbf_perform_writeback (current_cpu);
 474               writeback_done = 1;
 475               continue;
 476             }
 477           frv_external_interrupt (current_cpu, item, pc);
 478           return;
 479         case FRV_SOFTWARE_INTERRUPT:
 480           frv_interrupt_state.queue_index = index;
 481           frv_software_interrupt (current_cpu, item, pc);
 482           return;
 483         case FRV_PROGRAM_INTERRUPT:
 484           /* If the program interrupt is not strict (imprecise), then perform
 485              writeback first. This may, in turn, cause a higher priority
 486              interrupt.  */
 487           if (! interrupt->precise && ! writeback_done)
 488             {
 489               frv_interrupt_state.imprecise_interrupt = item;
 490               frvbf_perform_writeback (current_cpu);
 491               writeback_done = 1;
 492               continue;
 493             }
 494           frv_interrupt_state.queue_index = index;
 495           frv_program_interrupt (current_cpu, item, pc);
 496           return;
 497         case FRV_BREAK_INTERRUPT:
 498           frv_interrupt_state.queue_index = index;
 499           frv_break_interrupt (current_cpu, interrupt, pc);
 500           return;
 501         case FRV_RESET_INTERRUPT:
 502           break;
 503         default:
 504           break;
 505         }
 506       frv_interrupt_state.queue_index = index;
 507       break; /* out of loop.  */
 508     }
 509
 510   /* We should never get here.  */
 511   {
 512     SIM_DESC sd = CPU_STATE (current_cpu);
 513     sim_engine_abort (sd, current_cpu, pc,
 514                       "interrupt class not supported %d\n",
 515                       interrupt->iclass);
 516   }
 517 }
 518
 519 /* Check to see the if the RSTR.HR or RSTR.SR bits have been set.  If so, handle
 520    the appropriate reset interrupt.  */
 521 static int
 522 check_reset (SIM_CPU *current_cpu, IADDR pc)
 523 {
 524   int hsr0;
 525   int hr;
 526   int sr;
 527   SI rstr;
 528   FRV_CACHE *cache = CPU_DATA_CACHE (current_cpu);
 529   IADDR address = RSTR_ADDRESS;
 530
 531   /* We don't want this to show up in the cache statistics, so read the
 532      cache passively.  */
 533   if (! frv_cache_read_passive_SI (cache, address, & rstr))
 534     rstr = sim_core_read_unaligned_4 (current_cpu, pc, read_map, address);
 535
 536   hr = GET_RSTR_HR (rstr);
 537   sr = GET_RSTR_SR (rstr);
 538
 539   if (! hr && ! sr)
 540     return 0; /* no reset.  */
 541
 542   /* Reinitialize the machine state.  */
 543   if (hr)
 544     frv_hardware_reset (current_cpu);
 545   else
 546     frv_software_reset (current_cpu);
 547
 548   /* Branch to the reset address.  */
 549   hsr0 = GET_HSR0 ();
 550   if (GET_HSR0_SA (hsr0))
 551     SET_H_PC (0xff000000);
 552   else
 553     SET_H_PC (0);
 554
 555   return 1; /* reset */
 556 }
 557
 558 /* Process any pending interrupt(s) after a group of parallel insns.  */
 559 void
 560 frv_process_interrupts (SIM_CPU *current_cpu)
 561 {
 562   SI NE_flags[2];
 563   /* Need to save the pc here because writeback may change it (due to a
 564      branch).  */
 565   IADDR pc = CPU_PC_GET (current_cpu);
 566
 567   /* Check for a reset before anything else.  */
 568   if (check_reset (current_cpu, pc))
 569     return;
 570
 571   /* First queue the writes for any accumulated NE flags.  */
 572   if (frv_interrupt_state.f_ne_flags[0] != 0
 573       || frv_interrupt_state.f_ne_flags[1] != 0)
 574     {
 575       GET_NE_FLAGS (NE_flags, H_SPR_FNER0);
 576       NE_flags[0] |= frv_interrupt_state.f_ne_flags[0];
 577       NE_flags[1] |= frv_interrupt_state.f_ne_flags[1];
 578       SET_NE_FLAGS (H_SPR_FNER0, NE_flags);
 579     }
 580
 581   /* If there is no interrupt pending, then perform parallel writeback.  This
 582      may cause an interrupt.  */
 583   if (frv_interrupt_state.queue_index <= 0)
 584     frvbf_perform_writeback (current_cpu);
 585
 586   /* If there is an interrupt pending, then process it.  */
 587   if (frv_interrupt_state.queue_index > 0)
 588     handle_interrupt (current_cpu, pc);
 589 }
 590
 591 /* Find the next available ESR and return its index */
 592 static int
 593 esr_for_data_access_exception (
 594   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item
 595 )
 596 {
 597   SIM_DESC sd = CPU_STATE (current_cpu);
 598   if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550)
 599     return 8; /* Use ESR8, EPCR8.  */
 600
 601   if (item->slot == UNIT_I0)
 602     return 8; /* Use ESR8, EPCR8, EAR8, EDR8.  */
 603
 604   return 9; /* Use ESR9, EPCR9, EAR9.  */
 605 }
 606
 607 /* Set the next available EDR register with the data which was to be stored
 608    and return the index of the register.  */
 609 static int
 610 set_edr_register (
 611   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item, int edr_index
 612 )
 613 {
 614   /* EDR0, EDR4 and EDR8 are available as blocks of 4.
 615        SI data uses EDR3, EDR7 and EDR11
 616        DI data uses EDR2, EDR6 and EDR10
 617        XI data uses EDR0, EDR4 and EDR8.  */
 618   int i;
 619   edr_index += 4 - item->u.data_written.length;
 620   for (i = 0; i < item->u.data_written.length; ++i)
 621     SET_EDR (edr_index + i, item->u.data_written.words[i]);
 622
 623   return edr_index;
 624 };
 625
 626 /* Clear ESFR0, EPCRx, ESRx, EARx and EDRx.  */
 627 static void
 628 clear_exception_status_registers (SIM_CPU *current_cpu)
 629 {
 630   int i;
 631   /* It is only necessary to clear the flag bits indicating which registers
 632      are valid.  */
 633   SET_ESFR (0, 0);
 634   SET_ESFR (1, 0);
 635
 636   for (i = 0; i <= 2; ++i)
 637     {
 638       SI esr = GET_ESR (i);
 639       CLEAR_ESR_VALID (esr);
 640       SET_ESR (i, esr);
 641     }
 642   for (i = 8; i <= 15; ++i)
 643     {
 644       SI esr = GET_ESR (i);
 645       CLEAR_ESR_VALID (esr);
 646       SET_ESR (i, esr);
 647     }
 648 }
 649
 650 /* Record state for media exception.  */
 651 void
 652 frv_set_mp_exception_registers (
 653   SIM_CPU *current_cpu, enum frv_msr_mtt mtt, int sie
 654 )
 655 {
 656   /* Record the interrupt factor in MSR0.  */
 657   SI msr0 = GET_MSR (0);
 658   if (GET_MSR_MTT (msr0) == MTT_NONE)
 659     SET_MSR_MTT (msr0, mtt);
 660
 661   /* Also set the OVF bit in the appropriate MSR as well as MSR0.AOVF.  */
 662   if (mtt == MTT_OVERFLOW)
 663     {
 664       FRV_VLIW *vliw = CPU_VLIW (current_cpu);
 665       int slot = vliw->next_slot - 1;
 666       SIM_DESC sd = CPU_STATE (current_cpu);
 667
 668       /* If this insn is in the M2 slot, then set MSR1.OVF and MSR1.SIE,
 669          otherwise set MSR0.OVF and MSR0.SIE.  */
 670       if (STATE_ARCHITECTURE (sd)->mach != bfd_mach_fr550 && (*vliw->current_vliw)[slot] == UNIT_FM1)
 671         {
 672           SI msr = GET_MSR (1);
 673           OR_MSR_SIE (msr, sie);
 674           SET_MSR_OVF (msr);
 675           SET_MSR (1, msr);
 676         }
 677       else
 678         {
 679           OR_MSR_SIE (msr0, sie);
 680           SET_MSR_OVF (msr0);
 681         }
 682
 683       /* Generate the interrupt now if MSR0.MPEM is set on fr550 */
 684       if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550 && GET_MSR_MPEM (msr0))
 685         frv_queue_program_interrupt (current_cpu, FRV_MP_EXCEPTION);
 686       else
 687         {
 688           /* Regardless of the slot, set MSR0.AOVF.  */
 689           SET_MSR_AOVF (msr0);
 690         }
 691     }
 692
 693   SET_MSR (0, msr0);
 694 }
 695
 696 /* Determine the correct FQ register to use for the given exception.
 697    Return -1 if a register is not available.  */
 698 static int
 699 fq_for_exception (
 700   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item
 701 )
 702 {
 703   SI fq;
 704   struct frv_fp_exception_info *fp_info = & item->u.fp_info;
 705
 706   /* For fp_exception overflow, underflow or inexact, use FQ0 or FQ1.  */
 707   if (fp_info->ftt == FTT_IEEE_754_EXCEPTION
 708       && (fp_info->fsr_mask & (FSR_OVERFLOW | FSR_UNDERFLOW | FSR_INEXACT)))
 709     {
 710       fq = GET_FQ (0);
 711       if (! GET_FQ_VALID (fq))
 712         return 0; /* FQ0 is available.  */
 713       fq = GET_FQ (1);
 714       if (! GET_FQ_VALID (fq))
 715         return 1; /* FQ1 is available.  */
 716
 717       /* No FQ register is available */
 718       {
 719         SIM_DESC sd = CPU_STATE (current_cpu);
 720         IADDR pc = CPU_PC_GET (current_cpu);
 721         sim_engine_abort (sd, current_cpu, pc, "No FQ register available\n");
 722       }
 723       return -1;
 724     }
 725   /* For other exceptions, use FQ2 if the insn was in slot F0/I0 and FQ3
 726      otherwise.  */
 727   if (item->slot == UNIT_FM0 || item->slot == UNIT_I0)
 728     return 2;
 729
 730   return 3;
 731 }
 732
 733 /* Set FSR0, FQ0-FQ9, depending on the interrupt.  */
 734 static void
 735 set_fp_exception_registers (
 736   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item
 737 )
 738 {
 739   int fq_index;
 740   SI fq;
 741   SI insn;
 742   SI fsr0;
 743   IADDR pc;
 744   struct frv_fp_exception_info *fp_info;
 745   SIM_DESC sd = CPU_STATE (current_cpu);
 746
 747   /* No FQ registers on fr550 */
 748   if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550)
 749     {
 750       /* Update the fsr.  */
 751       fp_info = & item->u.fp_info;
 752       fsr0 = GET_FSR (0);
 753       SET_FSR_FTT (fsr0, fp_info->ftt);
 754       SET_FSR (0, fsr0);
 755       return;
 756     }
 757
 758   /* Select an FQ and update it with the exception information.  */
 759   fq_index = fq_for_exception (current_cpu, item);
 760   if (fq_index == -1)
 761     return;
 762
 763   fp_info = & item->u.fp_info;
 764   fq = GET_FQ (fq_index);
 765   SET_FQ_MIV (fq, MIV_FLOAT);
 766   SET_FQ_SIE (fq, SIE_NIL);
 767   SET_FQ_FTT (fq, fp_info->ftt);
 768   SET_FQ_CEXC (fq, fp_info->fsr_mask);
 769   SET_FQ_VALID (fq);
 770   SET_FQ (fq_index, fq);
 771
 772   /* Write the failing insn into FQx.OPC.  */
 773   pc = item->vpc;
 774   insn = GETMEMSI (current_cpu, pc, pc);
 775   SET_FQ_OPC (fq_index, insn);
 776
 777   /* Update the fsr.  */
 778   fsr0 = GET_FSR (0);
 779   SET_FSR_QNE (fsr0); /* FQ not empty */
 780   SET_FSR_FTT (fsr0, fp_info->ftt);
 781   SET_FSR (0, fsr0);
 782 }
 783
 784 /* Record the state of a division exception in the ISR.  */
 785 static void
 786 set_isr_exception_fields (
 787   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item
 788 )
 789 {
 790   USI isr = GET_ISR ();
 791   int dtt = GET_ISR_DTT (isr);
 792   dtt |= item->u.dtt;
 793   SET_ISR_DTT (isr, dtt);
 794   SET_ISR (isr);
 795 }
 796
 797 /* Set ESFR0, EPCRx, ESRx, EARx and EDRx, according to the given program
 798    interrupt.  */
 799 static void
 800 set_exception_status_registers (
 801   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item
 802 )
 803 {
 804   struct frv_interrupt *interrupt = & frv_interrupt_table[item->kind];
 805   int slot = (item->vpc - previous_vliw_pc) / 4;
 806   int reg_index = -1;
 807   int set_ear = 0;
 808   int set_edr = 0;
 809   int set_daec = 0;
 810   int set_epcr = 0;
 811   SI esr = 0;
 812   SIM_DESC sd = CPU_STATE (current_cpu);
 813
 814   /* If the interrupt is strict (precise) or the interrupt is on the insns
 815      in the I0 pipe, then set the 0 registers.  */
 816   if (interrupt->precise)
 817     {
 818       reg_index = 0;
 819       if (interrupt->kind == FRV_REGISTER_EXCEPTION)
 820         SET_ESR_REC (esr, item->u.rec);
 821       else if (interrupt->kind == FRV_INSTRUCTION_ACCESS_EXCEPTION)
 822         SET_ESR_IAEC (esr, item->u.iaec);
 823       /* For fr550, don't set epcr for precise interrupts.  */
 824       if (STATE_ARCHITECTURE (sd)->mach != bfd_mach_fr550)
 825         set_epcr = 1;
 826     }
 827   else
 828     {
 829       switch (interrupt->kind)
 830         {
 831         case FRV_DIVISION_EXCEPTION:
 832           set_isr_exception_fields (current_cpu, item);
 833           /* fall thru to set reg_index.  */
 834         case FRV_COMMIT_EXCEPTION:
 835           /* For fr550, always use ESR0.  */
 836           if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550)
 837             reg_index = 0;
 838           else if (item->slot == UNIT_I0)
 839             reg_index = 0;
 840           else if (item->slot == UNIT_I1)
 841             reg_index = 1;
 842           set_epcr = 1;
 843           break;
 844         case FRV_DATA_STORE_ERROR:
 845           reg_index = 14; /* Use ESR14.  */
 846           break;
 847         case FRV_DATA_ACCESS_ERROR:
 848           reg_index = 15; /* Use ESR15, EPCR15.  */
 849           set_ear = 1;
 850           break;
 851         case FRV_DATA_ACCESS_EXCEPTION:
 852           set_daec = 1;
 853           /* fall through */
 854         case FRV_DATA_ACCESS_MMU_MISS:
 855         case FRV_MEM_ADDRESS_NOT_ALIGNED:
 856           /* Get the appropriate ESR, EPCR, EAR and EDR.
 857              EAR will be set. EDR will not be set if this is a store insn.  */
 858           set_ear = 1;
 859           /* For fr550, never use EDRx.  */
 860           if (STATE_ARCHITECTURE (sd)->mach != bfd_mach_fr550)
 861             if (item->u.data_written.length != 0)
 862               set_edr = 1;
 863           reg_index = esr_for_data_access_exception (current_cpu, item);
 864           set_epcr = 1;
 865           break;
 866         case FRV_MP_EXCEPTION:
 867           /* For fr550, use EPCR2 and ESR2.  */
 868           if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550)
 869             {
 870               reg_index = 2;
 871               set_epcr = 1;
 872             }
 873           break; /* MSR0-1, FQ0-9 are already set.  */
 874         case FRV_FP_EXCEPTION:
 875           set_fp_exception_registers (current_cpu, item);
 876           /* For fr550, use EPCR2 and ESR2.  */
 877           if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr550)
 878             {
 879               reg_index = 2;
 880               set_epcr = 1;
 881             }
 882           break;
 883         default:
 884           {
 885             SIM_DESC sd = CPU_STATE (current_cpu);
 886             IADDR pc = CPU_PC_GET (current_cpu);
 887             sim_engine_abort (sd, current_cpu, pc,
 888                               "invalid non-strict program interrupt kind: %d\n",
 889                               interrupt->kind);
 890             break;
 891           }
 892         }
 893     } /* non-strict (imprecise) interrupt */
 894
 895   /* Now fill in the selected exception status registers.  */
 896   if (reg_index != -1)
 897     {
 898       /* Now set the exception status registers.  */
 899       SET_ESFR_FLAG (reg_index);
 900       SET_ESR_EC (esr, interrupt->ec);
 901
 902       if (set_epcr)
 903         {
 904           if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr400)
 905             SET_EPCR (reg_index, previous_vliw_pc);
 906           else
 907             SET_EPCR (reg_index, item->vpc);
 908         }
 909
 910       if (set_ear)
 911         {
 912           SET_EAR (reg_index, item->eaddress);
 913           SET_ESR_EAV (esr);
 914         }
 915       else
 916         CLEAR_ESR_EAV (esr);
 917
 918       if (set_edr)
 919         {
 920           int edn = set_edr_register (current_cpu, item, 0/* EDR0-3 */);
 921           SET_ESR_EDN (esr, edn);
 922           SET_ESR_EDV (esr);
 923         }
 924       else
 925         CLEAR_ESR_EDV (esr);
 926
 927       if (set_daec)
 928         SET_ESR_DAEC (esr, item->u.daec);
 929
 930       SET_ESR_VALID (esr);
 931       SET_ESR (reg_index, esr);
 932     }
 933 }
 934
 935 /* Check for compound interrupts.
 936    Returns NULL if no interrupt is to be processed.  */
 937 static struct frv_interrupt *
 938 check_for_compound_interrupt (
 939   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item
 940 )
 941 {
 942   struct frv_interrupt *interrupt;
 943
 944   /* Set the exception status registers for the original interrupt.  */
 945   set_exception_status_registers (current_cpu, item);
 946   interrupt = & frv_interrupt_table[item->kind];
 947
 948   if (! interrupt->precise)
 949     {
 950       IADDR vpc = 0;
 951       int mask = 0;
 952
 953       vpc = item->vpc;
 954       mask = (1 << item->kind);
 955
 956       /* Look for more queued program interrupts which are non-deferred
 957          (pending inhibit), imprecise (non-strict) different than an interrupt
 958          already found and caused by a different insn.  A bit mask is used
 959          to keep track of interrupts which have already been detected.  */
 960       while (item != frv_interrupt_state.queue)
 961         {
 962           enum frv_interrupt_kind kind;
 963           struct frv_interrupt *next_interrupt;
 964           --item;
 965           kind = item->kind;
 966           next_interrupt = & frv_interrupt_table[kind];
 967
 968           if (next_interrupt->iclass != FRV_PROGRAM_INTERRUPT)
 969             break; /* no program interrupts left.  */
 970
 971           if (item->vpc == vpc)
 972             continue; /* caused by the same insn.  */
 973
 974           vpc = item->vpc;
 975           if (! next_interrupt->precise && ! next_interrupt->deferred)
 976             {
 977               if (! (mask & (1 << kind)))
 978                 {
 979                   /* Set the exception status registers for the additional
 980                      interrupt.  */
 981                   set_exception_status_registers (current_cpu, item);
 982                   mask |= (1 << kind);
 983                   interrupt = & frv_interrupt_table[FRV_COMPOUND_EXCEPTION];
 984                 }
 985             }
 986         }
 987     }
 988
 989   /* Return with either the original interrupt, a compound_exception,
 990      or no exception.  */
 991   return interrupt;
 992 }
 993
 994 /* Handle a program interrupt.  */
 995 void
 996 frv_program_interrupt (
 997   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item, IADDR pc
 998 )
 999 {
1000   struct frv_interrupt *interrupt;
1001
1002   clear_exception_status_registers (current_cpu);
1003   /* If two or more non-deferred imprecise (non-strict) interrupts occur
1004      on two or more insns, then generate a compound_exception.  */
1005   interrupt = check_for_compound_interrupt (current_cpu, item);
1006   if (interrupt != NULL)
1007     {
1008       frv_program_or_software_interrupt (current_cpu, interrupt, pc);
1009       frv_clear_interrupt_classes (FRV_SOFTWARE_INTERRUPT,
1010                                    FRV_PROGRAM_INTERRUPT);
1011     }
1012 }
1013
1014 /* Handle a software interrupt.  */
1015 void
1016 frv_software_interrupt (
1017   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item, IADDR pc
1018 )
1019 {
1020   struct frv_interrupt *interrupt = & frv_interrupt_table[item->kind];
1021   frv_program_or_software_interrupt (current_cpu, interrupt, pc);
1022 }
1023
1024 /* Handle a program interrupt or a software interrupt in non-operating mode.  */
1025 void
1026 frv_non_operating_interrupt (
1027   SIM_CPU *current_cpu, enum frv_interrupt_kind kind, IADDR pc
1028 )
1029 {
1030   SIM_DESC sd = CPU_STATE (current_cpu);
1031   switch (kind)
1032     {
1033     case FRV_INTERRUPT_LEVEL_1:
1034     case FRV_INTERRUPT_LEVEL_2:
1035     case FRV_INTERRUPT_LEVEL_3:
1036     case FRV_INTERRUPT_LEVEL_4:
1037     case FRV_INTERRUPT_LEVEL_5:
1038     case FRV_INTERRUPT_LEVEL_6:
1039     case FRV_INTERRUPT_LEVEL_7:
1040     case FRV_INTERRUPT_LEVEL_8:
1041     case FRV_INTERRUPT_LEVEL_9:
1042     case FRV_INTERRUPT_LEVEL_10:
1043     case FRV_INTERRUPT_LEVEL_11:
1044     case FRV_INTERRUPT_LEVEL_12:
1045     case FRV_INTERRUPT_LEVEL_13:
1046     case FRV_INTERRUPT_LEVEL_14:
1047     case FRV_INTERRUPT_LEVEL_15:
1048       sim_engine_abort (sd, current_cpu, pc,
1049                         "interrupt: external %d\n", kind + 1);
1050       break;
1051     case FRV_TRAP_INSTRUCTION:
1052       break; /* handle as in operating mode.  */
1053     case FRV_COMMIT_EXCEPTION:
1054       sim_engine_abort (sd, current_cpu, pc,
1055                         "interrupt: commit_exception\n");
1056       break;
1057     case FRV_DIVISION_EXCEPTION:
1058       sim_engine_abort (sd, current_cpu, pc,
1059                         "interrupt: division_exception\n");
1060       break;
1061     case FRV_DATA_STORE_ERROR:
1062       sim_engine_abort (sd, current_cpu, pc,
1063                         "interrupt: data_store_error\n");
1064       break;
1065     case FRV_DATA_ACCESS_EXCEPTION:
1066       sim_engine_abort (sd, current_cpu, pc,
1067                         "interrupt: data_access_exception\n");
1068       break;
1069     case FRV_DATA_ACCESS_MMU_MISS:
1070       sim_engine_abort (sd, current_cpu, pc,
1071                         "interrupt: data_access_mmu_miss\n");
1072       break;
1073     case FRV_DATA_ACCESS_ERROR:
1074       sim_engine_abort (sd, current_cpu, pc,
1075                         "interrupt: data_access_error\n");
1076       break;
1077     case FRV_MP_EXCEPTION:
1078       sim_engine_abort (sd, current_cpu, pc,
1079                         "interrupt: mp_exception\n");
1080       break;
1081     case FRV_FP_EXCEPTION:
1082       sim_engine_abort (sd, current_cpu, pc,
1083                         "interrupt: fp_exception\n");
1084       break;
1085     case FRV_MEM_ADDRESS_NOT_ALIGNED:
1086       sim_engine_abort (sd, current_cpu, pc,
1087                         "interrupt: mem_address_not_aligned\n");
1088       break;
1089     case FRV_REGISTER_EXCEPTION:
1090       sim_engine_abort (sd, current_cpu, pc,
1091                         "interrupt: register_exception\n");
1092       break;
1093     case FRV_MP_DISABLED:
1094       sim_engine_abort (sd, current_cpu, pc,
1095                         "interrupt: mp_disabled\n");
1096       break;
1097     case FRV_FP_DISABLED:
1098       sim_engine_abort (sd, current_cpu, pc,
1099                         "interrupt: fp_disabled\n");
1100       break;
1101     case FRV_PRIVILEGED_INSTRUCTION:
1102       sim_engine_abort (sd, current_cpu, pc,
1103                         "interrupt: privileged_instruction\n");
1104       break;
1105     case FRV_ILLEGAL_INSTRUCTION:
1106       sim_engine_abort (sd, current_cpu, pc,
1107                         "interrupt: illegal_instruction\n");
1108       break;
1109     case FRV_INSTRUCTION_ACCESS_EXCEPTION:
1110       sim_engine_abort (sd, current_cpu, pc,
1111                         "interrupt: instruction_access_exception\n");
1112       break;
1113     case FRV_INSTRUCTION_ACCESS_MMU_MISS:
1114       sim_engine_abort (sd, current_cpu, pc,
1115                         "interrupt: instruction_access_mmu_miss\n");
1116       break;
1117     case FRV_INSTRUCTION_ACCESS_ERROR:
1118       sim_engine_abort (sd, current_cpu, pc,
1119                         "interrupt: insn_access_error\n");
1120       break;
1121     case FRV_COMPOUND_EXCEPTION:
1122       sim_engine_abort (sd, current_cpu, pc,
1123                         "interrupt: compound_exception\n");
1124       break;
1125     case FRV_BREAK_EXCEPTION:
1126       sim_engine_abort (sd, current_cpu, pc,
1127                         "interrupt: break_exception\n");
1128       break;
1129     case FRV_RESET:
1130       sim_engine_abort (sd, current_cpu, pc,
1131                         "interrupt: reset\n");
1132       break;
1133     default:
1134       sim_engine_abort (sd, current_cpu, pc,
1135                         "unhandled interrupt kind: %d\n", kind);
1136       break;
1137     }
1138 }
1139
1140 /* Handle a break interrupt.  */
1141 void
1142 frv_break_interrupt (
1143   SIM_CPU *current_cpu, struct frv_interrupt *interrupt, IADDR current_pc
1144 )
1145 {
1146   IADDR new_pc;
1147
1148   /* BPCSR=PC
1149      BPSR.BS=PSR.S
1150      BPSR.BET=PSR.ET
1151      PSR.S=1
1152      PSR.ET=0
1153      TBR.TT=0xff
1154      PC=TBR
1155   */
1156   /* Must set PSR.S first to allow access to supervisor-only spr registers.  */
1157   SET_H_BPSR_BS (GET_H_PSR_S ());
1158   SET_H_BPSR_BET (GET_H_PSR_ET ());
1159   SET_H_PSR_S (1);
1160   SET_H_PSR_ET (0);
1161   /* Must set PSR.S first to allow access to supervisor-only spr registers.  */
1162   SET_H_SPR (H_SPR_BPCSR, current_pc);
1163
1164   /* Set the new PC in the TBR.  */
1165   SET_H_TBR_TT (interrupt->handler_offset);
1166   new_pc = GET_H_SPR (H_SPR_TBR);
1167   SET_H_PC (new_pc);
1168
1169   CPU_DEBUG_STATE (current_cpu) = 1;
1170 }
1171
1172 /* Handle a program interrupt or a software interrupt.  */
1173 void
1174 frv_program_or_software_interrupt (
1175   SIM_CPU *current_cpu, struct frv_interrupt *interrupt, IADDR current_pc
1176 )
1177 {
1178   USI new_pc;
1179   int original_psr_et;
1180
1181   /* PCSR=PC
1182      PSR.PS=PSR.S
1183      PSR.ET=0
1184      PSR.S=1
1185      if PSR.ESR==1
1186        SR0 through SR3=GR4 through GR7
1187        TBR.TT=interrupt handler offset
1188        PC=TBR
1189   */
1190   original_psr_et = GET_H_PSR_ET ();
1191
1192   SET_H_PSR_PS (GET_H_PSR_S ());
1193   SET_H_PSR_ET (0);
1194   SET_H_PSR_S (1);
1195
1196   /* Must set PSR.S first to allow access to supervisor-only spr registers.  */
1197   /* The PCSR depends on the precision of the interrupt.  */
1198   if (interrupt->precise)
1199     SET_H_SPR (H_SPR_PCSR, previous_vliw_pc);
1200   else
1201     SET_H_SPR (H_SPR_PCSR, current_pc);
1202
1203   /* Set the new PC in the TBR.  */
1204   SET_H_TBR_TT (interrupt->handler_offset);
1205   new_pc = GET_H_SPR (H_SPR_TBR);
1206   SET_H_PC (new_pc);
1207
1208   /* If PSR.ET was not originally set, then enter the stopped state.  */
1209   if (! original_psr_et)
1210     {
1211       SIM_DESC sd = CPU_STATE (current_cpu);
1212       frv_non_operating_interrupt (current_cpu, interrupt->kind, current_pc);
1213       sim_engine_halt (sd, current_cpu, NULL, new_pc, sim_stopped, SIM_SIGINT);
1214     }
1215 }
1216
1217 /* Handle a program interrupt or a software interrupt.  */
1218 void
1219 frv_external_interrupt (
1220   SIM_CPU *current_cpu, struct frv_interrupt_queue_element *item, IADDR pc
1221 )
1222 {
1223   USI new_pc;
1224   struct frv_interrupt *interrupt = & frv_interrupt_table[item->kind];
1225
1226   /* Don't process the interrupt if PSR.ET is not set or if it is masked.
1227      Interrupt 15 is processed even if it appears to be masked.  */
1228   if (! GET_H_PSR_ET ()
1229       || (interrupt->kind != FRV_INTERRUPT_LEVEL_15
1230           && interrupt->kind < GET_H_PSR_PIL ()))
1231     return; /* Leave it for later.  */
1232
1233   /* Remove the interrupt from the queue.  */
1234   --frv_interrupt_state.queue_index;
1235
1236   /* PCSR=PC
1237      PSR.PS=PSR.S
1238      PSR.ET=0
1239      PSR.S=1
1240      if PSR.ESR==1
1241        SR0 through SR3=GR4 through GR7
1242        TBR.TT=interrupt handler offset
1243        PC=TBR
1244   */
1245   SET_H_PSR_PS (GET_H_PSR_S ());
1246   SET_H_PSR_ET (0);
1247   SET_H_PSR_S (1);
1248   /* Must set PSR.S first to allow access to supervisor-only spr registers.  */
1249   SET_H_SPR (H_SPR_PCSR, GET_H_PC ());
1250
1251   /* Set the new PC in the TBR.  */
1252   SET_H_TBR_TT (interrupt->handler_offset);
1253   new_pc = GET_H_SPR (H_SPR_TBR);
1254   SET_H_PC (new_pc);
1255 }
1256
1257 /* Clear interrupts which fall within the range of classes given.  */
1258 void
1259 frv_clear_interrupt_classes (
1260   enum frv_interrupt_class low_class, enum frv_interrupt_class high_class
1261 )
1262 {
1263   int i;
1264   int j;
1265   int limit = frv_interrupt_state.queue_index;
1266
1267   /* Find the lowest priority interrupt to be removed.  */
1268   for (i = 0; i < limit; ++i)
1269     {
1270       enum frv_interrupt_kind kind = frv_interrupt_state.queue[i].kind;
1271       struct frv_interrupt* interrupt = & frv_interrupt_table[kind];
1272       if (interrupt->iclass >= low_class)
1273         break;
1274     }
1275
1276   /* Find the highest priority interrupt to be removed.  */
1277   for (j = limit - 1; j >= i; --j)
1278     {
1279       enum frv_interrupt_kind kind = frv_interrupt_state.queue[j].kind;
1280       struct frv_interrupt* interrupt = & frv_interrupt_table[kind];
1281       if (interrupt->iclass <= high_class)
1282         break;
1283     }
1284
1285   /* Shuffle the remaining high priority interrupts down into the empty space
1286      left by the deleted interrupts.  */
1287   if (j >= i)
1288     {
1289       for (++j; j < limit; ++j)
1290         frv_interrupt_state.queue[i++] = frv_interrupt_state.queue[j];
1291       frv_interrupt_state.queue_index -= (j - i);
1292     }
1293 }
1294
1295 /* Save data written to memory into the interrupt state so that it can be
1296    copied to the appropriate EDR register, if necessary, in the event of an
1297    interrupt.  */
1298 void
1299 frv_save_data_written_for_interrupts (
1300   SIM_CPU *current_cpu, CGEN_WRITE_QUEUE_ELEMENT *item
1301 )
1302 {
1303   /* Record the slot containing the insn doing the write in the
1304      interrupt state.  */
1305   frv_interrupt_state.slot = CGEN_WRITE_QUEUE_ELEMENT_PIPE (item);
1306
1307   /* Now record any data written to memory in the interrupt state.  */
1308   switch (CGEN_WRITE_QUEUE_ELEMENT_KIND (item))
1309     {
1310     case CGEN_BI_WRITE:
1311     case CGEN_QI_WRITE:
1312     case CGEN_SI_WRITE:
1313     case CGEN_SF_WRITE:
1314     case CGEN_PC_WRITE:
1315     case CGEN_FN_HI_WRITE:
1316     case CGEN_FN_SI_WRITE:
1317     case CGEN_FN_SF_WRITE:
1318     case CGEN_FN_DI_WRITE:
1319     case CGEN_FN_DF_WRITE:
1320     case CGEN_FN_XI_WRITE:
1321     case CGEN_FN_PC_WRITE:
1322       break; /* Ignore writes to registers.  */
1323     case CGEN_MEM_QI_WRITE:
1324       frv_interrupt_state.data_written.length = 1;
1325       frv_interrupt_state.data_written.words[0]
1326         = item->kinds.mem_qi_write.value;
1327       break;
1328     case CGEN_MEM_HI_WRITE:
1329       frv_interrupt_state.data_written.length = 1;
1330       frv_interrupt_state.data_written.words[0]
1331         = item->kinds.mem_hi_write.value;
1332       break;
1333     case CGEN_MEM_SI_WRITE:
1334       frv_interrupt_state.data_written.length = 1;
1335       frv_interrupt_state.data_written.words[0]
1336         = item->kinds.mem_si_write.value;
1337       break;
1338     case CGEN_MEM_DI_WRITE:
1339       frv_interrupt_state.data_written.length = 2;
1340       frv_interrupt_state.data_written.words[0]
1341         = item->kinds.mem_di_write.value >> 32;
1342       frv_interrupt_state.data_written.words[1]
1343         = item->kinds.mem_di_write.value;
1344       break;
1345     case CGEN_MEM_DF_WRITE:
1346       frv_interrupt_state.data_written.length = 2;
1347       frv_interrupt_state.data_written.words[0]
1348         = item->kinds.mem_df_write.value >> 32;
1349       frv_interrupt_state.data_written.words[1]
1350         = item->kinds.mem_df_write.value;
1351       break;
1352     case CGEN_MEM_XI_WRITE:
1353       frv_interrupt_state.data_written.length = 4;
1354       frv_interrupt_state.data_written.words[0]
1355         = item->kinds.mem_xi_write.value[0];
1356       frv_interrupt_state.data_written.words[1]
1357         = item->kinds.mem_xi_write.value[1];
1358       frv_interrupt_state.data_written.words[2]
1359         = item->kinds.mem_xi_write.value[2];
1360       frv_interrupt_state.data_written.words[3]
1361         = item->kinds.mem_xi_write.value[3];
1362       break;
1363     case CGEN_FN_MEM_QI_WRITE:
1364       frv_interrupt_state.data_written.length = 1;
1365       frv_interrupt_state.data_written.words[0]
1366         = item->kinds.fn_mem_qi_write.value;
1367       break;
1368     case CGEN_FN_MEM_HI_WRITE:
1369       frv_interrupt_state.data_written.length = 1;
1370       frv_interrupt_state.data_written.words[0]
1371         = item->kinds.fn_mem_hi_write.value;
1372       break;
1373     case CGEN_FN_MEM_SI_WRITE:
1374       frv_interrupt_state.data_written.length = 1;
1375       frv_interrupt_state.data_written.words[0]
1376         = item->kinds.fn_mem_si_write.value;
1377       break;
1378     case CGEN_FN_MEM_DI_WRITE:
1379       frv_interrupt_state.data_written.length = 2;
1380       frv_interrupt_state.data_written.words[0]
1381         = item->kinds.fn_mem_di_write.value >> 32;
1382       frv_interrupt_state.data_written.words[1]
1383         = item->kinds.fn_mem_di_write.value;
1384       break;
1385     case CGEN_FN_MEM_DF_WRITE:
1386       frv_interrupt_state.data_written.length = 2;
1387       frv_interrupt_state.data_written.words[0]
1388         = item->kinds.fn_mem_df_write.value >> 32;
1389       frv_interrupt_state.data_written.words[1]
1390         = item->kinds.fn_mem_df_write.value;
1391       break;
1392     case CGEN_FN_MEM_XI_WRITE:
1393       frv_interrupt_state.data_written.length = 4;
1394       frv_interrupt_state.data_written.words[0]
1395         = item->kinds.fn_mem_xi_write.value[0];
1396       frv_interrupt_state.data_written.words[1]
1397         = item->kinds.fn_mem_xi_write.value[1];
1398       frv_interrupt_state.data_written.words[2]
1399         = item->kinds.fn_mem_xi_write.value[2];
1400       frv_interrupt_state.data_written.words[3]
1401         = item->kinds.fn_mem_xi_write.value[3];
1402       break;
1403     default:
1404       {
1405         SIM_DESC sd = CPU_STATE (current_cpu);
1406         IADDR pc = CPU_PC_GET (current_cpu);
1407         sim_engine_abort (sd, current_cpu, pc,
1408                           "unknown write kind during save for interrupt\n");
1409       }
1410       break;
1411     }
1412 }