?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH 22/57][Arm][GAS] Add support for MVE instructions: vmlaldav, vmlalv, vmlsldav...
[binutils-gdb.git] / sim / frv / profile-fr550.c
blob4eafa871d03ba877b86f907eace3d96d71a8e997
1 /* frv simulator fr550 dependent profiling code.
2
3 Copyright (C) 2003-2019 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-fr550.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 fr550_model_insn_before (SIM_CPU *cpu, int first_p)
38 {
39 if (first_p)
40 {
41 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
42 d->cur_fr_load = d->prev_fr_load;
43 d->cur_fr_complex_1 = d->prev_fr_complex_1;
44 d->cur_fr_complex_2 = d->prev_fr_complex_2;
45 d->cur_ccr_complex = d->prev_ccr_complex;
46 d->cur_acc_mmac = d->prev_acc_mmac;
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 fr550_model_insn_after (SIM_CPU *cpu, int last_p, int cycles)
56 {
57 if (last_p)
58 {
59 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
60 d->prev_fr_load = d->cur_fr_load;
61 d->prev_fr_complex_1 = d->cur_fr_complex_1;
62 d->prev_fr_complex_2 = d->cur_fr_complex_2;
63 d->prev_ccr_complex = d->cur_ccr_complex;
64 d->prev_acc_mmac = d->cur_acc_mmac;
65 }
66 }
67
68 static void fr550_reset_fr_flags (SIM_CPU *cpu, INT fr);
69 static void fr550_reset_ccr_flags (SIM_CPU *cpu, INT ccr);
70 static void fr550_reset_acc_flags (SIM_CPU *cpu, INT acc);
71
72 static void
73 set_use_is_fr_load (SIM_CPU *cpu, INT fr)
74 {
75 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
76 fr550_reset_fr_flags (cpu, (fr));
77 d->cur_fr_load |= (((DI)1) << (fr));
78 }
79
80 static void
81 set_use_not_fr_load (SIM_CPU *cpu, INT fr)
82 {
83 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
84 d->cur_fr_load &= ~(((DI)1) << (fr));
85 }
86
87 static int
88 use_is_fr_load (SIM_CPU *cpu, INT fr)
89 {
90 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
91 return d->prev_fr_load & (((DI)1) << (fr));
92 }
93
94 static void
95 set_use_is_fr_complex_1 (SIM_CPU *cpu, INT fr)
96 {
97 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
98 fr550_reset_fr_flags (cpu, (fr));
99 d->cur_fr_complex_1 |= (((DI)1) << (fr));
100 }
101
102 static void
103 set_use_not_fr_complex_1 (SIM_CPU *cpu, INT fr)
104 {
105 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
106 d->cur_fr_complex_1 &= ~(((DI)1) << (fr));
107 }
108
109 static int
110 use_is_fr_complex_1 (SIM_CPU *cpu, INT fr)
111 {
112 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
113 return d->prev_fr_complex_1 & (((DI)1) << (fr));
114 }
115
116 static void
117 set_use_is_fr_complex_2 (SIM_CPU *cpu, INT fr)
118 {
119 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
120 fr550_reset_fr_flags (cpu, (fr));
121 d->cur_fr_complex_2 |= (((DI)1) << (fr));
122 }
123
124 static void
125 set_use_not_fr_complex_2 (SIM_CPU *cpu, INT fr)
126 {
127 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
128 d->cur_fr_complex_2 &= ~(((DI)1) << (fr));
129 }
130
131 static int
132 use_is_fr_complex_2 (SIM_CPU *cpu, INT fr)
133 {
134 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
135 return d->prev_fr_complex_2 & (((DI)1) << (fr));
136 }
137
138 static void
139 set_use_is_ccr_complex (SIM_CPU *cpu, INT ccr)
140 {
141 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
142 fr550_reset_ccr_flags (cpu, (ccr));
143 d->cur_ccr_complex |= (((SI)1) << (ccr));
144 }
145
146 static void
147 set_use_not_ccr_complex (SIM_CPU *cpu, INT ccr)
148 {
149 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
150 d->cur_ccr_complex &= ~(((SI)1) << (ccr));
151 }
152
153 static int
154 use_is_ccr_complex (SIM_CPU *cpu, INT ccr)
155 {
156 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
157 return d->prev_ccr_complex & (((SI)1) << (ccr));
158 }
159
160 static void
161 set_use_is_acc_mmac (SIM_CPU *cpu, INT acc)
162 {
163 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
164 fr550_reset_acc_flags (cpu, (acc));
165 d->cur_acc_mmac |= (((DI)1) << (acc));
166 }
167
168 static void
169 set_use_not_acc_mmac (SIM_CPU *cpu, INT acc)
170 {
171 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
172 d->cur_acc_mmac &= ~(((DI)1) << (acc));
173 }
174
175 static int
176 use_is_acc_mmac (SIM_CPU *cpu, INT acc)
177 {
178 MODEL_FR550_DATA *d = CPU_MODEL_DATA (cpu);
179 return d->prev_acc_mmac & (((DI)1) << (acc));
180 }
181
182 static void
183 fr550_reset_fr_flags (SIM_CPU *cpu, INT fr)
184 {
185 set_use_not_fr_load (cpu, fr);
186 set_use_not_fr_complex_1 (cpu, fr);
187 set_use_not_fr_complex_2 (cpu, fr);
188 }
189
190 static void
191 fr550_reset_ccr_flags (SIM_CPU *cpu, INT ccr)
192 {
193 set_use_not_ccr_complex (cpu, ccr);
194 }
195
196 static void
197 fr550_reset_acc_flags (SIM_CPU *cpu, INT acc)
198 {
199 set_use_not_acc_mmac (cpu, acc);
200 }
201
202 /* Detect overlap between two register ranges. Works if one of the registers
203 is -1 with width 1 (i.e. undefined), but not both. */
204 #define REG_OVERLAP(r1, w1, r2, w2) ( \
205 (r1) + (w1) - 1 >= (r2) && (r2) + (w2) - 1 >= (r1) \
206 )
207
208 /* Latency of floating point registers may be less than recorded when followed
209 by another floating point insn. */
210 static void
211 adjust_float_register_busy (SIM_CPU *cpu,
212 INT in_FRi, int iwidth,
213 INT in_FRj, int jwidth,
214 INT out_FRk, int kwidth)
215 {
216 int i;
217 /* The latency of FRk may be less than previously recorded.
218 See Table 14-15 in the LSI. */
219 if (in_FRi >= 0)
220 {
221 for (i = 0; i < iwidth; ++i)
222 {
223 if (! REG_OVERLAP (in_FRi + i, 1, out_FRk, kwidth))
224 if (use_is_fr_load (cpu, in_FRi + i))
225 decrease_FR_busy (cpu, in_FRi + i, 1);
226 else
227 enforce_full_fr_latency (cpu, in_FRi + i);
228 }
229 }
230
231 if (in_FRj >= 0)
232 {
233 for (i = 0; i < jwidth; ++i)
234 {
235 if (! REG_OVERLAP (in_FRj + i, 1, in_FRi, iwidth)
236 && ! REG_OVERLAP (in_FRj + i, 1, out_FRk, kwidth))
237 if (use_is_fr_load (cpu, in_FRj + i))
238 decrease_FR_busy (cpu, in_FRj + i, 1);
239 else
240 enforce_full_fr_latency (cpu, in_FRj + i);
241 }
242 }
243
244 if (out_FRk >= 0)
245 {
246 for (i = 0; i < kwidth; ++i)
247 {
248 if (! REG_OVERLAP (out_FRk + i, 1, in_FRi, iwidth)
249 && ! REG_OVERLAP (out_FRk + i, 1, in_FRj, jwidth))
250 {
251 if (use_is_fr_complex_1 (cpu, out_FRk + i))
252 decrease_FR_busy (cpu, out_FRk + i, 1);
253 else if (use_is_fr_complex_2 (cpu, out_FRk + i))
254 decrease_FR_busy (cpu, out_FRk + i, 2);
255 else
256 enforce_full_fr_latency (cpu, out_FRk + i);
257 }
258 }
259 }
260 }
261
262 static void
263 restore_float_register_busy (SIM_CPU *cpu,
264 INT in_FRi, int iwidth,
265 INT in_FRj, int jwidth,
266 INT out_FRk, int kwidth)
267 {
268 int i;
269 /* The latency of FRk may be less than previously recorded.
270 See Table 14-15 in the LSI. */
271 if (in_FRi >= 0)
272 {
273 for (i = 0; i < iwidth; ++i)
274 {
275 if (! REG_OVERLAP (in_FRi + i, 1, out_FRk, kwidth))
276 if (use_is_fr_load (cpu, in_FRi + i))
277 increase_FR_busy (cpu, in_FRi + i, 1);
278 }
279 }
280
281 if (in_FRj >= 0)
282 {
283 for (i = 0; i < jwidth; ++i)
284 {
285 if (! REG_OVERLAP (in_FRj + i, 1, in_FRi, iwidth)
286 && ! REG_OVERLAP (in_FRj + i, 1, out_FRk, kwidth))
287 if (use_is_fr_load (cpu, in_FRj + i))
288 increase_FR_busy (cpu, in_FRj + i, 1);
289 }
290 }
291
292 if (out_FRk >= 0)
293 {
294 for (i = 0; i < kwidth; ++i)
295 {
296 if (! REG_OVERLAP (out_FRk + i, 1, in_FRi, iwidth)
297 && ! REG_OVERLAP (out_FRk + i, 1, in_FRj, jwidth))
298 {
299 if (use_is_fr_complex_1 (cpu, out_FRk + i))
300 increase_FR_busy (cpu, out_FRk + i, 1);
301 else if (use_is_fr_complex_2 (cpu, out_FRk + i))
302 increase_FR_busy (cpu, out_FRk + i, 2);
303 }
304 }
305 }
306 }
307
308 /* Latency of floating point registers may be less than recorded when used in a
309 media insns and followed by another media insn. */
310 static void
311 adjust_float_register_busy_for_media (SIM_CPU *cpu,
312 INT in_FRi, int iwidth,
313 INT in_FRj, int jwidth,
314 INT out_FRk, int kwidth)
315 {
316 int i;
317 /* The latency of FRk may be less than previously recorded.
318 See Table 14-15 in the LSI. */
319 if (out_FRk >= 0)
320 {
321 for (i = 0; i < kwidth; ++i)
322 {
323 if (! REG_OVERLAP (out_FRk + i, 1, in_FRi, iwidth)
324 && ! REG_OVERLAP (out_FRk + i, 1, in_FRj, jwidth))
325 {
326 if (use_is_fr_complex_1 (cpu, out_FRk + i))
327 decrease_FR_busy (cpu, out_FRk + i, 1);
328 else
329 enforce_full_fr_latency (cpu, out_FRk + i);
330 }
331 }
332 }
333 }
334
335 static void
336 restore_float_register_busy_for_media (SIM_CPU *cpu,
337 INT in_FRi, int iwidth,
338 INT in_FRj, int jwidth,
339 INT out_FRk, int kwidth)
340 {
341 int i;
342 if (out_FRk >= 0)
343 {
344 for (i = 0; i < kwidth; ++i)
345 {
346 if (! REG_OVERLAP (out_FRk + i, 1, in_FRi, iwidth)
347 && ! REG_OVERLAP (out_FRk + i, 1, in_FRj, jwidth))
348 {
349 if (use_is_fr_complex_1 (cpu, out_FRk + i))
350 increase_FR_busy (cpu, out_FRk + i, 1);
351 }
352 }
353 }
354 }
355
356 /* Latency of accumulator registers may be less than recorded when used in a
357 media insns and followed by another media insn. */
358 static void
359 adjust_acc_busy_for_mmac (SIM_CPU *cpu,
360 INT in_ACC, int inwidth,
361 INT out_ACC, int outwidth)
362 {
363 int i;
364 /* The latency of an accumulator may be less than previously recorded.
365 See Table 14-15 in the LSI. */
366 if (in_ACC >= 0)
367 {
368 for (i = 0; i < inwidth; ++i)
369 {
370 if (use_is_acc_mmac (cpu, in_ACC + i))
371 decrease_ACC_busy (cpu, in_ACC + i, 1);
372 else
373 enforce_full_acc_latency (cpu, in_ACC + i);
374 }
375 }
376 if (out_ACC >= 0)
377 {
378 for (i = 0; i < outwidth; ++i)
379 {
380 if (! REG_OVERLAP (out_ACC + i, 1, in_ACC, inwidth))
381 {
382 if (use_is_acc_mmac (cpu, out_ACC + i))
383 decrease_ACC_busy (cpu, out_ACC + i, 1);
384 else
385 enforce_full_acc_latency (cpu, out_ACC + i);
386 }
387 }
388 }
389 }
390
391 static void
392 restore_acc_busy_for_mmac (SIM_CPU *cpu,
393 INT in_ACC, int inwidth,
394 INT out_ACC, int outwidth)
395 {
396 int i;
397 if (in_ACC >= 0)
398 {
399 for (i = 0; i < inwidth; ++i)
400 {
401 if (use_is_acc_mmac (cpu, in_ACC + i))
402 increase_ACC_busy (cpu, in_ACC + i, 1);
403 }
404 }
405 if (out_ACC >= 0)
406 {
407 for (i = 0; i < outwidth; ++i)
408 {
409 if (! REG_OVERLAP (out_ACC + i, 1, in_ACC, inwidth))
410 {
411 if (use_is_acc_mmac (cpu, out_ACC + i))
412 increase_ACC_busy (cpu, out_ACC + i, 1);
413 }
414 }
415 }
416 }
417
418 int
419 frvbf_model_fr550_u_exec (SIM_CPU *cpu, const IDESC *idesc,
420 int unit_num, int referenced)
421 {
422 return idesc->timing->units[unit_num].done;
423 }
424
425 int
426 frvbf_model_fr550_u_integer (SIM_CPU *cpu, const IDESC *idesc,
427 int unit_num, int referenced,
428 INT in_GRi, INT in_GRj, INT out_GRk,
429 INT out_ICCi_1)
430 {
431 int cycles;
432
433 /* icc0-icc4 are the upper 4 fields of the CCR. */
434 if (out_ICCi_1 >= 0)
435 out_ICCi_1 += 4;
436
437 if (model_insn == FRV_INSN_MODEL_PASS_1)
438 {
439 /* The entire VLIW insn must wait if there is a dependency on a register
440 which is not ready yet. */
441 vliw_wait_for_GR (cpu, in_GRi);
442 vliw_wait_for_GR (cpu, in_GRj);
443 vliw_wait_for_GR (cpu, out_GRk);
444 vliw_wait_for_CCR (cpu, out_ICCi_1);
445 handle_resource_wait (cpu);
446 load_wait_for_GR (cpu, in_GRi);
447 load_wait_for_GR (cpu, in_GRj);
448 load_wait_for_GR (cpu, out_GRk);
449 trace_vliw_wait_cycles (cpu);
450 return 0;
451 }
452
453 fr550_reset_ccr_flags (cpu, out_ICCi_1);
454
455 /* GRk is available immediately to the next VLIW insn as is ICCi_1. */
456 cycles = idesc->timing->units[unit_num].done;
457 return cycles;
458 }
459
460 int
461 frvbf_model_fr550_u_imul (SIM_CPU *cpu, const IDESC *idesc,
462 int unit_num, int referenced,
463 INT in_GRi, INT in_GRj, INT out_GRk, INT out_ICCi_1)
464 {
465 int cycles;
466 /* icc0-icc4 are the upper 4 fields of the CCR. */
467 if (out_ICCi_1 >= 0)
468 out_ICCi_1 += 4;
469
470 if (model_insn == FRV_INSN_MODEL_PASS_1)
471 {
472 /* The entire VLIW insn must wait if there is a dependency on a register
473 which is not ready yet. */
474 vliw_wait_for_GR (cpu, in_GRi);
475 vliw_wait_for_GR (cpu, in_GRj);
476 vliw_wait_for_GRdouble (cpu, out_GRk);
477 vliw_wait_for_CCR (cpu, out_ICCi_1);
478 handle_resource_wait (cpu);
479 load_wait_for_GR (cpu, in_GRi);
480 load_wait_for_GR (cpu, in_GRj);
481 load_wait_for_GRdouble (cpu, out_GRk);
482 trace_vliw_wait_cycles (cpu);
483 return 0;
484 }
485
486 /* GRk has a latency of 1 cycles. */
487 cycles = idesc->timing->units[unit_num].done;
488 update_GRdouble_latency (cpu, out_GRk, cycles + 1);
489
490 /* ICCi_1 has a latency of 1 cycle. */
491 update_CCR_latency (cpu, out_ICCi_1, cycles + 1);
492
493 fr550_reset_ccr_flags (cpu, out_ICCi_1);
494
495 return cycles;
496 }
497
498 int
499 frvbf_model_fr550_u_idiv (SIM_CPU *cpu, const IDESC *idesc,
500 int unit_num, int referenced,
501 INT in_GRi, INT in_GRj, INT out_GRk, INT out_ICCi_1)
502 {
503 int cycles;
504 FRV_VLIW *vliw;
505 int slot;
506
507 /* icc0-icc4 are the upper 4 fields of the CCR. */
508 if (out_ICCi_1 >= 0)
509 out_ICCi_1 += 4;
510
511 vliw = CPU_VLIW (cpu);
512 slot = vliw->next_slot - 1;
513 slot = (*vliw->current_vliw)[slot] - UNIT_I0;
514
515 if (model_insn == FRV_INSN_MODEL_PASS_1)
516 {
517 /* The entire VLIW insn must wait if there is a dependency on a register
518 which is not ready yet. */
519 vliw_wait_for_GR (cpu, in_GRi);
520 vliw_wait_for_GR (cpu, in_GRj);
521 vliw_wait_for_GR (cpu, out_GRk);
522 vliw_wait_for_CCR (cpu, out_ICCi_1);
523 vliw_wait_for_idiv_resource (cpu, slot);
524 handle_resource_wait (cpu);
525 load_wait_for_GR (cpu, in_GRi);
526 load_wait_for_GR (cpu, in_GRj);
527 load_wait_for_GR (cpu, out_GRk);
528 trace_vliw_wait_cycles (cpu);
529 return 0;
530 }
531
532 /* GRk has a latency of 18 cycles! */
533 cycles = idesc->timing->units[unit_num].done;
534 update_GR_latency (cpu, out_GRk, cycles + 18);
535
536 /* ICCi_1 has a latency of 18 cycles. */
537 update_CCR_latency (cpu, out_ICCi_1, cycles + 18);
538
539 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
540 {
541 /* GNER has a latency of 18 cycles. */
542 update_SPR_latency (cpu, GNER_FOR_GR (out_GRk), cycles + 18);
543 }
544
545 /* the idiv resource has a latency of 18 cycles! */
546 update_idiv_resource_latency (cpu, slot, cycles + 18);
547
548 fr550_reset_ccr_flags (cpu, out_ICCi_1);
549
550 return cycles;
551 }
552
553 int
554 frvbf_model_fr550_u_branch (SIM_CPU *cpu, const IDESC *idesc,
555 int unit_num, int referenced,
556 INT in_GRi, INT in_GRj,
557 INT in_ICCi_2, INT in_FCCi_2)
558 {
559 int cycles;
560 FRV_PROFILE_STATE *ps;
561
562 if (model_insn == FRV_INSN_MODEL_PASS_1)
563 {
564 /* icc0-icc4 are the upper 4 fields of the CCR. */
565 if (in_ICCi_2 >= 0)
566 in_ICCi_2 += 4;
567
568 /* The entire VLIW insn must wait if there is a dependency on a register
569 which is not ready yet. */
570 vliw_wait_for_GR (cpu, in_GRi);
571 vliw_wait_for_GR (cpu, in_GRj);
572 vliw_wait_for_CCR (cpu, in_ICCi_2);
573 vliw_wait_for_CCR (cpu, in_FCCi_2);
574 handle_resource_wait (cpu);
575 load_wait_for_GR (cpu, in_GRi);
576 load_wait_for_GR (cpu, in_GRj);
577 trace_vliw_wait_cycles (cpu);
578 return 0;
579 }
580
581 /* When counting branches taken or not taken, don't consider branches after
582 the first taken branch in a vliw insn. */
583 ps = CPU_PROFILE_STATE (cpu);
584 if (! ps->vliw_branch_taken)
585 {
586 /* (1 << 4): The pc is the 5th element in inputs, outputs.
587 ??? can be cleaned up */
588 PROFILE_DATA *p = CPU_PROFILE_DATA (cpu);
589 int taken = (referenced & (1 << 4)) != 0;
590 if (taken)
591 {
592 ++PROFILE_MODEL_TAKEN_COUNT (p);
593 ps->vliw_branch_taken = 1;
594 }
595 else
596 ++PROFILE_MODEL_UNTAKEN_COUNT (p);
597 }
598
599 cycles = idesc->timing->units[unit_num].done;
600 return cycles;
601 }
602
603 int
604 frvbf_model_fr550_u_trap (SIM_CPU *cpu, const IDESC *idesc,
605 int unit_num, int referenced,
606 INT in_GRi, INT in_GRj,
607 INT in_ICCi_2, INT in_FCCi_2)
608 {
609 int cycles;
610
611 if (model_insn == FRV_INSN_MODEL_PASS_1)
612 {
613 /* icc0-icc4 are the upper 4 fields of the CCR. */
614 if (in_ICCi_2 >= 0)
615 in_ICCi_2 += 4;
616
617 /* The entire VLIW insn must wait if there is a dependency on a register
618 which is not ready yet. */
619 vliw_wait_for_GR (cpu, in_GRi);
620 vliw_wait_for_GR (cpu, in_GRj);
621 vliw_wait_for_CCR (cpu, in_ICCi_2);
622 vliw_wait_for_CCR (cpu, in_FCCi_2);
623 handle_resource_wait (cpu);
624 load_wait_for_GR (cpu, in_GRi);
625 load_wait_for_GR (cpu, in_GRj);
626 trace_vliw_wait_cycles (cpu);
627 return 0;
628 }
629
630 cycles = idesc->timing->units[unit_num].done;
631 return cycles;
632 }
633
634 int
635 frvbf_model_fr550_u_check (SIM_CPU *cpu, const IDESC *idesc,
636 int unit_num, int referenced,
637 INT in_ICCi_3, INT in_FCCi_3)
638 {
639 /* Modelling for this unit is the same as for fr500. */
640 return frvbf_model_fr500_u_check (cpu, idesc, unit_num, referenced,
641 in_ICCi_3, in_FCCi_3);
642 }
643
644 int
645 frvbf_model_fr550_u_set_hilo (SIM_CPU *cpu, const IDESC *idesc,
646 int unit_num, int referenced,
647 INT out_GRkhi, INT out_GRklo)
648 {
649 int cycles;
650
651 if (model_insn == FRV_INSN_MODEL_PASS_1)
652 {
653 /* The entire VLIW insn must wait if there is a dependency on a GR
654 which is not ready yet. */
655 vliw_wait_for_GR (cpu, out_GRkhi);
656 vliw_wait_for_GR (cpu, out_GRklo);
657 handle_resource_wait (cpu);
658 load_wait_for_GR (cpu, out_GRkhi);
659 load_wait_for_GR (cpu, out_GRklo);
660 trace_vliw_wait_cycles (cpu);
661 return 0;
662 }
663
664 /* GRk is available immediately to the next VLIW insn. */
665 cycles = idesc->timing->units[unit_num].done;
666
667 return cycles;
668 }
669
670 int
671 frvbf_model_fr550_u_gr_load (SIM_CPU *cpu, const IDESC *idesc,
672 int unit_num, int referenced,
673 INT in_GRi, INT in_GRj,
674 INT out_GRk, INT out_GRdoublek)
675 {
676 int cycles;
677
678 if (model_insn == FRV_INSN_MODEL_PASS_1)
679 {
680 /* The entire VLIW insn must wait if there is a dependency on a register
681 which is not ready yet. */
682 vliw_wait_for_GR (cpu, in_GRi);
683 vliw_wait_for_GR (cpu, in_GRj);
684 vliw_wait_for_GR (cpu, out_GRk);
685 vliw_wait_for_GRdouble (cpu, out_GRdoublek);
686 handle_resource_wait (cpu);
687 load_wait_for_GR (cpu, in_GRi);
688 load_wait_for_GR (cpu, in_GRj);
689 load_wait_for_GR (cpu, out_GRk);
690 load_wait_for_GRdouble (cpu, out_GRdoublek);
691 trace_vliw_wait_cycles (cpu);
692 return 0;
693 }
694
695 cycles = idesc->timing->units[unit_num].done;
696
697 /* The latency of GRk for a load will depend on how long it takes to retrieve
698 the the data from the cache or memory. */
699 update_GR_latency_for_load (cpu, out_GRk, cycles);
700 update_GRdouble_latency_for_load (cpu, out_GRdoublek, cycles);
701
702 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
703 {
704 /* GNER has a latency of 2 cycles. */
705 update_SPR_latency (cpu, GNER_FOR_GR (out_GRk), cycles + 2);
706 update_SPR_latency (cpu, GNER_FOR_GR (out_GRdoublek), cycles + 2);
707 }
708
709 return cycles;
710 }
711
712 int
713 frvbf_model_fr550_u_gr_store (SIM_CPU *cpu, const IDESC *idesc,
714 int unit_num, int referenced,
715 INT in_GRi, INT in_GRj,
716 INT in_GRk, INT in_GRdoublek)
717 {
718 int cycles;
719
720 if (model_insn == FRV_INSN_MODEL_PASS_1)
721 {
722 /* The entire VLIW insn must wait if there is a dependency on a register
723 which is not ready yet. */
724 vliw_wait_for_GR (cpu, in_GRi);
725 vliw_wait_for_GR (cpu, in_GRj);
726 vliw_wait_for_GR (cpu, in_GRk);
727 vliw_wait_for_GRdouble (cpu, in_GRdoublek);
728 handle_resource_wait (cpu);
729 load_wait_for_GR (cpu, in_GRi);
730 load_wait_for_GR (cpu, in_GRj);
731 load_wait_for_GR (cpu, in_GRk);
732 load_wait_for_GRdouble (cpu, in_GRdoublek);
733 trace_vliw_wait_cycles (cpu);
734 return 0;
735 }
736
737 /* The target register is available immediately. */
738 cycles = idesc->timing->units[unit_num].done;
739
740 return cycles;
741 }
742
743 int
744 frvbf_model_fr550_u_fr_load (SIM_CPU *cpu, const IDESC *idesc,
745 int unit_num, int referenced,
746 INT in_GRi, INT in_GRj,
747 INT out_FRk, INT out_FRdoublek)
748 {
749 int cycles;
750 if (model_insn == FRV_INSN_MODEL_PASS_1)
751 {
752 /* The entire VLIW insn must wait if there is a dependency on a register
753 which is not ready yet.
754 The latency of the registers may be less than previously recorded,
755 depending on how they were used previously.
756 See Table 13-8 in the LSI. */
757 adjust_float_register_busy (cpu, -1, 1, -1, 1, out_FRk, 1);
758 adjust_float_register_busy (cpu, -1, 1, -1, 1, out_FRdoublek, 2);
759 vliw_wait_for_GR (cpu, in_GRi);
760 vliw_wait_for_GR (cpu, in_GRj);
761 vliw_wait_for_FR (cpu, out_FRk);
762 vliw_wait_for_FRdouble (cpu, out_FRdoublek);
763 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
764 {
765 vliw_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
766 vliw_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
767 }
768 handle_resource_wait (cpu);
769 load_wait_for_GR (cpu, in_GRi);
770 load_wait_for_GR (cpu, in_GRj);
771 load_wait_for_FR (cpu, out_FRk);
772 load_wait_for_FRdouble (cpu, out_FRdoublek);
773 trace_vliw_wait_cycles (cpu);
774 return 0;
775 }
776
777 cycles = idesc->timing->units[unit_num].done;
778
779 /* The latency of FRk for a load will depend on how long it takes to retrieve
780 the the data from the cache or memory. */
781 update_FR_latency_for_load (cpu, out_FRk, cycles);
782 update_FRdouble_latency_for_load (cpu, out_FRdoublek, cycles);
783
784 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
785 {
786 /* FNER has a latency of 3 cycles. */
787 update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), cycles + 3);
788 update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), cycles + 3);
789 }
790
791 if (out_FRk >= 0)
792 set_use_is_fr_load (cpu, out_FRk);
793 if (out_FRdoublek >= 0)
794 {
795 set_use_is_fr_load (cpu, out_FRdoublek);
796 set_use_is_fr_load (cpu, out_FRdoublek + 1);
797 }
798
799 return cycles;
800 }
801
802 int
803 frvbf_model_fr550_u_fr_store (SIM_CPU *cpu, const IDESC *idesc,
804 int unit_num, int referenced,
805 INT in_GRi, INT in_GRj,
806 INT in_FRk, INT in_FRdoublek)
807 {
808 int cycles;
809
810 if (model_insn == FRV_INSN_MODEL_PASS_1)
811 {
812 /* The entire VLIW insn must wait if there is a dependency on a register
813 which is not ready yet. */
814 adjust_float_register_busy (cpu, in_FRk, 1, -1, 1, -1, 1);
815 adjust_float_register_busy (cpu, in_FRdoublek, 2, -1, 1, -1, 1);
816 vliw_wait_for_GR (cpu, in_GRi);
817 vliw_wait_for_GR (cpu, in_GRj);
818 vliw_wait_for_FR (cpu, in_FRk);
819 vliw_wait_for_FRdouble (cpu, in_FRdoublek);
820 handle_resource_wait (cpu);
821 load_wait_for_GR (cpu, in_GRi);
822 load_wait_for_GR (cpu, in_GRj);
823 load_wait_for_FR (cpu, in_FRk);
824 load_wait_for_FRdouble (cpu, in_FRdoublek);
825 trace_vliw_wait_cycles (cpu);
826 return 0;
827 }
828
829 /* The target register is available immediately. */
830 cycles = idesc->timing->units[unit_num].done;
831
832 return cycles;
833 }
834
835 int
836 frvbf_model_fr550_u_ici (SIM_CPU *cpu, const IDESC *idesc,
837 int unit_num, int referenced,
838 INT in_GRi, INT in_GRj)
839 {
840 int cycles;
841
842 if (model_insn == FRV_INSN_MODEL_PASS_1)
843 {
844 /* The entire VLIW insn must wait if there is a dependency on a register
845 which is not ready yet. */
846 vliw_wait_for_GR (cpu, in_GRi);
847 vliw_wait_for_GR (cpu, in_GRj);
848 handle_resource_wait (cpu);
849 load_wait_for_GR (cpu, in_GRi);
850 load_wait_for_GR (cpu, in_GRj);
851 trace_vliw_wait_cycles (cpu);
852 return 0;
853 }
854
855 cycles = idesc->timing->units[unit_num].done;
856 request_cache_invalidate (cpu, CPU_INSN_CACHE (cpu), cycles);
857 return cycles;
858 }
859
860 int
861 frvbf_model_fr550_u_dci (SIM_CPU *cpu, const IDESC *idesc,
862 int unit_num, int referenced,
863 INT in_GRi, INT in_GRj)
864 {
865 int cycles;
866
867 if (model_insn == FRV_INSN_MODEL_PASS_1)
868 {
869 /* The entire VLIW insn must wait if there is a dependency on a register
870 which is not ready yet. */
871 vliw_wait_for_GR (cpu, in_GRi);
872 vliw_wait_for_GR (cpu, in_GRj);
873 handle_resource_wait (cpu);
874 load_wait_for_GR (cpu, in_GRi);
875 load_wait_for_GR (cpu, in_GRj);
876 trace_vliw_wait_cycles (cpu);
877 return 0;
878 }
879
880 cycles = idesc->timing->units[unit_num].done;
881 request_cache_invalidate (cpu, CPU_DATA_CACHE (cpu), cycles);
882 return cycles;
883 }
884
885 int
886 frvbf_model_fr550_u_dcf (SIM_CPU *cpu, const IDESC *idesc,
887 int unit_num, int referenced,
888 INT in_GRi, INT in_GRj)
889 {
890 int cycles;
891
892 if (model_insn == FRV_INSN_MODEL_PASS_1)
893 {
894 /* The entire VLIW insn must wait if there is a dependency on a register
895 which is not ready yet. */
896 vliw_wait_for_GR (cpu, in_GRi);
897 vliw_wait_for_GR (cpu, in_GRj);
898 handle_resource_wait (cpu);
899 load_wait_for_GR (cpu, in_GRi);
900 load_wait_for_GR (cpu, in_GRj);
901 trace_vliw_wait_cycles (cpu);
902 return 0;
903 }
904
905 cycles = idesc->timing->units[unit_num].done;
906 request_cache_flush (cpu, CPU_DATA_CACHE (cpu), cycles);
907 return cycles;
908 }
909
910 int
911 frvbf_model_fr550_u_icpl (SIM_CPU *cpu, const IDESC *idesc,
912 int unit_num, int referenced,
913 INT in_GRi, INT in_GRj)
914 {
915 int cycles;
916
917 if (model_insn == FRV_INSN_MODEL_PASS_1)
918 {
919 /* The entire VLIW insn must wait if there is a dependency on a register
920 which is not ready yet. */
921 vliw_wait_for_GR (cpu, in_GRi);
922 vliw_wait_for_GR (cpu, in_GRj);
923 handle_resource_wait (cpu);
924 load_wait_for_GR (cpu, in_GRi);
925 load_wait_for_GR (cpu, in_GRj);
926 trace_vliw_wait_cycles (cpu);
927 return 0;
928 }
929
930 cycles = idesc->timing->units[unit_num].done;
931 request_cache_preload (cpu, CPU_INSN_CACHE (cpu), cycles);
932 return cycles;
933 }
934
935 int
936 frvbf_model_fr550_u_dcpl (SIM_CPU *cpu, const IDESC *idesc,
937 int unit_num, int referenced,
938 INT in_GRi, INT in_GRj)
939 {
940 int cycles;
941
942 if (model_insn == FRV_INSN_MODEL_PASS_1)
943 {
944 /* The entire VLIW insn must wait if there is a dependency on a register
945 which is not ready yet. */
946 vliw_wait_for_GR (cpu, in_GRi);
947 vliw_wait_for_GR (cpu, in_GRj);
948 handle_resource_wait (cpu);
949 load_wait_for_GR (cpu, in_GRi);
950 load_wait_for_GR (cpu, in_GRj);
951 trace_vliw_wait_cycles (cpu);
952 return 0;
953 }
954
955 cycles = idesc->timing->units[unit_num].done;
956 request_cache_preload (cpu, CPU_DATA_CACHE (cpu), cycles);
957 return cycles;
958 }
959
960 int
961 frvbf_model_fr550_u_icul (SIM_CPU *cpu, const IDESC *idesc,
962 int unit_num, int referenced,
963 INT in_GRi, INT in_GRj)
964 {
965 int cycles;
966
967 if (model_insn == FRV_INSN_MODEL_PASS_1)
968 {
969 /* The entire VLIW insn must wait if there is a dependency on a register
970 which is not ready yet. */
971 vliw_wait_for_GR (cpu, in_GRi);
972 vliw_wait_for_GR (cpu, in_GRj);
973 handle_resource_wait (cpu);
974 load_wait_for_GR (cpu, in_GRi);
975 load_wait_for_GR (cpu, in_GRj);
976 trace_vliw_wait_cycles (cpu);
977 return 0;
978 }
979
980 cycles = idesc->timing->units[unit_num].done;
981 request_cache_unlock (cpu, CPU_INSN_CACHE (cpu), cycles);
982 return cycles;
983 }
984
985 int
986 frvbf_model_fr550_u_dcul (SIM_CPU *cpu, const IDESC *idesc,
987 int unit_num, int referenced,
988 INT in_GRi, INT in_GRj)
989 {
990 int cycles;
991
992 if (model_insn == FRV_INSN_MODEL_PASS_1)
993 {
994 /* The entire VLIW insn must wait if there is a dependency on a register
995 which is not ready yet. */
996 vliw_wait_for_GR (cpu, in_GRi);
997 vliw_wait_for_GR (cpu, in_GRj);
998 handle_resource_wait (cpu);
999 load_wait_for_GR (cpu, in_GRi);
1000 load_wait_for_GR (cpu, in_GRj);
1001 trace_vliw_wait_cycles (cpu);
1002 return 0;
1003 }
1004
1005 cycles = idesc->timing->units[unit_num].done;
1006 request_cache_unlock (cpu, CPU_DATA_CACHE (cpu), cycles);
1007 return cycles;
1008 }
1009
1010 int
1011 frvbf_model_fr550_u_float_arith (SIM_CPU *cpu, const IDESC *idesc,
1012 int unit_num, int referenced,
1013 INT in_FRi, INT in_FRj,
1014 INT in_FRdoublei, INT in_FRdoublej,
1015 INT out_FRk, INT out_FRdoublek)
1016 {
1017 int cycles;
1018 FRV_PROFILE_STATE *ps;
1019 FRV_VLIW *vliw;
1020 int slot;
1021
1022 if (model_insn == FRV_INSN_MODEL_PASS_1)
1023 return 0;
1024
1025 /* The preprocessing can execute right away. */
1026 cycles = idesc->timing->units[unit_num].done;
1027
1028 /* The post processing must wait if there is a dependency on a FR
1029 which is not ready yet. */
1030 adjust_float_register_busy (cpu, in_FRi, 1, in_FRj, 1, out_FRk, 1);
1031 adjust_float_register_busy (cpu, in_FRdoublei, 2, in_FRdoublej, 2, out_FRdoublek, 2);
1032 ps = CPU_PROFILE_STATE (cpu);
1033 ps->post_wait = cycles;
1034 vliw = CPU_VLIW (cpu);
1035 slot = vliw->next_slot - 1;
1036 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1037 post_wait_for_float (cpu, slot);
1038 post_wait_for_FR (cpu, in_FRi);
1039 post_wait_for_FR (cpu, in_FRj);
1040 post_wait_for_FR (cpu, out_FRk);
1041 post_wait_for_FRdouble (cpu, in_FRdoublei);
1042 post_wait_for_FRdouble (cpu, in_FRdoublej);
1043 post_wait_for_FRdouble (cpu, out_FRdoublek);
1044 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1045 {
1046 post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1047 post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
1048 }
1049 restore_float_register_busy (cpu, in_FRi, 1, in_FRj, 1, out_FRk, 1);
1050 restore_float_register_busy (cpu, in_FRdoublei, 2, in_FRdoublej, 2, out_FRdoublek, 2);
1051
1052 /* The latency of FRk will be at least the latency of the other inputs. */
1053 update_FR_latency (cpu, out_FRk, ps->post_wait);
1054 update_FRdouble_latency (cpu, out_FRdoublek, ps->post_wait);
1055
1056 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1057 {
1058 update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1059 update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), ps->post_wait);
1060 }
1061
1062 /* Once initiated, post-processing will take 2 cycles. */
1063 update_FR_ptime (cpu, out_FRk, 2);
1064 update_FRdouble_ptime (cpu, out_FRdoublek, 2);
1065 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1066 {
1067 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 2);
1068 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRdoublek), 2);
1069 }
1070
1071 /* Mark this use of the register as a floating point op. */
1072 if (out_FRk >= 0)
1073 set_use_is_fr_complex_2 (cpu, out_FRk);
1074 if (out_FRdoublek >= 0)
1075 {
1076 set_use_is_fr_complex_2 (cpu, out_FRdoublek);
1077 if (out_FRdoublek < 63)
1078 set_use_is_fr_complex_2 (cpu, out_FRdoublek + 1);
1079 }
1080
1081 /* the media point unit resource has a latency of 4 cycles */
1082 update_media_resource_latency (cpu, slot, cycles + 4);
1083
1084 return cycles;
1085 }
1086
1087 int
1088 frvbf_model_fr550_u_float_dual_arith (SIM_CPU *cpu, const IDESC *idesc,
1089 int unit_num, int referenced,
1090 INT in_FRi, INT in_FRj,
1091 INT in_FRdoublei, INT in_FRdoublej,
1092 INT out_FRk, INT out_FRdoublek)
1093 {
1094 int cycles;
1095 INT dual_FRi;
1096 INT dual_FRj;
1097 INT dual_FRk;
1098 INT dual_FRdoublei;
1099 INT dual_FRdoublej;
1100 INT dual_FRdoublek;
1101 FRV_PROFILE_STATE *ps;
1102 FRV_VLIW *vliw;
1103 int slot;
1104
1105 if (model_insn == FRV_INSN_MODEL_PASS_1)
1106 return 0;
1107
1108 /* The preprocessing can execute right away. */
1109 cycles = idesc->timing->units[unit_num].done;
1110
1111 /* The post processing must wait if there is a dependency on a FR
1112 which is not ready yet. */
1113 dual_FRi = DUAL_REG (in_FRi);
1114 dual_FRj = DUAL_REG (in_FRj);
1115 dual_FRk = DUAL_REG (out_FRk);
1116 dual_FRdoublei = DUAL_DOUBLE (in_FRdoublei);
1117 dual_FRdoublej = DUAL_DOUBLE (in_FRdoublej);
1118 dual_FRdoublek = DUAL_DOUBLE (out_FRdoublek);
1119
1120 adjust_float_register_busy (cpu, in_FRi, 2, in_FRj, 2, out_FRk, 2);
1121 adjust_float_register_busy (cpu, in_FRdoublei, 4, in_FRdoublej, 4, out_FRdoublek, 4);
1122 ps = CPU_PROFILE_STATE (cpu);
1123 ps->post_wait = cycles;
1124 vliw = CPU_VLIW (cpu);
1125 slot = vliw->next_slot - 1;
1126 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1127 post_wait_for_float (cpu, slot);
1128 post_wait_for_FR (cpu, in_FRi);
1129 post_wait_for_FR (cpu, in_FRj);
1130 post_wait_for_FR (cpu, out_FRk);
1131 post_wait_for_FR (cpu, dual_FRi);
1132 post_wait_for_FR (cpu, dual_FRj);
1133 post_wait_for_FR (cpu, dual_FRk);
1134 post_wait_for_FRdouble (cpu, in_FRdoublei);
1135 post_wait_for_FRdouble (cpu, in_FRdoublej);
1136 post_wait_for_FRdouble (cpu, out_FRdoublek);
1137 post_wait_for_FRdouble (cpu, dual_FRdoublei);
1138 post_wait_for_FRdouble (cpu, dual_FRdoublej);
1139 post_wait_for_FRdouble (cpu, dual_FRdoublek);
1140 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1141 {
1142 post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1143 post_wait_for_SPR (cpu, FNER_FOR_FR (dual_FRk));
1144 post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
1145 post_wait_for_SPR (cpu, FNER_FOR_FR (dual_FRdoublek));
1146 }
1147 restore_float_register_busy (cpu, in_FRi, 2, in_FRj, 2, out_FRk, 2);
1148 restore_float_register_busy (cpu, in_FRdoublei, 4, in_FRdoublej, 4, out_FRdoublek, 4);
1149
1150 /* The latency of FRk will be at least the latency of the other inputs. */
1151 update_FR_latency (cpu, out_FRk, ps->post_wait);
1152 update_FR_latency (cpu, dual_FRk, ps->post_wait);
1153 update_FRdouble_latency (cpu, out_FRdoublek, ps->post_wait);
1154 update_FRdouble_latency (cpu, dual_FRdoublek, ps->post_wait);
1155
1156 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1157 {
1158 update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1159 update_SPR_latency (cpu, FNER_FOR_FR (dual_FRk), ps->post_wait);
1160 update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), ps->post_wait);
1161 update_SPR_latency (cpu, FNER_FOR_FR (dual_FRdoublek), ps->post_wait);
1162 }
1163
1164 /* Once initiated, post-processing will take 3 cycles. */
1165 update_FR_ptime (cpu, out_FRk, 3);
1166 update_FR_ptime (cpu, dual_FRk, 3);
1167 update_FRdouble_ptime (cpu, out_FRdoublek, 3);
1168 update_FRdouble_ptime (cpu, dual_FRdoublek, 3);
1169
1170 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1171 {
1172 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 3);
1173 update_SPR_ptime (cpu, FNER_FOR_FR (dual_FRk), 3);
1174 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRdoublek), 3);
1175 update_SPR_ptime (cpu, FNER_FOR_FR (dual_FRdoublek), 3);
1176 }
1177
1178 /* Mark this use of the register as a floating point op. */
1179 if (out_FRk >= 0)
1180 fr550_reset_fr_flags (cpu, out_FRk);
1181 if (dual_FRk >= 0)
1182 fr550_reset_fr_flags (cpu, dual_FRk);
1183 if (out_FRdoublek >= 0)
1184 {
1185 fr550_reset_fr_flags (cpu, out_FRdoublek);
1186 if (out_FRdoublek < 63)
1187 fr550_reset_fr_flags (cpu, out_FRdoublek + 1);
1188 }
1189 if (dual_FRdoublek >= 0)
1190 {
1191 fr550_reset_fr_flags (cpu, dual_FRdoublek);
1192 if (dual_FRdoublek < 63)
1193 fr550_reset_fr_flags (cpu, dual_FRdoublek + 1);
1194 }
1195
1196 /* the media point unit resource has a latency of 5 cycles */
1197 update_media_resource_latency (cpu, slot, cycles + 5);
1198
1199 return cycles;
1200 }
1201
1202 int
1203 frvbf_model_fr550_u_float_div (SIM_CPU *cpu, const IDESC *idesc,
1204 int unit_num, int referenced,
1205 INT in_FRi, INT in_FRj, INT out_FRk)
1206 {
1207 int cycles;
1208 FRV_VLIW *vliw;
1209 int slot;
1210 FRV_PROFILE_STATE *ps;
1211
1212 if (model_insn == FRV_INSN_MODEL_PASS_1)
1213 return 0;
1214
1215 cycles = idesc->timing->units[unit_num].done;
1216
1217 /* The post processing must wait if there is a dependency on a FR
1218 which is not ready yet. */
1219 adjust_float_register_busy (cpu, in_FRi, 1, in_FRj, 1, out_FRk, 1);
1220 ps = CPU_PROFILE_STATE (cpu);
1221 ps->post_wait = cycles;
1222 vliw = CPU_VLIW (cpu);
1223 slot = vliw->next_slot - 1;
1224 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1225 post_wait_for_float (cpu, slot);
1226 post_wait_for_fdiv (cpu, slot);
1227 post_wait_for_FR (cpu, in_FRi);
1228 post_wait_for_FR (cpu, in_FRj);
1229 post_wait_for_FR (cpu, out_FRk);
1230 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1231 post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1232 restore_float_register_busy (cpu, in_FRi, 1, in_FRj, 1, out_FRk, 1);
1233
1234 /* The latency of FRk will be at least the latency of the other inputs. */
1235 /* Once initiated, post-processing will take 9 cycles. */
1236 update_FR_latency (cpu, out_FRk, ps->post_wait);
1237 update_FR_ptime (cpu, out_FRk, 9);
1238
1239 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1240 {
1241 /* FNER has a latency of 9 cycles. */
1242 update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1243 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 9);
1244 }
1245
1246 /* The latency of the fdiv unit will be at least the latency of the other
1247 inputs. Once initiated, post-processing will take 9 cycles. */
1248 update_fdiv_resource_latency (cpu, slot, ps->post_wait + 9);
1249
1250 /* the media point unit resource has a latency of 11 cycles */
1251 update_media_resource_latency (cpu, slot, cycles + 11);
1252
1253 fr550_reset_fr_flags (cpu, out_FRk);
1254
1255 return cycles;
1256 }
1257
1258 int
1259 frvbf_model_fr550_u_float_sqrt (SIM_CPU *cpu, const IDESC *idesc,
1260 int unit_num, int referenced,
1261 INT in_FRj, INT in_FRdoublej,
1262 INT out_FRk, INT out_FRdoublek)
1263 {
1264 int cycles;
1265 FRV_VLIW *vliw;
1266 int slot;
1267 FRV_PROFILE_STATE *ps;
1268
1269 if (model_insn == FRV_INSN_MODEL_PASS_1)
1270 return 0;
1271
1272 cycles = idesc->timing->units[unit_num].done;
1273
1274 /* The post processing must wait if there is a dependency on a FR
1275 which is not ready yet. */
1276 adjust_float_register_busy (cpu, -1, 1, in_FRj, 1, out_FRk, 1);
1277 adjust_float_register_busy (cpu, -1, 1, in_FRdoublej, 2, out_FRdoublek, 2);
1278 ps = CPU_PROFILE_STATE (cpu);
1279 ps->post_wait = cycles;
1280 vliw = CPU_VLIW (cpu);
1281 slot = vliw->next_slot - 1;
1282 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1283 post_wait_for_float (cpu, slot);
1284 post_wait_for_fsqrt (cpu, slot);
1285 post_wait_for_FR (cpu, in_FRj);
1286 post_wait_for_FR (cpu, out_FRk);
1287 post_wait_for_FRdouble (cpu, in_FRdoublej);
1288 post_wait_for_FRdouble (cpu, out_FRdoublek);
1289 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1290 {
1291 post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRk));
1292 post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
1293 }
1294 restore_float_register_busy (cpu, -1, 1, in_FRj, 1, out_FRk, 1);
1295 restore_float_register_busy (cpu, -1, 1, in_FRdoublej, 2, out_FRdoublek, 2);
1296
1297 /* The latency of FRk will be at least the latency of the other inputs. */
1298 update_FR_latency (cpu, out_FRk, ps->post_wait);
1299 update_FRdouble_latency (cpu, out_FRdoublek, ps->post_wait);
1300
1301 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1302 {
1303 /* FNER has a latency of 14 cycles. */
1304 update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1305 update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), ps->post_wait);
1306 }
1307
1308 /* Once initiated, post-processing will take 14 cycles. */
1309 update_FR_ptime (cpu, out_FRk, 14);
1310 update_FRdouble_ptime (cpu, out_FRdoublek, 14);
1311
1312 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1313 {
1314 /* FNER has a latency of 14 cycles. */
1315 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 14);
1316 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRdoublek), 14);
1317 }
1318
1319 /* The latency of the sqrt unit will be the latency of the other
1320 inputs plus 14 cycles. */
1321 update_fsqrt_resource_latency (cpu, slot, ps->post_wait + 14);
1322
1323 fr550_reset_fr_flags (cpu, out_FRk);
1324 if (out_FRdoublek != -1)
1325 {
1326 fr550_reset_fr_flags (cpu, out_FRdoublek);
1327 fr550_reset_fr_flags (cpu, out_FRdoublek + 1);
1328 }
1329
1330 /* the media point unit resource has a latency of 16 cycles */
1331 update_media_resource_latency (cpu, slot, cycles + 16);
1332
1333 return cycles;
1334 }
1335
1336 int
1337 frvbf_model_fr550_u_float_compare (SIM_CPU *cpu, const IDESC *idesc,
1338 int unit_num, int referenced,
1339 INT in_FRi, INT in_FRj,
1340 INT in_FRdoublei, INT in_FRdoublej,
1341 INT out_FCCi_2)
1342 {
1343 int cycles;
1344 FRV_PROFILE_STATE *ps;
1345 FRV_VLIW *vliw;
1346 int slot;
1347
1348 if (model_insn == FRV_INSN_MODEL_PASS_1)
1349 return 0;
1350
1351 /* The preprocessing can execute right away. */
1352 cycles = idesc->timing->units[unit_num].done;
1353
1354 /* The post processing must wait if there is a dependency on a FR
1355 which is not ready yet. */
1356 adjust_float_register_busy (cpu, in_FRi, 1, in_FRj, 1, -1, 1);
1357 adjust_float_register_busy (cpu, in_FRdoublei, 2, in_FRdoublej, 2, -1, 1);
1358 ps = CPU_PROFILE_STATE (cpu);
1359 ps->post_wait = cycles;
1360 vliw = CPU_VLIW (cpu);
1361 slot = vliw->next_slot - 1;
1362 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1363 post_wait_for_float (cpu, slot);
1364 post_wait_for_FR (cpu, in_FRi);
1365 post_wait_for_FR (cpu, in_FRj);
1366 post_wait_for_FRdouble (cpu, in_FRdoublei);
1367 post_wait_for_FRdouble (cpu, in_FRdoublej);
1368 post_wait_for_CCR (cpu, out_FCCi_2);
1369 restore_float_register_busy (cpu, in_FRi, 1, in_FRj, 1, -1, 1);
1370 restore_float_register_busy (cpu, in_FRdoublei, 2, in_FRdoublej, 2, -1, 1);
1371
1372 /* The latency of FCCi_2 will be the latency of the other inputs plus 2
1373 cycles. */
1374 update_CCR_latency (cpu, out_FCCi_2, ps->post_wait + 2);
1375
1376 /* the media point unit resource has a latency of 4 cycles */
1377 update_media_resource_latency (cpu, slot, cycles + 4);
1378
1379 set_use_is_ccr_complex (cpu, out_FCCi_2);
1380
1381 return cycles;
1382 }
1383
1384 int
1385 frvbf_model_fr550_u_float_dual_compare (SIM_CPU *cpu, const IDESC *idesc,
1386 int unit_num, int referenced,
1387 INT in_FRi, INT in_FRj,
1388 INT out_FCCi_2)
1389 {
1390 int cycles;
1391 INT dual_FRi;
1392 INT dual_FRj;
1393 INT dual_FCCi_2;
1394 FRV_PROFILE_STATE *ps;
1395 FRV_VLIW *vliw;
1396 int slot;
1397
1398 if (model_insn == FRV_INSN_MODEL_PASS_1)
1399 return 0;
1400
1401 /* The preprocessing can execute right away. */
1402 cycles = idesc->timing->units[unit_num].done;
1403
1404 /* The post processing must wait if there is a dependency on a FR
1405 which is not ready yet. */
1406 ps = CPU_PROFILE_STATE (cpu);
1407 ps->post_wait = cycles;
1408 dual_FRi = DUAL_REG (in_FRi);
1409 dual_FRj = DUAL_REG (in_FRj);
1410 dual_FCCi_2 = out_FCCi_2 + 1;
1411 adjust_float_register_busy (cpu, in_FRi, 2, in_FRj, 2, -1, 1);
1412 vliw = CPU_VLIW (cpu);
1413 slot = vliw->next_slot - 1;
1414 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1415 post_wait_for_float (cpu, slot);
1416 post_wait_for_FR (cpu, in_FRi);
1417 post_wait_for_FR (cpu, in_FRj);
1418 post_wait_for_FR (cpu, dual_FRi);
1419 post_wait_for_FR (cpu, dual_FRj);
1420 post_wait_for_CCR (cpu, out_FCCi_2);
1421 post_wait_for_CCR (cpu, dual_FCCi_2);
1422 restore_float_register_busy (cpu, in_FRi, 2, in_FRj, 2, -1, 1);
1423
1424 /* The latency of FCCi_2 will be the latency of the other inputs plus 3
1425 cycles. */
1426 update_CCR_latency (cpu, out_FCCi_2, ps->post_wait + 3);
1427 update_CCR_latency (cpu, dual_FCCi_2, ps->post_wait + 3);
1428
1429 set_use_is_ccr_complex (cpu, out_FCCi_2);
1430 if (dual_FCCi_2 >= 0)
1431 set_use_is_ccr_complex (cpu, dual_FCCi_2);
1432
1433 /* the media point unit resource has a latency of 5 cycles */
1434 update_media_resource_latency (cpu, slot, cycles + 5);
1435
1436 return cycles;
1437 }
1438
1439 int
1440 frvbf_model_fr550_u_float_convert (SIM_CPU *cpu, const IDESC *idesc,
1441 int unit_num, int referenced,
1442 INT in_FRj, INT in_FRintj, INT in_FRdoublej,
1443 INT out_FRk, INT out_FRintk,
1444 INT out_FRdoublek)
1445 {
1446 int cycles;
1447 FRV_PROFILE_STATE *ps;
1448 FRV_VLIW *vliw;
1449 int slot;
1450
1451 if (model_insn == FRV_INSN_MODEL_PASS_1)
1452 return 0;
1453
1454 /* The preprocessing can execute right away. */
1455 cycles = idesc->timing->units[unit_num].done;
1456
1457 /* The post processing must wait if there is a dependency on a FR
1458 which is not ready yet. */
1459 ps = CPU_PROFILE_STATE (cpu);
1460 ps->post_wait = cycles;
1461 adjust_float_register_busy (cpu, -1, 1, in_FRj, 1, out_FRk, 1);
1462 adjust_float_register_busy (cpu, -1, 1, in_FRintj, 1, out_FRintk, 1);
1463 adjust_float_register_busy (cpu, -1, 1, in_FRdoublej, 2, out_FRdoublek, 2);
1464 vliw = CPU_VLIW (cpu);
1465 slot = vliw->next_slot - 1;
1466 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1467 post_wait_for_float (cpu, slot);
1468 post_wait_for_FR (cpu, in_FRj);
1469 post_wait_for_FR (cpu, in_FRintj);
1470 post_wait_for_FRdouble (cpu, in_FRdoublej);
1471 post_wait_for_FR (cpu, out_FRk);
1472 post_wait_for_FR (cpu, out_FRintk);
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_FRintk));
1478 post_wait_for_SPR (cpu, FNER_FOR_FR (out_FRdoublek));
1479 }
1480 restore_float_register_busy (cpu, -1, 1, in_FRj, 1, out_FRk, 1);
1481 restore_float_register_busy (cpu, -1, 1, in_FRintj, 1, out_FRintk, 1);
1482 restore_float_register_busy (cpu, -1, 1, in_FRdoublej, 2, out_FRdoublek, 2);
1483
1484 /* The latency of FRk will be at least the latency of the other inputs. */
1485 update_FR_latency (cpu, out_FRk, ps->post_wait);
1486 update_FR_latency (cpu, out_FRintk, ps->post_wait);
1487 update_FRdouble_latency (cpu, out_FRdoublek, ps->post_wait);
1488
1489 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1490 {
1491 update_SPR_latency (cpu, FNER_FOR_FR (out_FRk), ps->post_wait);
1492 update_SPR_latency (cpu, FNER_FOR_FR (out_FRintk), ps->post_wait);
1493 update_SPR_latency (cpu, FNER_FOR_FR (out_FRdoublek), ps->post_wait);
1494 }
1495
1496 /* Once initiated, post-processing will take 2 cycles. */
1497 update_FR_ptime (cpu, out_FRk, 2);
1498 update_FR_ptime (cpu, out_FRintk, 2);
1499 update_FRdouble_ptime (cpu, out_FRdoublek, 2);
1500
1501 if (CGEN_ATTR_VALUE(idesc, idesc->attrs, CGEN_INSN_NON_EXCEPTING))
1502 {
1503 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRk), 2);
1504 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRintk), 2);
1505 update_SPR_ptime (cpu, FNER_FOR_FR (out_FRdoublek), 2);
1506 }
1507
1508 /* Mark this use of the register as a floating point op. */
1509 if (out_FRk >= 0)
1510 set_use_is_fr_complex_2 (cpu, out_FRk);
1511 if (out_FRintk >= 0)
1512 set_use_is_fr_complex_2 (cpu, out_FRintk);
1513 if (out_FRdoublek >= 0)
1514 {
1515 set_use_is_fr_complex_2 (cpu, out_FRdoublek);
1516 set_use_is_fr_complex_2 (cpu, out_FRdoublek + 1);
1517 }
1518
1519 /* the media point unit resource has a latency of 4 cycles */
1520 update_media_resource_latency (cpu, slot, cycles + 4);
1521
1522 return cycles;
1523 }
1524
1525 int
1526 frvbf_model_fr550_u_spr2gr (SIM_CPU *cpu, const IDESC *idesc,
1527 int unit_num, int referenced,
1528 INT in_spr, INT out_GRj)
1529 {
1530 /* Modelling for this unit is the same as for fr500. */
1531 return frvbf_model_fr500_u_spr2gr (cpu, idesc, unit_num, referenced,
1532 in_spr, out_GRj);
1533 }
1534
1535 int
1536 frvbf_model_fr550_u_gr2spr (SIM_CPU *cpu, const IDESC *idesc,
1537 int unit_num, int referenced,
1538 INT in_GRj, INT out_spr)
1539 {
1540 int cycles;
1541
1542 if (model_insn == FRV_INSN_MODEL_PASS_1)
1543 {
1544 /* The entire VLIW insn must wait if there is a dependency on a register
1545 which is not ready yet. */
1546 vliw_wait_for_GR (cpu, in_GRj);
1547 vliw_wait_for_SPR (cpu, out_spr);
1548 handle_resource_wait (cpu);
1549 load_wait_for_GR (cpu, in_GRj);
1550 trace_vliw_wait_cycles (cpu);
1551 return 0;
1552 }
1553
1554 cycles = idesc->timing->units[unit_num].done;
1555
1556 #if 0
1557 /* The latency of spr is ? cycles. */
1558 update_SPR_latency (cpu, out_spr, cycles + ?);
1559 #endif
1560
1561 return cycles;
1562 }
1563
1564 int
1565 frvbf_model_fr550_u_gr2fr (SIM_CPU *cpu, const IDESC *idesc,
1566 int unit_num, int referenced,
1567 INT in_GRj, INT out_FRk)
1568 {
1569 int cycles;
1570
1571 if (model_insn == FRV_INSN_MODEL_PASS_1)
1572 {
1573 /* The entire VLIW insn must wait if there is a dependency on a register
1574 which is not ready yet.
1575 The latency of the registers may be less than previously recorded,
1576 depending on how they were used previously.
1577 See Table 14-15 in the LSI. */
1578 adjust_float_register_busy (cpu, -1, 1, -1, 1, out_FRk, 1);
1579 vliw_wait_for_GR (cpu, in_GRj);
1580 vliw_wait_for_FR (cpu, out_FRk);
1581 handle_resource_wait (cpu);
1582 load_wait_for_GR (cpu, in_GRj);
1583 load_wait_for_FR (cpu, out_FRk);
1584 trace_vliw_wait_cycles (cpu);
1585 return 0;
1586 }
1587
1588 /* The latency of FRk is 1 cycles. */
1589 cycles = idesc->timing->units[unit_num].done;
1590 update_FR_latency (cpu, out_FRk, cycles + 1);
1591
1592 set_use_is_fr_complex_1 (cpu, out_FRk);
1593
1594 return cycles;
1595 }
1596
1597 int
1598 frvbf_model_fr550_u_swap (SIM_CPU *cpu, const IDESC *idesc,
1599 int unit_num, int referenced,
1600 INT in_GRi, INT in_GRj, INT out_GRk)
1601 {
1602 int cycles;
1603
1604 if (model_insn == FRV_INSN_MODEL_PASS_1)
1605 {
1606 /* The entire VLIW insn must wait if there is a dependency on a register
1607 which is not ready yet. */
1608 vliw_wait_for_GR (cpu, in_GRi);
1609 vliw_wait_for_GR (cpu, in_GRj);
1610 vliw_wait_for_GR (cpu, out_GRk);
1611 handle_resource_wait (cpu);
1612 load_wait_for_GR (cpu, in_GRi);
1613 load_wait_for_GR (cpu, in_GRj);
1614 load_wait_for_GR (cpu, out_GRk);
1615 trace_vliw_wait_cycles (cpu);
1616 return 0;
1617 }
1618
1619 cycles = idesc->timing->units[unit_num].done;
1620
1621 /* The latency of GRk will depend on how long it takes to swap
1622 the the data from the cache or memory. */
1623 update_GR_latency_for_swap (cpu, out_GRk, cycles);
1624
1625 return cycles;
1626 }
1627
1628 int
1629 frvbf_model_fr550_u_fr2fr (SIM_CPU *cpu, const IDESC *idesc,
1630 int unit_num, int referenced,
1631 INT in_FRj, INT out_FRk)
1632 {
1633 int cycles;
1634
1635 if (model_insn == FRV_INSN_MODEL_PASS_1)
1636 {
1637 /* The entire VLIW insn must wait if there is a dependency on a register
1638 which is not ready yet.
1639 The latency of the registers may be less than previously recorded,
1640 depending on how they were used previously.
1641 See Table 14-15 in the LSI. */
1642 adjust_float_register_busy (cpu, -1, 1, in_FRj, 1, out_FRk, 1);
1643 vliw_wait_for_FR (cpu, in_FRj);
1644 vliw_wait_for_FR (cpu, out_FRk);
1645 handle_resource_wait (cpu);
1646 load_wait_for_FR (cpu, in_FRj);
1647 load_wait_for_FR (cpu, out_FRk);
1648 trace_vliw_wait_cycles (cpu);
1649 return 0;
1650 }
1651
1652 /* The latency of FRj is 2 cycles. */
1653 cycles = idesc->timing->units[unit_num].done;
1654 update_FR_latency (cpu, out_FRk, cycles + 2);
1655
1656 set_use_is_fr_complex_2 (cpu, out_FRk);
1657
1658 return cycles;
1659 }
1660
1661 int
1662 frvbf_model_fr550_u_fr2gr (SIM_CPU *cpu, const IDESC *idesc,
1663 int unit_num, int referenced,
1664 INT in_FRk, INT out_GRj)
1665 {
1666 int cycles;
1667
1668 if (model_insn == FRV_INSN_MODEL_PASS_1)
1669 {
1670 /* The entire VLIW insn must wait if there is a dependency on a register
1671 which is not ready yet.
1672 The latency of the registers may be less than previously recorded,
1673 depending on how they were used previously.
1674 See Table 14-15 in the LSI. */
1675 adjust_float_register_busy (cpu, in_FRk, 1, -1, 1, -1, 1);
1676 vliw_wait_for_FR (cpu, in_FRk);
1677 vliw_wait_for_GR (cpu, out_GRj);
1678 handle_resource_wait (cpu);
1679 load_wait_for_FR (cpu, in_FRk);
1680 load_wait_for_GR (cpu, out_GRj);
1681 trace_vliw_wait_cycles (cpu);
1682 return 0;
1683 }
1684
1685 /* The latency of GRj is 1 cycle. */
1686 cycles = idesc->timing->units[unit_num].done;
1687 update_GR_latency (cpu, out_GRj, cycles + 1);
1688
1689 return cycles;
1690 }
1691
1692 int
1693 frvbf_model_fr550_u_clrgr (SIM_CPU *cpu, const IDESC *idesc,
1694 int unit_num, int referenced,
1695 INT in_GRk)
1696 {
1697 /* Modelling for this unit is the same as for fr500. */
1698 return frvbf_model_fr500_u_clrgr (cpu, idesc, unit_num, referenced, in_GRk);
1699 }
1700
1701 int
1702 frvbf_model_fr550_u_clrfr (SIM_CPU *cpu, const IDESC *idesc,
1703 int unit_num, int referenced,
1704 INT in_FRk)
1705 {
1706 /* Modelling for this unit is the same as for fr500. */
1707 return frvbf_model_fr500_u_clrfr (cpu, idesc, unit_num, referenced, in_FRk);
1708 }
1709
1710 int
1711 frvbf_model_fr550_u_commit (SIM_CPU *cpu, const IDESC *idesc,
1712 int unit_num, int referenced,
1713 INT in_GRk, INT in_FRk)
1714 {
1715 /* Modelling for this unit is the same as for fr500. */
1716 return frvbf_model_fr500_u_commit (cpu, idesc, unit_num, referenced,
1717 in_GRk, in_FRk);
1718 }
1719
1720 int
1721 frvbf_model_fr550_u_media (SIM_CPU *cpu, const IDESC *idesc,
1722 int unit_num, int referenced,
1723 INT in_FRi, INT in_FRj, INT out_FRk)
1724 {
1725 int cycles;
1726 FRV_PROFILE_STATE *ps;
1727 FRV_VLIW *vliw;
1728 int slot;
1729
1730 if (model_insn == FRV_INSN_MODEL_PASS_1)
1731 return 0;
1732
1733 /* The preprocessing can execute right away. */
1734 cycles = idesc->timing->units[unit_num].done;
1735
1736 /* If the previous use of the registers was a media op,
1737 then their latency may be less than previously recorded.
1738 See Table 14-15 in the LSI. */
1739 adjust_float_register_busy_for_media (cpu, in_FRi, 1, in_FRj, 1, out_FRk, 1);
1740
1741 /* The post processing must wait if there is a dependency on a FR
1742 which is not ready yet. */
1743 ps = CPU_PROFILE_STATE (cpu);
1744 ps->post_wait = cycles;
1745 vliw = CPU_VLIW (cpu);
1746 slot = vliw->next_slot - 1;
1747 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1748 post_wait_for_media (cpu, slot);
1749 post_wait_for_FR (cpu, in_FRi);
1750 post_wait_for_FR (cpu, in_FRj);
1751 post_wait_for_FR (cpu, out_FRk);
1752
1753 /* Restore the busy cycles of the registers we used. */
1754 restore_float_register_busy_for_media (cpu, in_FRi, 1, in_FRj, 1, out_FRk, 1);
1755
1756 /* The latency of tht output register will be at least the latency of the
1757 other inputs. Once initiated, post-processing will take 1 cycle. */
1758 if (out_FRk >= 0)
1759 {
1760 update_FR_latency (cpu, out_FRk, ps->post_wait);
1761 update_FR_ptime (cpu, out_FRk, 1);
1762 /* Mark this use of the register as a media op. */
1763 set_use_is_fr_complex_1 (cpu, out_FRk);
1764 }
1765
1766 /* the floating point unit resource has a latency of 3 cycles */
1767 update_float_resource_latency (cpu, slot, cycles + 3);
1768
1769 return cycles;
1770 }
1771
1772 int
1773 frvbf_model_fr550_u_media_quad (SIM_CPU *cpu, const IDESC *idesc,
1774 int unit_num, int referenced,
1775 INT in_FRi, INT in_FRj,
1776 INT out_FRk)
1777 {
1778 int cycles;
1779 INT dual_FRi;
1780 INT dual_FRj;
1781 INT dual_FRk;
1782 FRV_PROFILE_STATE *ps;
1783 FRV_VLIW *vliw;
1784 int slot;
1785
1786 if (model_insn == FRV_INSN_MODEL_PASS_1)
1787 return 0;
1788
1789 /* The preprocessing can execute right away. */
1790 cycles = idesc->timing->units[unit_num].done;
1791
1792 dual_FRi = DUAL_REG (in_FRi);
1793 dual_FRj = DUAL_REG (in_FRj);
1794 dual_FRk = DUAL_REG (out_FRk);
1795
1796 /* The latency of the registers may be less than previously recorded,
1797 depending on how they were used previously.
1798 See Table 14-15 in the LSI. */
1799 adjust_float_register_busy_for_media (cpu, in_FRi, 2, in_FRj, 2, out_FRk, 2);
1800
1801 /* The post processing must wait if there is a dependency on a FR
1802 which is not ready yet. */
1803 ps = CPU_PROFILE_STATE (cpu);
1804 ps->post_wait = cycles;
1805 vliw = CPU_VLIW (cpu);
1806 slot = vliw->next_slot - 1;
1807 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1808 post_wait_for_media (cpu, slot);
1809 post_wait_for_FR (cpu, in_FRi);
1810 post_wait_for_FR (cpu, dual_FRi);
1811 post_wait_for_FR (cpu, in_FRj);
1812 post_wait_for_FR (cpu, dual_FRj);
1813 post_wait_for_FR (cpu, out_FRk);
1814 post_wait_for_FR (cpu, dual_FRk);
1815
1816 /* Restore the busy cycles of the registers we used. */
1817 restore_float_register_busy_for_media (cpu, in_FRi, 2, in_FRj, 2, out_FRk, 2);
1818
1819 /* The latency of the output register will be at least the latency of the
1820 other inputs. Once initiated, post-processing take 1 cycle. */
1821 update_FR_latency (cpu, out_FRk, ps->post_wait);
1822 update_FR_ptime (cpu, out_FRk, 1);
1823 set_use_is_fr_complex_1 (cpu, out_FRk);
1824
1825 if (dual_FRk >= 0)
1826 {
1827 update_FR_latency (cpu, dual_FRk, ps->post_wait);
1828 update_FR_ptime (cpu, dual_FRk, 1);
1829 set_use_is_fr_complex_1 (cpu, dual_FRk);
1830 }
1831
1832 /* the floating point unit resource has a latency of 3 cycles */
1833 update_float_resource_latency (cpu, slot, cycles + 3);
1834
1835 return cycles;
1836 }
1837
1838 int
1839 frvbf_model_fr550_u_media_dual_expand (SIM_CPU *cpu, const IDESC *idesc,
1840 int unit_num, int referenced,
1841 INT in_FRi, INT out_FRk)
1842 {
1843 int cycles;
1844 INT dual_FRk;
1845 FRV_PROFILE_STATE *ps;
1846 FRV_VLIW *vliw;
1847 int slot;
1848
1849 if (model_insn == FRV_INSN_MODEL_PASS_1)
1850 return 0;
1851
1852 /* The preprocessing can execute right away. */
1853 cycles = idesc->timing->units[unit_num].done;
1854
1855 /* If the previous use of the registers was a media op,
1856 then their latency will be less than previously recorded.
1857 See Table 14-15 in the LSI. */
1858 dual_FRk = DUAL_REG (out_FRk);
1859 adjust_float_register_busy_for_media (cpu, in_FRi, 1, -1, 1, out_FRk, 2);
1860
1861 /* The post processing must wait if there is a dependency on a FR
1862 which is not ready yet. */
1863 ps = CPU_PROFILE_STATE (cpu);
1864 ps->post_wait = cycles;
1865 vliw = CPU_VLIW (cpu);
1866 slot = vliw->next_slot - 1;
1867 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1868 post_wait_for_media (cpu, slot);
1869 post_wait_for_FR (cpu, in_FRi);
1870 post_wait_for_FR (cpu, out_FRk);
1871 post_wait_for_FR (cpu, dual_FRk);
1872
1873 /* Restore the busy cycles of the registers we used. */
1874 restore_float_register_busy_for_media (cpu, in_FRi, 1, -1, 1, out_FRk, 2);
1875
1876 /* The latency of the output register will be at least the latency of the
1877 other inputs. Once initiated, post-processing will take 1 cycle. */
1878 update_FR_latency (cpu, out_FRk, ps->post_wait);
1879 update_FR_ptime (cpu, out_FRk, 1);
1880 set_use_is_fr_complex_1 (cpu, out_FRk);
1881
1882 if (dual_FRk >= 0)
1883 {
1884 update_FR_latency (cpu, dual_FRk, ps->post_wait);
1885 update_FR_ptime (cpu, dual_FRk, 1);
1886 set_use_is_fr_complex_1 (cpu, dual_FRk);
1887 }
1888
1889 /* the floating point unit resource has a latency of 3 cycles */
1890 update_float_resource_latency (cpu, slot, cycles + 3);
1891
1892 return cycles;
1893 }
1894
1895 int
1896 frvbf_model_fr550_u_media_3_dual (SIM_CPU *cpu, const IDESC *idesc,
1897 int unit_num, int referenced,
1898 INT in_FRi, INT out_FRk)
1899 {
1900 int cycles;
1901 INT dual_FRi;
1902 FRV_PROFILE_STATE *ps;
1903 FRV_VLIW *vliw;
1904 int slot;
1905
1906 if (model_insn == FRV_INSN_MODEL_PASS_1)
1907 return 0;
1908
1909 /* The preprocessing can execute right away. */
1910 cycles = idesc->timing->units[unit_num].done;
1911
1912 dual_FRi = DUAL_REG (in_FRi);
1913
1914 /* The latency of the registers may be less than previously recorded,
1915 depending on how they were used previously.
1916 See Table 14-15 in the LSI. */
1917 adjust_float_register_busy_for_media (cpu, in_FRi, 2, -1, 1, out_FRk, 1);
1918
1919 /* The post processing must wait if there is a dependency on a FR
1920 which is not ready yet. */
1921 ps = CPU_PROFILE_STATE (cpu);
1922 ps->post_wait = cycles;
1923 vliw = CPU_VLIW (cpu);
1924 slot = vliw->next_slot - 1;
1925 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1926 post_wait_for_media (cpu, slot);
1927 post_wait_for_FR (cpu, in_FRi);
1928 post_wait_for_FR (cpu, dual_FRi);
1929 post_wait_for_FR (cpu, out_FRk);
1930
1931 /* Restore the busy cycles of the registers we used. */
1932 restore_float_register_busy_for_media (cpu, in_FRi, 2, -1, 1, out_FRk, 1);
1933
1934 /* The latency of the output register will be at least the latency of the
1935 other inputs. Once initiated, post-processing takes 1 cycle. */
1936 update_FR_latency (cpu, out_FRk, ps->post_wait);
1937 update_FR_ptime (cpu, out_FRk, 1);
1938
1939 set_use_is_fr_complex_1 (cpu, out_FRk);
1940
1941 /* the floating point unit resource has a latency of 3 cycles */
1942 update_float_resource_latency (cpu, slot, cycles + 3);
1943
1944 return cycles;
1945 }
1946
1947 int
1948 frvbf_model_fr550_u_media_3_acc (SIM_CPU *cpu, const IDESC *idesc,
1949 int unit_num, int referenced,
1950 INT in_FRj, INT in_ACC40Si,
1951 INT out_FRk)
1952 {
1953 int cycles;
1954 FRV_PROFILE_STATE *ps;
1955 FRV_VLIW *vliw;
1956 int slot;
1957
1958 if (model_insn == FRV_INSN_MODEL_PASS_1)
1959 return 0;
1960
1961 /* The preprocessing can execute right away. */
1962 cycles = idesc->timing->units[unit_num].done;
1963
1964 /* If the previous use of the registers was a media op,
1965 then their latency will be less than previously recorded.
1966 See Table 14-15 in the LSI. */
1967 adjust_float_register_busy_for_media (cpu, -1, 1, in_FRj, 1, out_FRk, 1);
1968
1969 /* The post processing must wait if there is a dependency on a FR
1970 which is not ready yet. */
1971 ps = CPU_PROFILE_STATE (cpu);
1972 ps->post_wait = cycles;
1973 vliw = CPU_VLIW (cpu);
1974 slot = vliw->next_slot - 1;
1975 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
1976 post_wait_for_media (cpu, slot);
1977 post_wait_for_FR (cpu, in_FRj);
1978 post_wait_for_FR (cpu, out_FRk);
1979 post_wait_for_ACC (cpu, in_ACC40Si);
1980
1981 /* Restore the busy cycles of the registers we used. */
1982 restore_float_register_busy_for_media (cpu, -1, 1, in_FRj, 1, out_FRk, 1);
1983
1984 /* The latency of tht output register will be at least the latency of the
1985 other inputs. Once initiated, post-processing will take 1 cycle. */
1986 update_FR_latency (cpu, out_FRk, ps->post_wait);
1987 update_FR_ptime (cpu, out_FRk, 1);
1988
1989 set_use_is_fr_complex_1 (cpu, out_FRk);
1990
1991 /* the floating point unit resource has a latency of 3 cycles */
1992 update_float_resource_latency (cpu, slot, cycles + 3);
1993
1994 return cycles;
1995 }
1996
1997 int
1998 frvbf_model_fr550_u_media_3_acc_dual (SIM_CPU *cpu, const IDESC *idesc,
1999 int unit_num, int referenced,
2000 INT in_ACC40Si, INT out_FRk)
2001 {
2002 int cycles;
2003 FRV_PROFILE_STATE *ps;
2004 INT ACC40Si_1;
2005 INT dual_FRk;
2006 FRV_VLIW *vliw;
2007 int slot;
2008
2009 if (model_insn == FRV_INSN_MODEL_PASS_1)
2010 return 0;
2011
2012 /* The preprocessing can execute right away. */
2013 cycles = idesc->timing->units[unit_num].done;
2014
2015 ACC40Si_1 = DUAL_REG (in_ACC40Si);
2016 dual_FRk = DUAL_REG (out_FRk);
2017
2018 /* If the previous use of the registers was a media op,
2019 then their latency will be less than previously recorded.
2020 See Table 14-15 in the LSI. */
2021 adjust_float_register_busy_for_media (cpu, -1, 1, -1, 1, out_FRk, 2);
2022
2023 /* The post processing must wait if there is a dependency on a FR
2024 which is not ready yet. */
2025 ps = CPU_PROFILE_STATE (cpu);
2026 ps->post_wait = cycles;
2027 vliw = CPU_VLIW (cpu);
2028 slot = vliw->next_slot - 1;
2029 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2030 post_wait_for_media (cpu, slot);
2031 post_wait_for_ACC (cpu, in_ACC40Si);
2032 post_wait_for_ACC (cpu, ACC40Si_1);
2033 post_wait_for_FR (cpu, out_FRk);
2034 post_wait_for_FR (cpu, dual_FRk);
2035
2036 /* Restore the busy cycles of the registers we used. */
2037 restore_float_register_busy_for_media (cpu, -1, 1, -1, 1, out_FRk, 2);
2038
2039 /* The latency of the output register will be at least the latency of the
2040 other inputs. Once initiated, post-processing will take 1 cycle. */
2041 update_FR_latency (cpu, out_FRk, ps->post_wait);
2042 update_FR_ptime (cpu, out_FRk, 1);
2043 set_use_is_fr_complex_1 (cpu, out_FRk);
2044 if (dual_FRk >= 0)
2045 {
2046 update_FR_latency (cpu, dual_FRk, ps->post_wait);
2047 update_FR_ptime (cpu, dual_FRk, 1);
2048 set_use_is_fr_complex_1 (cpu, dual_FRk);
2049 }
2050
2051 /* the floating point unit resource has a latency of 3 cycles */
2052 update_float_resource_latency (cpu, slot, cycles + 3);
2053
2054 return cycles;
2055 }
2056
2057 int
2058 frvbf_model_fr550_u_media_3_wtacc (SIM_CPU *cpu, const IDESC *idesc,
2059 int unit_num, int referenced,
2060 INT in_FRi, INT out_ACC40Sk)
2061 {
2062 int cycles;
2063 FRV_PROFILE_STATE *ps;
2064 FRV_VLIW *vliw;
2065 int slot;
2066
2067 if (model_insn == FRV_INSN_MODEL_PASS_1)
2068 return 0;
2069
2070 /* The preprocessing can execute right away. */
2071 cycles = idesc->timing->units[unit_num].done;
2072
2073 ps = CPU_PROFILE_STATE (cpu);
2074
2075 /* The latency of the registers may be less than previously recorded,
2076 depending on how they were used previously.
2077 See Table 14-15 in the LSI. */
2078 adjust_float_register_busy_for_media (cpu, in_FRi, 1, -1, 1, -1, 1);
2079
2080 /* The post processing must wait if there is a dependency on a FR
2081 which is not ready yet. */
2082 ps->post_wait = cycles;
2083 vliw = CPU_VLIW (cpu);
2084 slot = vliw->next_slot - 1;
2085 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2086 post_wait_for_media (cpu, slot);
2087 post_wait_for_FR (cpu, in_FRi);
2088 post_wait_for_ACC (cpu, out_ACC40Sk);
2089
2090 /* Restore the busy cycles of the registers we used. */
2091 restore_float_register_busy_for_media (cpu, in_FRi, 1, -1, 1, -1, 1);
2092
2093 /* The latency of the output register will be at least the latency of the
2094 other inputs. Once initiated, post-processing will take 1 cycle. */
2095 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait);
2096 update_ACC_ptime (cpu, out_ACC40Sk, 1);
2097 set_use_is_acc_mmac (cpu, out_ACC40Sk);
2098
2099 /* the floating point unit resource has a latency of 3 cycles */
2100 update_float_resource_latency (cpu, slot, cycles + 3);
2101
2102 return cycles;
2103 }
2104
2105 int
2106 frvbf_model_fr550_u_media_3_mclracc (SIM_CPU *cpu, const IDESC *idesc,
2107 int unit_num, int referenced)
2108 {
2109 int cycles;
2110 FRV_PROFILE_STATE *ps;
2111 FRV_VLIW *vliw;
2112 int slot;
2113 int i;
2114
2115 if (model_insn == FRV_INSN_MODEL_PASS_1)
2116 return 0;
2117
2118 /* The preprocessing can execute right away. */
2119 cycles = idesc->timing->units[unit_num].done;
2120
2121 ps = CPU_PROFILE_STATE (cpu);
2122
2123 /* The post processing must wait if there is a dependency on a FR
2124 which is not ready yet. */
2125 ps->post_wait = cycles;
2126 vliw = CPU_VLIW (cpu);
2127 slot = vliw->next_slot - 1;
2128 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2129 post_wait_for_media (cpu, slot);
2130
2131 /* If A was 1 and the accumulator was ACC0, then we must check all
2132 accumulators. Otherwise just wait for the specified accumulator. */
2133 if (ps->mclracc_A && ps->mclracc_acc == 0)
2134 {
2135 for (i = 0; i < 8; ++i)
2136 post_wait_for_ACC (cpu, i);
2137 }
2138 else
2139 post_wait_for_ACC (cpu, ps->mclracc_acc);
2140
2141 /* The latency of the output registers will be at least the latency of the
2142 other inputs. Once initiated, post-processing will take 1 cycle. */
2143 if (ps->mclracc_A && ps->mclracc_acc == 0)
2144 {
2145 for (i = 0; i < 8; ++i)
2146 {
2147 update_ACC_latency (cpu, i, ps->post_wait);
2148 update_ACC_ptime (cpu, i, 1);
2149 set_use_is_acc_mmac (cpu, i);
2150 }
2151 }
2152 else
2153 {
2154 update_ACC_latency (cpu, ps->mclracc_acc, ps->post_wait);
2155 update_ACC_ptime (cpu, ps->mclracc_acc, 1);
2156 set_use_is_acc_mmac (cpu, ps->mclracc_acc);
2157 }
2158
2159 /* the floating point unit resource has a latency of 3 cycles */
2160 update_float_resource_latency (cpu, slot, cycles + 3);
2161
2162 return cycles;
2163 }
2164
2165 int
2166 frvbf_model_fr550_u_media_set (SIM_CPU *cpu, const IDESC *idesc,
2167 int unit_num, int referenced,
2168 INT out_FRk)
2169 {
2170 int cycles;
2171 FRV_PROFILE_STATE *ps;
2172 FRV_VLIW *vliw;
2173 int slot;
2174
2175 if (model_insn == FRV_INSN_MODEL_PASS_1)
2176 return 0;
2177
2178 /* The preprocessing can execute right away. */
2179 cycles = idesc->timing->units[unit_num].done;
2180
2181 /* If the previous use of the registers was a media op,
2182 then their latency will be less than previously recorded.
2183 See Table 14-15 in the LSI. */
2184 adjust_float_register_busy_for_media (cpu, -1, 1, -1, 1, out_FRk, 1);
2185
2186 /* The post processing must wait if there is a dependency on a FR
2187 which is not ready yet. */
2188 ps = CPU_PROFILE_STATE (cpu);
2189 ps->post_wait = cycles;
2190 vliw = CPU_VLIW (cpu);
2191 slot = vliw->next_slot - 1;
2192 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2193 post_wait_for_media (cpu, slot);
2194 post_wait_for_FR (cpu, out_FRk);
2195
2196 /* Restore the busy cycles of the registers we used. */
2197 restore_float_register_busy_for_media (cpu, -1, 1, -1, 1, out_FRk, 1);
2198
2199 /* The latency of the output register will be at least the latency of the
2200 other inputs. Once initiated, post-processing takes 1 cycle. */
2201 update_FR_latency (cpu, out_FRk, ps->post_wait);
2202 update_FR_ptime (cpu, out_FRk, 1);
2203 fr550_reset_acc_flags (cpu, out_FRk);
2204
2205 /* the floating point unit resource has a latency of 3 cycles */
2206 update_float_resource_latency (cpu, slot, cycles + 3);
2207
2208 return cycles;
2209 }
2210
2211 int
2212 frvbf_model_fr550_u_media_4 (SIM_CPU *cpu, const IDESC *idesc,
2213 int unit_num, int referenced,
2214 INT in_FRi, INT in_FRj,
2215 INT out_ACC40Sk, INT out_ACC40Uk)
2216 {
2217 int cycles;
2218 INT dual_ACC40Sk;
2219 INT dual_ACC40Uk;
2220 FRV_PROFILE_STATE *ps;
2221 FRV_VLIW *vliw;
2222 int slot;
2223
2224 if (model_insn == FRV_INSN_MODEL_PASS_1)
2225 return 0;
2226
2227 /* The preprocessing can execute right away. */
2228 cycles = idesc->timing->units[unit_num].done;
2229
2230 ps = CPU_PROFILE_STATE (cpu);
2231 dual_ACC40Sk = DUAL_REG (out_ACC40Sk);
2232 dual_ACC40Uk = DUAL_REG (out_ACC40Uk);
2233
2234 /* The latency of the registers may be less than previously recorded,
2235 depending on how they were used previously.
2236 See Table 14-15 in the LSI. */
2237 adjust_acc_busy_for_mmac (cpu, -1, 1, out_ACC40Sk, 2);
2238 adjust_acc_busy_for_mmac (cpu, -1, 1, out_ACC40Uk, 2);
2239
2240 /* The post processing must wait if there is a dependency on a FR
2241 which is not ready yet. */
2242 ps->post_wait = cycles;
2243 vliw = CPU_VLIW (cpu);
2244 slot = vliw->next_slot - 1;
2245 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2246 post_wait_for_media (cpu, slot);
2247 post_wait_for_FR (cpu, in_FRi);
2248 post_wait_for_FR (cpu, in_FRj);
2249 post_wait_for_ACC (cpu, out_ACC40Sk);
2250 post_wait_for_ACC (cpu, dual_ACC40Sk);
2251 post_wait_for_ACC (cpu, out_ACC40Uk);
2252 post_wait_for_ACC (cpu, dual_ACC40Uk);
2253
2254 /* Restore the busy cycles of the registers we used. */
2255 restore_acc_busy_for_mmac (cpu, -1, 1, out_ACC40Sk, 2);
2256 restore_acc_busy_for_mmac (cpu, -1, 1, out_ACC40Uk, 2);
2257
2258 /* The latency of the output register will be at least the latency of the
2259 other inputs. Once initiated, post-processing will take 1 cycles. */
2260 if (out_ACC40Sk >= 0)
2261 {
2262 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2263 set_use_is_acc_mmac (cpu, out_ACC40Sk);
2264 }
2265 if (dual_ACC40Sk >= 0)
2266 {
2267 update_ACC_latency (cpu, dual_ACC40Sk, ps->post_wait + 1);
2268 set_use_is_acc_mmac (cpu, dual_ACC40Sk);
2269 }
2270 if (out_ACC40Uk >= 0)
2271 {
2272 update_ACC_latency (cpu, out_ACC40Uk, ps->post_wait + 1);
2273 set_use_is_acc_mmac (cpu, out_ACC40Uk);
2274 }
2275 if (dual_ACC40Uk >= 0)
2276 {
2277 update_ACC_latency (cpu, dual_ACC40Uk, ps->post_wait + 1);
2278 set_use_is_acc_mmac (cpu, dual_ACC40Uk);
2279 }
2280
2281 /* the floating point unit resource has a latency of 3 cycles */
2282 update_float_resource_latency (cpu, slot, cycles + 3);
2283
2284 return cycles;
2285 }
2286
2287 int
2288 frvbf_model_fr550_u_media_4_acc (SIM_CPU *cpu, const IDESC *idesc,
2289 int unit_num, int referenced,
2290 INT in_ACC40Si, INT out_ACC40Sk)
2291 {
2292 int cycles;
2293 INT ACC40Si_1;
2294 FRV_PROFILE_STATE *ps;
2295 FRV_VLIW *vliw;
2296 int slot;
2297
2298 if (model_insn == FRV_INSN_MODEL_PASS_1)
2299 return 0;
2300
2301 /* The preprocessing can execute right away. */
2302 cycles = idesc->timing->units[unit_num].done;
2303
2304 ACC40Si_1 = DUAL_REG (in_ACC40Si);
2305
2306 ps = CPU_PROFILE_STATE (cpu);
2307 /* The latency of the registers may be less than previously recorded,
2308 depending on how they were used previously.
2309 See Table 14-15 in the LSI. */
2310 adjust_acc_busy_for_mmac (cpu, in_ACC40Si, 2, out_ACC40Sk, 1);
2311
2312 /* The post processing must wait if there is a dependency on a register
2313 which is not ready yet. */
2314 ps->post_wait = cycles;
2315 vliw = CPU_VLIW (cpu);
2316 slot = vliw->next_slot - 1;
2317 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2318 post_wait_for_media (cpu, slot);
2319 post_wait_for_ACC (cpu, in_ACC40Si);
2320 post_wait_for_ACC (cpu, ACC40Si_1);
2321 post_wait_for_ACC (cpu, out_ACC40Sk);
2322
2323 /* Restore the busy cycles of the registers we used. */
2324 restore_acc_busy_for_mmac (cpu, in_ACC40Si, 2, out_ACC40Sk, 1);
2325
2326 /* The latency of the output register will be at least the latency of the
2327 other inputs. Once initiated, post-processing will take 1 cycle. */
2328 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2329 set_use_is_acc_mmac (cpu, out_ACC40Sk);
2330
2331 /* the floating point unit resource has a latency of 3 cycles */
2332 update_float_resource_latency (cpu, slot, cycles + 3);
2333
2334 return cycles;
2335 }
2336
2337 int
2338 frvbf_model_fr550_u_media_4_acc_dual (SIM_CPU *cpu, const IDESC *idesc,
2339 int unit_num, int referenced,
2340 INT in_ACC40Si, INT out_ACC40Sk)
2341 {
2342 int cycles;
2343 INT ACC40Si_1;
2344 INT ACC40Si_2;
2345 INT ACC40Si_3;
2346 INT ACC40Sk_1;
2347 FRV_PROFILE_STATE *ps;
2348 FRV_VLIW *vliw;
2349 int slot;
2350
2351 if (model_insn == FRV_INSN_MODEL_PASS_1)
2352 return 0;
2353
2354 /* The preprocessing can execute right away. */
2355 cycles = idesc->timing->units[unit_num].done;
2356
2357 ACC40Si_1 = DUAL_REG (in_ACC40Si);
2358 ACC40Si_2 = DUAL_REG (ACC40Si_1);
2359 ACC40Si_3 = DUAL_REG (ACC40Si_2);
2360 ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
2361
2362 ps = CPU_PROFILE_STATE (cpu);
2363 /* The latency of the registers may be less than previously recorded,
2364 depending on how they were used previously.
2365 See Table 14-15 in the LSI. */
2366 adjust_acc_busy_for_mmac (cpu, in_ACC40Si, 4, out_ACC40Sk, 2);
2367
2368 /* The post processing must wait if there is a dependency on a register
2369 which is not ready yet. */
2370 ps->post_wait = cycles;
2371 vliw = CPU_VLIW (cpu);
2372 slot = vliw->next_slot - 1;
2373 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2374 post_wait_for_media (cpu, slot);
2375 post_wait_for_ACC (cpu, in_ACC40Si);
2376 post_wait_for_ACC (cpu, ACC40Si_1);
2377 post_wait_for_ACC (cpu, ACC40Si_2);
2378 post_wait_for_ACC (cpu, ACC40Si_3);
2379 post_wait_for_ACC (cpu, out_ACC40Sk);
2380 post_wait_for_ACC (cpu, ACC40Sk_1);
2381
2382 /* Restore the busy cycles of the registers we used. */
2383 restore_acc_busy_for_mmac (cpu, in_ACC40Si, 4, out_ACC40Sk, 2);
2384
2385 /* The latency of the output register will be at least the latency of the
2386 other inputs. Once initiated, post-processing will take 1 cycle. */
2387 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2388 set_use_is_acc_mmac (cpu, out_ACC40Sk);
2389 if (ACC40Sk_1 >= 0)
2390 {
2391 update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
2392 set_use_is_acc_mmac (cpu, ACC40Sk_1);
2393 }
2394
2395 /* the floating point unit resource has a latency of 3 cycles */
2396 update_float_resource_latency (cpu, slot, cycles + 3);
2397
2398 return cycles;
2399 }
2400
2401 int
2402 frvbf_model_fr550_u_media_4_add_sub (SIM_CPU *cpu, const IDESC *idesc,
2403 int unit_num, int referenced,
2404 INT in_ACC40Si, INT out_ACC40Sk)
2405 {
2406 int cycles;
2407 INT ACC40Si_1;
2408 INT ACC40Sk_1;
2409 FRV_PROFILE_STATE *ps;
2410 FRV_VLIW *vliw;
2411 int slot;
2412
2413 if (model_insn == FRV_INSN_MODEL_PASS_1)
2414 return 0;
2415
2416 /* The preprocessing can execute right away. */
2417 cycles = idesc->timing->units[unit_num].done;
2418
2419 ACC40Si_1 = DUAL_REG (in_ACC40Si);
2420 ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
2421
2422 ps = CPU_PROFILE_STATE (cpu);
2423 /* The latency of the registers may be less than previously recorded,
2424 depending on how they were used previously.
2425 See Table 14-15 in the LSI. */
2426 adjust_acc_busy_for_mmac (cpu, in_ACC40Si, 2, out_ACC40Sk, 2);
2427
2428 /* The post processing must wait if there is a dependency on a register
2429 which is not ready yet. */
2430 ps->post_wait = cycles;
2431 vliw = CPU_VLIW (cpu);
2432 slot = vliw->next_slot - 1;
2433 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2434 post_wait_for_media (cpu, slot);
2435 post_wait_for_ACC (cpu, in_ACC40Si);
2436 post_wait_for_ACC (cpu, ACC40Si_1);
2437 post_wait_for_ACC (cpu, out_ACC40Sk);
2438 post_wait_for_ACC (cpu, ACC40Sk_1);
2439
2440 /* Restore the busy cycles of the registers we used. */
2441 restore_acc_busy_for_mmac (cpu, in_ACC40Si, 2, out_ACC40Sk, 2);
2442
2443 /* The latency of the output register will be at least the latency of the
2444 other inputs. Once initiated, post-processing will take 1 cycle. */
2445 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2446 set_use_is_acc_mmac (cpu, out_ACC40Sk);
2447 if (ACC40Sk_1 >= 0)
2448 {
2449 update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
2450 set_use_is_acc_mmac (cpu, ACC40Sk_1);
2451 }
2452
2453 /* the floating point unit resource has a latency of 3 cycles */
2454 update_float_resource_latency (cpu, slot, cycles + 3);
2455
2456 return cycles;
2457 }
2458
2459 int
2460 frvbf_model_fr550_u_media_4_add_sub_dual (SIM_CPU *cpu, const IDESC *idesc,
2461 int unit_num, int referenced,
2462 INT in_ACC40Si, INT out_ACC40Sk)
2463 {
2464 int cycles;
2465 INT ACC40Si_1;
2466 INT ACC40Si_2;
2467 INT ACC40Si_3;
2468 INT ACC40Sk_1;
2469 INT ACC40Sk_2;
2470 INT ACC40Sk_3;
2471 FRV_PROFILE_STATE *ps;
2472 FRV_VLIW *vliw;
2473 int slot;
2474
2475 if (model_insn == FRV_INSN_MODEL_PASS_1)
2476 return 0;
2477
2478 /* The preprocessing can execute right away. */
2479 cycles = idesc->timing->units[unit_num].done;
2480
2481 ACC40Si_1 = DUAL_REG (in_ACC40Si);
2482 ACC40Si_2 = DUAL_REG (ACC40Si_1);
2483 ACC40Si_3 = DUAL_REG (ACC40Si_2);
2484 ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
2485 ACC40Sk_2 = DUAL_REG (ACC40Sk_1);
2486 ACC40Sk_3 = DUAL_REG (ACC40Sk_2);
2487
2488 ps = CPU_PROFILE_STATE (cpu);
2489 /* The latency of the registers may be less than previously recorded,
2490 depending on how they were used previously.
2491 See Table 14-15 in the LSI. */
2492 adjust_acc_busy_for_mmac (cpu, in_ACC40Si, 4, out_ACC40Sk, 4);
2493
2494 /* The post processing must wait if there is a dependency on a register
2495 which is not ready yet. */
2496 ps->post_wait = cycles;
2497 vliw = CPU_VLIW (cpu);
2498 slot = vliw->next_slot - 1;
2499 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2500 post_wait_for_media (cpu, slot);
2501 post_wait_for_ACC (cpu, in_ACC40Si);
2502 post_wait_for_ACC (cpu, ACC40Si_1);
2503 post_wait_for_ACC (cpu, ACC40Si_2);
2504 post_wait_for_ACC (cpu, ACC40Si_3);
2505 post_wait_for_ACC (cpu, out_ACC40Sk);
2506 post_wait_for_ACC (cpu, ACC40Sk_1);
2507 post_wait_for_ACC (cpu, ACC40Sk_2);
2508 post_wait_for_ACC (cpu, ACC40Sk_3);
2509
2510 /* Restore the busy cycles of the registers we used. */
2511 restore_acc_busy_for_mmac (cpu, in_ACC40Si, 4, out_ACC40Sk, 4);
2512
2513 /* The latency of the output register will be at least the latency of the
2514 other inputs. Once initiated, post-processing will take 1 cycle. */
2515 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2516 set_use_is_acc_mmac (cpu, out_ACC40Sk);
2517 if (ACC40Sk_1 >= 0)
2518 {
2519 update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
2520 set_use_is_acc_mmac (cpu, ACC40Sk_1);
2521 }
2522 if (ACC40Sk_2 >= 0)
2523 {
2524 update_ACC_latency (cpu, ACC40Sk_2, ps->post_wait + 1);
2525 set_use_is_acc_mmac (cpu, ACC40Sk_2);
2526 }
2527 if (ACC40Sk_3 >= 0)
2528 {
2529 update_ACC_latency (cpu, ACC40Sk_3, ps->post_wait + 1);
2530 set_use_is_acc_mmac (cpu, ACC40Sk_3);
2531 }
2532
2533 /* the floating point unit resource has a latency of 3 cycles */
2534 update_float_resource_latency (cpu, slot, cycles + 3);
2535
2536 return cycles;
2537 }
2538
2539 int
2540 frvbf_model_fr550_u_media_4_quad (SIM_CPU *cpu, const IDESC *idesc,
2541 int unit_num, int referenced,
2542 INT in_FRi, INT in_FRj,
2543 INT out_ACC40Sk, INT out_ACC40Uk)
2544 {
2545 int cycles;
2546 INT dual_FRi;
2547 INT dual_FRj;
2548 INT ACC40Sk_1;
2549 INT ACC40Sk_2;
2550 INT ACC40Sk_3;
2551 INT ACC40Uk_1;
2552 INT ACC40Uk_2;
2553 INT ACC40Uk_3;
2554 FRV_PROFILE_STATE *ps;
2555 FRV_VLIW *vliw;
2556 int slot;
2557
2558 if (model_insn == FRV_INSN_MODEL_PASS_1)
2559 return 0;
2560
2561 /* The preprocessing can execute right away. */
2562 cycles = idesc->timing->units[unit_num].done;
2563
2564 dual_FRi = DUAL_REG (in_FRi);
2565 dual_FRj = DUAL_REG (in_FRj);
2566 ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
2567 ACC40Sk_2 = DUAL_REG (ACC40Sk_1);
2568 ACC40Sk_3 = DUAL_REG (ACC40Sk_2);
2569 ACC40Uk_1 = DUAL_REG (out_ACC40Uk);
2570 ACC40Uk_2 = DUAL_REG (ACC40Uk_1);
2571 ACC40Uk_3 = DUAL_REG (ACC40Uk_2);
2572
2573 ps = CPU_PROFILE_STATE (cpu);
2574 /* The latency of the registers may be less than previously recorded,
2575 depending on how they were used previously.
2576 See Table 14-15 in the LSI. */
2577 adjust_float_register_busy_for_media (cpu, in_FRi, 2, in_FRj, 2, -1, 1);
2578 adjust_acc_busy_for_mmac (cpu, -1, 1, out_ACC40Sk, 4);
2579 adjust_acc_busy_for_mmac (cpu, -1, 1, out_ACC40Uk, 4);
2580
2581 /* The post processing must wait if there is a dependency on a FR
2582 which is not ready yet. */
2583 ps->post_wait = cycles;
2584 vliw = CPU_VLIW (cpu);
2585 slot = vliw->next_slot - 1;
2586 slot = (*vliw->current_vliw)[slot] - UNIT_FM0;
2587 post_wait_for_media (cpu, slot);
2588 post_wait_for_FR (cpu, in_FRi);
2589 post_wait_for_FR (cpu, dual_FRi);
2590 post_wait_for_FR (cpu, in_FRj);
2591 post_wait_for_FR (cpu, dual_FRj);
2592 post_wait_for_ACC (cpu, out_ACC40Sk);
2593 post_wait_for_ACC (cpu, ACC40Sk_1);
2594 post_wait_for_ACC (cpu, ACC40Sk_2);
2595 post_wait_for_ACC (cpu, ACC40Sk_3);
2596 post_wait_for_ACC (cpu, out_ACC40Uk);
2597 post_wait_for_ACC (cpu, ACC40Uk_1);
2598 post_wait_for_ACC (cpu, ACC40Uk_2);
2599 post_wait_for_ACC (cpu, ACC40Uk_3);
2600
2601 /* Restore the busy cycles of the registers we used. */
2602 restore_float_register_busy_for_media (cpu, in_FRi, 2, in_FRj, 2, -1, 1);
2603 restore_acc_busy_for_mmac (cpu, -1, 1, out_ACC40Sk, 4);
2604 restore_acc_busy_for_mmac (cpu, -1, 1, out_ACC40Uk, 4);
2605
2606 /* The latency of the output register will be at least the latency of the
2607 other inputs. Once initiated, post-processing will take 1 cycle. */
2608 if (out_ACC40Sk >= 0)
2609 {
2610 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
2611
2612 set_use_is_acc_mmac (cpu, out_ACC40Sk);
2613 if (ACC40Sk_1 >= 0)
2614 {
2615 update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
2616
2617 set_use_is_acc_mmac (cpu, ACC40Sk_1);
2618 }
2619 if (ACC40Sk_2 >= 0)
2620 {
2621 update_ACC_latency (cpu, ACC40Sk_2, ps->post_wait + 1);
2622
2623 set_use_is_acc_mmac (cpu, ACC40Sk_2);
2624 }
2625 if (ACC40Sk_3 >= 0)
2626 {
2627 update_ACC_latency (cpu, ACC40Sk_3, ps->post_wait + 1);
2628
2629 set_use_is_acc_mmac (cpu, ACC40Sk_3);
2630 }
2631 }
2632 else if (out_ACC40Uk >= 0)
2633 {
2634 update_ACC_latency (cpu, out_ACC40Uk, ps->post_wait + 1);
2635
2636 set_use_is_acc_mmac (cpu, out_ACC40Uk);
2637 if (ACC40Uk_1 >= 0)
2638 {
2639 update_ACC_latency (cpu, ACC40Uk_1, ps->post_wait + 1);
2640
2641 set_use_is_acc_mmac (cpu, ACC40Uk_1);
2642 }
2643 if (ACC40Uk_2 >= 0)
2644 {
2645 update_ACC_latency (cpu, ACC40Uk_2, ps->post_wait + 1);
2646
2647 set_use_is_acc_mmac (cpu, ACC40Uk_2);
2648 }
2649 if (ACC40Uk_3 >= 0)
2650 {
2651 update_ACC_latency (cpu, ACC40Uk_3, ps->post_wait + 1);
2652
2653 set_use_is_acc_mmac (cpu, ACC40Uk_3);
2654 }
2655 }
2656
2657 /* the floating point unit resource has a latency of 3 cycles */
2658 update_float_resource_latency (cpu, slot, cycles + 3);
2659
2660 return cycles;
2661 }
2662
2663 #endif /* WITH_PROFILE_MODEL_P */
The GNU Binutils are a collection of binary tools.