sim/frv/profile-fr500.c

   1 /* frv simulator fr500 dependent profiling code.
   2
   3    Copyright (C) 1998-2014 Free Software Foundation, Inc.
   4    Contributed by Red Hat
   5
   6 This file is part of the GNU simulators.
   7
   8 This program is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 This program is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 */
  22 #define WANT_CPU
  23 #define WANT_CPU_FRVBF
  24
  25 #include "sim-main.h"
  26 #include "bfd.h"
  27
  28 #if WITH_PROFILE_MODEL_P
  29
  30 #include "profile.h"
  31 #include "profile-fr500.h"
  32
  33 /* Initialize cycle counting for an insn.
  34    FIRST_P is non-zero if this is the first insn in a set of parallel
  35    insns.  */
  36 void
  37 fr500_model_insn_before (SIM_CPU *cpu, int first_p)
  38 {
  39   if (first_p)
  40     {
  41       MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
  42       FRV_PROFILE_STATE *ps = CPU_PROFILE_STATE (cpu);
  43       ps->cur_gr_complex = ps->prev_gr_complex;
  44       d->cur_fpop     = d->prev_fpop;
  45       d->cur_media    = d->prev_media;
  46       d->cur_cc_complex = d->prev_cc_complex;
  47     }
  48 }
  49
  50 /* Record the cycles computed for an insn.
  51    LAST_P is non-zero if this is the last insn in a set of parallel insns,
  52    and we update the total cycle count.
  53    CYCLES is the cycle count of the insn.  */
  54 void
  55 fr500_model_insn_after (SIM_CPU *cpu, int last_p, int cycles)
  56 {
  57   if (last_p)
  58     {
  59       MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
  60       FRV_PROFILE_STATE *ps = CPU_PROFILE_STATE (cpu);
  61       ps->prev_gr_complex = ps->cur_gr_complex;
  62       d->prev_fpop     = d->cur_fpop;
  63       d->prev_media    = d->cur_media;
  64       d->prev_cc_complex = d->cur_cc_complex;
  65     }
  66 }
  67
  68 static void
  69 set_use_is_fpop (SIM_CPU *cpu, INT fr)
  70 {
  71   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
  72   fr500_reset_fr_flags (cpu, (fr));
  73   d->cur_fpop |=  (((DI)1) << (fr));
  74 }
  75
  76 static void
  77 set_use_not_fpop (SIM_CPU *cpu, INT fr)
  78 {
  79   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
  80   d->cur_fpop &= ~(((DI)1) << (fr));
  81 }
  82
  83 static int
  84 use_is_fpop (SIM_CPU *cpu, INT fr)
  85 {
  86   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
  87   return d->prev_fpop & (((DI)1) << (fr));
  88 }
  89
  90 static void
  91 set_use_is_media ( SIM_CPU *cpu, INT fr)
  92 {
  93   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
  94   fr500_reset_fr_flags (cpu, (fr));
  95   d->cur_media |=  (((DI)1) << (fr));
  96 }
  97
  98 static void
  99 set_use_not_media (SIM_CPU *cpu, INT fr)
 100 {
 101   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
 102   d->cur_media &= ~(((DI)1) << (fr));
 103 }
 104
 105 static int
 106 use_is_media (SIM_CPU *cpu, INT fr)
 107 {
 108   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
 109   return d->prev_media & (((DI)1) << (fr));
 110 }
 111
 112 static void
 113 set_use_is_cc_complex (SIM_CPU *cpu, INT cc)
 114 {
 115   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
 116   fr500_reset_cc_flags (cpu, cc);
 117   d->cur_cc_complex |= (((DI)1) << (cc));
 118 }
 119
 120 static void
 121 set_use_not_cc_complex (SIM_CPU *cpu, INT cc)
 122 {
 123   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
 124   d->cur_cc_complex &= ~(((DI)1) << (cc));
 125 }
 126
 127 static int
 128 use_is_cc_complex (SIM_CPU *cpu, INT cc)
 129 {
 130   MODEL_FR500_DATA *d = CPU_MODEL_DATA (cpu);
 131   return d->prev_cc_complex &   (((DI)1) << (cc));
 132 }
 133
 134 void
 135 fr500_reset_fr_flags (SIM_CPU *cpu, INT fr)
 136 {
 137   set_use_not_fpop (cpu, fr);
 138   set_use_not_media (cpu, fr);
 139 }
 140
 141 void
 142 fr500_reset_cc_flags (SIM_CPU *cpu, INT cc)
 143 {
 144   set_use_not_cc_complex (cpu, cc);
 145 }
 146
 147 /* Latency of floating point registers may be less than recorded when followed
 148    by another floating point insn.  */
 149 static void
 150 adjust_float_register_busy (SIM_CPU *cpu, INT in_FRi, INT in_FRj, INT out_FRk,
 151                             int cycles)
 152 {
 153   /* If the registers were previously used in a floating point op,
 154      then their latency will be less than previously recorded.
 155      See Table 13-13 in the LSI.  */
 156   if (in_FRi >= 0)
 157     if (use_is_fpop (cpu, in_FRi))
 158       decrease_FR_busy (cpu, in_FRi, cycles);
 159     else
 160       enforce_full_fr_latency (cpu, in_FRi);
 161
 162   if (in_FRj >= 0 && in_FRj != in_FRi)
 163     if (use_is_fpop (cpu, in_FRj))
 164       decrease_FR_busy (cpu, in_FRj, cycles);
 165     else
 166       enforce_full_fr_latency (cpu, in_FRj);
 167
 168   if (out_FRk >= 0 && out_FRk != in_FRi && out_FRk != in_FRj)
 169     if (use_is_fpop (cpu, out_FRk))
 170       decrease_FR_busy (cpu, out_FRk, cycles);
 171     else
 172       enforce_full_fr_latency (cpu, out_FRk);
 173 }
 174
 175 /* Latency of floating point registers may be less than recorded when followed
 176    by another floating point insn.  */
 177 static void
 178 adjust_double_register_busy (SIM_CPU *cpu, INT in_FRi, INT in_FRj, INT out_FRk,
 179                             int cycles)
 180 {
 181   /* If the registers were previously used in a floating point op,
 182      then their latency will be less than previously recorded.
 183      See Table 13-13 in the LSI.  */
 184   adjust_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, cycles);
 185   if (in_FRi >= 0)  ++in_FRi;
 186   if (in_FRj >= 0)  ++in_FRj;
 187   if (out_FRk >= 0) ++out_FRk;
 188   adjust_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, cycles);
 189 }
 190
 191 /* Latency of floating point registers is less than recorded when followed
 192    by another floating point insn.  */
 193 static void
 194 restore_float_register_busy (SIM_CPU *cpu, INT in_FRi, INT in_FRj, INT out_FRk,
 195                              int cycles)
 196 {
 197   /* If the registers were previously used in a floating point op,
 198      then their latency will be less than previously recorded.
 199      See Table 13-13 in the LSI.  */
 200   if (in_FRi >= 0 && use_is_fpop (cpu, in_FRi))
 201     increase_FR_busy (cpu, in_FRi, cycles);
 202   if (in_FRj != in_FRi && use_is_fpop (cpu, in_FRj))
 203     increase_FR_busy (cpu, in_FRj, cycles);
 204   if (out_FRk != in_FRi && out_FRk != in_FRj && use_is_fpop (cpu, out_FRk))
 205     increase_FR_busy (cpu, out_FRk, cycles);
 206 }
 207
 208 /* Latency of floating point registers is less than recorded when followed
 209    by another floating point insn.  */
 210 static void
 211 restore_double_register_busy (SIM_CPU *cpu, INT in_FRi, INT in_FRj, INT out_FRk,
 212                             int cycles)
 213 {
 214   /* If the registers were previously used in a floating point op,
 215      then their latency will be less than previously recorded.
 216      See Table 13-13 in the LSI.  */
 217   restore_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, cycles);
 218   if (in_FRi >= 0)  ++in_FRi;
 219   if (in_FRj >= 0)  ++in_FRj;
 220   if (out_FRk >= 0) ++out_FRk;
 221   restore_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, cycles);
 222 }
 223
 224 int
 225 frvbf_model_fr500_u_exec (SIM_CPU *cpu, const IDESC *idesc,
 226                           int unit_num, int referenced)
 227 {
 228   return idesc->timing->units[unit_num].done;
 229 }
 230
 231 int
 232 frvbf_model_fr500_u_integer (SIM_CPU *cpu, const IDESC *idesc,
 233                              int unit_num, int referenced,
 234                              INT in_GRi, INT in_GRj, INT out_GRk,
 235                              INT out_ICCi_1)
 236 {
 237   int cycles;
 238
 239   if (model_insn == FRV_INSN_MODEL_PASS_1)
 240     {
 241       /* icc0-icc4 are the upper 4 fields of the CCR.  */
 242       if (out_ICCi_1 >= 0)
 243         out_ICCi_1 += 4;
 244
 245       /* The entire VLIW insn must wait if there is a dependency on a register
 246          which is not ready yet.
 247          The latency of the registers may be less than previously recorded,
 248          depending on how they were used previously.
 249          See Table 13-8 in the LSI.  */
 250       if (in_GRi != out_GRk && in_GRi >= 0)
 251         {
 252           if (use_is_gr_complex (cpu, in_GRi))
 253             decrease_GR_busy (cpu, in_GRi, 1);
 254         }
 255       if (in_GRj != out_GRk && in_GRj != in_GRi && in_GRj >= 0)
 256         {
 257           if (use_is_gr_complex (cpu, in_GRj))
 258             decrease_GR_busy (cpu, in_GRj, 1);
 259         }
 260       vliw_wait_for_GR (cpu, in_GRi);
 261       vliw_wait_for_GR (cpu, in_GRj);
 262       vliw_wait_for_GR (cpu, out_GRk);
 263       vliw_wait_for_CCR (cpu, out_ICCi_1);
 264       handle_resource_wait (cpu);
 265       load_wait_for_GR (cpu, in_GRi);
 266       load_wait_for_GR (cpu, in_GRj);
 267       load_wait_for_GR (cpu, out_GRk);
 268       trace_vliw_wait_cycles (cpu);
 269       return 0;
 270     }
 271
 272   /* GRk is available immediately to the next VLIW insn as is ICCi_1.  */
 273   cycles = idesc->timing->units[unit_num].done;
 274   return cycles;
 275 }
 276
 277 int
 278 frvbf_model_fr500_u_imul (SIM_CPU *cpu, const IDESC *idesc,
 279                           int unit_num, int referenced,
 280                           INT in_GRi, INT in_GRj, INT out_GRk, INT out_ICCi_1)
 281 {
 282   int cycles;
 283   /* icc0-icc4 are the upper 4 fields of the CCR.  */
 284   if (out_ICCi_1 >= 0)
 285     out_ICCi_1 += 4;
 286
 287   if (model_insn == FRV_INSN_MODEL_PASS_1)
 288     {
 289       /* The entire VLIW insn must wait if there is a dependency on a register
 290          which is not ready yet.
 291          The latency of the registers may be less than previously recorded,
 292          depending on how they were used previously.
 293          See Table 13-8 in the LSI.  */
 294       if (in_GRi != out_GRk && in_GRi >= 0)
 295         {
 296           if (use_is_gr_complex (cpu, in_GRi))
 297             decrease_GR_busy (cpu, in_GRi, 1);
 298         }
 299       if (in_GRj != out_GRk && in_GRj != in_GRi && in_GRj >= 0)
 300         {
 301           if (use_is_gr_complex (cpu, in_GRj))
 302             decrease_GR_busy (cpu, in_GRj, 1);
 303         }
 304       vliw_wait_for_GR (cpu, in_GRi);
 305       vliw_wait_for_GR (cpu, in_GRj);
 306       vliw_wait_for_GRdouble (cpu, out_GRk);
 307       vliw_wait_for_CCR (cpu, out_ICCi_1);
 308       handle_resource_wait (cpu);
 309       load_wait_for_GR (cpu, in_GRi);
 310       load_wait_for_GR (cpu, in_GRj);
 311       load_wait_for_GRdouble (cpu, out_GRk);
 312       trace_vliw_wait_cycles (cpu);
 313       return 0;
 314     }
 315
 316   /* GRk has a latency of 2 cycles.  */
 317   cycles = idesc->timing->units[unit_num].done;
 318   update_GRdouble_latency (cpu, out_GRk, cycles + 2);
 319   set_use_is_gr_complex (cpu, out_GRk);
 320   set_use_is_gr_complex (cpu, out_GRk + 1);
 321
 322   /* ICCi_1 has a latency of 1 cycle.  */
 323   update_CCR_latency (cpu, out_ICCi_1, cycles + 1);
 324
 325   return cycles;
 326 }
 327
 328 int
 329 frvbf_model_fr500_u_idiv (SIM_CPU *cpu, const IDESC *idesc,
 330                           int unit_num, int referenced,
 331                           INT in_GRi, INT in_GRj, INT out_GRk, INT out_ICCi_1)
 332 {
 333   int cycles;
 334   FRV_VLIW *vliw;
 335   int slot;
 336
 337   /* icc0-icc4 are the upper 4 fields of the CCR.  */
 338   if (out_ICCi_1 >= 0)
 339     out_ICCi_1 += 4;
 340
 341   vliw = CPU_VLIW (cpu);
 342   slot = vliw->next_slot - 1;
 343   slot = (*vliw->current_vliw)[slot] - UNIT_I0;
 344
 345   if (model_insn == FRV_INSN_MODEL_PASS_1)
 346     {
 347       /* The entire VLIW insn must wait if there is a dependency on a register
 348          which is not ready yet.
 349          The latency of the registers may be less than previously recorded,
 350          depending on how they were used previously.
 351          See Table 13-8 in the LSI.  */
 352       if (in_GRi != out_GRk && in_GRi >= 0)
 353         {
 354           if (use_is_gr_complex (cpu, in_GRi))
 355             decrease_GR_busy (cpu, in_GRi, 1);
 356         }
 357       if (in_GRj != out_GRk && in_GRj != in_GRi && in_GRj >= 0)
 358         {
 359           if (use_is_gr_complex (cpu, in_GRj))
 360             decrease_GR_busy (cpu, in_GRj, 1);
 361         }
 362       vliw_wait_for_GR (cpu, in_GRi);
 363       vliw_wait_for_GR (cpu, in_GRj);
 364       vliw_wait_for_GR (cpu, out_GRk);
 365       vliw_wait_for_CCR (cpu, out_ICCi_1);
 366       vliw_wait_for_idiv_resource (cpu, slot);
 367       handle_resource_wait (cpu);
 368       load_wait_for_GR (cpu, in_GRi);
 369       load_wait_for_GR (cpu, in_GRj);
 370       load_wait_for_GR (cpu, out_GRk);
 371       trace_vliw_wait_cycles (cpu);
 372       return 0;
 373     }
 374
 375   /* GRk has a latency of 19 cycles!  */
 376   cycles = idesc->timing->units[unit_num].done;
 377   update_GR_latency (cpu, out_GRk, cycles + 19);
 378   set_use_is_gr_complex (cpu, out_GRk);
 379
 380   /* ICCi_1 has a latency of 19 cycles.  */
 381   update_CCR_latency (cpu, out_ICCi_1, cycles + 19);
 382   set_use_is_cc_complex (cpu, out_ICCi_1);
 383
 384   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
 385     {
 386       /* GNER has a latency of 18 cycles.  */
 387       update_SPR_latency (cpu, GNER_FOR_GR (out_GRk), cycles + 18);
 388     }
 389
 390   /* the idiv resource has a latency of 18 cycles!  */
 391   update_idiv_resource_latency (cpu, slot, cycles + 18);
 392
 393   return cycles;
 394 }
 395
 396 int
 397 frvbf_model_fr500_u_branch (SIM_CPU *cpu, const IDESC *idesc,
 398                             int unit_num, int referenced,
 399                             INT in_GRi, INT in_GRj,
 400                             INT in_ICCi_2, INT in_FCCi_2)
 401 {
 402   int cycles;
 403   FRV_PROFILE_STATE *ps;
 404
 405   if (model_insn == FRV_INSN_MODEL_PASS_1)
 406     {
 407       /* icc0-icc4 are the upper 4 fields of the CCR.  */
 408       if (in_ICCi_2 >= 0)
 409         in_ICCi_2 += 4;
 410
 411       /* The entire VLIW insn must wait if there is a dependency on a register
 412          which is not ready yet.
 413          The latency of the registers may be less than previously recorded,
 414          depending on how they were used previously.
 415          See Table 13-8 in the LSI.  */
 416       if (in_GRi >= 0)
 417         {
 418           if (use_is_gr_complex (cpu, in_GRi))
 419             decrease_GR_busy (cpu, in_GRi, 1);
 420         }
 421       if (in_GRj != in_GRi && in_GRj >= 0)
 422         {
 423           if (use_is_gr_complex (cpu, in_GRj))
 424             decrease_GR_busy (cpu, in_GRj, 1);
 425         }
 426       vliw_wait_for_GR (cpu, in_GRi);
 427       vliw_wait_for_GR (cpu, in_GRj);
 428       vliw_wait_for_CCR (cpu, in_ICCi_2);
 429       vliw_wait_for_CCR (cpu, in_FCCi_2);
 430       handle_resource_wait (cpu);
 431       load_wait_for_GR (cpu, in_GRi);
 432       load_wait_for_GR (cpu, in_GRj);
 433       trace_vliw_wait_cycles (cpu);
 434       return 0;
 435     }
 436
 437   /* When counting branches taken or not taken, don't consider branches after
 438      the first taken branch in a vliw insn.  */
 439   ps = CPU_PROFILE_STATE (cpu);
 440   if (! ps->vliw_branch_taken)
 441     {
 442       /* (1 << 4): The pc is the 5th element in inputs, outputs.
 443          ??? can be cleaned up */
 444       PROFILE_DATA *p = CPU_PROFILE_DATA (cpu);
 445       int taken = (referenced & (1 << 4)) != 0;
 446       if (taken)
 447         {
 448           ++PROFILE_MODEL_TAKEN_COUNT (p);
 449           ps->vliw_branch_taken = 1;
 450         }
 451       else
 452         ++PROFILE_MODEL_UNTAKEN_COUNT (p);
 453     }
 454
 455   cycles = idesc->timing->units[unit_num].done;
 456   return cycles;
 457 }
 458
 459 int
 460 frvbf_model_fr500_u_trap (SIM_CPU *cpu, const IDESC *idesc,
 461                           int unit_num, int referenced,
 462                           INT in_GRi, INT in_GRj,
 463                           INT in_ICCi_2, INT in_FCCi_2)
 464 {
 465   int cycles;
 466
 467   if (model_insn == FRV_INSN_MODEL_PASS_1)
 468     {
 469       /* icc0-icc4 are the upper 4 fields of the CCR.  */
 470       if (in_ICCi_2 >= 0)
 471         in_ICCi_2 += 4;
 472
 473       /* The entire VLIW insn must wait if there is a dependency on a register
 474          which is not ready yet.
 475          The latency of the registers may be less than previously recorded,
 476          depending on how they were used previously.
 477          See Table 13-8 in the LSI.  */
 478       if (in_GRi >= 0)
 479         {
 480           if (use_is_gr_complex (cpu, in_GRi))
 481             decrease_GR_busy (cpu, in_GRi, 1);
 482         }
 483       if (in_GRj != in_GRi && in_GRj >= 0)
 484         {
 485           if (use_is_gr_complex (cpu, in_GRj))
 486             decrease_GR_busy (cpu, in_GRj, 1);
 487         }
 488       vliw_wait_for_GR (cpu, in_GRi);
 489       vliw_wait_for_GR (cpu, in_GRj);
 490       vliw_wait_for_CCR (cpu, in_ICCi_2);
 491       vliw_wait_for_CCR (cpu, in_FCCi_2);
 492       handle_resource_wait (cpu);
 493       load_wait_for_GR (cpu, in_GRi);
 494       load_wait_for_GR (cpu, in_GRj);
 495       trace_vliw_wait_cycles (cpu);
 496       return 0;
 497     }
 498
 499   cycles = idesc->timing->units[unit_num].done;
 500   return cycles;
 501 }
 502
 503 int
 504 frvbf_model_fr500_u_check (SIM_CPU *cpu, const IDESC *idesc,
 505                            int unit_num, int referenced,
 506                            INT in_ICCi_3, INT in_FCCi_3)
 507 {
 508   int cycles;
 509
 510   if (model_insn == FRV_INSN_MODEL_PASS_1)
 511     {
 512       /* icc0-icc4 are the upper 4 fields of the CCR.  */
 513       if (in_ICCi_3 >= 0)
 514         in_ICCi_3 += 4;
 515
 516       /* The entire VLIW insn must wait if there is a dependency on a register
 517          which is not ready yet.  */
 518       vliw_wait_for_CCR (cpu, in_ICCi_3);
 519       vliw_wait_for_CCR (cpu, in_FCCi_3);
 520       handle_resource_wait (cpu);
 521       trace_vliw_wait_cycles (cpu);
 522       return 0;
 523     }
 524
 525   cycles = idesc->timing->units[unit_num].done;
 526   return cycles;
 527 }
 528
 529 int
 530 frvbf_model_fr500_u_clrgr (SIM_CPU *cpu, const IDESC *idesc,
 531                            int unit_num, int referenced,
 532                            INT in_GRk)
 533 {
 534   int cycles;
 535
 536   if (model_insn == FRV_INSN_MODEL_PASS_1)
 537     {
 538       /* Wait for both GNER registers or just the one specified.  */
 539       if (in_GRk == -1)
 540         {
 541           vliw_wait_for_SPR (cpu, H_SPR_GNER0);
 542           vliw_wait_for_SPR (cpu, H_SPR_GNER1);
 543         }
 544       else
 545         vliw_wait_for_SPR (cpu, GNER_FOR_GR (in_GRk));
 546       handle_resource_wait (cpu);
 547       trace_vliw_wait_cycles (cpu);
 548       return 0;
 549     }
 550
 551   cycles = idesc->timing->units[unit_num].done;
 552   return cycles;
 553 }
 554
 555 int
 556 frvbf_model_fr500_u_clrfr (SIM_CPU *cpu, const IDESC *idesc,
 557                            int unit_num, int referenced,
 558                            INT in_FRk)
 559 {
 560   int cycles;
 561
 562   if (model_insn == FRV_INSN_MODEL_PASS_1)
 563     {
 564       /* Wait for both GNER registers or just the one specified.  */
 565       if (in_FRk == -1)
 566         {
 567           vliw_wait_for_SPR (cpu, H_SPR_FNER0);
 568           vliw_wait_for_SPR (cpu, H_SPR_FNER1);
 569         }
 570       else
 571         vliw_wait_for_SPR (cpu, FNER_FOR_FR (in_FRk));
 572       handle_resource_wait (cpu);
 573       trace_vliw_wait_cycles (cpu);
 574       return 0;
 575     }
 576
 577   cycles = idesc->timing->units[unit_num].done;
 578   return cycles;
 579 }
 580
 581 int
 582 frvbf_model_fr500_u_commit (SIM_CPU *cpu, const IDESC *idesc,
 583                             int unit_num, int referenced,
 584                             INT in_GRk, INT in_FRk)
 585 {
 586   int cycles;
 587
 588   if (model_insn == FRV_INSN_MODEL_PASS_1)
 589     {
 590       /* If GR is specified, then FR is not and vice-versa. If neither is
 591          then it's a commitga or commitfa. Check the insn attribute to
 592          figure out which.  */
 593       if (in_GRk != -1)
 594         vliw_wait_for_SPR (cpu, GNER_FOR_GR (in_GRk));
 595       else if (in_FRk != -1)
 596         vliw_wait_for_SPR (cpu, FNER_FOR_FR (in_FRk));
 597       else if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_FR_ACCESS))
 598         {
 599           vliw_wait_for_SPR (cpu, H_SPR_FNER0);
 600           vliw_wait_for_SPR (cpu, H_SPR_FNER1);
 601         }
 602       else
 603         {
 604           vliw_wait_for_SPR (cpu, H_SPR_GNER0);
 605           vliw_wait_for_SPR (cpu, H_SPR_GNER1);
 606         }
 607       handle_resource_wait (cpu);
 608       trace_vliw_wait_cycles (cpu);
 609       return 0;
 610     }
 611
 612   cycles = idesc->timing->units[unit_num].done;
 613   return cycles;
 614 }
 615
 616 int
 617 frvbf_model_fr500_u_set_hilo (SIM_CPU *cpu, const IDESC *idesc,
 618                              int unit_num, int referenced,
 619                              INT out_GRkhi, INT out_GRklo)
 620 {
 621   int cycles;
 622
 623   if (model_insn == FRV_INSN_MODEL_PASS_1)
 624     {
 625       /* The entire VLIW insn must wait if there is a dependency on a GR
 626          which is not ready yet.  */
 627       vliw_wait_for_GR (cpu, out_GRkhi);
 628       vliw_wait_for_GR (cpu, out_GRklo);
 629       handle_resource_wait (cpu);
 630       load_wait_for_GR (cpu, out_GRkhi);
 631       load_wait_for_GR (cpu, out_GRklo);
 632       trace_vliw_wait_cycles (cpu);
 633       return 0;
 634     }
 635
 636   /* GRk is available immediately to the next VLIW insn.  */
 637   cycles = idesc->timing->units[unit_num].done;
 638
 639   set_use_not_gr_complex (cpu, out_GRkhi);
 640   set_use_not_gr_complex (cpu, out_GRklo);
 641
 642   return cycles;
 643 }
 644
 645 int
 646 frvbf_model_fr500_u_gr_load (SIM_CPU *cpu, const IDESC *idesc,
 647                              int unit_num, int referenced,
 648                              INT in_GRi, INT in_GRj,
 649                              INT out_GRk, INT out_GRdoublek)
 650 {
 651   int cycles;
 652
 653   if (model_insn == FRV_INSN_MODEL_PASS_1)
 654     {
 655       /* The entire VLIW insn must wait if there is a dependency on a register
 656          which is not ready yet.
 657          The latency of the registers may be less than previously recorded,
 658          depending on how they were used previously.
 659          See Table 13-8 in the LSI.  */
 660       if (in_GRi != out_GRk && in_GRi != out_GRdoublek
 661           && in_GRi != out_GRdoublek + 1 && in_GRi >= 0)
 662         {
 663           if (use_is_gr_complex (cpu, in_GRi))
 664             decrease_GR_busy (cpu, in_GRi, 1);
 665         }
 666       if (in_GRj != in_GRi && in_GRj != out_GRk && in_GRj != out_GRdoublek
 667           && in_GRj != out_GRdoublek + 1 && in_GRj >= 0)
 668
 669         {
 670           if (use_is_gr_complex (cpu, in_GRj))
 671             decrease_GR_busy (cpu, in_GRj, 1);
 672         }
 673       vliw_wait_for_GR (cpu, in_GRi);
 674       vliw_wait_for_GR (cpu, in_GRj);
 675       vliw_wait_for_GR (cpu, out_GRk);
 676       vliw_wait_for_GRdouble (cpu, out_GRdoublek);
 677       handle_resource_wait (cpu);
 678       load_wait_for_GR (cpu, in_GRi);
 679       load_wait_for_GR (cpu, in_GRj);
 680       load_wait_for_GR (cpu, out_GRk);
 681       load_wait_for_GRdouble (cpu, out_GRdoublek);
 682       trace_vliw_wait_cycles (cpu);
 683       return 0;
 684     }
 685
 686   cycles = idesc->timing->units[unit_num].done;
 687
 688   /* The latency of GRk for a load will depend on how long it takes to retrieve
 689      the the data from the cache or memory.  */
 690   update_GR_latency_for_load (cpu, out_GRk, cycles);
 691   update_GRdouble_latency_for_load (cpu, out_GRdoublek, cycles);
 692
 693   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
 694     {
 695       /* GNER has a latency of 2 cycles.  */
 696       update_SPR_latency (cpu, GNER_FOR_GR (out_GRk), cycles + 2);
 697       update_SPR_latency (cpu, GNER_FOR_GR (out_GRdoublek), cycles + 2);
 698     }
 699
 700   if (out_GRk >= 0)
 701     set_use_is_gr_complex (cpu, out_GRk);
 702   if (out_GRdoublek != -1)
 703     {
 704       set_use_is_gr_complex (cpu, out_GRdoublek);
 705       set_use_is_gr_complex (cpu, out_GRdoublek + 1);
 706     }
 707
 708   return cycles;
 709 }
 710
 711 int
 712 frvbf_model_fr500_u_gr_store (SIM_CPU *cpu, const IDESC *idesc,
 713                               int unit_num, int referenced,
 714                               INT in_GRi, INT in_GRj,
 715                               INT in_GRk, INT in_GRdoublek)
 716 {
 717   int cycles;
 718
 719   if (model_insn == FRV_INSN_MODEL_PASS_1)
 720     {
 721       /* The entire VLIW insn must wait if there is a dependency on a register
 722          which is not ready yet.
 723          The latency of the registers may be less than previously recorded,
 724          depending on how they were used previously.
 725          See Table 13-8 in the LSI.  */
 726       if (in_GRi >= 0)
 727         {
 728           if (use_is_gr_complex (cpu, in_GRi))
 729             decrease_GR_busy (cpu, in_GRi, 1);
 730         }
 731       if (in_GRj != in_GRi && in_GRj >= 0)
 732         {
 733           if (use_is_gr_complex (cpu, in_GRj))
 734             decrease_GR_busy (cpu, in_GRj, 1);
 735         }
 736       if (in_GRk != in_GRi && in_GRk != in_GRj && in_GRk >= 0)
 737         {
 738           if (use_is_gr_complex (cpu, in_GRk))
 739             decrease_GR_busy (cpu, in_GRk, 1);
 740         }
 741       if (in_GRdoublek != in_GRi && in_GRdoublek != in_GRj
 742           && in_GRdoublek + 1 != in_GRi && in_GRdoublek + 1 != in_GRj
 743           && in_GRdoublek >= 0)
 744         {
 745           if (use_is_gr_complex (cpu, in_GRdoublek))
 746             decrease_GR_busy (cpu, in_GRdoublek, 1);
 747           if (use_is_gr_complex (cpu, in_GRdoublek + 1))
 748             decrease_GR_busy (cpu, in_GRdoublek + 1, 1);
 749         }
 750       vliw_wait_for_GR (cpu, in_GRi);
 751       vliw_wait_for_GR (cpu, in_GRj);
 752       vliw_wait_for_GR (cpu, in_GRk);
 753       vliw_wait_for_GRdouble (cpu, in_GRdoublek);
 754       handle_resource_wait (cpu);
 755       load_wait_for_GR (cpu, in_GRi);
 756       load_wait_for_GR (cpu, in_GRj);
 757       load_wait_for_GR (cpu, in_GRk);
 758       load_wait_for_GRdouble (cpu, in_GRdoublek);
 759       trace_vliw_wait_cycles (cpu);
 760       return 0;
 761     }
 762
 763   cycles = idesc->timing->units[unit_num].done;
 764
 765   return cycles;
 766 }
 767
 768 int
 769 frvbf_model_fr500_u_gr_r_store (SIM_CPU *cpu, const IDESC *idesc,
 770                                 int unit_num, int referenced,
 771                                 INT in_GRi, INT in_GRj,
 772                                 INT in_GRk, INT in_GRdoublek)
 773 {
 774   int cycles = frvbf_model_fr500_u_gr_store (cpu, idesc, unit_num, referenced,
 775                                              in_GRi, in_GRj, in_GRk,
 776                                              in_GRdoublek);
 777
 778   if (model_insn == FRV_INSN_MODEL_PASS_2)
 779     {
 780       if (CPU_RSTR_INVALIDATE(cpu))
 781         request_cache_invalidate (cpu, CPU_DATA_CACHE (cpu), cycles);
 782     }
 783
 784   return cycles;
 785 }
 786
 787 int
 788 frvbf_model_fr500_u_fr_load (SIM_CPU *cpu, const IDESC *idesc,
 789                              int unit_num, int referenced,
 790                              INT in_GRi, INT in_GRj,
 791                              INT out_FRk, INT out_FRdoublek)
 792 {
 793   int cycles;
 794
 795   if (model_insn == FRV_INSN_MODEL_PASS_1)
 796     {
 797       /* The entire VLIW insn must wait if there is a dependency on a register
 798          which is not ready yet.
 799          The latency of the registers may be less than previously recorded,
 800          depending on how they were used previously.
 801          See Table 13-8 in the LSI.  */
 802       if (in_GRi >= 0)
 803         {
 804           if (use_is_gr_complex (cpu, in_GRi))
 805             decrease_GR_busy (cpu, in_GRi, 1);
 806         }
 807       if (in_GRj != in_GRi && in_GRj >= 0)
 808         {
 809           if (use_is_gr_complex (cpu, in_GRj))
 810             decrease_GR_busy (cpu, in_GRj, 1);
 811         }
 812       if (out_FRk >= 0)
 813         {
 814           if (use_is_media (cpu, out_FRk))
 815             decrease_FR_busy (cpu, out_FRk, 1);
 816           else
 817             adjust_float_register_busy (cpu, -1, -1, out_FRk, 1);
 818         }
 819       if (out_FRdoublek >= 0)
 820         {
 821           if (use_is_media (cpu, out_FRdoublek))
 822             decrease_FR_busy (cpu, out_FRdoublek, 1);
 823           else
 824             adjust_float_register_busy (cpu, -1, -1, out_FRdoublek, 1);
 825           if (use_is_media (cpu, out_FRdoublek + 1))
 826             decrease_FR_busy (cpu, out_FRdoublek + 1, 1);
 827           else
 828             adjust_float_register_busy (cpu, -1, -1, out_FRdoublek + 1, 1);
 829         }
 830       vliw_wait_for_GR (cpu, in_GRi);
 831       vliw_wait_for_GR (cpu, in_GRj);
 832       vliw_wait_for_FR (cpu, out_FRk);
 833       vliw_wait_for_FRdouble (cpu, out_FRdoublek);
 834       if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
 835         {
 836           vliw_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
 837           vliw_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
 838         }
 839       handle_resource_wait (cpu);
 840       load_wait_for_GR (cpu, in_GRi);
 841       load_wait_for_GR (cpu, in_GRj);
 842       load_wait_for_FR (cpu, out_FRk);
 843       load_wait_for_FRdouble (cpu, out_FRdoublek);
 844       trace_vliw_wait_cycles (cpu);
 845       return 0;
 846     }
 847
 848   cycles = idesc->timing->units[unit_num].done;
 849
 850   /* The latency of FRk for a load will depend on how long it takes to retrieve
 851      the the data from the cache or memory.  */
 852   update_FR_latency_for_load (cpu, out_FRk, cycles);
 853   update_FRdouble_latency_for_load (cpu, out_FRdoublek, cycles);
 854
 855   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
 856     {
 857       /* FNER has a latency of 3 cycles.  */
 858       update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), cycles + 3);
 859       update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), cycles + 3);
 860     }
 861
 862   fr500_reset_fr_flags (cpu, out_FRk);
 863
 864   return cycles;
 865 }
 866
 867 int
 868 frvbf_model_fr500_u_fr_store (SIM_CPU *cpu, const IDESC *idesc,
 869                               int unit_num, int referenced,
 870                               INT in_GRi, INT in_GRj,
 871                               INT in_FRk, INT in_FRdoublek)
 872 {
 873   int cycles;
 874
 875   if (model_insn == FRV_INSN_MODEL_PASS_1)
 876     {
 877       /* The entire VLIW insn must wait if there is a dependency on a register
 878          which is not ready yet.
 879          The latency of the registers may be less than previously recorded,
 880          depending on how they were used previously.
 881          See Table 13-8 in the LSI.  */
 882       if (in_GRi >= 0)
 883         {
 884           if (use_is_gr_complex (cpu, in_GRi))
 885             decrease_GR_busy (cpu, in_GRi, 1);
 886         }
 887       if (in_GRj != in_GRi && in_GRj >= 0)
 888         {
 889           if (use_is_gr_complex (cpu, in_GRj))
 890             decrease_GR_busy (cpu, in_GRj, 1);
 891         }
 892       if (in_FRk >= 0)
 893         {
 894           if (use_is_media (cpu, in_FRk))
 895             decrease_FR_busy (cpu, in_FRk, 1);
 896           else
 897             adjust_float_register_busy (cpu, -1, -1, in_FRk, 1);
 898         }
 899       if (in_FRdoublek >= 0)
 900         {
 901           if (use_is_media (cpu, in_FRdoublek))
 902             decrease_FR_busy (cpu, in_FRdoublek, 1);
 903           else
 904             adjust_float_register_busy (cpu, -1, -1, in_FRdoublek, 1);
 905           if (use_is_media (cpu, in_FRdoublek + 1))
 906             decrease_FR_busy (cpu, in_FRdoublek + 1, 1);
 907           else
 908             adjust_float_register_busy (cpu, -1, -1, in_FRdoublek + 1, 1);
 909         }
 910       vliw_wait_for_GR (cpu, in_GRi);
 911       vliw_wait_for_GR (cpu, in_GRj);
 912       vliw_wait_for_FR (cpu, in_FRk);
 913       vliw_wait_for_FRdouble (cpu, in_FRdoublek);
 914       handle_resource_wait (cpu);
 915       load_wait_for_GR (cpu, in_GRi);
 916       load_wait_for_GR (cpu, in_GRj);
 917       load_wait_for_FR (cpu, in_FRk);
 918       load_wait_for_FRdouble (cpu, in_FRdoublek);
 919       trace_vliw_wait_cycles (cpu);
 920       return 0;
 921     }
 922
 923   cycles = idesc->timing->units[unit_num].done;
 924
 925   return cycles;
 926 }
 927
 928 int
 929 frvbf_model_fr500_u_fr_r_store (SIM_CPU *cpu, const IDESC *idesc,
 930                                 int unit_num, int referenced,
 931                                 INT in_GRi, INT in_GRj,
 932                                 INT in_FRk, INT in_FRdoublek)
 933 {
 934   int cycles = frvbf_model_fr500_u_fr_store (cpu, idesc, unit_num, referenced,
 935                                              in_GRi, in_GRj, in_FRk,
 936                                              in_FRdoublek);
 937
 938   if (model_insn == FRV_INSN_MODEL_PASS_2)
 939     {
 940       if (CPU_RSTR_INVALIDATE(cpu))
 941         request_cache_invalidate (cpu, CPU_DATA_CACHE (cpu), cycles);
 942     }
 943
 944   return cycles;
 945 }
 946
 947 int
 948 frvbf_model_fr500_u_swap (SIM_CPU *cpu, const IDESC *idesc,
 949                           int unit_num, int referenced,
 950                           INT in_GRi, INT in_GRj, INT out_GRk)
 951 {
 952   int cycles;
 953
 954   if (model_insn == FRV_INSN_MODEL_PASS_1)
 955     {
 956       /* The entire VLIW insn must wait if there is a dependency on a register
 957          which is not ready yet.
 958          The latency of the registers may be less than previously recorded,
 959          depending on how they were used previously.
 960          See Table 13-8 in the LSI.  */
 961       if (in_GRi != out_GRk && in_GRi >= 0)
 962         {
 963           if (use_is_gr_complex (cpu, in_GRi))
 964             decrease_GR_busy (cpu, in_GRi, 1);
 965         }
 966       if (in_GRj != out_GRk && in_GRj != in_GRi && in_GRj >= 0)
 967         {
 968           if (use_is_gr_complex (cpu, in_GRj))
 969             decrease_GR_busy (cpu, in_GRj, 1);
 970         }
 971       vliw_wait_for_GR (cpu, in_GRi);
 972       vliw_wait_for_GR (cpu, in_GRj);
 973       vliw_wait_for_GR (cpu, out_GRk);
 974       handle_resource_wait (cpu);
 975       load_wait_for_GR (cpu, in_GRi);
 976       load_wait_for_GR (cpu, in_GRj);
 977       load_wait_for_GR (cpu, out_GRk);
 978       trace_vliw_wait_cycles (cpu);
 979       return 0;
 980     }
 981
 982   cycles = idesc->timing->units[unit_num].done;
 983
 984   /* The latency of GRk will depend on how long it takes to swap
 985      the the data from the cache or memory.  */
 986   update_GR_latency_for_swap (cpu, out_GRk, cycles);
 987   set_use_is_gr_complex (cpu, out_GRk);
 988
 989   return cycles;
 990 }
 991
 992 int
 993 frvbf_model_fr500_u_fr2fr (SIM_CPU *cpu, const IDESC *idesc,
 994                            int unit_num, int referenced,
 995                            INT in_FRj, INT out_FRk)
 996 {
 997   int cycles;
 998
 999   if (model_insn == FRV_INSN_MODEL_PASS_1)
1000     {
1001       /* The entire VLIW insn must wait if there is a dependency on a register
1002          which is not ready yet.  */
1003       if (in_FRj >= 0)
1004         {
1005           if (use_is_media (cpu, in_FRj))
1006             decrease_FR_busy (cpu, in_FRj, 1);
1007           else
1008             adjust_float_register_busy (cpu, -1, in_FRj, -1, 1);
1009         }
1010       if (out_FRk >= 0 && out_FRk != in_FRj)
1011         {
1012           if (use_is_media (cpu, out_FRk))
1013             decrease_FR_busy (cpu, out_FRk, 1);
1014           else
1015             adjust_float_register_busy (cpu, -1, -1, out_FRk, 1);
1016         }
1017       vliw_wait_for_FR (cpu, in_FRj);
1018       vliw_wait_for_FR (cpu, out_FRk);
1019       handle_resource_wait (cpu);
1020       load_wait_for_FR (cpu, in_FRj);
1021       load_wait_for_FR (cpu, out_FRk);
1022       trace_vliw_wait_cycles (cpu);
1023       return 0;
1024     }
1025
1026   /* The latency of FRj is 3 cycles.  */
1027   cycles = idesc->timing->units[unit_num].done;
1028   update_FR_latency (cpu, out_FRk, cycles + 3);
1029
1030   return cycles;
1031 }
1032
1033 int
1034 frvbf_model_fr500_u_fr2gr (SIM_CPU *cpu, const IDESC *idesc,
1035                            int unit_num, int referenced,
1036                            INT in_FRk, INT out_GRj)
1037 {
1038   int cycles;
1039
1040   if (model_insn == FRV_INSN_MODEL_PASS_1)
1041     {
1042       /* The entire VLIW insn must wait if there is a dependency on a register
1043          which is not ready yet.  */
1044       if (in_FRk >= 0)
1045         {
1046           if (use_is_media (cpu, in_FRk))
1047             decrease_FR_busy (cpu, in_FRk, 1);
1048           else
1049             adjust_float_register_busy (cpu, -1, in_FRk, -1, 1);
1050         }
1051       vliw_wait_for_FR (cpu, in_FRk);
1052       vliw_wait_for_GR (cpu, out_GRj);
1053       handle_resource_wait (cpu);
1054       load_wait_for_FR (cpu, in_FRk);
1055       load_wait_for_GR (cpu, out_GRj);
1056       trace_vliw_wait_cycles (cpu);
1057       return 0;
1058     }
1059
1060   /* The latency of GRj is 2 cycles.  */
1061   cycles = idesc->timing->units[unit_num].done;
1062   update_GR_latency (cpu, out_GRj, cycles + 2);
1063   set_use_is_gr_complex (cpu, out_GRj);
1064
1065   return cycles;
1066 }
1067
1068 int
1069 frvbf_model_fr500_u_spr2gr (SIM_CPU *cpu, const IDESC *idesc,
1070                            int unit_num, int referenced,
1071                            INT in_spr, INT out_GRj)
1072 {
1073   int cycles;
1074
1075   if (model_insn == FRV_INSN_MODEL_PASS_1)
1076     {
1077       /* The entire VLIW insn must wait if there is a dependency on a register
1078          which is not ready yet.  */
1079       vliw_wait_for_SPR (cpu, in_spr);
1080       vliw_wait_for_GR (cpu, out_GRj);
1081       handle_resource_wait (cpu);
1082       load_wait_for_GR (cpu, out_GRj);
1083       trace_vliw_wait_cycles (cpu);
1084       return 0;
1085     }
1086
1087   cycles = idesc->timing->units[unit_num].done;
1088
1089 #if 0 /* no latency?  */
1090   /* The latency of GRj is 2 cycles.  */
1091   update_GR_latency (cpu, out_GRj, cycles + 2);
1092 #endif
1093
1094   return cycles;
1095 }
1096
1097 int
1098 frvbf_model_fr500_u_gr2fr (SIM_CPU *cpu, const IDESC *idesc,
1099                            int unit_num, int referenced,
1100                            INT in_GRj, INT out_FRk)
1101 {
1102   int cycles;
1103
1104   if (model_insn == FRV_INSN_MODEL_PASS_1)
1105     {
1106       /* The entire VLIW insn must wait if there is a dependency on a register
1107          which is not ready yet.
1108          The latency of the registers may be less than previously recorded,
1109          depending on how they were used previously.
1110          See Table 13-8 in the LSI.  */
1111       if (in_GRj >= 0)
1112         {
1113           if (use_is_gr_complex (cpu, in_GRj))
1114             decrease_GR_busy (cpu, in_GRj, 1);
1115         }
1116       if (out_FRk >= 0)
1117         {
1118           if (use_is_media (cpu, out_FRk))
1119             decrease_FR_busy (cpu, out_FRk, 1);
1120           else
1121             adjust_float_register_busy (cpu, -1, -1, out_FRk, 1);
1122         }
1123       vliw_wait_for_GR (cpu, in_GRj);
1124       vliw_wait_for_FR (cpu, out_FRk);
1125       handle_resource_wait (cpu);
1126       load_wait_for_GR (cpu, in_GRj);
1127       load_wait_for_FR (cpu, out_FRk);
1128       trace_vliw_wait_cycles (cpu);
1129       return 0;
1130     }
1131
1132   /* The latency of FRk is 2 cycles.  */
1133   cycles = idesc->timing->units[unit_num].done;
1134   update_FR_latency (cpu, out_FRk, cycles + 2);
1135
1136   /* Mark this use of the register as NOT a floating point op.  */
1137   fr500_reset_fr_flags (cpu, out_FRk);
1138
1139   return cycles;
1140 }
1141
1142 int
1143 frvbf_model_fr500_u_gr2spr (SIM_CPU *cpu, const IDESC *idesc,
1144                             int unit_num, int referenced,
1145                             INT in_GRj, INT out_spr)
1146 {
1147   int cycles;
1148
1149   if (model_insn == FRV_INSN_MODEL_PASS_1)
1150     {
1151       /* The entire VLIW insn must wait if there is a dependency on a register
1152          which is not ready yet.
1153          The latency of the registers may be less than previously recorded,
1154          depending on how they were used previously.
1155          See Table 13-8 in the LSI.  */
1156       if (in_GRj >= 0)
1157         {
1158           if (use_is_gr_complex (cpu, in_GRj))
1159             decrease_GR_busy (cpu, in_GRj, 1);
1160         }
1161       vliw_wait_for_GR (cpu, in_GRj);
1162       vliw_wait_for_SPR (cpu, out_spr);
1163       handle_resource_wait (cpu);
1164       load_wait_for_GR (cpu, in_GRj);
1165       trace_vliw_wait_cycles (cpu);
1166       return 0;
1167     }
1168
1169   cycles = idesc->timing->units[unit_num].done;
1170
1171 #if 0
1172   /* The latency of spr is ? cycles.  */
1173   update_SPR_latency (cpu, out_spr, cycles + ?);
1174 #endif
1175
1176   return cycles;
1177 }
1178
1179 int
1180 frvbf_model_fr500_u_ici (SIM_CPU *cpu, const IDESC *idesc,
1181                          int unit_num, int referenced,
1182                          INT in_GRi, INT in_GRj)
1183 {
1184   int cycles;
1185
1186   if (model_insn == FRV_INSN_MODEL_PASS_1)
1187     {
1188       /* The entire VLIW insn must wait if there is a dependency on a register
1189          which is not ready yet.
1190          The latency of the registers may be less than previously recorded,
1191          depending on how they were used previously.
1192          See Table 13-8 in the LSI.  */
1193       if (in_GRi >= 0)
1194         {
1195           if (use_is_gr_complex (cpu, in_GRi))
1196             decrease_GR_busy (cpu, in_GRi, 1);
1197         }
1198       if (in_GRj != in_GRi && in_GRj >= 0)
1199         {
1200           if (use_is_gr_complex (cpu, in_GRj))
1201             decrease_GR_busy (cpu, in_GRj, 1);
1202         }
1203       vliw_wait_for_GR (cpu, in_GRi);
1204       vliw_wait_for_GR (cpu, in_GRj);
1205       handle_resource_wait (cpu);
1206       load_wait_for_GR (cpu, in_GRi);
1207       load_wait_for_GR (cpu, in_GRj);
1208       trace_vliw_wait_cycles (cpu);
1209       return 0;
1210     }
1211
1212   cycles = idesc->timing->units[unit_num].done;
1213   request_cache_invalidate (cpu, CPU_INSN_CACHE (cpu), cycles);
1214   return cycles;
1215 }
1216
1217 int
1218 frvbf_model_fr500_u_dci (SIM_CPU *cpu, const IDESC *idesc,
1219                          int unit_num, int referenced,
1220                          INT in_GRi, INT in_GRj)
1221 {
1222   int cycles;
1223
1224   if (model_insn == FRV_INSN_MODEL_PASS_1)
1225     {
1226       /* The entire VLIW insn must wait if there is a dependency on a register
1227          which is not ready yet.
1228          The latency of the registers may be less than previously recorded,
1229          depending on how they were used previously.
1230          See Table 13-8 in the LSI.  */
1231       if (in_GRi >= 0)
1232         {
1233           if (use_is_gr_complex (cpu, in_GRi))
1234             decrease_GR_busy (cpu, in_GRi, 1);
1235         }
1236       if (in_GRj != in_GRi && in_GRj >= 0)
1237         {
1238           if (use_is_gr_complex (cpu, in_GRj))
1239             decrease_GR_busy (cpu, in_GRj, 1);
1240         }
1241       vliw_wait_for_GR (cpu, in_GRi);
1242       vliw_wait_for_GR (cpu, in_GRj);
1243       handle_resource_wait (cpu);
1244       load_wait_for_GR (cpu, in_GRi);
1245       load_wait_for_GR (cpu, in_GRj);
1246       trace_vliw_wait_cycles (cpu);
1247       return 0;
1248     }
1249
1250   cycles = idesc->timing->units[unit_num].done;
1251   request_cache_invalidate (cpu, CPU_DATA_CACHE (cpu), cycles);
1252   return cycles;
1253 }
1254
1255 int
1256 frvbf_model_fr500_u_dcf (SIM_CPU *cpu, const IDESC *idesc,
1257                          int unit_num, int referenced,
1258                          INT in_GRi, INT in_GRj)
1259 {
1260   int cycles;
1261
1262   if (model_insn == FRV_INSN_MODEL_PASS_1)
1263     {
1264       /* The entire VLIW insn must wait if there is a dependency on a register
1265          which is not ready yet.
1266          The latency of the registers may be less than previously recorded,
1267          depending on how they were used previously.
1268          See Table 13-8 in the LSI.  */
1269       if (in_GRi >= 0)
1270         {
1271           if (use_is_gr_complex (cpu, in_GRi))
1272             decrease_GR_busy (cpu, in_GRi, 1);
1273         }
1274       if (in_GRj != in_GRi && in_GRj >= 0)
1275         {
1276           if (use_is_gr_complex (cpu, in_GRj))
1277             decrease_GR_busy (cpu, in_GRj, 1);
1278         }
1279       vliw_wait_for_GR (cpu, in_GRi);
1280       vliw_wait_for_GR (cpu, in_GRj);
1281       handle_resource_wait (cpu);
1282       load_wait_for_GR (cpu, in_GRi);
1283       load_wait_for_GR (cpu, in_GRj);
1284       trace_vliw_wait_cycles (cpu);
1285       return 0;
1286     }
1287
1288   cycles = idesc->timing->units[unit_num].done;
1289   request_cache_flush (cpu, CPU_DATA_CACHE (cpu), cycles);
1290   return cycles;
1291 }
1292
1293 int
1294 frvbf_model_fr500_u_icpl (SIM_CPU *cpu, const IDESC *idesc,
1295                           int unit_num, int referenced,
1296                           INT in_GRi, INT in_GRj)
1297 {
1298   int cycles;
1299
1300   if (model_insn == FRV_INSN_MODEL_PASS_1)
1301     {
1302       /* The entire VLIW insn must wait if there is a dependency on a register
1303          which is not ready yet.
1304          The latency of the registers may be less than previously recorded,
1305          depending on how they were used previously.
1306          See Table 13-8 in the LSI.  */
1307       if (in_GRi >= 0)
1308         {
1309           if (use_is_gr_complex (cpu, in_GRi))
1310             decrease_GR_busy (cpu, in_GRi, 1);
1311         }
1312       if (in_GRj != in_GRi && in_GRj >= 0)
1313         {
1314           if (use_is_gr_complex (cpu, in_GRj))
1315             decrease_GR_busy (cpu, in_GRj, 1);
1316         }
1317       vliw_wait_for_GR (cpu, in_GRi);
1318       vliw_wait_for_GR (cpu, in_GRj);
1319       handle_resource_wait (cpu);
1320       load_wait_for_GR (cpu, in_GRi);
1321       load_wait_for_GR (cpu, in_GRj);
1322       trace_vliw_wait_cycles (cpu);
1323       return 0;
1324     }
1325
1326   cycles = idesc->timing->units[unit_num].done;
1327   request_cache_preload (cpu, CPU_INSN_CACHE (cpu), cycles);
1328   return cycles;
1329 }
1330
1331 int
1332 frvbf_model_fr500_u_dcpl (SIM_CPU *cpu, const IDESC *idesc,
1333                           int unit_num, int referenced,
1334                           INT in_GRi, INT in_GRj)
1335 {
1336   int cycles;
1337
1338   if (model_insn == FRV_INSN_MODEL_PASS_1)
1339     {
1340       /* The entire VLIW insn must wait if there is a dependency on a register
1341          which is not ready yet.
1342          The latency of the registers may be less than previously recorded,
1343          depending on how they were used previously.
1344          See Table 13-8 in the LSI.  */
1345       if (in_GRi >= 0)
1346         {
1347           if (use_is_gr_complex (cpu, in_GRi))
1348             decrease_GR_busy (cpu, in_GRi, 1);
1349         }
1350       if (in_GRj != in_GRi && in_GRj >= 0)
1351         {
1352           if (use_is_gr_complex (cpu, in_GRj))
1353             decrease_GR_busy (cpu, in_GRj, 1);
1354         }
1355       vliw_wait_for_GR (cpu, in_GRi);
1356       vliw_wait_for_GR (cpu, in_GRj);
1357       handle_resource_wait (cpu);
1358       load_wait_for_GR (cpu, in_GRi);
1359       load_wait_for_GR (cpu, in_GRj);
1360       trace_vliw_wait_cycles (cpu);
1361       return 0;
1362     }
1363
1364   cycles = idesc->timing->units[unit_num].done;
1365   request_cache_preload (cpu, CPU_DATA_CACHE (cpu), cycles);
1366   return cycles;
1367 }
1368
1369 int
1370 frvbf_model_fr500_u_icul (SIM_CPU *cpu, const IDESC *idesc,
1371                           int unit_num, int referenced,
1372                           INT in_GRi, INT in_GRj)
1373 {
1374   int cycles;
1375
1376   if (model_insn == FRV_INSN_MODEL_PASS_1)
1377     {
1378       /* The entire VLIW insn must wait if there is a dependency on a register
1379          which is not ready yet.
1380          The latency of the registers may be less than previously recorded,
1381          depending on how they were used previously.
1382          See Table 13-8 in the LSI.  */
1383       if (in_GRi >= 0)
1384         {
1385           if (use_is_gr_complex (cpu, in_GRi))
1386             decrease_GR_busy (cpu, in_GRi, 1);
1387         }
1388       if (in_GRj != in_GRi && in_GRj >= 0)
1389         {
1390           if (use_is_gr_complex (cpu, in_GRj))
1391             decrease_GR_busy (cpu, in_GRj, 1);
1392         }
1393       vliw_wait_for_GR (cpu, in_GRi);
1394       vliw_wait_for_GR (cpu, in_GRj);
1395       handle_resource_wait (cpu);
1396       load_wait_for_GR (cpu, in_GRi);
1397       load_wait_for_GR (cpu, in_GRj);
1398       trace_vliw_wait_cycles (cpu);
1399       return 0;
1400     }
1401
1402   cycles = idesc->timing->units[unit_num].done;
1403   request_cache_unlock (cpu, CPU_INSN_CACHE (cpu), cycles);
1404   return cycles;
1405 }
1406
1407 int
1408 frvbf_model_fr500_u_dcul (SIM_CPU *cpu, const IDESC *idesc,
1409                           int unit_num, int referenced,
1410                           INT in_GRi, INT in_GRj)
1411 {
1412   int cycles;
1413
1414   if (model_insn == FRV_INSN_MODEL_PASS_1)
1415     {
1416       /* The entire VLIW insn must wait if there is a dependency on a register
1417          which is not ready yet.
1418          The latency of the registers may be less than previously recorded,
1419          depending on how they were used previously.
1420          See Table 13-8 in the LSI.  */
1421       if (in_GRi >= 0)
1422         {
1423           if (use_is_gr_complex (cpu, in_GRi))
1424             decrease_GR_busy (cpu, in_GRi, 1);
1425         }
1426       if (in_GRj != in_GRi && in_GRj >= 0)
1427         {
1428           if (use_is_gr_complex (cpu, in_GRj))
1429             decrease_GR_busy (cpu, in_GRj, 1);
1430         }
1431       vliw_wait_for_GR (cpu, in_GRi);
1432       vliw_wait_for_GR (cpu, in_GRj);
1433       handle_resource_wait (cpu);
1434       load_wait_for_GR (cpu, in_GRi);
1435       load_wait_for_GR (cpu, in_GRj);
1436       trace_vliw_wait_cycles (cpu);
1437       return 0;
1438     }
1439
1440   cycles = idesc->timing->units[unit_num].done;
1441   request_cache_unlock (cpu, CPU_DATA_CACHE (cpu), cycles);
1442   return cycles;
1443 }
1444
1445 int
1446 frvbf_model_fr500_u_float_arith (SIM_CPU *cpu, const IDESC *idesc,
1447                                  int unit_num, int referenced,
1448                                  INT in_FRi, INT in_FRj,
1449                                  INT in_FRdoublei, INT in_FRdoublej,
1450                                  INT out_FRk, INT out_FRdoublek)
1451 {
1452   int cycles;
1453   FRV_PROFILE_STATE *ps;
1454
1455   if (model_insn == FRV_INSN_MODEL_PASS_1)
1456     return 0;
1457
1458   /* The preprocessing can execute right away.  */
1459   cycles = idesc->timing->units[unit_num].done;
1460
1461   /* The post processing must wait if there is a dependency on a FR
1462      which is not ready yet.  */
1463   adjust_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, 1);
1464   adjust_double_register_busy (cpu, in_FRdoublei, in_FRdoublej, out_FRdoublek,
1465                                1);
1466   ps = CPU_PROFILE_STATE (cpu);
1467   ps->post_wait = cycles;
1468   post_wait_for_FR (cpu, in_FRi);
1469   post_wait_for_FR (cpu, in_FRj);
1470   post_wait_for_FR (cpu, out_FRk);
1471   post_wait_for_FRdouble (cpu, in_FRdoublei);
1472   post_wait_for_FRdouble (cpu, in_FRdoublej);
1473   post_wait_for_FRdouble (cpu, out_FRdoublek);
1474   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1475     {
1476       post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1477       post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
1478     }
1479   restore_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, 1);
1480   restore_double_register_busy (cpu, in_FRdoublei, in_FRdoublej, out_FRdoublek,
1481                                 1);
1482
1483   /* The latency of FRk will be at least the latency of the other inputs.  */
1484   update_FR_latency (cpu, out_FRk, ps->post_wait);
1485   update_FRdouble_latency (cpu, out_FRdoublek, ps->post_wait);
1486
1487   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1488     {
1489       update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1490       update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), ps->post_wait);
1491     }
1492
1493   /* Once initiated, post-processing will take 3 cycles.  */
1494   update_FR_ptime (cpu, out_FRk, 3);
1495   update_FRdouble_ptime (cpu, out_FRdoublek, 3);
1496
1497   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1498     {
1499       update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 3);
1500       update_SPR_ptime (cpu, FNER_FOR_FR (out_FRdoublek), 3);
1501     }
1502
1503   /* Mark this use of the register as a floating point op.  */
1504   if (out_FRk >= 0)
1505     set_use_is_fpop (cpu, out_FRk);
1506   if (out_FRdoublek >= 0)
1507     {
1508       set_use_is_fpop (cpu, out_FRdoublek);
1509       if (out_FRdoublek < 63)
1510         set_use_is_fpop (cpu, out_FRdoublek + 1);
1511     }
1512
1513   return cycles;
1514 }
1515
1516 int
1517 frvbf_model_fr500_u_float_dual_arith (SIM_CPU *cpu, const IDESC *idesc,
1518                                       int unit_num, int referenced,
1519                                       INT in_FRi, INT in_FRj,
1520                                       INT in_FRdoublei, INT in_FRdoublej,
1521                                       INT out_FRk, INT out_FRdoublek)
1522 {
1523   int cycles;
1524   INT dual_FRi;
1525   INT dual_FRj;
1526   INT dual_FRk;
1527   INT dual_FRdoublei;
1528   INT dual_FRdoublej;
1529   INT dual_FRdoublek;
1530   FRV_PROFILE_STATE *ps;
1531
1532   if (model_insn == FRV_INSN_MODEL_PASS_1)
1533     return 0;
1534
1535   /* The preprocessing can execute right away.  */
1536   cycles = idesc->timing->units[unit_num].done;
1537
1538   /* The post processing must wait if there is a dependency on a FR
1539      which is not ready yet.  */
1540   dual_FRi = DUAL_REG (in_FRi);
1541   dual_FRj = DUAL_REG (in_FRj);
1542   dual_FRk = DUAL_REG (out_FRk);
1543   dual_FRdoublei = DUAL_DOUBLE (in_FRdoublei);
1544   dual_FRdoublej = DUAL_DOUBLE (in_FRdoublej);
1545   dual_FRdoublek = DUAL_DOUBLE (out_FRdoublek);
1546
1547   adjust_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, 1);
1548   adjust_float_register_busy (cpu, dual_FRi, dual_FRj, dual_FRk, 1);
1549   adjust_double_register_busy (cpu, in_FRdoublei, in_FRdoublej, out_FRdoublek,
1550                                1);
1551   adjust_double_register_busy (cpu, dual_FRdoublei, dual_FRdoublej,
1552                                dual_FRdoublek, 1);
1553   ps = CPU_PROFILE_STATE (cpu);
1554   ps->post_wait = cycles;
1555   post_wait_for_FR (cpu, in_FRi);
1556   post_wait_for_FR (cpu, in_FRj);
1557   post_wait_for_FR (cpu, out_FRk);
1558   post_wait_for_FR (cpu, dual_FRi);
1559   post_wait_for_FR (cpu, dual_FRj);
1560   post_wait_for_FR (cpu, dual_FRk);
1561   post_wait_for_FRdouble (cpu, in_FRdoublei);
1562   post_wait_for_FRdouble (cpu, in_FRdoublej);
1563   post_wait_for_FRdouble (cpu, out_FRdoublek);
1564   post_wait_for_FRdouble (cpu, dual_FRdoublei);
1565   post_wait_for_FRdouble (cpu, dual_FRdoublej);
1566   post_wait_for_FRdouble (cpu, dual_FRdoublek);
1567   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1568     {
1569       post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1570       post_wait_for_SPR (cpu, FNER_FOR_FR (dual_FRk));
1571       post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
1572       post_wait_for_SPR (cpu, FNER_FOR_FR (dual_FRdoublek));
1573     }
1574   restore_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, 1);
1575   restore_float_register_busy (cpu, dual_FRi, dual_FRj, dual_FRk, 1);
1576   restore_double_register_busy (cpu, in_FRdoublei, in_FRdoublej, out_FRdoublek,
1577                                 1);
1578   restore_double_register_busy (cpu, dual_FRdoublei, dual_FRdoublej,
1579                                 dual_FRdoublek, 1);
1580
1581   /* The latency of FRk will be at least the latency of the other inputs.  */
1582   update_FR_latency (cpu, out_FRk, ps->post_wait);
1583   update_FR_latency (cpu, dual_FRk, ps->post_wait);
1584   update_FRdouble_latency (cpu, out_FRdoublek, ps->post_wait);
1585   update_FRdouble_latency (cpu, dual_FRdoublek, ps->post_wait);
1586
1587   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1588     {
1589       update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1590       update_SPR_latency (cpu, FNER_FOR_FR (dual_FRk), ps->post_wait);
1591       update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), ps->post_wait);
1592       update_SPR_latency (cpu, FNER_FOR_FR (dual_FRdoublek), ps->post_wait);
1593     }
1594
1595   /* Once initiated, post-processing will take 3 cycles.  */
1596   update_FR_ptime (cpu, out_FRk, 3);
1597   update_FR_ptime (cpu, dual_FRk, 3);
1598   update_FRdouble_ptime (cpu, out_FRdoublek, 3);
1599   update_FRdouble_ptime (cpu, dual_FRdoublek, 3);
1600
1601   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1602     {
1603       update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 3);
1604       update_SPR_ptime (cpu, FNER_FOR_FR (dual_FRk), 3);
1605       update_SPR_ptime (cpu, FNER_FOR_FR (out_FRdoublek), 3);
1606       update_SPR_ptime (cpu, FNER_FOR_FR (dual_FRdoublek), 3);
1607     }
1608
1609   /* Mark this use of the register as a floating point op.  */
1610   if (out_FRk >= 0)
1611     set_use_is_fpop (cpu, out_FRk);
1612   if (dual_FRk >= 0)
1613     set_use_is_fpop (cpu, dual_FRk);
1614   if (out_FRdoublek >= 0)
1615     {
1616       set_use_is_fpop (cpu, out_FRdoublek);
1617       if (out_FRdoublek < 63)
1618         set_use_is_fpop (cpu, out_FRdoublek + 1);
1619     }
1620   if (dual_FRdoublek >= 0)
1621     {
1622       set_use_is_fpop (cpu, dual_FRdoublek);
1623       if (dual_FRdoublek < 63)
1624         set_use_is_fpop (cpu, dual_FRdoublek + 1);
1625     }
1626
1627   return cycles;
1628 }
1629
1630 int
1631 frvbf_model_fr500_u_float_div (SIM_CPU *cpu, const IDESC *idesc,
1632                                int unit_num, int referenced,
1633                                INT in_FRi, INT in_FRj, INT out_FRk)
1634 {
1635   int cycles;
1636   FRV_VLIW *vliw;
1637   int slot;
1638   FRV_PROFILE_STATE *ps;
1639
1640   if (model_insn == FRV_INSN_MODEL_PASS_1)
1641     return 0;
1642
1643   cycles = idesc->timing->units[unit_num].done;
1644
1645   /* The post processing must wait if there is a dependency on a FR
1646      which is not ready yet.  */
1647   adjust_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, 1);
1648   ps = CPU_PROFILE_STATE (cpu);
1649   ps->post_wait = cycles;
1650   post_wait_for_FR (cpu, in_FRi);
1651   post_wait_for_FR (cpu, in_FRj);
1652   post_wait_for_FR (cpu, out_FRk);
1653   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1654     post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1655   vliw = CPU_VLIW (cpu);
1656   slot = vliw->next_slot - 1;
1657   slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1658   post_wait_for_fdiv (cpu, slot);
1659   restore_float_register_busy (cpu, in_FRi, in_FRj, out_FRk, 1);
1660
1661   /* The latency of FRk will be at least the latency of the other inputs.  */
1662   /* Once initiated, post-processing will take 10 cycles.  */
1663   update_FR_latency (cpu, out_FRk, ps->post_wait);
1664   update_FR_ptime (cpu, out_FRk, 10);
1665
1666   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1667     {
1668       /* FNER has a latency of 10 cycles.  */
1669       update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1670       update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 10);
1671     }
1672
1673   /* The latency of the fdiv unit will be at least the latency of the other
1674      inputs.  Once initiated, post-processing will take 9 cycles.  */
1675   update_fdiv_resource_latency (cpu, slot, ps->post_wait + 9);
1676
1677   /* Mark this use of the register as a floating point op.  */
1678   set_use_is_fpop (cpu, out_FRk);
1679
1680   return cycles;
1681 }
1682
1683 int
1684 frvbf_model_fr500_u_float_sqrt (SIM_CPU *cpu, const IDESC *idesc,
1685                                 int unit_num, int referenced,
1686                                 INT in_FRj, INT in_FRdoublej,
1687                                 INT out_FRk, INT out_FRdoublek)
1688 {
1689   int cycles;
1690   FRV_VLIW *vliw;
1691   int slot;
1692   FRV_PROFILE_STATE *ps;
1693
1694   if (model_insn == FRV_INSN_MODEL_PASS_1)
1695     return 0;
1696
1697   cycles = idesc->timing->units[unit_num].done;
1698
1699   /* The post processing must wait if there is a dependency on a FR
1700      which is not ready yet.  */
1701   adjust_float_register_busy (cpu, -1, in_FRj, out_FRk, 1);
1702   adjust_double_register_busy (cpu, -1, in_FRdoublej, out_FRdoublek, 1);
1703   ps = CPU_PROFILE_STATE (cpu);
1704   ps->post_wait = cycles;
1705   post_wait_for_FR (cpu, in_FRj);
1706   post_wait_for_FR (cpu, out_FRk);
1707   post_wait_for_FRdouble (cpu, in_FRdoublej);
1708   post_wait_for_FRdouble (cpu, out_FRdoublek);
1709   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1710     post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1711   vliw = CPU_VLIW (cpu);
1712   slot = vliw->next_slot - 1;
1713   slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1714   post_wait_for_fsqrt (cpu, slot);
1715   restore_float_register_busy (cpu, -1, in_FRj, out_FRk, 1);
1716   restore_double_register_busy (cpu, -1, in_FRdoublej, out_FRdoublek, 1);
1717
1718   /* The latency of FRk will be at least the latency of the other inputs.  */
1719   update_FR_latency (cpu, out_FRk, ps->post_wait);
1720   update_FRdouble_latency (cpu, out_FRdoublek, ps->post_wait);
1721   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1722     update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1723
1724   /* Once initiated, post-processing will take 15 cycles.  */
1725   update_FR_ptime (cpu, out_FRk, 15);
1726   update_FRdouble_ptime (cpu, out_FRdoublek, 15);
1727
1728   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1729     update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 15);
1730
1731   /* The latency of the sqrt unit will be the latency of the other
1732      inputs plus 14 cycles.  */
1733   update_fsqrt_resource_latency (cpu, slot, ps->post_wait + 14);
1734
1735   /* Mark this use of the register as a floating point op.  */
1736   if (out_FRk >= 0)
1737     set_use_is_fpop (cpu, out_FRk);
1738   if (out_FRdoublek >= 0)
1739     {
1740       set_use_is_fpop (cpu, out_FRdoublek);
1741       if (out_FRdoublek < 63)
1742         set_use_is_fpop (cpu, out_FRdoublek + 1);
1743     }
1744
1745   return cycles;
1746 }
1747
1748 int
1749 frvbf_model_fr500_u_float_dual_sqrt (SIM_CPU *cpu, const IDESC *idesc,
1750                                      int unit_num, int referenced,
1751                                      INT in_FRj, INT out_FRk)
1752 {
1753   int cycles;
1754   FRV_VLIW *vliw;
1755   int slot;
1756   INT dual_FRj;
1757   INT dual_FRk;
1758   FRV_PROFILE_STATE *ps;
1759
1760   if (model_insn == FRV_INSN_MODEL_PASS_1)
1761     return 0;
1762
1763   cycles = idesc->timing->units[unit_num].done;
1764
1765   /* The post processing must wait if there is a dependency on a FR
1766      which is not ready yet.  */
1767   dual_FRj = DUAL_REG (in_FRj);
1768   dual_FRk = DUAL_REG (out_FRk);
1769   adjust_float_register_busy (cpu, -1, in_FRj, out_FRk, 1);
1770   adjust_float_register_busy (cpu, -1, dual_FRj, dual_FRk, 1);
1771   ps = CPU_PROFILE_STATE (cpu);
1772   ps->post_wait = cycles;
1773   post_wait_for_FR (cpu, in_FRj);
1774   post_wait_for_FR (cpu, out_FRk);
1775   post_wait_for_FR (cpu, dual_FRj);
1776   post_wait_for_FR (cpu, dual_FRk);
1777
1778   vliw = CPU_VLIW (cpu);
1779   slot = vliw->next_slot - 1;
1780   slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1781   post_wait_for_fsqrt (cpu, slot);
1782   restore_float_register_busy (cpu, -1, in_FRj, out_FRk, 1);
1783   restore_float_register_busy (cpu, -1, dual_FRj, dual_FRk, 1);
1784
1785   /* The latency of FRk will be at least the latency of the other inputs.  */
1786   update_FR_latency (cpu, out_FRk, ps->post_wait);
1787   update_FR_latency (cpu, dual_FRk, ps->post_wait);
1788
1789   /* Once initiated, post-processing will take 15 cycles.  */
1790   update_FR_ptime (cpu, out_FRk, 15);
1791   update_FR_ptime (cpu, dual_FRk, 15);
1792
1793   /* The latency of the sqrt unit will be at least the latency of the other
1794      inputs.  */
1795   update_fsqrt_resource_latency (cpu, slot, ps->post_wait + 14);
1796
1797   /* Mark this use of the register as a floating point op.  */
1798   if (out_FRk >= 0)
1799     set_use_is_fpop (cpu, out_FRk);
1800   if (dual_FRk >= 0)
1801     set_use_is_fpop (cpu, dual_FRk);
1802
1803   return cycles;
1804 }
1805
1806 int
1807 frvbf_model_fr500_u_float_compare (SIM_CPU *cpu, const IDESC *idesc,
1808                                    int unit_num, int referenced,
1809                                    INT in_FRi, INT in_FRj,
1810                                    INT in_FRdoublei, INT in_FRdoublej,
1811                                    INT out_FCCi_2)
1812 {
1813   int cycles;
1814   FRV_PROFILE_STATE *ps;
1815
1816   if (model_insn == FRV_INSN_MODEL_PASS_1)
1817     return 0;
1818
1819   /* The preprocessing can execute right away.  */
1820   cycles = idesc->timing->units[unit_num].done;
1821
1822   /* The post processing must wait if there is a dependency on a FR
1823      which is not ready yet.  */
1824   adjust_double_register_busy (cpu, in_FRdoublei, in_FRdoublej, -1, 1);
1825   ps = CPU_PROFILE_STATE (cpu);
1826   ps->post_wait = cycles;
1827   post_wait_for_FR (cpu, in_FRi);
1828   post_wait_for_FR (cpu, in_FRj);
1829   post_wait_for_FRdouble (cpu, in_FRdoublei);
1830   post_wait_for_FRdouble (cpu, in_FRdoublej);
1831   post_wait_for_CCR (cpu, out_FCCi_2);
1832   restore_double_register_busy (cpu, in_FRdoublei, in_FRdoublej, -1, 1);
1833
1834   /* The latency of FCCi_2 will be the latency of the other inputs plus 3
1835      cycles.  */
1836   update_CCR_latency (cpu, out_FCCi_2, ps->post_wait + 3);
1837
1838   return cycles;
1839 }
1840
1841 int
1842 frvbf_model_fr500_u_float_dual_compare (SIM_CPU *cpu, const IDESC *idesc,
1843                                         int unit_num, int referenced,
1844                                         INT in_FRi, INT in_FRj,
1845                                         INT out_FCCi_2)
1846 {
1847   int cycles;
1848   INT dual_FRi;
1849   INT dual_FRj;
1850   INT dual_FCCi_2;
1851   FRV_PROFILE_STATE *ps;
1852
1853   if (model_insn == FRV_INSN_MODEL_PASS_1)
1854     return 0;
1855
1856   /* The preprocessing can execute right away.  */
1857   cycles = idesc->timing->units[unit_num].done;
1858
1859   /* The post processing must wait if there is a dependency on a FR
1860      which is not ready yet.  */
1861   ps = CPU_PROFILE_STATE (cpu);
1862   ps->post_wait = cycles;
1863   dual_FRi = DUAL_REG (in_FRi);
1864   dual_FRj = DUAL_REG (in_FRj);
1865   dual_FCCi_2 = out_FCCi_2 + 1;
1866   adjust_float_register_busy (cpu, in_FRi, in_FRj, -1, 1);
1867   adjust_float_register_busy (cpu, dual_FRi, dual_FRj, -1, 1);
1868   post_wait_for_FR (cpu, in_FRi);
1869   post_wait_for_FR (cpu, in_FRj);
1870   post_wait_for_FR (cpu, dual_FRi);
1871   post_wait_for_FR (cpu, dual_FRj);
1872   post_wait_for_CCR (cpu, out_FCCi_2);
1873   post_wait_for_CCR (cpu, dual_FCCi_2);
1874   restore_float_register_busy (cpu, in_FRi, in_FRj, -1, 1);
1875   restore_float_register_busy (cpu, dual_FRi, dual_FRj, -1, 1);
1876
1877   /* The latency of FCCi_2 will be the latency of the other inputs plus 3
1878      cycles.  */
1879   update_CCR_latency (cpu, out_FCCi_2, ps->post_wait + 3);
1880   update_CCR_latency (cpu, dual_FCCi_2, ps->post_wait + 3);
1881
1882   return cycles;
1883 }
1884
1885 int
1886 frvbf_model_fr500_u_float_convert (SIM_CPU *cpu, const IDESC *idesc,
1887                                    int unit_num, int referenced,
1888                                    INT in_FRj, INT in_FRintj, INT in_FRdoublej,
1889                                    INT out_FRk, INT out_FRintk,
1890                                    INT out_FRdoublek)
1891 {
1892   int cycles;
1893   FRV_PROFILE_STATE *ps;
1894
1895   if (model_insn == FRV_INSN_MODEL_PASS_1)
1896     return 0;
1897
1898   /* The preprocessing can execute right away.  */
1899   cycles = idesc->timing->units[unit_num].done;
1900
1901   /* The post processing must wait if there is a dependency on a FR
1902      which is not ready yet.  */
1903   ps = CPU_PROFILE_STATE (cpu);
1904   ps->post_wait = cycles;
1905   adjust_float_register_busy (cpu, -1, in_FRj, out_FRk, 1);
1906   adjust_float_register_busy (cpu, -1, in_FRintj, out_FRintk, 1);
1907   adjust_double_register_busy (cpu, -1, in_FRdoublej, out_FRdoublek, 1);
1908   post_wait_for_FR (cpu, in_FRj);
1909   post_wait_for_FR (cpu, in_FRintj);
1910   post_wait_for_FRdouble (cpu, in_FRdoublej);
1911   post_wait_for_FR (cpu, out_FRk);
1912   post_wait_for_FR (cpu, out_FRintk);
1913   post_wait_for_FRdouble (cpu, out_FRdoublek);
1914   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1915     {
1916       post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1917       post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRintk));
1918       post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
1919     }
1920   restore_float_register_busy (cpu, -1, in_FRj, out_FRk, 1);
1921   restore_float_register_busy (cpu, -1, in_FRintj, out_FRintk, 1);
1922   restore_double_register_busy (cpu, -1, in_FRdoublej, out_FRdoublek, 1);
1923
1924   /* The latency of FRk will be at least the latency of the other inputs.  */
1925   update_FR_latency (cpu, out_FRk, ps->post_wait);
1926   update_FR_latency (cpu, out_FRintk, ps->post_wait);
1927   update_FRdouble_latency (cpu, out_FRdoublek, ps->post_wait);
1928
1929   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1930     {
1931       update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1932       update_SPR_latency (cpu, FNER_FOR_FR (out_FRintk), ps->post_wait);
1933       update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), ps->post_wait);
1934     }
1935
1936   /* Once initiated, post-processing will take 3 cycles.  */
1937   update_FR_ptime (cpu, out_FRk, 3);
1938   update_FR_ptime (cpu, out_FRintk, 3);
1939   update_FRdouble_ptime (cpu, out_FRdoublek, 3);
1940
1941   if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1942     {
1943       update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 3);
1944       update_SPR_ptime (cpu, FNER_FOR_FR (out_FRintk), 3);
1945       update_SPR_ptime (cpu, FNER_FOR_FR (out_FRdoublek), 3);
1946     }
1947
1948   /* Mark this use of the register as a floating point op.  */
1949   if (out_FRk >= 0)
1950     set_use_is_fpop (cpu, out_FRk);
1951   if (out_FRintk >= 0)
1952     set_use_is_fpop (cpu, out_FRintk);
1953   if (out_FRdoublek >= 0)
1954     {
1955       set_use_is_fpop (cpu, out_FRdoublek);
1956       set_use_is_fpop (cpu, out_FRdoublek + 1);
1957     }
1958
1959   return cycles;
1960 }
1961
1962 int
1963 frvbf_model_fr500_u_float_dual_convert (SIM_CPU *cpu, const IDESC *idesc,
1964                                         int unit_num, int referenced,
1965                                         INT in_FRj, INT in_FRintj,
1966                                         INT out_FRk, INT out_FRintk)
1967 {
1968   int cycles;
1969   INT dual_FRj;
1970   INT dual_FRintj;
1971   INT dual_FRk;
1972   INT dual_FRintk;
1973   FRV_PROFILE_STATE *ps;
1974
1975   if (model_insn == FRV_INSN_MODEL_PASS_1)
1976     return 0;
1977
1978   /* The preprocessing can execute right away.  */
1979   cycles = idesc->timing->units[unit_num].done;
1980
1981   /* The post processing must wait if there is a dependency on a FR
1982      which is not ready yet.  */
1983   ps = CPU_PROFILE_STATE (cpu);
1984   ps->post_wait = cycles;
1985   dual_FRj = DUAL_REG (in_FRj);
1986   dual_FRintj = DUAL_REG (in_FRintj);
1987   dual_FRk = DUAL_REG (out_FRk);
1988   dual_FRintk = DUAL_REG (out_FRintk);
1989   adjust_float_register_busy (cpu, -1, in_FRj, out_FRk, 1);
1990   adjust_float_register_busy (cpu, -1, dual_FRj, dual_FRk, 1);
1991   adjust_float_register_busy (cpu, -1, in_FRintj, out_FRintk, 1);
1992   adjust_float_register_busy (cpu, -1, dual_FRintj, dual_FRintk, 1);
1993   post_wait_for_FR (cpu, in_FRj);
1994   post_wait_for_FR (cpu, in_FRintj);
1995   post_wait_for_FR (cpu, out_FRk);
1996   post_wait_for_FR (cpu, out_FRintk);
1997   post_wait_for_FR (cpu, dual_FRj);
1998   post_wait_for_FR (cpu, dual_FRintj);
1999   post_wait_for_FR (cpu, dual_FRk);
2000   post_wait_for_FR (cpu, dual_FRintk);
2001   restore_float_register_busy (cpu, -1, in_FRj, out_FRk, 1);
2002   restore_float_register_busy (cpu, -1, dual_FRj, dual_FRk, 1);
2003   restore_float_register_busy (cpu, -1, in_FRintj, out_FRintk, 1);
2004   restore_float_register_busy (cpu, -1, dual_FRintj, dual_FRintk, 1);
2005
2006   /* The latency of FRk will be at least the latency of the other inputs.  */
2007   update_FR_latency (cpu, out_FRk, ps->post_wait);
2008   update_FR_latency (cpu, out_FRintk, ps->post_wait);
2009   update_FR_latency (cpu, dual_FRk, ps->post_wait);
2010   update_FR_latency (cpu, dual_FRintk, ps->post_wait);
2011
2012   /* Once initiated, post-processing will take 3 cycles.  */
2013   update_FR_ptime (cpu, out_FRk, 3);
2014   update_FR_ptime (cpu, out_FRintk, 3);
2015   update_FR_ptime (cpu, dual_FRk, 3);
2016   update_FR_ptime (cpu, dual_FRintk, 3);
2017
2018   /* Mark this use of the register as a floating point op.  */
2019   if (out_FRk >= 0)
2020     set_use_is_fpop (cpu, out_FRk);
2021   if (out_FRintk >= 0)
2022     set_use_is_fpop (cpu, out_FRintk);
2023
2024   return cycles;
2025 }
2026
2027 int
2028 frvbf_model_fr500_u_media (SIM_CPU *cpu, const IDESC *idesc,
2029                            int unit_num, int referenced,
2030                            INT in_FRi, INT in_FRj, INT in_ACC40Si, INT in_ACCGi,
2031                            INT out_FRk,
2032                            INT out_ACC40Sk, INT out_ACC40Uk, INT out_ACCGk)
2033 {
2034   int cycles;
2035   FRV_PROFILE_STATE *ps;
2036   const CGEN_INSN *insn;
2037   int is_media_s1;
2038   int is_media_s2;
2039   int busy_adjustment[] = {0, 0, 0};
2040   int *fr;
2041   int *acc;
2042
2043   if (model_insn == FRV_INSN_MODEL_PASS_1)
2044     return 0;
2045
2046   /* The preprocessing can execute right away.  */
2047   cycles = idesc->timing->units[unit_num].done;
2048
2049   ps = CPU_PROFILE_STATE (cpu);
2050   insn = idesc->idata;
2051
2052   /* If the previous use of the registers was a media op,
2053      then their latency will be less than previously recorded.
2054      See Table 13-13 in the LSI.  */
2055   if (in_FRi >= 0)
2056     {
2057       if (use_is_media (cpu, in_FRi))
2058         {
2059           busy_adjustment[0] = 2;
2060           decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
2061         }
2062       else
2063         enforce_full_fr_latency (cpu, in_FRi);
2064     }
2065   if (in_FRj >= 0 && in_FRj != in_FRi)
2066     {
2067       if (use_is_media (cpu, in_FRj))
2068         {
2069           busy_adjustment[1] = 2;
2070           decrease_FR_busy (cpu, in_FRj, busy_adjustment[1]);
2071         }
2072       else
2073         enforce_full_fr_latency (cpu, in_FRj);
2074     }
2075   if (out_FRk >= 0 && out_FRk != in_FRi && out_FRk != in_FRj)
2076     {
2077       if (use_is_media (cpu, out_FRk))
2078         {
2079           busy_adjustment[2] = 2;
2080           decrease_FR_busy (cpu, out_FRk, busy_adjustment[2]);
2081         }
2082       else
2083         enforce_full_fr_latency (cpu, out_FRk);
2084     }
2085
2086   /* The post processing must wait if there is a dependency on a FR
2087      which is not ready yet.  */
2088   ps->post_wait = cycles;
2089   post_wait_for_FR (cpu, in_FRi);
2090   post_wait_for_FR (cpu, in_FRj);
2091   post_wait_for_FR (cpu, out_FRk);
2092   post_wait_for_ACC (cpu, in_ACC40Si);
2093   post_wait_for_ACC (cpu, in_ACCGi);
2094   post_wait_for_ACC (cpu, out_ACC40Sk);
2095   post_wait_for_ACC (cpu, out_ACC40Uk);
2096   post_wait_for_ACC (cpu, out_ACCGk);
2097
2098   /* Restore the busy cycles of the registers we used.  */
2099   fr = ps->fr_busy;
2100   if (in_FRi >= 0)
2101     fr[in_FRi] += busy_adjustment[0];
2102   if (in_FRj >= 0)
2103     fr[in_FRj] += busy_adjustment[1];
2104   if (out_FRk >= 0)
2105     fr[out_FRk] += busy_adjustment[2];
2106
2107   /* The latency of tht output register will be at least the latency of the
2108      other inputs.  Once initiated, post-processing will take 3 cycles.  */
2109   if (out_FRk >= 0)
2110     {
2111       update_FR_latency (cpu, out_FRk, ps->post_wait);
2112       update_FR_ptime (cpu, out_FRk, 3);
2113       /* Mark this use of the register as a media op.  */
2114       set_use_is_media (cpu, out_FRk);
2115     }
2116   /* The latency of tht output accumulator will be at least the latency of the
2117      other inputs.  Once initiated, post-processing will take 1 cycle.  */
2118   if (out_ACC40Sk >= 0)
2119     update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2120   if (out_ACC40Uk >= 0)
2121     update_ACC_latency (cpu, out_ACC40Uk, ps->post_wait + 1);
2122   if (out_ACCGk >= 0)
2123     update_ACC_latency (cpu, out_ACCGk, ps->post_wait + 1);
2124
2125   return cycles;
2126 }
2127
2128 int
2129 frvbf_model_fr500_u_media_quad_arith (SIM_CPU *cpu, const IDESC *idesc,
2130                                        int unit_num, int referenced,
2131                                        INT in_FRi, INT in_FRj,
2132                                        INT out_FRk)
2133 {
2134   int cycles;
2135   INT dual_FRi;
2136   INT dual_FRj;
2137   INT dual_FRk;
2138   FRV_PROFILE_STATE *ps;
2139   int busy_adjustment[] = {0, 0, 0, 0, 0, 0};
2140   int *fr;
2141
2142   if (model_insn == FRV_INSN_MODEL_PASS_1)
2143     return 0;
2144
2145   /* The preprocessing can execute right away.  */
2146   cycles = idesc->timing->units[unit_num].done;
2147
2148   ps = CPU_PROFILE_STATE (cpu);
2149   dual_FRi = DUAL_REG (in_FRi);
2150   dual_FRj = DUAL_REG (in_FRj);
2151   dual_FRk = DUAL_REG (out_FRk);
2152
2153   /* If the previous use of the registers was a media op,
2154      then their latency will be less than previously recorded.
2155      See Table 13-13 in the LSI.  */
2156   if (use_is_media (cpu, in_FRi))
2157     {
2158       busy_adjustment[0] = 2;
2159       decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
2160     }
2161   else
2162     enforce_full_fr_latency (cpu, in_FRi);
2163   if (dual_FRi >= 0 && use_is_media (cpu, dual_FRi))
2164     {
2165       busy_adjustment[1] = 2;
2166       decrease_FR_busy (cpu, dual_FRi, busy_adjustment[1]);
2167     }
2168   else
2169     enforce_full_fr_latency (cpu, dual_FRi);
2170   if (in_FRj != in_FRi)
2171     {
2172       if (use_is_media (cpu, in_FRj))
2173         {
2174           busy_adjustment[2] = 2;
2175           decrease_FR_busy (cpu, in_FRj, busy_adjustment[2]);
2176         }
2177       else
2178         enforce_full_fr_latency (cpu, in_FRj);
2179       if (dual_FRj >= 0 && use_is_media (cpu, dual_FRj))
2180         {
2181           busy_adjustment[3] = 2;
2182           decrease_FR_busy (cpu, dual_FRj, busy_adjustment[3]);
2183         }
2184       else
2185         enforce_full_fr_latency (cpu, dual_FRj + 1);
2186     }
2187   if (out_FRk != in_FRi && out_FRk != in_FRj)
2188     {
2189       if (use_is_media (cpu, out_FRk))
2190         {
2191           busy_adjustment[4] = 2;
2192           decrease_FR_busy (cpu, out_FRk, busy_adjustment[4]);
2193         }
2194       else
2195         enforce_full_fr_latency (cpu, out_FRk);
2196       if (dual_FRk >= 0 && use_is_media (cpu, dual_FRk))
2197         {
2198           busy_adjustment[5] = 2;
2199           decrease_FR_busy (cpu, dual_FRk, busy_adjustment[5]);
2200         }
2201       else
2202         enforce_full_fr_latency (cpu, dual_FRk);
2203     }
2204
2205   /* The post processing must wait if there is a dependency on a FR
2206      which is not ready yet.  */
2207   ps->post_wait = cycles;
2208   post_wait_for_FR (cpu, in_FRi);
2209   post_wait_for_FR (cpu, dual_FRi);
2210   post_wait_for_FR (cpu, in_FRj);
2211   post_wait_for_FR (cpu, dual_FRj);
2212   post_wait_for_FR (cpu, out_FRk);
2213   post_wait_for_FR (cpu, dual_FRk);
2214
2215   /* Restore the busy cycles of the registers we used.  */
2216   fr = ps->fr_busy;
2217   fr[in_FRi] += busy_adjustment[0];
2218   if (dual_FRi >= 0)
2219     fr[dual_FRi] += busy_adjustment[1];
2220   fr[in_FRj] += busy_adjustment[2];
2221   if (dual_FRj >= 0)
2222     fr[dual_FRj] += busy_adjustment[3];
2223   fr[out_FRk] += busy_adjustment[4];
2224   if (dual_FRk >= 0)
2225     fr[dual_FRk] += busy_adjustment[5];
2226
2227   /* The latency of tht output register will be at least the latency of the
2228      other inputs.  */
2229   update_FR_latency (cpu, out_FRk, ps->post_wait);
2230
2231   /* Once initiated, post-processing will take 3 cycles.  */
2232   update_FR_ptime (cpu, out_FRk, 3);
2233
2234   /* Mark this use of the register as a media op.  */
2235   set_use_is_media (cpu, out_FRk);
2236   if (dual_FRk >= 0)
2237     {
2238       update_FR_latency (cpu, dual_FRk, ps->post_wait);
2239       update_FR_ptime (cpu, dual_FRk, 3);
2240       /* Mark this use of the register as a media op.  */
2241       set_use_is_media (cpu, dual_FRk);
2242     }
2243
2244   return cycles;
2245 }
2246
2247 int
2248 frvbf_model_fr500_u_media_dual_mul (SIM_CPU *cpu, const IDESC *idesc,
2249                                     int unit_num, int referenced,
2250                                     INT in_FRi, INT in_FRj,
2251                                     INT out_ACC40Sk, INT out_ACC40Uk)
2252 {
2253   int cycles;
2254   INT dual_ACC40Sk;
2255   INT dual_ACC40Uk;
2256   FRV_PROFILE_STATE *ps;
2257   int busy_adjustment[] = {0, 0, 0, 0, 0, 0};
2258   int *fr;
2259   int *acc;
2260
2261   if (model_insn == FRV_INSN_MODEL_PASS_1)
2262     return 0;
2263
2264   /* The preprocessing can execute right away.  */
2265   cycles = idesc->timing->units[unit_num].done;
2266
2267   ps = CPU_PROFILE_STATE (cpu);
2268   dual_ACC40Sk = DUAL_REG (out_ACC40Sk);
2269   dual_ACC40Uk = DUAL_REG (out_ACC40Uk);
2270
2271   /* If the previous use of the registers was a media op,
2272      then their latency will be less than previously recorded.
2273      See Table 13-13 in the LSI.  */
2274   if (use_is_media (cpu, in_FRi))
2275     {
2276       busy_adjustment[0] = 2;
2277       decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
2278     }
2279   else
2280     enforce_full_fr_latency (cpu, in_FRi);
2281   if (in_FRj != in_FRi)
2282     {
2283       if (use_is_media (cpu, in_FRj))
2284         {
2285           busy_adjustment[1] = 2;
2286           decrease_FR_busy (cpu, in_FRj, busy_adjustment[1]);
2287         }
2288       else
2289         enforce_full_fr_latency (cpu, in_FRj);
2290     }
2291   if (out_ACC40Sk >= 0)
2292     {
2293       busy_adjustment[2] = 1;
2294       decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[2]);
2295     }
2296   if (dual_ACC40Sk >= 0)
2297     {
2298       busy_adjustment[3] = 1;
2299       decrease_ACC_busy (cpu, dual_ACC40Sk, busy_adjustment[3]);
2300     }
2301   if (out_ACC40Uk >= 0)
2302     {
2303       busy_adjustment[4] = 1;
2304       decrease_ACC_busy (cpu, out_ACC40Uk, busy_adjustment[4]);
2305     }
2306   if (dual_ACC40Uk >= 0)
2307     {
2308       busy_adjustment[5] = 1;
2309       decrease_ACC_busy (cpu, dual_ACC40Uk, busy_adjustment[5]);
2310     }
2311
2312   /* The post processing must wait if there is a dependency on a FR
2313      which is not ready yet.  */
2314   ps->post_wait = cycles;
2315   post_wait_for_FR (cpu, in_FRi);
2316   post_wait_for_FR (cpu, in_FRj);
2317   post_wait_for_ACC (cpu, out_ACC40Sk);
2318   post_wait_for_ACC (cpu, dual_ACC40Sk);
2319   post_wait_for_ACC (cpu, out_ACC40Uk);
2320   post_wait_for_ACC (cpu, dual_ACC40Uk);
2321
2322   /* Restore the busy cycles of the registers we used.  */
2323   fr = ps->fr_busy;
2324   acc = ps->acc_busy;
2325   fr[in_FRi] += busy_adjustment[0];
2326   fr[in_FRj] += busy_adjustment[1];
2327   if (out_ACC40Sk >= 0)
2328     acc[out_ACC40Sk] += busy_adjustment[2];
2329   if (dual_ACC40Sk >= 0)
2330     acc[dual_ACC40Sk] += busy_adjustment[3];
2331   if (out_ACC40Uk >= 0)
2332     acc[out_ACC40Uk] += busy_adjustment[4];
2333   if (dual_ACC40Uk >= 0)
2334     acc[dual_ACC40Uk] += busy_adjustment[5];
2335
2336   /* The latency of tht output register will be at least the latency of the
2337      other inputs.  Once initiated, post-processing will take 1 cycle.  */
2338   if (out_ACC40Sk >= 0)
2339     update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2340   if (dual_ACC40Sk >= 0)
2341     update_ACC_latency (cpu, dual_ACC40Sk, ps->post_wait + 1);
2342   if (out_ACC40Uk >= 0)
2343     update_ACC_latency (cpu, out_ACC40Uk, ps->post_wait + 1);
2344   if (dual_ACC40Uk >= 0)
2345     update_ACC_latency (cpu, dual_ACC40Uk, ps->post_wait + 1);
2346
2347   return cycles;
2348 }
2349
2350 int
2351 frvbf_model_fr500_u_media_quad_mul (SIM_CPU *cpu, const IDESC *idesc,
2352                                     int unit_num, int referenced,
2353                                     INT in_FRi, INT in_FRj,
2354                                     INT out_ACC40Sk, INT out_ACC40Uk)
2355 {
2356   int cycles;
2357   INT FRi_1;
2358   INT FRj_1;
2359   INT ACC40Sk_1;
2360   INT ACC40Sk_2;
2361   INT ACC40Sk_3;
2362   INT ACC40Uk_1;
2363   INT ACC40Uk_2;
2364   INT ACC40Uk_3;
2365   FRV_PROFILE_STATE *ps;
2366   int busy_adjustment[] = {0, 0, 0, 0, 0, 0, 0 ,0};
2367   int *fr;
2368   int *acc;
2369
2370   if (model_insn == FRV_INSN_MODEL_PASS_1)
2371     return 0;
2372
2373   /* The preprocessing can execute right away.  */
2374   cycles = idesc->timing->units[unit_num].done;
2375
2376   FRi_1 = DUAL_REG (in_FRi);
2377   FRj_1 = DUAL_REG (in_FRj);
2378   ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
2379   ACC40Sk_2 = DUAL_REG (ACC40Sk_1);
2380   ACC40Sk_3 = DUAL_REG (ACC40Sk_2);
2381   ACC40Uk_1 = DUAL_REG (out_ACC40Uk);
2382   ACC40Uk_2 = DUAL_REG (ACC40Uk_1);
2383   ACC40Uk_3 = DUAL_REG (ACC40Uk_2);
2384
2385   /* If the previous use of the registers was a media op,
2386      then their latency will be less than previously recorded.
2387      See Table 13-13 in the LSI.  */
2388   ps = CPU_PROFILE_STATE (cpu);
2389   if (use_is_media (cpu, in_FRi))
2390     {
2391       busy_adjustment[0] = 2;
2392       decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
2393     }
2394   else
2395     enforce_full_fr_latency (cpu, in_FRi);
2396   if (FRi_1 >= 0)
2397     {
2398       if (use_is_media (cpu, FRi_1))
2399         {
2400           busy_adjustment[1] = 2;
2401           decrease_FR_busy (cpu, FRi_1, busy_adjustment[1]);
2402         }
2403       else
2404         enforce_full_fr_latency (cpu, FRi_1);
2405     }
2406   if (in_FRj != in_FRi)
2407     {
2408       if (use_is_media (cpu, in_FRj))
2409         {
2410           busy_adjustment[2] = 2;
2411           decrease_FR_busy (cpu, in_FRj, busy_adjustment[2]);
2412         }
2413       else
2414         enforce_full_fr_latency (cpu, in_FRj);
2415       if (FRj_1 >= 0)
2416         {
2417           if (use_is_media (cpu, FRj_1))
2418             {
2419               busy_adjustment[3] = 2;
2420               decrease_FR_busy (cpu, FRj_1, busy_adjustment[3]);
2421             }
2422           else
2423             enforce_full_fr_latency (cpu, FRj_1);
2424         }
2425     }
2426   if (out_ACC40Sk >= 0)
2427     {
2428       busy_adjustment[4] = 1;
2429       decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[4]);
2430
2431       if (ACC40Sk_1 >= 0)
2432         {
2433           busy_adjustment[5] = 1;
2434           decrease_ACC_busy (cpu, ACC40Sk_1, busy_adjustment[5]);
2435         }
2436       if (ACC40Sk_2 >= 0)
2437         {
2438           busy_adjustment[6] = 1;
2439           decrease_ACC_busy (cpu, ACC40Sk_2, busy_adjustment[6]);
2440         }
2441       if (ACC40Sk_3 >= 0)
2442         {
2443           busy_adjustment[7] = 1;
2444           decrease_ACC_busy (cpu, ACC40Sk_3, busy_adjustment[7]);
2445         }
2446     }
2447   else if (out_ACC40Uk >= 0)
2448     {
2449       busy_adjustment[4] = 1;
2450       decrease_ACC_busy (cpu, out_ACC40Uk, busy_adjustment[4]);
2451
2452       if (ACC40Uk_1 >= 0)
2453         {
2454           busy_adjustment[5] = 1;
2455           decrease_ACC_busy (cpu, ACC40Uk_1, busy_adjustment[5]);
2456         }
2457       if (ACC40Uk_2 >= 0)
2458         {
2459           busy_adjustment[6] = 1;
2460           decrease_ACC_busy (cpu, ACC40Uk_2, busy_adjustment[6]);
2461         }
2462       if (ACC40Uk_3 >= 0)
2463         {
2464           busy_adjustment[7] = 1;
2465           decrease_ACC_busy (cpu, ACC40Uk_3, busy_adjustment[7]);
2466         }
2467     }
2468
2469   /* The post processing must wait if there is a dependency on a FR
2470      which is not ready yet.  */
2471   ps->post_wait = cycles;
2472   post_wait_for_FR (cpu, in_FRi);
2473   post_wait_for_FR (cpu, FRi_1);
2474   post_wait_for_FR (cpu, in_FRj);
2475   post_wait_for_FR (cpu, FRj_1);
2476   post_wait_for_ACC (cpu, out_ACC40Sk);
2477   post_wait_for_ACC (cpu, ACC40Sk_1);
2478   post_wait_for_ACC (cpu, ACC40Sk_2);
2479   post_wait_for_ACC (cpu, ACC40Sk_3);
2480   post_wait_for_ACC (cpu, out_ACC40Uk);
2481   post_wait_for_ACC (cpu, ACC40Uk_1);
2482   post_wait_for_ACC (cpu, ACC40Uk_2);
2483   post_wait_for_ACC (cpu, ACC40Uk_3);
2484
2485   /* Restore the busy cycles of the registers we used.  */
2486   fr = ps->fr_busy;
2487   acc = ps->acc_busy;
2488   fr[in_FRi] += busy_adjustment[0];
2489   if (FRi_1 >= 0)
2490     fr[FRi_1] += busy_adjustment[1];
2491   fr[in_FRj] += busy_adjustment[2];
2492   if (FRj_1 > 0)
2493     fr[FRj_1] += busy_adjustment[3];
2494   if (out_ACC40Sk >= 0)
2495     {
2496       acc[out_ACC40Sk] += busy_adjustment[4];
2497       if (ACC40Sk_1 >= 0)
2498         acc[ACC40Sk_1] += busy_adjustment[5];
2499       if (ACC40Sk_2 >= 0)
2500         acc[ACC40Sk_2] += busy_adjustment[6];
2501       if (ACC40Sk_3 >= 0)
2502         acc[ACC40Sk_3] += busy_adjustment[7];
2503     }
2504   else if (out_ACC40Uk >= 0)
2505     {
2506       acc[out_ACC40Uk] += busy_adjustment[4];
2507       if (ACC40Uk_1 >= 0)
2508         acc[ACC40Uk_1] += busy_adjustment[5];
2509       if (ACC40Uk_2 >= 0)
2510         acc[ACC40Uk_2] += busy_adjustment[6];
2511       if (ACC40Uk_3 >= 0)
2512         acc[ACC40Uk_3] += busy_adjustment[7];
2513     }
2514
2515   /* The latency of tht output register will be at least the latency of the
2516      other inputs.  Once initiated, post-processing will take 1 cycle.  */
2517   if (out_ACC40Sk >= 0)
2518     {
2519       update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2520       if (ACC40Sk_1 >= 0)
2521         update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
2522       if (ACC40Sk_2 >= 0)
2523         update_ACC_latency (cpu, ACC40Sk_2, ps->post_wait + 1);
2524       if (ACC40Sk_3 >= 0)
2525         update_ACC_latency (cpu, ACC40Sk_3, ps->post_wait + 1);
2526     }
2527   else if (out_ACC40Uk >= 0)
2528     {
2529       update_ACC_latency (cpu, out_ACC40Uk, ps->post_wait + 1);
2530       if (ACC40Uk_1 >= 0)
2531         update_ACC_latency (cpu, ACC40Uk_1, ps->post_wait + 1);
2532       if (ACC40Uk_2 >= 0)
2533         update_ACC_latency (cpu, ACC40Uk_2, ps->post_wait + 1);
2534       if (ACC40Uk_3 >= 0)
2535         update_ACC_latency (cpu, ACC40Uk_3, ps->post_wait + 1);
2536     }
2537
2538   return cycles;
2539 }
2540
2541 int
2542 frvbf_model_fr500_u_media_quad_complex (SIM_CPU *cpu, const IDESC *idesc,
2543                                         int unit_num, int referenced,
2544                                         INT in_FRi, INT in_FRj,
2545                                         INT out_ACC40Sk)
2546 {
2547   int cycles;
2548   INT FRi_1;
2549   INT FRj_1;
2550   INT ACC40Sk_1;
2551   FRV_PROFILE_STATE *ps;
2552   int busy_adjustment[] = {0, 0, 0, 0, 0, 0};
2553   int *fr;
2554   int *acc;
2555
2556   if (model_insn == FRV_INSN_MODEL_PASS_1)
2557     return 0;
2558
2559   /* The preprocessing can execute right away.  */
2560   cycles = idesc->timing->units[unit_num].done;
2561
2562   FRi_1 = DUAL_REG (in_FRi);
2563   FRj_1 = DUAL_REG (in_FRj);
2564   ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
2565
2566   /* If the previous use of the registers was a media op,
2567      then their latency will be less than previously recorded.
2568      See Table 13-13 in the LSI.  */
2569   ps = CPU_PROFILE_STATE (cpu);
2570   if (use_is_media (cpu, in_FRi))
2571     {
2572       busy_adjustment[0] = 2;
2573       decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
2574     }
2575   else
2576     enforce_full_fr_latency (cpu, in_FRi);
2577   if (FRi_1 >= 0)
2578     {
2579       if (use_is_media (cpu, FRi_1))
2580         {
2581           busy_adjustment[1] = 2;
2582           decrease_FR_busy (cpu, FRi_1, busy_adjustment[1]);
2583         }
2584       else
2585         enforce_full_fr_latency (cpu, FRi_1);
2586     }
2587   if (in_FRj != in_FRi)
2588     {
2589       if (use_is_media (cpu, in_FRj))
2590         {
2591           busy_adjustment[2] = 2;
2592           decrease_FR_busy (cpu, in_FRj, busy_adjustment[2]);
2593         }
2594       else
2595         enforce_full_fr_latency (cpu, in_FRj);
2596       if (FRj_1 >= 0)
2597         {
2598           if (use_is_media (cpu, FRj_1))
2599             {
2600               busy_adjustment[3] = 2;
2601               decrease_FR_busy (cpu, FRj_1, busy_adjustment[3]);
2602             }
2603           else
2604             enforce_full_fr_latency (cpu, FRj_1);
2605         }
2606     }
2607   if (out_ACC40Sk >= 0)
2608     {
2609       busy_adjustment[4] = 1;
2610       decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[4]);
2611
2612       if (ACC40Sk_1 >= 0)
2613         {
2614           busy_adjustment[5] = 1;
2615           decrease_ACC_busy (cpu, ACC40Sk_1, busy_adjustment[5]);
2616         }
2617     }
2618
2619   /* The post processing must wait if there is a dependency on a FR
2620      which is not ready yet.  */
2621   ps->post_wait = cycles;
2622   post_wait_for_FR (cpu, in_FRi);
2623   post_wait_for_FR (cpu, FRi_1);
2624   post_wait_for_FR (cpu, in_FRj);
2625   post_wait_for_FR (cpu, FRj_1);
2626   post_wait_for_ACC (cpu, out_ACC40Sk);
2627   post_wait_for_ACC (cpu, ACC40Sk_1);
2628
2629   /* Restore the busy cycles of the registers we used.  */
2630   fr = ps->fr_busy;
2631   acc = ps->acc_busy;
2632   fr[in_FRi] += busy_adjustment[0];
2633   if (FRi_1 >= 0)
2634     fr[FRi_1] += busy_adjustment[1];
2635   fr[in_FRj] += busy_adjustment[2];
2636   if (FRj_1 > 0)
2637     fr[FRj_1] += busy_adjustment[3];
2638   if (out_ACC40Sk >= 0)
2639     {
2640       acc[out_ACC40Sk] += busy_adjustment[4];
2641       if (ACC40Sk_1 >= 0)
2642         acc[ACC40Sk_1] += busy_adjustment[5];
2643     }
2644
2645   /* The latency of tht output register will be at least the latency of the
2646      other inputs.  Once initiated, post-processing will take 1 cycle.  */
2647   if (out_ACC40Sk >= 0)
2648     {
2649       update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2650       if (ACC40Sk_1 >= 0)
2651         update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
2652     }
2653
2654   return cycles;
2655 }
2656
2657 int
2658 frvbf_model_fr500_u_media_dual_expand (SIM_CPU *cpu, const IDESC *idesc,
2659                                        int unit_num, int referenced,
2660                                        INT in_FRi,
2661                                        INT out_FRk)
2662 {
2663   int cycles;
2664   INT dual_FRk;
2665   FRV_PROFILE_STATE *ps;
2666   int busy_adjustment[] = {0, 0, 0};
2667   int *fr;
2668
2669   if (model_insn == FRV_INSN_MODEL_PASS_1)
2670     return 0;
2671
2672   /* The preprocessing can execute right away.  */
2673   cycles = idesc->timing->units[unit_num].done;
2674
2675   /* If the previous use of the registers was a media op,
2676      then their latency will be less than previously recorded.
2677      See Table 13-13 in the LSI.  */
2678   dual_FRk = DUAL_REG (out_FRk);
2679   ps = CPU_PROFILE_STATE (cpu);
2680   if (use_is_media (cpu, in_FRi))
2681     {
2682       busy_adjustment[0] = 2;
2683       decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
2684     }
2685   else
2686     enforce_full_fr_latency (cpu, in_FRi);
2687   if (out_FRk != in_FRi)
2688     {
2689       if (use_is_media (cpu, out_FRk))
2690         {
2691           busy_adjustment[1] = 2;
2692           decrease_FR_busy (cpu, out_FRk, busy_adjustment[1]);
2693         }
2694       else
2695         enforce_full_fr_latency (cpu, out_FRk);
2696     }
2697   if (dual_FRk >= 0 && dual_FRk != in_FRi)
2698     {
2699       if (use_is_media (cpu, dual_FRk))
2700         {
2701           busy_adjustment[2] = 2;
2702           decrease_FR_busy (cpu, dual_FRk, busy_adjustment[2]);
2703         }
2704       else
2705         enforce_full_fr_latency (cpu, dual_FRk);
2706     }
2707
2708   /* The post processing must wait if there is a dependency on a FR
2709      which is not ready yet.  */
2710   ps->post_wait = cycles;
2711   post_wait_for_FR (cpu, in_FRi);
2712   post_wait_for_FR (cpu, out_FRk);
2713   post_wait_for_FR (cpu, dual_FRk);
2714
2715   /* Restore the busy cycles of the registers we used.  */
2716   fr = ps->fr_busy;
2717   fr[in_FRi] += busy_adjustment[0];
2718   fr[out_FRk] += busy_adjustment[1];
2719   if (dual_FRk >= 0)
2720     fr[dual_FRk] += busy_adjustment[2];
2721
2722   /* The latency of the output register will be at least the latency of the
2723      other inputs.  Once initiated, post-processing will take 3 cycles.  */
2724   update_FR_latency (cpu, out_FRk, ps->post_wait);
2725   update_FR_ptime (cpu, out_FRk, 3);
2726
2727   /* Mark this use of the register as a media op.  */
2728   set_use_is_media (cpu, out_FRk);
2729   if (dual_FRk >= 0)
2730     {
2731       update_FR_latency (cpu, dual_FRk, ps->post_wait);
2732       update_FR_ptime (cpu, dual_FRk, 3);
2733
2734       /* Mark this use of the register as a media op.  */
2735       set_use_is_media (cpu, dual_FRk);
2736     }
2737
2738   return cycles;
2739 }
2740
2741 int
2742 frvbf_model_fr500_u_media_dual_unpack (SIM_CPU *cpu, const IDESC *idesc,
2743                                        int unit_num, int referenced,
2744                                        INT in_FRi,
2745                                        INT out_FRk)
2746 {
2747   int cycles;
2748   INT FRi_1;
2749   INT FRk_1;
2750   INT FRk_2;
2751   INT FRk_3;
2752   FRV_PROFILE_STATE *ps;
2753   int busy_adjustment[] = {0, 0, 0, 0, 0, 0};
2754   int *fr;
2755
2756   if (model_insn == FRV_INSN_MODEL_PASS_1)
2757     return 0;
2758
2759   /* The preprocessing can execute right away.  */
2760   cycles = idesc->timing->units[unit_num].done;
2761
2762   FRi_1 = DUAL_REG (in_FRi);
2763   FRk_1 = DUAL_REG (out_FRk);
2764   FRk_2 = DUAL_REG (FRk_1);
2765   FRk_3 = DUAL_REG (FRk_2);
2766
2767   /* If the previous use of the registers was a media op,
2768      then their latency will be less than previously recorded.
2769      See Table 13-13 in the LSI.  */
2770   ps = CPU_PROFILE_STATE (cpu);
2771   if (use_is_media (cpu, in_FRi))
2772     {
2773       busy_adjustment[0] = 2;
2774       decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
2775     }
2776   else
2777     enforce_full_fr_latency (cpu, in_FRi);
2778   if (FRi_1 >= 0 && use_is_media (cpu, FRi_1))
2779     {
2780       busy_adjustment[1] = 2;
2781       decrease_FR_busy (cpu, FRi_1, busy_adjustment[1]);
2782     }
2783   else
2784     enforce_full_fr_latency (cpu, FRi_1);
2785   if (out_FRk != in_FRi)
2786     {
2787       if (use_is_media (cpu, out_FRk))
2788         {
2789           busy_adjustment[2] = 2;
2790           decrease_FR_busy (cpu, out_FRk, busy_adjustment[2]);
2791         }
2792       else
2793         enforce_full_fr_latency (cpu, out_FRk);
2794       if (FRk_1 >= 0 && FRk_1 != in_FRi)
2795         {
2796           if (use_is_media (cpu, FRk_1))
2797             {
2798               busy_adjustment[3] = 2;
2799               decrease_FR_busy (cpu, FRk_1, busy_adjustment[3]);
2800             }
2801           else
2802             enforce_full_fr_latency (cpu, FRk_1);
2803         }
2804       if (FRk_2 >= 0 && FRk_2 != in_FRi)
2805         {
2806           if (use_is_media (cpu, FRk_2))
2807             {
2808               busy_adjustment[4] = 2;
2809               decrease_FR_busy (cpu, FRk_2, busy_adjustment[4]);
2810             }
2811           else
2812             enforce_full_fr_latency (cpu, FRk_2);
2813         }
2814       if (FRk_3 >= 0 && FRk_3 != in_FRi)
2815         {
2816           if (use_is_media (cpu, FRk_3))
2817             {
2818               busy_adjustment[5] = 2;
2819               decrease_FR_busy (cpu, FRk_3, busy_adjustment[5]);
2820             }
2821           else
2822             enforce_full_fr_latency (cpu, FRk_3);
2823         }
2824     }
2825
2826   /* The post processing must wait if there is a dependency on a FR
2827      which is not ready yet.  */
2828   ps->post_wait = cycles;
2829   post_wait_for_FR (cpu, in_FRi);
2830   post_wait_for_FR (cpu, FRi_1);
2831   post_wait_for_FR (cpu, out_FRk);
2832   post_wait_for_FR (cpu, FRk_1);
2833   post_wait_for_FR (cpu, FRk_2);
2834   post_wait_for_FR (cpu, FRk_3);
2835
2836   /* Restore the busy cycles of the registers we used.  */
2837   fr = ps->fr_busy;
2838   fr[in_FRi] += busy_adjustment[0];
2839   if (FRi_1 >= 0)
2840     fr[FRi_1] += busy_adjustment[1];
2841   fr[out_FRk] += busy_adjustment[2];
2842   if (FRk_1 >= 0)
2843     fr[FRk_1] += busy_adjustment[3];
2844   if (FRk_2 >= 0)
2845     fr[FRk_2] += busy_adjustment[4];
2846   if (FRk_3 >= 0)
2847     fr[FRk_3] += busy_adjustment[5];
2848
2849   /* The latency of tht output register will be at least the latency of the
2850      other inputs.  Once initiated, post-processing will take 3 cycles.  */
2851   update_FR_latency (cpu, out_FRk, ps->post_wait);
2852   update_FR_ptime (cpu, out_FRk, 3);
2853
2854   /* Mark this use of the register as a media op.  */
2855   set_use_is_media (cpu, out_FRk);
2856   if (FRk_1 >= 0)
2857     {
2858       update_FR_latency (cpu, FRk_1, ps->post_wait);
2859       update_FR_ptime (cpu, FRk_1, 3);
2860
2861       /* Mark this use of the register as a media op.  */
2862       set_use_is_media (cpu, FRk_1);
2863     }
2864   if (FRk_2 >= 0)
2865     {
2866       update_FR_latency (cpu, FRk_2, ps->post_wait);
2867       update_FR_ptime (cpu, FRk_2, 3);
2868
2869       /* Mark this use of the register as a media op.  */
2870       set_use_is_media (cpu, FRk_2);
2871     }
2872   if (FRk_3 >= 0)
2873     {
2874       update_FR_latency (cpu, FRk_3, ps->post_wait);
2875       update_FR_ptime (cpu, FRk_3, 3);
2876
2877       /* Mark this use of the register as a media op.  */
2878       set_use_is_media (cpu, FRk_3);
2879     }
2880
2881   return cycles;
2882 }
2883
2884 int
2885 frvbf_model_fr500_u_media_dual_btoh (SIM_CPU *cpu, const IDESC *idesc,
2886                                      int unit_num, int referenced,
2887                                      INT in_FRj,
2888                                      INT out_FRk)
2889 {
2890   return frvbf_model_fr500_u_media_dual_expand (cpu, idesc, unit_num,
2891                                                 referenced, in_FRj, out_FRk);
2892 }
2893
2894 int
2895 frvbf_model_fr500_u_media_dual_htob (SIM_CPU *cpu, const IDESC *idesc,
2896                                      int unit_num, int referenced,
2897                                      INT in_FRj,
2898                                      INT out_FRk)
2899 {
2900   int cycles;
2901   INT dual_FRj;
2902   FRV_PROFILE_STATE *ps;
2903   int busy_adjustment[] = {0, 0, 0};
2904   int *fr;
2905
2906   if (model_insn == FRV_INSN_MODEL_PASS_1)
2907     return 0;
2908
2909   /* The preprocessing can execute right away.  */
2910   cycles = idesc->timing->units[unit_num].done;
2911
2912   /* If the previous use of the registers was a media op,
2913      then their latency will be less than previously recorded.
2914      See Table 13-13 in the LSI.  */
2915   dual_FRj = DUAL_REG (in_FRj);
2916   ps = CPU_PROFILE_STATE (cpu);
2917   if (use_is_media (cpu, in_FRj))
2918     {
2919       busy_adjustment[0] = 2;
2920       decrease_FR_busy (cpu, in_FRj, busy_adjustment[0]);
2921     }
2922   else
2923     enforce_full_fr_latency (cpu, in_FRj);
2924   if (dual_FRj >= 0)
2925     {
2926       if (use_is_media (cpu, dual_FRj))
2927         {
2928           busy_adjustment[1] = 2;
2929           decrease_FR_busy (cpu, dual_FRj, busy_adjustment[1]);
2930         }
2931       else
2932         enforce_full_fr_latency (cpu, dual_FRj);
2933     }
2934   if (out_FRk != in_FRj)
2935     {
2936       if (use_is_media (cpu, out_FRk))
2937         {
2938           busy_adjustment[2] = 2;
2939           decrease_FR_busy (cpu, out_FRk, busy_adjustment[2]);
2940         }
2941       else
2942         enforce_full_fr_latency (cpu, out_FRk);
2943     }
2944
2945   /* The post processing must wait if there is a dependency on a FR
2946      which is not ready yet.  */
2947   ps->post_wait = cycles;
2948   post_wait_for_FR (cpu, in_FRj);
2949   post_wait_for_FR (cpu, dual_FRj);
2950   post_wait_for_FR (cpu, out_FRk);
2951
2952   /* Restore the busy cycles of the registers we used.  */
2953   fr = ps->fr_busy;
2954   fr[in_FRj] += busy_adjustment[0];
2955   if (dual_FRj >= 0)
2956     fr[dual_FRj] += busy_adjustment[1];
2957   fr[out_FRk] += busy_adjustment[2];
2958
2959   /* The latency of tht output register will be at least the latency of the
2960      other inputs.  */
2961   update_FR_latency (cpu, out_FRk, ps->post_wait);
2962
2963   /* Once initiated, post-processing will take 3 cycles.  */
2964   update_FR_ptime (cpu, out_FRk, 3);
2965
2966   /* Mark this use of the register as a media op.  */
2967   set_use_is_media (cpu, out_FRk);
2968
2969   return cycles;
2970 }
2971
2972 int
2973 frvbf_model_fr500_u_media_dual_btohe (SIM_CPU *cpu, const IDESC *idesc,
2974                                       int unit_num, int referenced,
2975                                       INT in_FRj,
2976                                       INT out_FRk)
2977 {
2978   int cycles;
2979   INT FRk_1;
2980   INT FRk_2;
2981   INT FRk_3;
2982   FRV_PROFILE_STATE *ps;
2983   int busy_adjustment[] = {0, 0, 0, 0, 0};
2984   int *fr;
2985
2986   if (model_insn == FRV_INSN_MODEL_PASS_1)
2987     return 0;
2988
2989   /* The preprocessing can execute right away.  */
2990   cycles = idesc->timing->units[unit_num].done;
2991
2992   FRk_1 = DUAL_REG (out_FRk);
2993   FRk_2 = DUAL_REG (FRk_1);
2994   FRk_3 = DUAL_REG (FRk_2);
2995
2996   /* If the previous use of the registers was a media op,
2997      then their latency will be less than previously recorded.
2998      See Table 13-13 in the LSI.  */
2999   ps = CPU_PROFILE_STATE (cpu);
3000   if (use_is_media (cpu, in_FRj))
3001     {
3002       busy_adjustment[0] = 2;
3003       decrease_FR_busy (cpu, in_FRj, busy_adjustment[0]);
3004     }
3005   else
3006     enforce_full_fr_latency (cpu, in_FRj);
3007   if (out_FRk != in_FRj)
3008     {
3009       if (use_is_media (cpu, out_FRk))
3010         {
3011           busy_adjustment[1] = 2;
3012           decrease_FR_busy (cpu, out_FRk, busy_adjustment[1]);
3013         }
3014       else
3015         enforce_full_fr_latency (cpu, out_FRk);
3016       if (FRk_1 >= 0 && FRk_1 != in_FRj)
3017         {
3018           if (use_is_media (cpu, FRk_1))
3019             {
3020               busy_adjustment[2] = 2;
3021               decrease_FR_busy (cpu, FRk_1, busy_adjustment[2]);
3022             }
3023           else
3024             enforce_full_fr_latency (cpu, FRk_1);
3025         }
3026       if (FRk_2 >= 0 && FRk_2 != in_FRj)
3027         {
3028           if (use_is_media (cpu, FRk_2))
3029             {
3030               busy_adjustment[3] = 2;
3031               decrease_FR_busy (cpu, FRk_2, busy_adjustment[3]);
3032             }
3033           else
3034             enforce_full_fr_latency (cpu, FRk_2);
3035         }
3036       if (FRk_3 >= 0 && FRk_3 != in_FRj)
3037         {
3038           if (use_is_media (cpu, FRk_3))
3039             {
3040               busy_adjustment[4] = 2;
3041               decrease_FR_busy (cpu, FRk_3, busy_adjustment[4]);
3042             }
3043           else
3044             enforce_full_fr_latency (cpu, FRk_3);
3045         }
3046     }
3047
3048   /* The post processing must wait if there is a dependency on a FR
3049      which is not ready yet.  */
3050   ps->post_wait = cycles;
3051   post_wait_for_FR (cpu, in_FRj);
3052   post_wait_for_FR (cpu, out_FRk);
3053   post_wait_for_FR (cpu, FRk_1);
3054   post_wait_for_FR (cpu, FRk_2);
3055   post_wait_for_FR (cpu, FRk_3);
3056
3057   /* Restore the busy cycles of the registers we used.  */
3058   fr = ps->fr_busy;
3059   fr[in_FRj] += busy_adjustment[0];
3060   fr[out_FRk] += busy_adjustment[1];
3061   if (FRk_1 >= 0)
3062     fr[FRk_1] += busy_adjustment[2];
3063   if (FRk_2 >= 0)
3064     fr[FRk_2] += busy_adjustment[3];
3065   if (FRk_3 >= 0)
3066     fr[FRk_3] += busy_adjustment[4];
3067
3068   /* The latency of tht output register will be at least the latency of the
3069      other inputs.  Once initiated, post-processing will take 3 cycles.  */
3070   update_FR_latency (cpu, out_FRk, ps->post_wait);
3071   update_FR_ptime (cpu, out_FRk, 3);
3072
3073   /* Mark this use of the register as a media op.  */
3074   set_use_is_media (cpu, out_FRk);
3075   if (FRk_1 >= 0)
3076     {
3077       update_FR_latency (cpu, FRk_1, ps->post_wait);
3078       update_FR_ptime (cpu, FRk_1, 3);
3079
3080       /* Mark this use of the register as a media op.  */
3081       set_use_is_media (cpu, FRk_1);
3082     }
3083   if (FRk_2 >= 0)
3084     {
3085       update_FR_latency (cpu, FRk_2, ps->post_wait);
3086       update_FR_ptime (cpu, FRk_2, 3);
3087
3088       /* Mark this use of the register as a media op.  */
3089       set_use_is_media (cpu, FRk_2);
3090     }
3091   if (FRk_3 >= 0)
3092     {
3093       update_FR_latency (cpu, FRk_3, ps->post_wait);
3094       update_FR_ptime (cpu, FRk_3, 3);
3095
3096       /* Mark this use of the register as a media op.  */
3097       set_use_is_media (cpu, FRk_3);
3098     }
3099
3100   return cycles;
3101 }
3102
3103 int
3104 frvbf_model_fr500_u_barrier (SIM_CPU *cpu, const IDESC *idesc,
3105                              int unit_num, int referenced)
3106 {
3107   int cycles;
3108   if (model_insn == FRV_INSN_MODEL_PASS_1)
3109     {
3110       int i;
3111       /* Wait for ALL resources.  */
3112       for (i = 0; i < 64; ++i)
3113         {
3114           enforce_full_fr_latency (cpu, i);
3115           vliw_wait_for_GR (cpu, i);
3116           vliw_wait_for_FR (cpu, i);
3117           vliw_wait_for_ACC (cpu, i);
3118         }
3119       for (i = 0; i < 8; ++i)
3120         vliw_wait_for_CCR (cpu, i);
3121       for (i = 0; i < 2; ++i)
3122         {
3123           vliw_wait_for_idiv_resource (cpu, i);
3124           vliw_wait_for_fdiv_resource (cpu, i);
3125           vliw_wait_for_fsqrt_resource (cpu, i);
3126         }
3127       handle_resource_wait (cpu);
3128       for (i = 0; i < 64; ++i)
3129         {
3130           load_wait_for_GR (cpu, i);
3131           load_wait_for_FR (cpu, i);
3132         }
3133       trace_vliw_wait_cycles (cpu);
3134       return 0;
3135     }
3136
3137   cycles = idesc->timing->units[unit_num].done;
3138   return cycles;
3139 }
3140
3141 int
3142 frvbf_model_fr500_u_membar (SIM_CPU *cpu, const IDESC *idesc,
3143                             int unit_num, int referenced)
3144 {
3145   int cycles;
3146   if (model_insn == FRV_INSN_MODEL_PASS_1)
3147     {
3148       int i;
3149       /* Wait for ALL resources, except GR and ICC.  */
3150       for (i = 0; i < 64; ++i)
3151         {
3152           enforce_full_fr_latency (cpu, i);
3153           vliw_wait_for_FR (cpu, i);
3154           vliw_wait_for_ACC (cpu, i);
3155         }
3156       for (i = 0; i < 4; ++i)
3157         vliw_wait_for_CCR (cpu, i);
3158       for (i = 0; i < 2; ++i)
3159         {
3160           vliw_wait_for_idiv_resource (cpu, i);
3161           vliw_wait_for_fdiv_resource (cpu, i);
3162           vliw_wait_for_fsqrt_resource (cpu, i);
3163         }
3164       handle_resource_wait (cpu);
3165       for (i = 0; i < 64; ++i)
3166         {
3167           load_wait_for_FR (cpu, i);
3168         }
3169       trace_vliw_wait_cycles (cpu);
3170       return 0;
3171     }
3172
3173   cycles = idesc->timing->units[unit_num].done;
3174   return cycles;
3175 }
3176
3177 /* The frv machine is a fictional implementation of the fr500 which implements
3178    all frv architectural features.  */
3179 int
3180 frvbf_model_frv_u_exec (SIM_CPU *cpu, const IDESC *idesc,
3181                             int unit_num, int referenced)
3182 {
3183   return idesc->timing->units[unit_num].done;
3184 }
3185
3186 /* The simple machine is a fictional implementation of the fr500 which
3187    implements limited frv architectural features.  */
3188 int
3189 frvbf_model_simple_u_exec (SIM_CPU *cpu, const IDESC *idesc,
3190                             int unit_num, int referenced)
3191 {
3192   return idesc->timing->units[unit_num].done;
3193 }
3194
3195 /* The tomcat machine is models a prototype fr500 machine which had a few
3196    bugs and restrictions to work around.  */
3197 int
3198 frvbf_model_tomcat_u_exec (SIM_CPU *cpu, const IDESC *idesc,
3199                             int unit_num, int referenced)
3200 {
3201   return idesc->timing->units[unit_num].done;
3202 }
3203
3204 #endif /* WITH_PROFILE_MODEL_P */