sim/frv/traps.c

   1 /* frv trap support
   2    Copyright (C) 1999, 2000, 2001, 2003 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 2, or (at your option)
  10 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 along
  18 with this program; if not, write to the Free Software Foundation, Inc.,
  19 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #define WANT_CPU frvbf
  22 #define WANT_CPU_FRVBF
  23
  24 #include "sim-main.h"
  25 #include "targ-vals.h"
  26 #include "cgen-engine.h"
  27 #include "cgen-par.h"
  28 #include "sim-fpu.h"
  29
  30 #include "bfd.h"
  31 #include "libiberty.h"
  32
  33 CGEN_ATTR_VALUE_TYPE frv_current_fm_slot;
  34
  35 /* The semantic code invokes this for invalid (unrecognized) instructions.  */
  36
  37 SEM_PC
  38 sim_engine_invalid_insn (SIM_CPU *current_cpu, IADDR cia, SEM_PC vpc)
  39 {
  40   frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
  41   return vpc;
  42 }
  43
  44 /* Process an address exception.  */
  45
  46 void
  47 frv_core_signal (SIM_DESC sd, SIM_CPU *current_cpu, sim_cia cia,
  48                   unsigned int map, int nr_bytes, address_word addr,
  49                   transfer_type transfer, sim_core_signals sig)
  50 {
  51   if (sig == sim_core_unaligned_signal)
  52     {
  53       if (STATE_ARCHITECTURE (sd)->mach == bfd_mach_fr400)
  54         frv_queue_data_access_error_interrupt (current_cpu, addr);
  55       else
  56         frv_queue_mem_address_not_aligned_interrupt (current_cpu, addr);
  57     }
  58
  59   frv_term (sd);
  60   sim_core_signal (sd, current_cpu, cia, map, nr_bytes, addr, transfer, sig);
  61 }
  62
  63 void
  64 frv_sim_engine_halt_hook (SIM_DESC sd, SIM_CPU *current_cpu, sim_cia cia)
  65 {
  66   int i;
  67   if (current_cpu != NULL)
  68     CIA_SET (current_cpu, cia);
  69
  70   /* Invalidate the insn and data caches of all cpus.  */
  71   for (i = 0; i < MAX_NR_PROCESSORS; ++i)
  72     {
  73       current_cpu = STATE_CPU (sd, i);
  74       frv_cache_invalidate_all (CPU_INSN_CACHE (current_cpu), 0);
  75       frv_cache_invalidate_all (CPU_DATA_CACHE (current_cpu), 1);
  76     }
  77   frv_term (sd);
  78 }
  79 \f
  80 /* Read/write functions for system call interface.  */
  81
  82 static int
  83 syscall_read_mem (host_callback *cb, struct cb_syscall *sc,
  84                   unsigned long taddr, char *buf, int bytes)
  85 {
  86   SIM_DESC sd = (SIM_DESC) sc->p1;
  87   SIM_CPU *cpu = (SIM_CPU *) sc->p2;
  88
  89   frv_cache_invalidate_all (CPU_DATA_CACHE (cpu), 1);
  90   return sim_core_read_buffer (sd, cpu, read_map, buf, taddr, bytes);
  91 }
  92
  93 static int
  94 syscall_write_mem (host_callback *cb, struct cb_syscall *sc,
  95                    unsigned long taddr, const char *buf, int bytes)
  96 {
  97   SIM_DESC sd = (SIM_DESC) sc->p1;
  98   SIM_CPU *cpu = (SIM_CPU *) sc->p2;
  99
 100   frv_cache_invalidate_all (CPU_INSN_CACHE (cpu), 0);
 101   frv_cache_invalidate_all (CPU_DATA_CACHE (cpu), 1);
 102   return sim_core_write_buffer (sd, cpu, write_map, buf, taddr, bytes);
 103 }
 104
 105 /* Handle TRA and TIRA insns.  */
 106 void
 107 frv_itrap (SIM_CPU *current_cpu, PCADDR pc, USI base, SI offset)
 108 {
 109   SIM_DESC sd = CPU_STATE (current_cpu);
 110   host_callback *cb = STATE_CALLBACK (sd);
 111   USI num = ((base + offset) & 0x7f) + 0x80;
 112
 113 #ifdef SIM_HAVE_BREAKPOINTS
 114   /* Check for breakpoints "owned" by the simulator first, regardless
 115      of --environment.  */
 116   if (num == TRAP_BREAKPOINT)
 117     {
 118       /* First try sim-break.c.  If it's a breakpoint the simulator "owns"
 119          it doesn't return.  Otherwise it returns and let's us try.  */
 120       sim_handle_breakpoint (sd, current_cpu, pc);
 121       /* Fall through.  */
 122     }
 123 #endif
 124
 125   if (STATE_ENVIRONMENT (sd) == OPERATING_ENVIRONMENT)
 126     {
 127       frv_queue_software_interrupt (current_cpu, num);
 128       return;
 129     }
 130
 131   switch (num)
 132     {
 133     case TRAP_SYSCALL :
 134       {
 135         CB_SYSCALL s;
 136         CB_SYSCALL_INIT (&s);
 137         s.func = GET_H_GR (7);
 138         s.arg1 = GET_H_GR (8);
 139         s.arg2 = GET_H_GR (9);
 140         s.arg3 = GET_H_GR (10);
 141
 142         if (s.func == TARGET_SYS_exit)
 143           {
 144             sim_engine_halt (sd, current_cpu, NULL, pc, sim_exited, s.arg1);
 145           }
 146
 147         s.p1 = (PTR) sd;
 148         s.p2 = (PTR) current_cpu;
 149         s.read_mem = syscall_read_mem;
 150         s.write_mem = syscall_write_mem;
 151         cb_syscall (cb, &s);
 152         SET_H_GR (8, s.result);
 153         SET_H_GR (9, s.result2);
 154         SET_H_GR (10, s.errcode);
 155         break;
 156       }
 157
 158     case TRAP_BREAKPOINT:
 159       sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGTRAP);
 160       break;
 161
 162       /* Add support for dumping registers, either at fixed traps, or all
 163          unknown traps if configured with --enable-sim-trapdump.  */
 164     default:
 165 #if !TRAPDUMP
 166       frv_queue_software_interrupt (current_cpu, num);
 167       return;
 168 #endif
 169
 170 #ifdef TRAP_REGDUMP1
 171     case TRAP_REGDUMP1:
 172 #endif
 173
 174 #ifdef TRAP_REGDUMP2
 175     case TRAP_REGDUMP2:
 176 #endif
 177
 178 #if TRAPDUMP || (defined (TRAP_REGDUMP1)) || (defined (TRAP_REGDUMP2))
 179       {
 180         char buf[256];
 181         int i, j;
 182
 183         buf[0] = 0;
 184         if (STATE_TEXT_SECTION (sd)
 185             && pc >= STATE_TEXT_START (sd)
 186             && pc < STATE_TEXT_END (sd))
 187           {
 188             const char *pc_filename = (const char *)0;
 189             const char *pc_function = (const char *)0;
 190             unsigned int pc_linenum = 0;
 191
 192             if (bfd_find_nearest_line (STATE_PROG_BFD (sd),
 193                                        STATE_TEXT_SECTION (sd),
 194                                        (struct bfd_symbol **) 0,
 195                                        pc - STATE_TEXT_START (sd),
 196                                        &pc_filename, &pc_function, &pc_linenum)
 197                 && (pc_function || pc_filename))
 198               {
 199                 char *p = buf+2;
 200                 buf[0] = ' ';
 201                 buf[1] = '(';
 202                 if (pc_function)
 203                   {
 204                     strcpy (p, pc_function);
 205                     p += strlen (p);
 206                   }
 207                 else
 208                   {
 209                     char *q = (char *) strrchr (pc_filename, '/');
 210                     strcpy (p, (q) ? q+1 : pc_filename);
 211                     p += strlen (p);
 212                   }
 213
 214                 if (pc_linenum)
 215                   {
 216                     sprintf (p, " line %d", pc_linenum);
 217                     p += strlen (p);
 218                   }
 219
 220                 p[0] = ')';
 221                 p[1] = '\0';
 222                 if ((p+1) - buf > sizeof (buf))
 223                   abort ();
 224               }
 225           }
 226
 227         sim_io_printf (sd,
 228                        "\nRegister dump,    pc = 0x%.8x%s, base = %u, offset = %d\n",
 229                        (unsigned)pc, buf, (unsigned)base, (int)offset);
 230
 231         for (i = 0; i < 64; i += 8)
 232           {
 233             long g0 = (long)GET_H_GR (i);
 234             long g1 = (long)GET_H_GR (i+1);
 235             long g2 = (long)GET_H_GR (i+2);
 236             long g3 = (long)GET_H_GR (i+3);
 237             long g4 = (long)GET_H_GR (i+4);
 238             long g5 = (long)GET_H_GR (i+5);
 239             long g6 = (long)GET_H_GR (i+6);
 240             long g7 = (long)GET_H_GR (i+7);
 241
 242             if ((g0 | g1 | g2 | g3 | g4 | g5 | g6 | g7) != 0)
 243               sim_io_printf (sd,
 244                              "\tgr%02d - gr%02d:   0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx\n",
 245                              i, i+7, g0, g1, g2, g3, g4, g5, g6, g7);
 246           }
 247
 248         for (i = 0; i < 64; i += 8)
 249           {
 250             long f0 = (long)GET_H_FR (i);
 251             long f1 = (long)GET_H_FR (i+1);
 252             long f2 = (long)GET_H_FR (i+2);
 253             long f3 = (long)GET_H_FR (i+3);
 254             long f4 = (long)GET_H_FR (i+4);
 255             long f5 = (long)GET_H_FR (i+5);
 256             long f6 = (long)GET_H_FR (i+6);
 257             long f7 = (long)GET_H_FR (i+7);
 258
 259             if ((f0 | f1 | f2 | f3 | f4 | f5 | f6 | f7) != 0)
 260               sim_io_printf (sd,
 261                              "\tfr%02d - fr%02d:   0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx\n",
 262                              i, i+7, f0, f1, f2, f3, f4, f5, f6, f7);
 263           }
 264
 265         sim_io_printf (sd,
 266                        "\tlr/lcr/cc/ccc: 0x%.8lx 0x%.8lx 0x%.8lx 0x%.8lx\n",
 267                        (long)GET_H_SPR (272),
 268                        (long)GET_H_SPR (273),
 269                        (long)GET_H_SPR (256),
 270                        (long)GET_H_SPR (263));
 271       }
 272       break;
 273 #endif
 274     }
 275 }
 276
 277 /* Handle the MTRAP insn.  */
 278 void
 279 frv_mtrap (SIM_CPU *current_cpu)
 280 {
 281   SIM_DESC sd = CPU_STATE (current_cpu);
 282
 283   /* Check the status of media exceptions in MSR0.  */
 284   SI msr = GET_MSR (0);
 285   if (GET_MSR_AOVF (msr) || GET_MSR_MTT (msr) && STATE_ARCHITECTURE (sd)->mach != bfd_mach_fr550)
 286     frv_queue_program_interrupt (current_cpu, FRV_MP_EXCEPTION);
 287 }
 288
 289 /* Handle the BREAK insn.  */
 290 void
 291 frv_break (SIM_CPU *current_cpu)
 292 {
 293   IADDR pc;
 294   SIM_DESC sd = CPU_STATE (current_cpu);
 295
 296 #ifdef SIM_HAVE_BREAKPOINTS
 297   /* First try sim-break.c.  If it's a breakpoint the simulator "owns"
 298      it doesn't return.  Otherwise it returns and let's us try.  */
 299   pc = GET_H_PC ();
 300   sim_handle_breakpoint (sd, current_cpu, pc);
 301   /* Fall through.  */
 302 #endif
 303
 304   if (STATE_ENVIRONMENT (sd) != OPERATING_ENVIRONMENT)
 305     {
 306       /* Invalidate the insn cache because the debugger will presumably
 307          replace the breakpoint insn with the real one.  */
 308 #ifndef SIM_HAVE_BREAKPOINTS
 309       pc = GET_H_PC ();
 310 #endif
 311       sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGTRAP);
 312     }
 313
 314   frv_queue_break_interrupt (current_cpu);
 315 }
 316
 317 /* Return from trap.  */
 318 USI
 319 frv_rett (SIM_CPU *current_cpu, PCADDR pc, BI debug_field)
 320 {
 321   USI new_pc;
 322   /* if (normal running mode and debug_field==0
 323        PC=PCSR
 324        PSR.ET=1
 325        PSR.S=PSR.PS
 326      else if (debug running mode and debug_field==1)
 327        PC=(BPCSR)
 328        PSR.ET=BPSR.BET
 329        PSR.S=BPSR.BS
 330        change to normal running mode
 331   */
 332   int psr_s = GET_H_PSR_S ();
 333   int psr_et = GET_H_PSR_ET ();
 334
 335   /* Check for exceptions in the priority order listed in the FRV Architecture
 336      Volume 2.  */
 337   if (! psr_s)
 338     {
 339       /* Halt if PSR.ET is not set.  See chapter 6 of the LSI.  */
 340       if (! psr_et)
 341         {
 342           SIM_DESC sd = CPU_STATE (current_cpu);
 343           sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGTRAP);
 344         }
 345
 346       /* privileged_instruction interrupt will have already been queued by
 347          frv_detect_insn_access_interrupts.  */
 348       new_pc = pc + 4;
 349     }
 350   else if (psr_et)
 351     {
 352       /* Halt if PSR.S is set.  See chapter 6 of the LSI.  */
 353       if (psr_s)
 354         {
 355           SIM_DESC sd = CPU_STATE (current_cpu);
 356           sim_engine_halt (sd, current_cpu, NULL, pc, sim_stopped, SIM_SIGTRAP);
 357         }
 358
 359       frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 360       new_pc = pc + 4;
 361     }
 362   else if (! CPU_DEBUG_STATE (current_cpu) && debug_field == 0)
 363     {
 364       USI psr = GET_PSR ();
 365       /* Return from normal running state.  */
 366       new_pc = GET_H_SPR (H_SPR_PCSR);
 367       SET_PSR_ET (psr, 1);
 368       SET_PSR_S (psr, GET_PSR_PS (psr));
 369       sim_queue_fn_si_write (current_cpu, frvbf_h_spr_set, H_SPR_PSR, psr);
 370     }
 371   else if (CPU_DEBUG_STATE (current_cpu) && debug_field == 1)
 372     {
 373       USI psr = GET_PSR ();
 374       /* Return from debug state.  */
 375       new_pc = GET_H_SPR (H_SPR_BPCSR);
 376       SET_PSR_ET (psr, GET_H_BPSR_BET ());
 377       SET_PSR_S (psr, GET_H_BPSR_BS ());
 378       sim_queue_fn_si_write (current_cpu, frvbf_h_spr_set, H_SPR_PSR, psr);
 379       CPU_DEBUG_STATE (current_cpu) = 0;
 380     }
 381   else
 382     new_pc = pc + 4;
 383
 384   return new_pc;
 385 }
 386 \f
 387 /* Functions for handling non-excepting instruction side effects.  */
 388 static SI next_available_nesr (SIM_CPU *current_cpu, SI current_index)
 389 {
 390   FRV_REGISTER_CONTROL *control = CPU_REGISTER_CONTROL (current_cpu);
 391   if (control->spr[H_SPR_NECR].implemented)
 392     {
 393       int limit;
 394       USI necr = GET_NECR ();
 395
 396       /* See if any NESRs are implemented. First need to check the validity of
 397          the NECR.  */
 398       if (! GET_NECR_VALID (necr))
 399         return NO_NESR;
 400
 401       limit = GET_NECR_NEN (necr);
 402       for (++current_index; current_index < limit; ++current_index)
 403         {
 404           SI nesr = GET_NESR (current_index);
 405           if (! GET_NESR_VALID (nesr))
 406             return current_index;
 407         }
 408     }
 409   return NO_NESR;
 410 }
 411
 412 static SI next_valid_nesr (SIM_CPU *current_cpu, SI current_index)
 413 {
 414   FRV_REGISTER_CONTROL *control = CPU_REGISTER_CONTROL (current_cpu);
 415   if (control->spr[H_SPR_NECR].implemented)
 416     {
 417       int limit;
 418       USI necr = GET_NECR ();
 419
 420       /* See if any NESRs are implemented. First need to check the validity of
 421          the NECR.  */
 422       if (! GET_NECR_VALID (necr))
 423         return NO_NESR;
 424
 425       limit = GET_NECR_NEN (necr);
 426       for (++current_index; current_index < limit; ++current_index)
 427         {
 428           SI nesr = GET_NESR (current_index);
 429           if (GET_NESR_VALID (nesr))
 430             return current_index;
 431         }
 432     }
 433   return NO_NESR;
 434 }
 435
 436 BI
 437 frvbf_check_non_excepting_load (
 438   SIM_CPU *current_cpu, SI base_index, SI disp_index, SI target_index,
 439   SI immediate_disp, QI data_size, BI is_float
 440 )
 441 {
 442   BI rc = 1; /* perform the load.  */
 443   SIM_DESC sd = CPU_STATE (current_cpu);
 444   int daec = 0;
 445   int rec  = 0;
 446   int ec   = 0;
 447   USI necr;
 448   int do_elos;
 449   SI NE_flags[2];
 450   SI NE_base;
 451   SI nesr;
 452   SI ne_index;
 453   FRV_REGISTER_CONTROL *control;
 454
 455   SI address = GET_H_GR (base_index);
 456   if (disp_index >= 0)
 457     address += GET_H_GR (disp_index);
 458   else
 459     address += immediate_disp;
 460
 461   /* Check for interrupt factors.  */
 462   switch (data_size)
 463     {
 464     case NESR_UQI_SIZE:
 465     case NESR_QI_SIZE:
 466       break;
 467     case NESR_UHI_SIZE:
 468     case NESR_HI_SIZE:
 469       if (address & 1)
 470         ec = 1;
 471       break;
 472     case NESR_SI_SIZE:
 473       if (address & 3)
 474         ec = 1;
 475       break;
 476     case NESR_DI_SIZE:
 477       if (address & 7)
 478         ec = 1;
 479       if (target_index & 1)
 480         rec = 1;
 481       break;
 482     case NESR_XI_SIZE:
 483       if (address & 0xf)
 484         ec = 1;
 485       if (target_index & 3)
 486         rec = 1;
 487       break;
 488     default:
 489       {
 490         IADDR pc = GET_H_PC ();
 491         sim_engine_abort (sd, current_cpu, pc,
 492                           "check_non_excepting_load: Incorrect data_size\n");
 493         break;
 494       }
 495     }
 496
 497   control = CPU_REGISTER_CONTROL (current_cpu);
 498   if (control->spr[H_SPR_NECR].implemented)
 499     {
 500       necr = GET_NECR ();
 501       do_elos = GET_NECR_VALID (necr) && GET_NECR_ELOS (necr);
 502     }
 503   else
 504     do_elos = 0;
 505
 506   /* NECR, NESR, NEEAR are only implemented for the full frv machine.  */
 507   if (do_elos)
 508     {
 509       ne_index = next_available_nesr (current_cpu, NO_NESR);
 510       if (ne_index == NO_NESR)
 511         {
 512           IADDR pc = GET_H_PC ();
 513           sim_engine_abort (sd, current_cpu, pc,
 514                             "No available NESR register\n");
 515         }
 516
 517       /* Fill in the basic fields of the NESR.  */
 518       nesr = GET_NESR (ne_index);
 519       SET_NESR_VALID (nesr);
 520       SET_NESR_EAV (nesr);
 521       SET_NESR_DRN (nesr, target_index);
 522       SET_NESR_SIZE (nesr, data_size);
 523       SET_NESR_NEAN (nesr, ne_index);
 524       if (is_float)
 525         SET_NESR_FR (nesr);
 526       else
 527         CLEAR_NESR_FR (nesr);
 528
 529       /* Set the corresponding NEEAR.  */
 530       SET_NEEAR (ne_index, address);
 531
 532       SET_NESR_DAEC (nesr, 0);
 533       SET_NESR_REC (nesr, 0);
 534       SET_NESR_EC (nesr, 0);
 535     }
 536
 537   /* Set the NE flag corresponding to the target register if an interrupt
 538      factor was detected.
 539      daec is not checked here yet, but is declared for future reference.  */
 540   if (is_float)
 541     NE_base = H_SPR_FNER0;
 542   else
 543     NE_base = H_SPR_GNER0;
 544
 545   GET_NE_FLAGS (NE_flags, NE_base);
 546   if (rec)
 547     {
 548       SET_NE_FLAG (NE_flags, target_index);
 549       if (do_elos)
 550         SET_NESR_REC (nesr, NESR_REGISTER_NOT_ALIGNED);
 551     }
 552
 553   if (ec)
 554     {
 555       SET_NE_FLAG (NE_flags, target_index);
 556       if (do_elos)
 557         SET_NESR_EC (nesr, NESR_MEM_ADDRESS_NOT_ALIGNED);
 558     }
 559
 560   if (do_elos)
 561     SET_NESR (ne_index, nesr);
 562
 563   /* If no interrupt factor was detected then set the NE flag on the
 564      target register if the NE flag on one of the input registers
 565      is already set.  */
 566   if (! rec && ! ec && ! daec)
 567     {
 568       BI ne_flag = GET_NE_FLAG (NE_flags, base_index);
 569       if (disp_index >= 0)
 570         ne_flag |= GET_NE_FLAG (NE_flags, disp_index);
 571       if (ne_flag)
 572         {
 573           SET_NE_FLAG (NE_flags, target_index);
 574           rc = 0; /* Do not perform the load.  */
 575         }
 576       else
 577         CLEAR_NE_FLAG (NE_flags, target_index);
 578     }
 579
 580   SET_NE_FLAGS (NE_base, NE_flags);
 581
 582   return rc; /* perform the load?  */
 583 }
 584
 585 /* Record state for media exception: media_cr_not_aligned.  */
 586 void
 587 frvbf_media_cr_not_aligned (SIM_CPU *current_cpu)
 588 {
 589   SIM_DESC sd = CPU_STATE (current_cpu);
 590
 591   /* On some machines this generates an illegal_instruction interrupt.  */
 592   switch (STATE_ARCHITECTURE (sd)->mach)
 593     {
 594     case bfd_mach_fr400:
 595     case bfd_mach_fr550:
 596       frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 597       break;
 598     default:
 599       frv_set_mp_exception_registers (current_cpu, MTT_CR_NOT_ALIGNED, 0);
 600       break;
 601     }
 602 }
 603
 604 /* Record state for media exception: media_acc_not_aligned.  */
 605 void
 606 frvbf_media_acc_not_aligned (SIM_CPU *current_cpu)
 607 {
 608   SIM_DESC sd = CPU_STATE (current_cpu);
 609
 610   /* On some machines this generates an illegal_instruction interrupt.  */
 611   switch (STATE_ARCHITECTURE (sd)->mach)
 612     {
 613     case bfd_mach_fr400:
 614     case bfd_mach_fr550:
 615       frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 616       break;
 617     default:
 618       frv_set_mp_exception_registers (current_cpu, MTT_ACC_NOT_ALIGNED, 0);
 619       break;
 620     }
 621 }
 622
 623 /* Record state for media exception: media_register_not_aligned.  */
 624 void
 625 frvbf_media_register_not_aligned (SIM_CPU *current_cpu)
 626 {
 627   SIM_DESC sd = CPU_STATE (current_cpu);
 628
 629   /* On some machines this generates an illegal_instruction interrupt.  */
 630   switch (STATE_ARCHITECTURE (sd)->mach)
 631     {
 632     case bfd_mach_fr400:
 633     case bfd_mach_fr550:
 634       frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 635       break;
 636     default:
 637       frv_set_mp_exception_registers (current_cpu, MTT_INVALID_FR, 0);
 638       break;
 639     }
 640 }
 641
 642 /* Record state for media exception: media_overflow.  */
 643 void
 644 frvbf_media_overflow (SIM_CPU *current_cpu, int sie)
 645 {
 646   frv_set_mp_exception_registers (current_cpu, MTT_OVERFLOW, sie);
 647 }
 648
 649 /* Queue a division exception.  */
 650 enum frv_dtt
 651 frvbf_division_exception (SIM_CPU *current_cpu, enum frv_dtt dtt,
 652                           int target_index, int non_excepting)
 653 {
 654   /* If there was an overflow and it is masked, then record it in
 655      ISR.AEXC.  */
 656   USI isr = GET_ISR ();
 657   if ((dtt & FRV_DTT_OVERFLOW) && GET_ISR_EDE (isr))
 658     {
 659       dtt &= ~FRV_DTT_OVERFLOW;
 660       SET_ISR_AEXC (isr);
 661       SET_ISR (isr);
 662     }
 663   if (dtt != FRV_DTT_NO_EXCEPTION)
 664     {
 665       if (non_excepting)
 666         {
 667           /* Non excepting instruction, simply set the NE flag for the target
 668              register.  */
 669           SI NE_flags[2];
 670           GET_NE_FLAGS (NE_flags, H_SPR_GNER0);
 671           SET_NE_FLAG (NE_flags, target_index);
 672           SET_NE_FLAGS (H_SPR_GNER0, NE_flags);
 673         }
 674       else
 675         frv_queue_division_exception_interrupt (current_cpu, dtt);
 676     }
 677   return dtt;
 678 }
 679
 680 void
 681 frvbf_check_recovering_store (
 682   SIM_CPU *current_cpu, PCADDR address, SI regno, int size, int is_float
 683 )
 684 {
 685   FRV_CACHE *cache = CPU_DATA_CACHE (current_cpu);
 686   int reg_ix;
 687
 688   CPU_RSTR_INVALIDATE(current_cpu) = 0;
 689
 690   for (reg_ix = next_valid_nesr (current_cpu, NO_NESR);
 691        reg_ix != NO_NESR;
 692        reg_ix = next_valid_nesr (current_cpu, reg_ix))
 693     {
 694       if (address == GET_H_SPR (H_SPR_NEEAR0 + reg_ix))
 695         {
 696           SI nesr = GET_NESR (reg_ix);
 697           int nesr_drn = GET_NESR_DRN (nesr);
 698           BI nesr_fr = GET_NESR_FR (nesr);
 699           SI remain;
 700
 701           /* Invalidate cache block containing this address.
 702              If we need to count cycles, then the cache operation will be
 703              initiated from the model profiling functions.
 704              See frvbf_model_....  */
 705           if (model_insn)
 706             {
 707               CPU_RSTR_INVALIDATE(current_cpu) = 1;
 708               CPU_LOAD_ADDRESS (current_cpu) = address;
 709             }
 710           else
 711             frv_cache_invalidate (cache, address, 1/* flush */);
 712
 713           /* Copy the stored value to the register indicated by NESR.DRN.  */
 714           for (remain = size; remain > 0; remain -= 4)
 715             {
 716               SI value;
 717
 718               if (is_float)
 719                 value = GET_H_FR (regno);
 720               else
 721                 value = GET_H_GR (regno);
 722
 723               switch (size)
 724                 {
 725                 case 1:
 726                   value &= 0xff;
 727                   break;
 728                 case 2:
 729                   value &= 0xffff;
 730                   break;
 731                 default:
 732                   break;
 733                 }
 734
 735               if (nesr_fr)
 736                 sim_queue_fn_sf_write (current_cpu, frvbf_h_fr_set, nesr_drn,
 737                                        value);
 738               else
 739                 sim_queue_fn_si_write (current_cpu, frvbf_h_gr_set, nesr_drn,
 740                                        value);
 741
 742               nesr_drn++;
 743               regno++;
 744             }
 745           break; /* Only consider the first matching register.  */
 746         }
 747     } /* loop over active neear registers.  */
 748 }
 749
 750 SI
 751 frvbf_check_acc_range (SIM_CPU *current_cpu, SI regno)
 752 {
 753   /* Only applicable to fr550 */
 754   SIM_DESC sd = CPU_STATE (current_cpu);
 755   if (STATE_ARCHITECTURE (sd)->mach != bfd_mach_fr550)
 756     return;
 757
 758   /* On the fr550, media insns in slots 0 and 2 can only access
 759      accumulators acc0-acc3. Insns in slots 1 and 3 can only access
 760      accumulators acc4-acc7 */
 761   switch (frv_current_fm_slot)
 762     {
 763     case UNIT_FM0:
 764     case UNIT_FM2:
 765       if (regno <= 3)
 766         return 1; /* all is ok */
 767       break;
 768     case UNIT_FM1:
 769     case UNIT_FM3:
 770       if (regno >= 4)
 771         return 1; /* all is ok */
 772       break;
 773     }
 774
 775   /* The specified accumulator is out of range. Queue an illegal_instruction
 776      interrupt.  */
 777   frv_queue_program_interrupt (current_cpu, FRV_ILLEGAL_INSTRUCTION);
 778   return 0;
 779 }
 780
 781 void
 782 frvbf_check_swap_address (SIM_CPU *current_cpu, SI address)
 783 {
 784   /* Only applicable to fr550 */
 785   SIM_DESC sd = CPU_STATE (current_cpu);
 786   if (STATE_ARCHITECTURE (sd)->mach != bfd_mach_fr550)
 787     return;
 788
 789   /* Adress must be aligned on a word boundary.  */
 790   if (address & 0x3)
 791     frv_queue_data_access_exception_interrupt (current_cpu);
 792 }
 793
 794 static void
 795 clear_nesr_neear (SIM_CPU *current_cpu, SI target_index, BI is_float)
 796 {
 797   int reg_ix;
 798
 799   /* Only implemented for full frv.  */
 800   SIM_DESC sd = CPU_STATE (current_cpu);
 801   if (STATE_ARCHITECTURE (sd)->mach != bfd_mach_frv)
 802     return;
 803
 804   /* Clear the appropriate NESR and NEEAR registers.  */
 805   for (reg_ix = next_valid_nesr (current_cpu, NO_NESR);
 806        reg_ix != NO_NESR;
 807        reg_ix = next_valid_nesr (current_cpu, reg_ix))
 808     {
 809       SI nesr;
 810       /* The register is available, now check if it is active.  */
 811       nesr = GET_NESR (reg_ix);
 812       if (GET_NESR_FR (nesr) == is_float)
 813         {
 814           if (target_index < 0 || GET_NESR_DRN (nesr) == target_index)
 815             {
 816               SET_NESR (reg_ix, 0);
 817               SET_NEEAR (reg_ix, 0);
 818             }
 819         }
 820     }
 821 }
 822
 823 static void
 824 clear_ne_flags (
 825   SIM_CPU *current_cpu,
 826   SI target_index,
 827   int hi_available,
 828   int lo_available,
 829   SI NE_base
 830 )
 831 {
 832   SI NE_flags[2];
 833   int exception;
 834
 835   GET_NE_FLAGS (NE_flags, NE_base);
 836   if (target_index >= 0)
 837     CLEAR_NE_FLAG (NE_flags, target_index);
 838   else
 839     {
 840       if (lo_available)
 841         NE_flags[1] = 0;
 842       if (hi_available)
 843         NE_flags[0] = 0;
 844     }
 845   SET_NE_FLAGS (NE_base, NE_flags);
 846 }
 847
 848 /* Return 1 if the given register is available, 0 otherwise.  TARGET_INDEX==-1
 849    means to check for any register available.  */
 850 static void
 851 which_registers_available (
 852   SIM_CPU *current_cpu, int *hi_available, int *lo_available, int is_float
 853 )
 854 {
 855   if (is_float)
 856     frv_fr_registers_available (current_cpu, hi_available, lo_available);
 857   else
 858     frv_gr_registers_available (current_cpu, hi_available, lo_available);
 859 }
 860
 861 void
 862 frvbf_clear_ne_flags (SIM_CPU *current_cpu, SI target_index, BI is_float)
 863 {
 864   int hi_available;
 865   int lo_available;
 866   int exception;
 867   SI NE_base;
 868   USI necr;
 869   FRV_REGISTER_CONTROL *control;
 870
 871   /* Check for availability of the target register(s).  */
 872   which_registers_available (current_cpu, & hi_available, & lo_available,
 873                              is_float);
 874
 875   /* Check to make sure that the target register is available.  */
 876   if (! frv_check_register_access (current_cpu, target_index,
 877                                    hi_available, lo_available))
 878     return;
 879
 880   /* Determine whether we're working with GR or FR registers.  */
 881   if (is_float)
 882     NE_base = H_SPR_FNER0;
 883   else
 884     NE_base = H_SPR_GNER0;
 885
 886   /* Always clear the appropriate NE flags.  */
 887   clear_ne_flags (current_cpu, target_index, hi_available, lo_available,
 888                   NE_base);
 889
 890   /* Clear the appropriate NESR and NEEAR registers.  */
 891   control = CPU_REGISTER_CONTROL (current_cpu);
 892   if (control->spr[H_SPR_NECR].implemented)
 893     {
 894       necr = GET_NECR ();
 895       if (GET_NECR_VALID (necr) && GET_NECR_ELOS (necr))
 896         clear_nesr_neear (current_cpu, target_index, is_float);
 897     }
 898 }
 899
 900 void
 901 frvbf_commit (SIM_CPU *current_cpu, SI target_index, BI is_float)
 902 {
 903   SI NE_base;
 904   SI NE_flags[2];
 905   BI NE_flag;
 906   int exception;
 907   int hi_available;
 908   int lo_available;
 909   USI necr;
 910   FRV_REGISTER_CONTROL *control;
 911
 912   /* Check for availability of the target register(s).  */
 913   which_registers_available (current_cpu, & hi_available, & lo_available,
 914                              is_float);
 915
 916   /* Check to make sure that the target register is available.  */
 917   if (! frv_check_register_access (current_cpu, target_index,
 918                                    hi_available, lo_available))
 919     return;
 920
 921   /* Determine whether we're working with GR or FR registers.  */
 922   if (is_float)
 923     NE_base = H_SPR_FNER0;
 924   else
 925     NE_base = H_SPR_GNER0;
 926
 927   /* Determine whether a ne exception is pending.  */
 928   GET_NE_FLAGS (NE_flags, NE_base);
 929   if (target_index >= 0)
 930     NE_flag = GET_NE_FLAG (NE_flags, target_index);
 931   else
 932     {
 933       NE_flag =
 934         hi_available && NE_flags[0] != 0 || lo_available && NE_flags[1] != 0;
 935     }
 936
 937   /* Always clear the appropriate NE flags.  */
 938   clear_ne_flags (current_cpu, target_index, hi_available, lo_available,
 939                   NE_base);
 940
 941   control = CPU_REGISTER_CONTROL (current_cpu);
 942   if (control->spr[H_SPR_NECR].implemented)
 943     {
 944       necr = GET_NECR ();
 945       if (GET_NECR_VALID (necr) && GET_NECR_ELOS (necr) && NE_flag)
 946         {
 947           /* Clear the appropriate NESR and NEEAR registers.  */
 948           clear_nesr_neear (current_cpu, target_index, is_float);
 949           frv_queue_program_interrupt (current_cpu, FRV_COMMIT_EXCEPTION);
 950         }
 951     }
 952 }
 953
 954 /* Generate the appropriate fp_exception(s) based on the given status code.  */
 955 void
 956 frvbf_fpu_error (CGEN_FPU* fpu, int status)
 957 {
 958   struct frv_fp_exception_info fp_info = {
 959     FSR_NO_EXCEPTION, FTT_IEEE_754_EXCEPTION
 960   };
 961
 962   if (status &
 963       (sim_fpu_status_invalid_snan |
 964        sim_fpu_status_invalid_qnan |
 965        sim_fpu_status_invalid_isi |
 966        sim_fpu_status_invalid_idi |
 967        sim_fpu_status_invalid_zdz |
 968        sim_fpu_status_invalid_imz |
 969        sim_fpu_status_invalid_cvi |
 970        sim_fpu_status_invalid_cmp |
 971        sim_fpu_status_invalid_sqrt))
 972     fp_info.fsr_mask |= FSR_INVALID_OPERATION;
 973
 974   if (status & sim_fpu_status_invalid_div0)
 975     fp_info.fsr_mask |= FSR_DIVISION_BY_ZERO;
 976
 977   if (status & sim_fpu_status_inexact)
 978     fp_info.fsr_mask |= FSR_INEXACT;
 979
 980   if (status & sim_fpu_status_overflow)
 981     fp_info.fsr_mask |= FSR_OVERFLOW;
 982
 983   if (status & sim_fpu_status_underflow)
 984     fp_info.fsr_mask |= FSR_UNDERFLOW;
 985
 986   if (status & sim_fpu_status_denorm)
 987     {
 988       fp_info.fsr_mask |= FSR_DENORMAL_INPUT;
 989       fp_info.ftt = FTT_DENORMAL_INPUT;
 990     }
 991
 992   if (fp_info.fsr_mask != FSR_NO_EXCEPTION)
 993     {
 994       SIM_CPU *current_cpu = (SIM_CPU *)fpu->owner;
 995       frv_queue_fp_exception_interrupt (current_cpu, & fp_info);
 996     }
 997 }