?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH 47/57][Arm][OBJDUMP] Add support for MVE instructions: vaddv, vmlaldav, vmlada...
[binutils-gdb.git] / sim / frv / profile-fr400.c
blobcdaf4f8b1b05718b749180fd4940625420cf1b72
1 /* frv simulator fr400 dependent profiling code.
2
3 Copyright (C) 2001-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-fr400.h"
32
33 /* These functions get and set flags representing the use of
34 registers/resources. */
35 static void set_use_not_fp_load (SIM_CPU *, INT);
36 static void set_use_not_media_p4 (SIM_CPU *, INT);
37 static void set_use_not_media_p6 (SIM_CPU *, INT);
38
39 static void set_acc_use_not_media_p2 (SIM_CPU *, INT);
40 static void set_acc_use_not_media_p4 (SIM_CPU *, INT);
41
42 void
43 fr400_reset_gr_flags (SIM_CPU *cpu, INT fr)
44 {
45 set_use_not_gr_complex (cpu, fr);
46 }
47
48 void
49 fr400_reset_fr_flags (SIM_CPU *cpu, INT fr)
50 {
51 set_use_not_fp_load (cpu, fr);
52 set_use_not_media_p4 (cpu, fr);
53 set_use_not_media_p6 (cpu, fr);
54 }
55
56 void
57 fr400_reset_acc_flags (SIM_CPU *cpu, INT acc)
58 {
59 set_acc_use_not_media_p2 (cpu, acc);
60 set_acc_use_not_media_p4 (cpu, acc);
61 }
62
63 static void
64 set_use_is_fp_load (SIM_CPU *cpu, INT fr, INT fr_double)
65 {
66 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
67 if (fr != -1)
68 {
69 fr400_reset_fr_flags (cpu, fr);
70 d->cur_fp_load |= (((DI)1) << fr);
71 }
72 if (fr_double != -1)
73 {
74 fr400_reset_fr_flags (cpu, fr_double);
75 d->cur_fp_load |= (((DI)1) << fr_double);
76 if (fr_double < 63)
77 {
78 fr400_reset_fr_flags (cpu, fr_double + 1);
79 d->cur_fp_load |= (((DI)1) << (fr_double + 1));
80 }
81 }
82
83 }
84
85 static void
86 set_use_not_fp_load (SIM_CPU *cpu, INT fr)
87 {
88 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
89 if (fr != -1)
90 d->cur_fp_load &= ~(((DI)1) << fr);
91 }
92
93 static int
94 use_is_fp_load (SIM_CPU *cpu, INT fr)
95 {
96 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
97 if (fr != -1)
98 return (d->prev_fp_load >> fr) & 1;
99 return 0;
100 }
101
102 static void
103 set_acc_use_is_media_p2 (SIM_CPU *cpu, INT acc)
104 {
105 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
106 if (acc != -1)
107 {
108 fr400_reset_acc_flags (cpu, acc);
109 d->cur_acc_p2 |= (((DI)1) << acc);
110 }
111 }
112
113 static void
114 set_acc_use_not_media_p2 (SIM_CPU *cpu, INT acc)
115 {
116 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
117 if (acc != -1)
118 d->cur_acc_p2 &= ~(((DI)1) << acc);
119 }
120
121 static int
122 acc_use_is_media_p2 (SIM_CPU *cpu, INT acc)
123 {
124 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
125 if (acc != -1)
126 return d->cur_acc_p2 & (((DI)1) << acc);
127 return 0;
128 }
129
130 static void
131 set_use_is_media_p4 (SIM_CPU *cpu, INT fr)
132 {
133 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
134 if (fr != -1)
135 {
136 fr400_reset_fr_flags (cpu, fr);
137 d->cur_fr_p4 |= (((DI)1) << fr);
138 }
139 }
140
141 static void
142 set_use_not_media_p4 (SIM_CPU *cpu, INT fr)
143 {
144 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
145 if (fr != -1)
146 d->cur_fr_p4 &= ~(((DI)1) << fr);
147 }
148
149 static int
150 use_is_media_p4 (SIM_CPU *cpu, INT fr)
151 {
152 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
153 if (fr != -1)
154 return d->cur_fr_p4 & (((DI)1) << fr);
155 return 0;
156 }
157
158 static void
159 set_acc_use_is_media_p4 (SIM_CPU *cpu, INT acc)
160 {
161 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
162 if (acc != -1)
163 {
164 fr400_reset_acc_flags (cpu, acc);
165 d->cur_acc_p4 |= (((DI)1) << acc);
166 }
167 }
168
169 static void
170 set_acc_use_not_media_p4 (SIM_CPU *cpu, INT acc)
171 {
172 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
173 if (acc != -1)
174 d->cur_acc_p4 &= ~(((DI)1) << acc);
175 }
176
177 static int
178 acc_use_is_media_p4 (SIM_CPU *cpu, INT acc)
179 {
180 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
181 if (acc != -1)
182 return d->cur_acc_p4 & (((DI)1) << acc);
183 return 0;
184 }
185
186 static void
187 set_use_is_media_p6 (SIM_CPU *cpu, INT fr)
188 {
189 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
190 if (fr != -1)
191 {
192 fr400_reset_fr_flags (cpu, fr);
193 d->cur_fr_p6 |= (((DI)1) << fr);
194 }
195 }
196
197 static void
198 set_use_not_media_p6 (SIM_CPU *cpu, INT fr)
199 {
200 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
201 if (fr != -1)
202 d->cur_fr_p6 &= ~(((DI)1) << fr);
203 }
204
205 static int
206 use_is_media_p6 (SIM_CPU *cpu, INT fr)
207 {
208 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
209 if (fr != -1)
210 return d->cur_fr_p6 & (((DI)1) << fr);
211 return 0;
212 }
213
214 /* Initialize cycle counting for an insn.
215 FIRST_P is non-zero if this is the first insn in a set of parallel
216 insns. */
217 void
218 fr400_model_insn_before (SIM_CPU *cpu, int first_p)
219 {
220 if (first_p)
221 {
222 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
223 FRV_PROFILE_STATE *ps = CPU_PROFILE_STATE (cpu);
224 ps->cur_gr_complex = ps->prev_gr_complex;
225 d->cur_fp_load = d->prev_fp_load;
226 d->cur_fr_p4 = d->prev_fr_p4;
227 d->cur_fr_p6 = d->prev_fr_p6;
228 d->cur_acc_p2 = d->prev_acc_p2;
229 d->cur_acc_p4 = d->prev_acc_p4;
230 }
231 }
232
233 /* Record the cycles computed for an insn.
234 LAST_P is non-zero if this is the last insn in a set of parallel insns,
235 and we update the total cycle count.
236 CYCLES is the cycle count of the insn. */
237 void
238 fr400_model_insn_after (SIM_CPU *cpu, int last_p, int cycles)
239 {
240 if (last_p)
241 {
242 MODEL_FR400_DATA *d = CPU_MODEL_DATA (cpu);
243 FRV_PROFILE_STATE *ps = CPU_PROFILE_STATE (cpu);
244 ps->prev_gr_complex = ps->cur_gr_complex;
245 d->prev_fp_load = d->cur_fp_load;
246 d->prev_fr_p4 = d->cur_fr_p4;
247 d->prev_fr_p6 = d->cur_fr_p6;
248 d->prev_acc_p2 = d->cur_acc_p2;
249 d->prev_acc_p4 = d->cur_acc_p4;
250 }
251 }
252
253 int
254 frvbf_model_fr400_u_exec (SIM_CPU *cpu, const IDESC *idesc,
255 int unit_num, int referenced)
256 {
257 return idesc->timing->units[unit_num].done;
258 }
259
260 int
261 frvbf_model_fr400_u_integer (SIM_CPU *cpu, const IDESC *idesc,
262 int unit_num, int referenced,
263 INT in_GRi, INT in_GRj, INT out_GRk,
264 INT out_ICCi_1)
265 {
266 /* Modelling for this unit is the same as for fr500. */
267 return frvbf_model_fr500_u_integer (cpu, idesc, unit_num, referenced,
268 in_GRi, in_GRj, out_GRk, out_ICCi_1);
269 }
270
271 int
272 frvbf_model_fr400_u_imul (SIM_CPU *cpu, const IDESC *idesc,
273 int unit_num, int referenced,
274 INT in_GRi, INT in_GRj, INT out_GRk, INT out_ICCi_1)
275 {
276 /* Modelling for this unit is the same as for fr500. */
277 return frvbf_model_fr500_u_imul (cpu, idesc, unit_num, referenced,
278 in_GRi, in_GRj, out_GRk, out_ICCi_1);
279 }
280
281 int
282 frvbf_model_fr400_u_idiv (SIM_CPU *cpu, const IDESC *idesc,
283 int unit_num, int referenced,
284 INT in_GRi, INT in_GRj, INT out_GRk, INT out_ICCi_1)
285 {
286 int cycles;
287 FRV_VLIW *vliw;
288 int slot;
289
290 /* icc0-icc4 are the upper 4 fields of the CCR. */
291 if (out_ICCi_1 >= 0)
292 out_ICCi_1 += 4;
293
294 vliw = CPU_VLIW (cpu);
295 slot = vliw->next_slot - 1;
296 slot = (*vliw->current_vliw)[slot] - UNIT_I0;
297
298 if (model_insn == FRV_INSN_MODEL_PASS_1)
299 {
300 /* The entire VLIW insn must wait if there is a dependency on a register
301 which is not ready yet.
302 The latency of the registers may be less than previously recorded,
303 depending on how they were used previously.
304 See Table 13-8 in the LSI. */
305 if (in_GRi != out_GRk && in_GRi >= 0)
306 {
307 if (use_is_gr_complex (cpu, in_GRi))
308 decrease_GR_busy (cpu, in_GRi, 1);
309 }
310 if (in_GRj != out_GRk && in_GRj != in_GRi && in_GRj >= 0)
311 {
312 if (use_is_gr_complex (cpu, in_GRj))
313 decrease_GR_busy (cpu, in_GRj, 1);
314 }
315 vliw_wait_for_GR (cpu, in_GRi);
316 vliw_wait_for_GR (cpu, in_GRj);
317 vliw_wait_for_GR (cpu, out_GRk);
318 vliw_wait_for_CCR (cpu, out_ICCi_1);
319 vliw_wait_for_idiv_resource (cpu, slot);
320 handle_resource_wait (cpu);
321 load_wait_for_GR (cpu, in_GRi);
322 load_wait_for_GR (cpu, in_GRj);
323 load_wait_for_GR (cpu, out_GRk);
324 trace_vliw_wait_cycles (cpu);
325 return 0;
326 }
327
328 /* GRk has a latency of 19 cycles! */
329 cycles = idesc->timing->units[unit_num].done;
330 update_GR_latency (cpu, out_GRk, cycles + 19);
331 set_use_is_gr_complex (cpu, out_GRk);
332
333 /* ICCi_1 has a latency of 18 cycles. */
334 update_CCR_latency (cpu, out_ICCi_1, cycles + 18);
335
336 /* the idiv resource has a latency of 18 cycles! */
337 update_idiv_resource_latency (cpu, slot, cycles + 18);
338
339 return cycles;
340 }
341
342 int
343 frvbf_model_fr400_u_branch (SIM_CPU *cpu, const IDESC *idesc,
344 int unit_num, int referenced,
345 INT in_GRi, INT in_GRj,
346 INT in_ICCi_2, INT in_ICCi_3)
347 {
348 #define BRANCH_PREDICTED(ps) ((ps)->branch_hint & 2)
349 FRV_PROFILE_STATE *ps;
350 int cycles;
351
352 if (model_insn == FRV_INSN_MODEL_PASS_1)
353 {
354 /* Modelling for this unit is the same as for fr500 in pass 1. */
355 return frvbf_model_fr500_u_branch (cpu, idesc, unit_num, referenced,
356 in_GRi, in_GRj, in_ICCi_2, in_ICCi_3);
357 }
358
359 cycles = idesc->timing->units[unit_num].done;
360
361 /* Compute the branch penalty, based on the the prediction and the out
362 come. When counting branches taken or not taken, don't consider branches
363 after the first taken branch in a vliw insn. */
364 ps = CPU_PROFILE_STATE (cpu);
365 if (! ps->vliw_branch_taken)
366 {
367 int penalty;
368 /* (1 << 4): The pc is the 5th element in inputs, outputs.
369 ??? can be cleaned up */
370 PROFILE_DATA *p = CPU_PROFILE_DATA (cpu);
371 int taken = (referenced & (1 << 4)) != 0;
372 if (taken)
373 {
374 ++PROFILE_MODEL_TAKEN_COUNT (p);
375 ps->vliw_branch_taken = 1;
376 if (BRANCH_PREDICTED (ps))
377 penalty = 1;
378 else
379 penalty = 3;
380 }
381 else
382 {
383 ++PROFILE_MODEL_UNTAKEN_COUNT (p);
384 if (BRANCH_PREDICTED (ps))
385 penalty = 3;
386 else
387 penalty = 0;
388 }
389 if (penalty > 0)
390 {
391 /* Additional 1 cycle penalty if the branch address is not 8 byte
392 aligned. */
393 if (ps->branch_address & 7)
394 ++penalty;
395 update_branch_penalty (cpu, penalty);
396 PROFILE_MODEL_CTI_STALL_CYCLES (p) += penalty;
397 }
398 }
399
400 return cycles;
401 }
402
403 int
404 frvbf_model_fr400_u_trap (SIM_CPU *cpu, const IDESC *idesc,
405 int unit_num, int referenced,
406 INT in_GRi, INT in_GRj,
407 INT in_ICCi_2, INT in_FCCi_2)
408 {
409 /* Modelling for this unit is the same as for fr500. */
410 return frvbf_model_fr500_u_trap (cpu, idesc, unit_num, referenced,
411 in_GRi, in_GRj, in_ICCi_2, in_FCCi_2);
412 }
413
414 int
415 frvbf_model_fr400_u_check (SIM_CPU *cpu, const IDESC *idesc,
416 int unit_num, int referenced,
417 INT in_ICCi_3, INT in_FCCi_3)
418 {
419 /* Modelling for this unit is the same as for fr500. */
420 return frvbf_model_fr500_u_check (cpu, idesc, unit_num, referenced,
421 in_ICCi_3, in_FCCi_3);
422 }
423
424 int
425 frvbf_model_fr400_u_set_hilo (SIM_CPU *cpu, const IDESC *idesc,
426 int unit_num, int referenced,
427 INT out_GRkhi, INT out_GRklo)
428 {
429 /* Modelling for this unit is the same as for fr500. */
430 return frvbf_model_fr500_u_set_hilo (cpu, idesc, unit_num, referenced,
431 out_GRkhi, out_GRklo);
432 }
433
434 int
435 frvbf_model_fr400_u_gr_load (SIM_CPU *cpu, const IDESC *idesc,
436 int unit_num, int referenced,
437 INT in_GRi, INT in_GRj,
438 INT out_GRk, INT out_GRdoublek)
439 {
440 /* Modelling for this unit is the same as for fr500. */
441 return frvbf_model_fr500_u_gr_load (cpu, idesc, unit_num, referenced,
442 in_GRi, in_GRj, out_GRk, out_GRdoublek);
443 }
444
445 int
446 frvbf_model_fr400_u_gr_store (SIM_CPU *cpu, const IDESC *idesc,
447 int unit_num, int referenced,
448 INT in_GRi, INT in_GRj,
449 INT in_GRk, INT in_GRdoublek)
450 {
451 /* Modelling for this unit is the same as for fr500. */
452 return frvbf_model_fr500_u_gr_store (cpu, idesc, unit_num, referenced,
453 in_GRi, in_GRj, in_GRk, in_GRdoublek);
454 }
455
456 int
457 frvbf_model_fr400_u_fr_load (SIM_CPU *cpu, const IDESC *idesc,
458 int unit_num, int referenced,
459 INT in_GRi, INT in_GRj,
460 INT out_FRk, INT out_FRdoublek)
461 {
462 int cycles;
463
464 if (model_insn == FRV_INSN_MODEL_PASS_1)
465 {
466 /* Pass 1 is the same as for fr500. */
467 return frvbf_model_fr500_u_fr_load (cpu, idesc, unit_num, referenced,
468 in_GRi, in_GRj, out_FRk,
469 out_FRdoublek);
470 }
471
472 cycles = idesc->timing->units[unit_num].done;
473
474 /* The latency of FRk for a load will depend on how long it takes to retrieve
475 the the data from the cache or memory. */
476 update_FR_latency_for_load (cpu, out_FRk, cycles);
477 update_FRdouble_latency_for_load (cpu, out_FRdoublek, cycles);
478
479 set_use_is_fp_load (cpu, out_FRk, out_FRdoublek);
480
481 return cycles;
482 }
483
484 int
485 frvbf_model_fr400_u_fr_store (SIM_CPU *cpu, const IDESC *idesc,
486 int unit_num, int referenced,
487 INT in_GRi, INT in_GRj,
488 INT in_FRk, INT in_FRdoublek)
489 {
490 int cycles;
491
492 if (model_insn == FRV_INSN_MODEL_PASS_1)
493 {
494 /* The entire VLIW insn must wait if there is a dependency on a register
495 which is not ready yet.
496 The latency of the registers may be less than previously recorded,
497 depending on how they were used previously.
498 See Table 13-8 in the LSI. */
499 if (in_GRi >= 0)
500 {
501 if (use_is_gr_complex (cpu, in_GRi))
502 decrease_GR_busy (cpu, in_GRi, 1);
503 }
504 if (in_GRj != in_GRi && in_GRj >= 0)
505 {
506 if (use_is_gr_complex (cpu, in_GRj))
507 decrease_GR_busy (cpu, in_GRj, 1);
508 }
509 if (in_FRk >= 0)
510 {
511 if (use_is_media_p4 (cpu, in_FRk) || use_is_media_p6 (cpu, in_FRk))
512 decrease_FR_busy (cpu, in_FRk, 1);
513 else
514 enforce_full_fr_latency (cpu, in_FRk);
515 }
516 vliw_wait_for_GR (cpu, in_GRi);
517 vliw_wait_for_GR (cpu, in_GRj);
518 vliw_wait_for_FR (cpu, in_FRk);
519 vliw_wait_for_FRdouble (cpu, in_FRdoublek);
520 handle_resource_wait (cpu);
521 load_wait_for_GR (cpu, in_GRi);
522 load_wait_for_GR (cpu, in_GRj);
523 load_wait_for_FR (cpu, in_FRk);
524 load_wait_for_FRdouble (cpu, in_FRdoublek);
525 trace_vliw_wait_cycles (cpu);
526 return 0;
527 }
528
529 cycles = idesc->timing->units[unit_num].done;
530
531 return cycles;
532 }
533
534 int
535 frvbf_model_fr400_u_swap (SIM_CPU *cpu, const IDESC *idesc,
536 int unit_num, int referenced,
537 INT in_GRi, INT in_GRj, INT out_GRk)
538 {
539 /* Modelling for this unit is the same as for fr500. */
540 return frvbf_model_fr500_u_swap (cpu, idesc, unit_num, referenced,
541 in_GRi, in_GRj, out_GRk);
542 }
543
544 int
545 frvbf_model_fr400_u_fr2gr (SIM_CPU *cpu, const IDESC *idesc,
546 int unit_num, int referenced,
547 INT in_FRk, INT out_GRj)
548 {
549 int cycles;
550
551 if (model_insn == FRV_INSN_MODEL_PASS_1)
552 {
553 /* The entire VLIW insn must wait if there is a dependency on a register
554 which is not ready yet.
555 The latency of the registers may be less than previously recorded,
556 depending on how they were used previously.
557 See Table 13-8 in the LSI. */
558 if (in_FRk >= 0)
559 {
560 if (use_is_media_p4 (cpu, in_FRk) || use_is_media_p6 (cpu, in_FRk))
561 decrease_FR_busy (cpu, in_FRk, 1);
562 else
563 enforce_full_fr_latency (cpu, in_FRk);
564 }
565 vliw_wait_for_FR (cpu, in_FRk);
566 vliw_wait_for_GR (cpu, out_GRj);
567 handle_resource_wait (cpu);
568 load_wait_for_FR (cpu, in_FRk);
569 load_wait_for_GR (cpu, out_GRj);
570 trace_vliw_wait_cycles (cpu);
571 return 0;
572 }
573
574 /* The latency of GRj is 2 cycles. */
575 cycles = idesc->timing->units[unit_num].done;
576 update_GR_latency (cpu, out_GRj, cycles + 2);
577 set_use_is_gr_complex (cpu, out_GRj);
578
579 return cycles;
580 }
581
582 int
583 frvbf_model_fr400_u_spr2gr (SIM_CPU *cpu, const IDESC *idesc,
584 int unit_num, int referenced,
585 INT in_spr, INT out_GRj)
586 {
587 /* Modelling for this unit is the same as for fr500. */
588 return frvbf_model_fr500_u_spr2gr (cpu, idesc, unit_num, referenced,
589 in_spr, out_GRj);
590 }
591
592 int
593 frvbf_model_fr400_u_gr2fr (SIM_CPU *cpu, const IDESC *idesc,
594 int unit_num, int referenced,
595 INT in_GRj, INT out_FRk)
596 {
597 int cycles;
598
599 if (model_insn == FRV_INSN_MODEL_PASS_1)
600 {
601 /* Pass 1 is the same as for fr500. */
602 frvbf_model_fr500_u_gr2fr (cpu, idesc, unit_num, referenced,
603 in_GRj, out_FRk);
604 }
605
606 /* The latency of FRk is 1 cycles. */
607 cycles = idesc->timing->units[unit_num].done;
608 update_FR_latency (cpu, out_FRk, cycles + 1);
609
610 return cycles;
611 }
612
613 int
614 frvbf_model_fr400_u_gr2spr (SIM_CPU *cpu, const IDESC *idesc,
615 int unit_num, int referenced,
616 INT in_GRj, INT out_spr)
617 {
618 /* Modelling for this unit is the same as for fr500. */
619 return frvbf_model_fr500_u_gr2spr (cpu, idesc, unit_num, referenced,
620 in_GRj, out_spr);
621 }
622
623 int
624 frvbf_model_fr400_u_media_1 (SIM_CPU *cpu, const IDESC *idesc,
625 int unit_num, int referenced,
626 INT in_FRi, INT in_FRj,
627 INT out_FRk)
628 {
629 int cycles;
630 FRV_PROFILE_STATE *ps;
631 const CGEN_INSN *insn;
632 int busy_adjustment[] = {0, 0};
633 int *fr;
634
635 if (model_insn == FRV_INSN_MODEL_PASS_1)
636 return 0;
637
638 /* The preprocessing can execute right away. */
639 cycles = idesc->timing->units[unit_num].done;
640
641 ps = CPU_PROFILE_STATE (cpu);
642 insn = idesc->idata;
643
644 /* The latency of the registers may be less than previously recorded,
645 depending on how they were used previously.
646 See Table 13-8 in the LSI. */
647 if (in_FRi >= 0)
648 {
649 if (use_is_fp_load (cpu, in_FRi))
650 {
651 busy_adjustment[0] = 1;
652 decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
653 }
654 else
655 enforce_full_fr_latency (cpu, in_FRi);
656 }
657 if (in_FRj >= 0 && in_FRj != in_FRi)
658 {
659 if (use_is_fp_load (cpu, in_FRj))
660 {
661 busy_adjustment[1] = 1;
662 decrease_FR_busy (cpu, in_FRj, busy_adjustment[1]);
663 }
664 else
665 enforce_full_fr_latency (cpu, in_FRj);
666 }
667
668 /* The post processing must wait if there is a dependency on a FR
669 which is not ready yet. */
670 ps->post_wait = cycles;
671 post_wait_for_FR (cpu, in_FRi);
672 post_wait_for_FR (cpu, in_FRj);
673 post_wait_for_FR (cpu, out_FRk);
674
675 /* Restore the busy cycles of the registers we used. */
676 fr = ps->fr_busy;
677 if (in_FRi >= 0)
678 fr[in_FRi] += busy_adjustment[0];
679 if (in_FRj >= 0)
680 fr[in_FRj] += busy_adjustment[1];
681
682 /* The latency of the output register will be at least the latency of the
683 other inputs. Once initiated, post-processing has no latency. */
684 if (out_FRk >= 0)
685 {
686 update_FR_latency (cpu, out_FRk, ps->post_wait);
687 update_FR_ptime (cpu, out_FRk, 0);
688 }
689
690 return cycles;
691 }
692
693 int
694 frvbf_model_fr400_u_media_1_quad (SIM_CPU *cpu, const IDESC *idesc,
695 int unit_num, int referenced,
696 INT in_FRi, INT in_FRj,
697 INT out_FRk)
698 {
699 int cycles;
700 INT dual_FRi;
701 INT dual_FRj;
702 INT dual_FRk;
703 FRV_PROFILE_STATE *ps;
704 int busy_adjustment[] = {0, 0, 0, 0};
705 int *fr;
706
707 if (model_insn == FRV_INSN_MODEL_PASS_1)
708 return 0;
709
710 /* The preprocessing can execute right away. */
711 cycles = idesc->timing->units[unit_num].done;
712
713 ps = CPU_PROFILE_STATE (cpu);
714 dual_FRi = DUAL_REG (in_FRi);
715 dual_FRj = DUAL_REG (in_FRj);
716 dual_FRk = DUAL_REG (out_FRk);
717
718 /* The latency of the registers may be less than previously recorded,
719 depending on how they were used previously.
720 See Table 13-8 in the LSI. */
721 if (use_is_fp_load (cpu, in_FRi))
722 {
723 busy_adjustment[0] = 1;
724 decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
725 }
726 else
727 enforce_full_fr_latency (cpu, in_FRi);
728 if (dual_FRi >= 0 && use_is_fp_load (cpu, dual_FRi))
729 {
730 busy_adjustment[1] = 1;
731 decrease_FR_busy (cpu, dual_FRi, busy_adjustment[1]);
732 }
733 else
734 enforce_full_fr_latency (cpu, dual_FRi);
735 if (in_FRj != in_FRi)
736 {
737 if (use_is_fp_load (cpu, in_FRj))
738 {
739 busy_adjustment[2] = 1;
740 decrease_FR_busy (cpu, in_FRj, busy_adjustment[2]);
741 }
742 else
743 enforce_full_fr_latency (cpu, in_FRj);
744 if (dual_FRj >= 0 && use_is_fp_load (cpu, dual_FRj))
745 {
746 busy_adjustment[3] = 1;
747 decrease_FR_busy (cpu, dual_FRj, busy_adjustment[3]);
748 }
749 else
750 enforce_full_fr_latency (cpu, dual_FRj);
751 }
752
753 /* The post processing must wait if there is a dependency on a FR
754 which is not ready yet. */
755 ps->post_wait = cycles;
756 post_wait_for_FR (cpu, in_FRi);
757 post_wait_for_FR (cpu, dual_FRi);
758 post_wait_for_FR (cpu, in_FRj);
759 post_wait_for_FR (cpu, dual_FRj);
760 post_wait_for_FR (cpu, out_FRk);
761 post_wait_for_FR (cpu, dual_FRk);
762
763 /* Restore the busy cycles of the registers we used. */
764 fr = ps->fr_busy;
765 fr[in_FRi] += busy_adjustment[0];
766 if (dual_FRi >= 0)
767 fr[dual_FRi] += busy_adjustment[1];
768 fr[in_FRj] += busy_adjustment[2];
769 if (dual_FRj >= 0)
770 fr[dual_FRj] += busy_adjustment[3];
771
772 /* The latency of the output register will be at least the latency of the
773 other inputs. */
774 update_FR_latency (cpu, out_FRk, ps->post_wait);
775
776 /* Once initiated, post-processing has no latency. */
777 update_FR_ptime (cpu, out_FRk, 0);
778
779 if (dual_FRk >= 0)
780 {
781 update_FR_latency (cpu, dual_FRk, ps->post_wait);
782 update_FR_ptime (cpu, dual_FRk, 0);
783 }
784
785 return cycles;
786 }
787
788 int
789 frvbf_model_fr400_u_media_hilo (SIM_CPU *cpu, const IDESC *idesc,
790 int unit_num, int referenced,
791 INT out_FRkhi, INT out_FRklo)
792 {
793 int cycles;
794 FRV_PROFILE_STATE *ps;
795
796 if (model_insn == FRV_INSN_MODEL_PASS_1)
797 return 0;
798
799 /* The preprocessing can execute right away. */
800 cycles = idesc->timing->units[unit_num].done;
801
802 ps = CPU_PROFILE_STATE (cpu);
803
804 /* The post processing must wait if there is a dependency on a FR
805 which is not ready yet. */
806 ps->post_wait = cycles;
807 post_wait_for_FR (cpu, out_FRkhi);
808 post_wait_for_FR (cpu, out_FRklo);
809
810 /* The latency of the output register will be at least the latency of the
811 other inputs. Once initiated, post-processing has no latency. */
812 if (out_FRkhi >= 0)
813 {
814 update_FR_latency (cpu, out_FRkhi, ps->post_wait);
815 update_FR_ptime (cpu, out_FRkhi, 0);
816 }
817 if (out_FRklo >= 0)
818 {
819 update_FR_latency (cpu, out_FRklo, ps->post_wait);
820 update_FR_ptime (cpu, out_FRklo, 0);
821 }
822
823 return cycles;
824 }
825
826 int
827 frvbf_model_fr400_u_media_2 (SIM_CPU *cpu, const IDESC *idesc,
828 int unit_num, int referenced,
829 INT in_FRi, INT in_FRj,
830 INT out_ACC40Sk, INT out_ACC40Uk)
831 {
832 int cycles;
833 INT dual_ACC40Sk;
834 INT dual_ACC40Uk;
835 FRV_PROFILE_STATE *ps;
836 int busy_adjustment[] = {0, 0, 0, 0, 0, 0};
837 int *fr;
838 int *acc;
839
840 if (model_insn == FRV_INSN_MODEL_PASS_1)
841 return 0;
842
843 /* The preprocessing can execute right away. */
844 cycles = idesc->timing->units[unit_num].done;
845
846 ps = CPU_PROFILE_STATE (cpu);
847 dual_ACC40Sk = DUAL_REG (out_ACC40Sk);
848 dual_ACC40Uk = DUAL_REG (out_ACC40Uk);
849
850 /* The latency of the registers may be less than previously recorded,
851 depending on how they were used previously.
852 See Table 13-8 in the LSI. */
853 if (in_FRi >= 0)
854 {
855 if (use_is_fp_load (cpu, in_FRi))
856 {
857 busy_adjustment[0] = 1;
858 decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
859 }
860 else
861 enforce_full_fr_latency (cpu, in_FRi);
862 }
863 if (in_FRj >= 0 && in_FRj != in_FRi)
864 {
865 if (use_is_fp_load (cpu, in_FRj))
866 {
867 busy_adjustment[1] = 1;
868 decrease_FR_busy (cpu, in_FRj, busy_adjustment[1]);
869 }
870 else
871 enforce_full_fr_latency (cpu, in_FRj);
872 }
873 if (out_ACC40Sk >= 0)
874 {
875 if (acc_use_is_media_p2 (cpu, out_ACC40Sk))
876 {
877 busy_adjustment[2] = 1;
878 decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[2]);
879 }
880 }
881 if (dual_ACC40Sk >= 0)
882 {
883 if (acc_use_is_media_p2 (cpu, dual_ACC40Sk))
884 {
885 busy_adjustment[3] = 1;
886 decrease_ACC_busy (cpu, dual_ACC40Sk, busy_adjustment[3]);
887 }
888 }
889 if (out_ACC40Uk >= 0)
890 {
891 if (acc_use_is_media_p2 (cpu, out_ACC40Uk))
892 {
893 busy_adjustment[4] = 1;
894 decrease_ACC_busy (cpu, out_ACC40Uk, busy_adjustment[4]);
895 }
896 }
897 if (dual_ACC40Uk >= 0)
898 {
899 if (acc_use_is_media_p2 (cpu, dual_ACC40Uk))
900 {
901 busy_adjustment[5] = 1;
902 decrease_ACC_busy (cpu, dual_ACC40Uk, busy_adjustment[5]);
903 }
904 }
905
906 /* The post processing must wait if there is a dependency on a FR
907 which is not ready yet. */
908 ps->post_wait = cycles;
909 post_wait_for_FR (cpu, in_FRi);
910 post_wait_for_FR (cpu, in_FRj);
911 post_wait_for_ACC (cpu, out_ACC40Sk);
912 post_wait_for_ACC (cpu, dual_ACC40Sk);
913 post_wait_for_ACC (cpu, out_ACC40Uk);
914 post_wait_for_ACC (cpu, dual_ACC40Uk);
915
916 /* Restore the busy cycles of the registers we used. */
917 fr = ps->fr_busy;
918 acc = ps->acc_busy;
919 fr[in_FRi] += busy_adjustment[0];
920 fr[in_FRj] += busy_adjustment[1];
921 if (out_ACC40Sk >= 0)
922 acc[out_ACC40Sk] += busy_adjustment[2];
923 if (dual_ACC40Sk >= 0)
924 acc[dual_ACC40Sk] += busy_adjustment[3];
925 if (out_ACC40Uk >= 0)
926 acc[out_ACC40Uk] += busy_adjustment[4];
927 if (dual_ACC40Uk >= 0)
928 acc[dual_ACC40Uk] += busy_adjustment[5];
929
930 /* The latency of the output register will be at least the latency of the
931 other inputs. Once initiated, post-processing will take 1 cycles. */
932 if (out_ACC40Sk >= 0)
933 {
934 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
935 set_acc_use_is_media_p2 (cpu, out_ACC40Sk);
936 }
937 if (dual_ACC40Sk >= 0)
938 {
939 update_ACC_latency (cpu, dual_ACC40Sk, ps->post_wait + 1);
940 set_acc_use_is_media_p2 (cpu, dual_ACC40Sk);
941 }
942 if (out_ACC40Uk >= 0)
943 {
944 update_ACC_latency (cpu, out_ACC40Uk, ps->post_wait + 1);
945 set_acc_use_is_media_p2 (cpu, out_ACC40Uk);
946 }
947 if (dual_ACC40Uk >= 0)
948 {
949 update_ACC_latency (cpu, dual_ACC40Uk, ps->post_wait + 1);
950 set_acc_use_is_media_p2 (cpu, dual_ACC40Uk);
951 }
952
953 return cycles;
954 }
955
956 int
957 frvbf_model_fr400_u_media_2_quad (SIM_CPU *cpu, const IDESC *idesc,
958 int unit_num, int referenced,
959 INT in_FRi, INT in_FRj,
960 INT out_ACC40Sk, INT out_ACC40Uk)
961 {
962 int cycles;
963 INT dual_FRi;
964 INT dual_FRj;
965 INT ACC40Sk_1;
966 INT ACC40Sk_2;
967 INT ACC40Sk_3;
968 INT ACC40Uk_1;
969 INT ACC40Uk_2;
970 INT ACC40Uk_3;
971 FRV_PROFILE_STATE *ps;
972 int busy_adjustment[] = {0, 0, 0, 0, 0, 0, 0 ,0};
973 int *fr;
974 int *acc;
975
976 if (model_insn == FRV_INSN_MODEL_PASS_1)
977 return 0;
978
979 /* The preprocessing can execute right away. */
980 cycles = idesc->timing->units[unit_num].done;
981
982 dual_FRi = DUAL_REG (in_FRi);
983 dual_FRj = DUAL_REG (in_FRj);
984 ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
985 ACC40Sk_2 = DUAL_REG (ACC40Sk_1);
986 ACC40Sk_3 = DUAL_REG (ACC40Sk_2);
987 ACC40Uk_1 = DUAL_REG (out_ACC40Uk);
988 ACC40Uk_2 = DUAL_REG (ACC40Uk_1);
989 ACC40Uk_3 = DUAL_REG (ACC40Uk_2);
990
991 ps = CPU_PROFILE_STATE (cpu);
992 /* The latency of the registers may be less than previously recorded,
993 depending on how they were used previously.
994 See Table 13-8 in the LSI. */
995 if (use_is_fp_load (cpu, in_FRi))
996 {
997 busy_adjustment[0] = 1;
998 decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
999 }
1000 else
1001 enforce_full_fr_latency (cpu, in_FRi);
1002 if (dual_FRi >= 0 && use_is_fp_load (cpu, dual_FRi))
1003 {
1004 busy_adjustment[1] = 1;
1005 decrease_FR_busy (cpu, dual_FRi, busy_adjustment[1]);
1006 }
1007 else
1008 enforce_full_fr_latency (cpu, dual_FRi);
1009 if (in_FRj != in_FRi)
1010 {
1011 if (use_is_fp_load (cpu, in_FRj))
1012 {
1013 busy_adjustment[2] = 1;
1014 decrease_FR_busy (cpu, in_FRj, busy_adjustment[2]);
1015 }
1016 else
1017 enforce_full_fr_latency (cpu, in_FRj);
1018 if (dual_FRj >= 0 && use_is_fp_load (cpu, dual_FRj))
1019 {
1020 busy_adjustment[3] = 1;
1021 decrease_FR_busy (cpu, dual_FRj, busy_adjustment[3]);
1022 }
1023 else
1024 enforce_full_fr_latency (cpu, dual_FRj);
1025 }
1026 if (out_ACC40Sk >= 0)
1027 {
1028 if (acc_use_is_media_p2 (cpu, out_ACC40Sk))
1029 {
1030 busy_adjustment[4] = 1;
1031 decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[4]);
1032 }
1033 if (ACC40Sk_1 >= 0)
1034 {
1035 if (acc_use_is_media_p2 (cpu, ACC40Sk_1))
1036 {
1037 busy_adjustment[5] = 1;
1038 decrease_ACC_busy (cpu, ACC40Sk_1, busy_adjustment[5]);
1039 }
1040 }
1041 if (ACC40Sk_2 >= 0)
1042 {
1043 if (acc_use_is_media_p2 (cpu, ACC40Sk_2))
1044 {
1045 busy_adjustment[6] = 1;
1046 decrease_ACC_busy (cpu, ACC40Sk_2, busy_adjustment[6]);
1047 }
1048 }
1049 if (ACC40Sk_3 >= 0)
1050 {
1051 if (acc_use_is_media_p2 (cpu, ACC40Sk_3))
1052 {
1053 busy_adjustment[7] = 1;
1054 decrease_ACC_busy (cpu, ACC40Sk_3, busy_adjustment[7]);
1055 }
1056 }
1057 }
1058 else if (out_ACC40Uk >= 0)
1059 {
1060 if (acc_use_is_media_p2 (cpu, out_ACC40Uk))
1061 {
1062 busy_adjustment[4] = 1;
1063 decrease_ACC_busy (cpu, out_ACC40Uk, busy_adjustment[4]);
1064 }
1065 if (ACC40Uk_1 >= 0)
1066 {
1067 if (acc_use_is_media_p2 (cpu, ACC40Uk_1))
1068 {
1069 busy_adjustment[5] = 1;
1070 decrease_ACC_busy (cpu, ACC40Uk_1, busy_adjustment[5]);
1071 }
1072 }
1073 if (ACC40Uk_2 >= 0)
1074 {
1075 if (acc_use_is_media_p2 (cpu, ACC40Uk_2))
1076 {
1077 busy_adjustment[6] = 1;
1078 decrease_ACC_busy (cpu, ACC40Uk_2, busy_adjustment[6]);
1079 }
1080 }
1081 if (ACC40Uk_3 >= 0)
1082 {
1083 if (acc_use_is_media_p2 (cpu, ACC40Uk_3))
1084 {
1085 busy_adjustment[7] = 1;
1086 decrease_ACC_busy (cpu, ACC40Uk_3, busy_adjustment[7]);
1087 }
1088 }
1089 }
1090
1091 /* The post processing must wait if there is a dependency on a FR
1092 which is not ready yet. */
1093 ps->post_wait = cycles;
1094 post_wait_for_FR (cpu, in_FRi);
1095 post_wait_for_FR (cpu, dual_FRi);
1096 post_wait_for_FR (cpu, in_FRj);
1097 post_wait_for_FR (cpu, dual_FRj);
1098 post_wait_for_ACC (cpu, out_ACC40Sk);
1099 post_wait_for_ACC (cpu, ACC40Sk_1);
1100 post_wait_for_ACC (cpu, ACC40Sk_2);
1101 post_wait_for_ACC (cpu, ACC40Sk_3);
1102 post_wait_for_ACC (cpu, out_ACC40Uk);
1103 post_wait_for_ACC (cpu, ACC40Uk_1);
1104 post_wait_for_ACC (cpu, ACC40Uk_2);
1105 post_wait_for_ACC (cpu, ACC40Uk_3);
1106
1107 /* Restore the busy cycles of the registers we used. */
1108 fr = ps->fr_busy;
1109 acc = ps->acc_busy;
1110 fr[in_FRi] += busy_adjustment[0];
1111 if (dual_FRi >= 0)
1112 fr[dual_FRi] += busy_adjustment[1];
1113 fr[in_FRj] += busy_adjustment[2];
1114 if (dual_FRj > 0)
1115 fr[dual_FRj] += busy_adjustment[3];
1116 if (out_ACC40Sk >= 0)
1117 {
1118 acc[out_ACC40Sk] += busy_adjustment[4];
1119 if (ACC40Sk_1 >= 0)
1120 acc[ACC40Sk_1] += busy_adjustment[5];
1121 if (ACC40Sk_2 >= 0)
1122 acc[ACC40Sk_2] += busy_adjustment[6];
1123 if (ACC40Sk_3 >= 0)
1124 acc[ACC40Sk_3] += busy_adjustment[7];
1125 }
1126 else if (out_ACC40Uk >= 0)
1127 {
1128 acc[out_ACC40Uk] += busy_adjustment[4];
1129 if (ACC40Uk_1 >= 0)
1130 acc[ACC40Uk_1] += busy_adjustment[5];
1131 if (ACC40Uk_2 >= 0)
1132 acc[ACC40Uk_2] += busy_adjustment[6];
1133 if (ACC40Uk_3 >= 0)
1134 acc[ACC40Uk_3] += busy_adjustment[7];
1135 }
1136
1137 /* The latency of the output register will be at least the latency of the
1138 other inputs. Once initiated, post-processing will take 1 cycle. */
1139 if (out_ACC40Sk >= 0)
1140 {
1141 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
1142
1143 set_acc_use_is_media_p2 (cpu, out_ACC40Sk);
1144 if (ACC40Sk_1 >= 0)
1145 {
1146 update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
1147
1148 set_acc_use_is_media_p2 (cpu, ACC40Sk_1);
1149 }
1150 if (ACC40Sk_2 >= 0)
1151 {
1152 update_ACC_latency (cpu, ACC40Sk_2, ps->post_wait + 1);
1153
1154 set_acc_use_is_media_p2 (cpu, ACC40Sk_2);
1155 }
1156 if (ACC40Sk_3 >= 0)
1157 {
1158 update_ACC_latency (cpu, ACC40Sk_3, ps->post_wait + 1);
1159
1160 set_acc_use_is_media_p2 (cpu, ACC40Sk_3);
1161 }
1162 }
1163 else if (out_ACC40Uk >= 0)
1164 {
1165 update_ACC_latency (cpu, out_ACC40Uk, ps->post_wait + 1);
1166
1167 set_acc_use_is_media_p2 (cpu, out_ACC40Uk);
1168 if (ACC40Uk_1 >= 0)
1169 {
1170 update_ACC_latency (cpu, ACC40Uk_1, ps->post_wait + 1);
1171
1172 set_acc_use_is_media_p2 (cpu, ACC40Uk_1);
1173 }
1174 if (ACC40Uk_2 >= 0)
1175 {
1176 update_ACC_latency (cpu, ACC40Uk_2, ps->post_wait + 1);
1177
1178 set_acc_use_is_media_p2 (cpu, ACC40Uk_2);
1179 }
1180 if (ACC40Uk_3 >= 0)
1181 {
1182 update_ACC_latency (cpu, ACC40Uk_3, ps->post_wait + 1);
1183
1184 set_acc_use_is_media_p2 (cpu, ACC40Uk_3);
1185 }
1186 }
1187
1188 return cycles;
1189 }
1190
1191 int
1192 frvbf_model_fr400_u_media_2_acc (SIM_CPU *cpu, const IDESC *idesc,
1193 int unit_num, int referenced,
1194 INT in_ACC40Si, INT out_ACC40Sk)
1195 {
1196 int cycles;
1197 INT ACC40Si_1;
1198 FRV_PROFILE_STATE *ps;
1199 int busy_adjustment[] = {0, 0, 0};
1200 int *acc;
1201
1202 if (model_insn == FRV_INSN_MODEL_PASS_1)
1203 return 0;
1204
1205 /* The preprocessing can execute right away. */
1206 cycles = idesc->timing->units[unit_num].done;
1207
1208 ACC40Si_1 = DUAL_REG (in_ACC40Si);
1209
1210 ps = CPU_PROFILE_STATE (cpu);
1211 /* The latency of the registers may be less than previously recorded,
1212 depending on how they were used previously.
1213 See Table 13-8 in the LSI. */
1214 if (acc_use_is_media_p2 (cpu, in_ACC40Si))
1215 {
1216 busy_adjustment[0] = 1;
1217 decrease_ACC_busy (cpu, in_ACC40Si, busy_adjustment[0]);
1218 }
1219 if (ACC40Si_1 >= 0 && acc_use_is_media_p2 (cpu, ACC40Si_1))
1220 {
1221 busy_adjustment[1] = 1;
1222 decrease_ACC_busy (cpu, ACC40Si_1, busy_adjustment[1]);
1223 }
1224 if (out_ACC40Sk != in_ACC40Si && out_ACC40Sk != ACC40Si_1
1225 && acc_use_is_media_p2 (cpu, out_ACC40Sk))
1226 {
1227 busy_adjustment[2] = 1;
1228 decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[2]);
1229 }
1230
1231 /* The post processing must wait if there is a dependency on a register
1232 which is not ready yet. */
1233 ps->post_wait = cycles;
1234 post_wait_for_ACC (cpu, in_ACC40Si);
1235 post_wait_for_ACC (cpu, ACC40Si_1);
1236 post_wait_for_ACC (cpu, out_ACC40Sk);
1237
1238 /* Restore the busy cycles of the registers we used. */
1239 acc = ps->acc_busy;
1240 acc[in_ACC40Si] += busy_adjustment[0];
1241 if (ACC40Si_1 >= 0)
1242 acc[ACC40Si_1] += busy_adjustment[1];
1243 acc[out_ACC40Sk] += busy_adjustment[2];
1244
1245 /* The latency of the output register will be at least the latency of the
1246 other inputs. Once initiated, post-processing will take 1 cycle. */
1247 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
1248 set_acc_use_is_media_p2 (cpu, out_ACC40Sk);
1249
1250 return cycles;
1251 }
1252
1253 int
1254 frvbf_model_fr400_u_media_2_acc_dual (SIM_CPU *cpu, const IDESC *idesc,
1255 int unit_num, int referenced,
1256 INT in_ACC40Si, INT out_ACC40Sk)
1257 {
1258 int cycles;
1259 INT ACC40Si_1;
1260 INT ACC40Si_2;
1261 INT ACC40Si_3;
1262 INT ACC40Sk_1;
1263 FRV_PROFILE_STATE *ps;
1264 int busy_adjustment[] = {0, 0, 0, 0, 0, 0};
1265 int *acc;
1266
1267 if (model_insn == FRV_INSN_MODEL_PASS_1)
1268 return 0;
1269
1270 /* The preprocessing can execute right away. */
1271 cycles = idesc->timing->units[unit_num].done;
1272
1273 ACC40Si_1 = DUAL_REG (in_ACC40Si);
1274 ACC40Si_2 = DUAL_REG (ACC40Si_1);
1275 ACC40Si_3 = DUAL_REG (ACC40Si_2);
1276 ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
1277
1278 ps = CPU_PROFILE_STATE (cpu);
1279 /* The latency of the registers may be less than previously recorded,
1280 depending on how they were used previously.
1281 See Table 13-8 in the LSI. */
1282 if (acc_use_is_media_p2 (cpu, in_ACC40Si))
1283 {
1284 busy_adjustment[0] = 1;
1285 decrease_ACC_busy (cpu, in_ACC40Si, busy_adjustment[0]);
1286 }
1287 if (ACC40Si_1 >= 0 && acc_use_is_media_p2 (cpu, ACC40Si_1))
1288 {
1289 busy_adjustment[1] = 1;
1290 decrease_ACC_busy (cpu, ACC40Si_1, busy_adjustment[1]);
1291 }
1292 if (ACC40Si_2 >= 0 && acc_use_is_media_p2 (cpu, ACC40Si_2))
1293 {
1294 busy_adjustment[2] = 1;
1295 decrease_ACC_busy (cpu, ACC40Si_2, busy_adjustment[2]);
1296 }
1297 if (ACC40Si_3 >= 0 && acc_use_is_media_p2 (cpu, ACC40Si_3))
1298 {
1299 busy_adjustment[3] = 1;
1300 decrease_ACC_busy (cpu, ACC40Si_3, busy_adjustment[3]);
1301 }
1302 if (out_ACC40Sk != in_ACC40Si && out_ACC40Sk != ACC40Si_1
1303 && out_ACC40Sk != ACC40Si_2 && out_ACC40Sk != ACC40Si_3)
1304 {
1305 if (acc_use_is_media_p2 (cpu, out_ACC40Sk))
1306 {
1307 busy_adjustment[4] = 1;
1308 decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[4]);
1309 }
1310 }
1311 if (ACC40Sk_1 != in_ACC40Si && ACC40Sk_1 != ACC40Si_1
1312 && ACC40Sk_1 != ACC40Si_2 && ACC40Sk_1 != ACC40Si_3)
1313 {
1314 if (acc_use_is_media_p2 (cpu, ACC40Sk_1))
1315 {
1316 busy_adjustment[5] = 1;
1317 decrease_ACC_busy (cpu, ACC40Sk_1, busy_adjustment[5]);
1318 }
1319 }
1320
1321 /* The post processing must wait if there is a dependency on a register
1322 which is not ready yet. */
1323 ps->post_wait = cycles;
1324 post_wait_for_ACC (cpu, in_ACC40Si);
1325 post_wait_for_ACC (cpu, ACC40Si_1);
1326 post_wait_for_ACC (cpu, ACC40Si_2);
1327 post_wait_for_ACC (cpu, ACC40Si_3);
1328 post_wait_for_ACC (cpu, out_ACC40Sk);
1329 post_wait_for_ACC (cpu, ACC40Sk_1);
1330
1331 /* Restore the busy cycles of the registers we used. */
1332 acc = ps->acc_busy;
1333 acc[in_ACC40Si] += busy_adjustment[0];
1334 if (ACC40Si_1 >= 0)
1335 acc[ACC40Si_1] += busy_adjustment[1];
1336 if (ACC40Si_2 >= 0)
1337 acc[ACC40Si_2] += busy_adjustment[2];
1338 if (ACC40Si_3 >= 0)
1339 acc[ACC40Si_3] += busy_adjustment[3];
1340 acc[out_ACC40Sk] += busy_adjustment[4];
1341 if (ACC40Sk_1 >= 0)
1342 acc[ACC40Sk_1] += busy_adjustment[5];
1343
1344 /* The latency of the output register will be at least the latency of the
1345 other inputs. Once initiated, post-processing will take 1 cycle. */
1346 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
1347 set_acc_use_is_media_p2 (cpu, out_ACC40Sk);
1348 if (ACC40Sk_1 >= 0)
1349 {
1350 update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
1351 set_acc_use_is_media_p2 (cpu, ACC40Sk_1);
1352 }
1353
1354 return cycles;
1355 }
1356
1357 int
1358 frvbf_model_fr400_u_media_2_add_sub (SIM_CPU *cpu, const IDESC *idesc,
1359 int unit_num, int referenced,
1360 INT in_ACC40Si, INT out_ACC40Sk)
1361 {
1362 int cycles;
1363 INT ACC40Si_1;
1364 INT ACC40Sk_1;
1365 FRV_PROFILE_STATE *ps;
1366 int busy_adjustment[] = {0, 0, 0, 0};
1367 int *acc;
1368
1369 if (model_insn == FRV_INSN_MODEL_PASS_1)
1370 return 0;
1371
1372 /* The preprocessing can execute right away. */
1373 cycles = idesc->timing->units[unit_num].done;
1374
1375 ACC40Si_1 = DUAL_REG (in_ACC40Si);
1376 ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
1377
1378 ps = CPU_PROFILE_STATE (cpu);
1379 /* The latency of the registers may be less than previously recorded,
1380 depending on how they were used previously.
1381 See Table 13-8 in the LSI. */
1382 if (acc_use_is_media_p2 (cpu, in_ACC40Si))
1383 {
1384 busy_adjustment[0] = 1;
1385 decrease_ACC_busy (cpu, in_ACC40Si, busy_adjustment[0]);
1386 }
1387 if (ACC40Si_1 >= 0 && acc_use_is_media_p2 (cpu, ACC40Si_1))
1388 {
1389 busy_adjustment[1] = 1;
1390 decrease_ACC_busy (cpu, ACC40Si_1, busy_adjustment[1]);
1391 }
1392 if (out_ACC40Sk != in_ACC40Si && out_ACC40Sk != ACC40Si_1)
1393 {
1394 if (acc_use_is_media_p2 (cpu, out_ACC40Sk))
1395 {
1396 busy_adjustment[2] = 1;
1397 decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[2]);
1398 }
1399 }
1400 if (ACC40Sk_1 != in_ACC40Si && ACC40Sk_1 != ACC40Si_1)
1401 {
1402 if (acc_use_is_media_p2 (cpu, ACC40Sk_1))
1403 {
1404 busy_adjustment[3] = 1;
1405 decrease_ACC_busy (cpu, ACC40Sk_1, busy_adjustment[3]);
1406 }
1407 }
1408
1409 /* The post processing must wait if there is a dependency on a register
1410 which is not ready yet. */
1411 ps->post_wait = cycles;
1412 post_wait_for_ACC (cpu, in_ACC40Si);
1413 post_wait_for_ACC (cpu, ACC40Si_1);
1414 post_wait_for_ACC (cpu, out_ACC40Sk);
1415 post_wait_for_ACC (cpu, ACC40Sk_1);
1416
1417 /* Restore the busy cycles of the registers we used. */
1418 acc = ps->acc_busy;
1419 acc[in_ACC40Si] += busy_adjustment[0];
1420 if (ACC40Si_1 >= 0)
1421 acc[ACC40Si_1] += busy_adjustment[1];
1422 acc[out_ACC40Sk] += busy_adjustment[2];
1423 if (ACC40Sk_1 >= 0)
1424 acc[ACC40Sk_1] += busy_adjustment[3];
1425
1426 /* The latency of the output register will be at least the latency of the
1427 other inputs. Once initiated, post-processing will take 1 cycle. */
1428 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
1429 set_acc_use_is_media_p2 (cpu, out_ACC40Sk);
1430 if (ACC40Sk_1 >= 0)
1431 {
1432 update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
1433 set_acc_use_is_media_p2 (cpu, ACC40Sk_1);
1434 }
1435
1436 return cycles;
1437 }
1438
1439 int
1440 frvbf_model_fr400_u_media_2_add_sub_dual (SIM_CPU *cpu, const IDESC *idesc,
1441 int unit_num, int referenced,
1442 INT in_ACC40Si, INT out_ACC40Sk)
1443 {
1444 int cycles;
1445 INT ACC40Si_1;
1446 INT ACC40Si_2;
1447 INT ACC40Si_3;
1448 INT ACC40Sk_1;
1449 INT ACC40Sk_2;
1450 INT ACC40Sk_3;
1451 FRV_PROFILE_STATE *ps;
1452 int busy_adjustment[] = {0, 0, 0, 0, 0, 0, 0, 0};
1453 int *acc;
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 ACC40Si_1 = DUAL_REG (in_ACC40Si);
1462 ACC40Si_2 = DUAL_REG (ACC40Si_1);
1463 ACC40Si_3 = DUAL_REG (ACC40Si_2);
1464 ACC40Sk_1 = DUAL_REG (out_ACC40Sk);
1465 ACC40Sk_2 = DUAL_REG (ACC40Sk_1);
1466 ACC40Sk_3 = DUAL_REG (ACC40Sk_2);
1467
1468 ps = CPU_PROFILE_STATE (cpu);
1469 /* The latency of the registers may be less than previously recorded,
1470 depending on how they were used previously.
1471 See Table 13-8 in the LSI. */
1472 if (acc_use_is_media_p2 (cpu, in_ACC40Si))
1473 {
1474 busy_adjustment[0] = 1;
1475 decrease_ACC_busy (cpu, in_ACC40Si, busy_adjustment[0]);
1476 }
1477 if (ACC40Si_1 >= 0 && acc_use_is_media_p2 (cpu, ACC40Si_1))
1478 {
1479 busy_adjustment[1] = 1;
1480 decrease_ACC_busy (cpu, ACC40Si_1, busy_adjustment[1]);
1481 }
1482 if (ACC40Si_2 >= 0 && acc_use_is_media_p2 (cpu, ACC40Si_2))
1483 {
1484 busy_adjustment[2] = 1;
1485 decrease_ACC_busy (cpu, ACC40Si_2, busy_adjustment[2]);
1486 }
1487 if (ACC40Si_3 >= 0 && acc_use_is_media_p2 (cpu, ACC40Si_3))
1488 {
1489 busy_adjustment[3] = 1;
1490 decrease_ACC_busy (cpu, ACC40Si_3, busy_adjustment[3]);
1491 }
1492 if (out_ACC40Sk != in_ACC40Si && out_ACC40Sk != ACC40Si_1
1493 && out_ACC40Sk != ACC40Si_2 && out_ACC40Sk != ACC40Si_3)
1494 {
1495 if (acc_use_is_media_p2 (cpu, out_ACC40Sk))
1496 {
1497 busy_adjustment[4] = 1;
1498 decrease_ACC_busy (cpu, out_ACC40Sk, busy_adjustment[4]);
1499 }
1500 }
1501 if (ACC40Sk_1 != in_ACC40Si && ACC40Sk_1 != ACC40Si_1
1502 && ACC40Sk_1 != ACC40Si_2 && ACC40Sk_1 != ACC40Si_3)
1503 {
1504 if (acc_use_is_media_p2 (cpu, ACC40Sk_1))
1505 {
1506 busy_adjustment[5] = 1;
1507 decrease_ACC_busy (cpu, ACC40Sk_1, busy_adjustment[5]);
1508 }
1509 }
1510 if (ACC40Sk_2 != in_ACC40Si && ACC40Sk_2 != ACC40Si_1
1511 && ACC40Sk_2 != ACC40Si_2 && ACC40Sk_2 != ACC40Si_3)
1512 {
1513 if (acc_use_is_media_p2 (cpu, ACC40Sk_2))
1514 {
1515 busy_adjustment[6] = 1;
1516 decrease_ACC_busy (cpu, ACC40Sk_2, busy_adjustment[6]);
1517 }
1518 }
1519 if (ACC40Sk_3 != in_ACC40Si && ACC40Sk_3 != ACC40Si_1
1520 && ACC40Sk_3 != ACC40Si_2 && ACC40Sk_3 != ACC40Si_3)
1521 {
1522 if (acc_use_is_media_p2 (cpu, ACC40Sk_3))
1523 {
1524 busy_adjustment[7] = 1;
1525 decrease_ACC_busy (cpu, ACC40Sk_3, busy_adjustment[7]);
1526 }
1527 }
1528
1529 /* The post processing must wait if there is a dependency on a register
1530 which is not ready yet. */
1531 ps->post_wait = cycles;
1532 post_wait_for_ACC (cpu, in_ACC40Si);
1533 post_wait_for_ACC (cpu, ACC40Si_1);
1534 post_wait_for_ACC (cpu, ACC40Si_2);
1535 post_wait_for_ACC (cpu, ACC40Si_3);
1536 post_wait_for_ACC (cpu, out_ACC40Sk);
1537 post_wait_for_ACC (cpu, ACC40Sk_1);
1538 post_wait_for_ACC (cpu, ACC40Sk_2);
1539 post_wait_for_ACC (cpu, ACC40Sk_3);
1540
1541 /* Restore the busy cycles of the registers we used. */
1542 acc = ps->acc_busy;
1543 acc[in_ACC40Si] += busy_adjustment[0];
1544 if (ACC40Si_1 >= 0)
1545 acc[ACC40Si_1] += busy_adjustment[1];
1546 if (ACC40Si_2 >= 0)
1547 acc[ACC40Si_2] += busy_adjustment[2];
1548 if (ACC40Si_3 >= 0)
1549 acc[ACC40Si_3] += busy_adjustment[3];
1550 acc[out_ACC40Sk] += busy_adjustment[4];
1551 if (ACC40Sk_1 >= 0)
1552 acc[ACC40Sk_1] += busy_adjustment[5];
1553 if (ACC40Sk_2 >= 0)
1554 acc[ACC40Sk_2] += busy_adjustment[6];
1555 if (ACC40Sk_3 >= 0)
1556 acc[ACC40Sk_3] += busy_adjustment[7];
1557
1558 /* The latency of the output register will be at least the latency of the
1559 other inputs. Once initiated, post-processing will take 1 cycle. */
1560 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait + 1);
1561 set_acc_use_is_media_p2 (cpu, out_ACC40Sk);
1562 if (ACC40Sk_1 >= 0)
1563 {
1564 update_ACC_latency (cpu, ACC40Sk_1, ps->post_wait + 1);
1565 set_acc_use_is_media_p2 (cpu, ACC40Sk_1);
1566 }
1567 if (ACC40Sk_2 >= 0)
1568 {
1569 update_ACC_latency (cpu, ACC40Sk_2, ps->post_wait + 1);
1570 set_acc_use_is_media_p2 (cpu, ACC40Sk_2);
1571 }
1572 if (ACC40Sk_3 >= 0)
1573 {
1574 update_ACC_latency (cpu, ACC40Sk_3, ps->post_wait + 1);
1575 set_acc_use_is_media_p2 (cpu, ACC40Sk_3);
1576 }
1577
1578 return cycles;
1579 }
1580
1581 int
1582 frvbf_model_fr400_u_media_3 (SIM_CPU *cpu, const IDESC *idesc,
1583 int unit_num, int referenced,
1584 INT in_FRi, INT in_FRj,
1585 INT out_FRk)
1586 {
1587 /* Modelling is the same as media unit 1. */
1588 return frvbf_model_fr400_u_media_1 (cpu, idesc, unit_num, referenced,
1589 in_FRi, in_FRj, out_FRk);
1590 }
1591
1592 int
1593 frvbf_model_fr400_u_media_3_dual (SIM_CPU *cpu, const IDESC *idesc,
1594 int unit_num, int referenced,
1595 INT in_FRi, INT out_FRk)
1596 {
1597 int cycles;
1598 INT dual_FRi;
1599 FRV_PROFILE_STATE *ps;
1600 int busy_adjustment[] = {0, 0};
1601 int *fr;
1602
1603 if (model_insn == FRV_INSN_MODEL_PASS_1)
1604 return 0;
1605
1606 /* The preprocessing can execute right away. */
1607 cycles = idesc->timing->units[unit_num].done;
1608
1609 ps = CPU_PROFILE_STATE (cpu);
1610 dual_FRi = DUAL_REG (in_FRi);
1611
1612 /* The latency of the registers may be less than previously recorded,
1613 depending on how they were used previously.
1614 See Table 13-8 in the LSI. */
1615 if (use_is_fp_load (cpu, in_FRi))
1616 {
1617 busy_adjustment[0] = 1;
1618 decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
1619 }
1620 else
1621 enforce_full_fr_latency (cpu, in_FRi);
1622 if (dual_FRi >= 0 && use_is_fp_load (cpu, dual_FRi))
1623 {
1624 busy_adjustment[1] = 1;
1625 decrease_FR_busy (cpu, dual_FRi, busy_adjustment[1]);
1626 }
1627 else
1628 enforce_full_fr_latency (cpu, dual_FRi);
1629
1630 /* The post processing must wait if there is a dependency on a FR
1631 which is not ready yet. */
1632 ps->post_wait = cycles;
1633 post_wait_for_FR (cpu, in_FRi);
1634 post_wait_for_FR (cpu, dual_FRi);
1635 post_wait_for_FR (cpu, out_FRk);
1636
1637 /* Restore the busy cycles of the registers we used. */
1638 fr = ps->fr_busy;
1639 fr[in_FRi] += busy_adjustment[0];
1640 if (dual_FRi >= 0)
1641 fr[dual_FRi] += busy_adjustment[1];
1642
1643 /* The latency of the output register will be at least the latency of the
1644 other inputs. */
1645 update_FR_latency (cpu, out_FRk, ps->post_wait);
1646
1647 /* Once initiated, post-processing has no latency. */
1648 update_FR_ptime (cpu, out_FRk, 0);
1649
1650 return cycles;
1651 }
1652
1653 int
1654 frvbf_model_fr400_u_media_3_quad (SIM_CPU *cpu, const IDESC *idesc,
1655 int unit_num, int referenced,
1656 INT in_FRi, INT in_FRj,
1657 INT out_FRk)
1658 {
1659 /* Modelling is the same as media unit 1. */
1660 return frvbf_model_fr400_u_media_1_quad (cpu, idesc, unit_num, referenced,
1661 in_FRi, in_FRj, out_FRk);
1662 }
1663
1664 int
1665 frvbf_model_fr400_u_media_4 (SIM_CPU *cpu, const IDESC *idesc,
1666 int unit_num, int referenced,
1667 INT in_ACC40Si, INT in_FRj,
1668 INT out_ACC40Sk, INT out_FRk)
1669 {
1670 int cycles;
1671 FRV_PROFILE_STATE *ps;
1672 const CGEN_INSN *insn;
1673 int busy_adjustment[] = {0};
1674 int *fr;
1675
1676 if (model_insn == FRV_INSN_MODEL_PASS_1)
1677 return 0;
1678
1679 /* The preprocessing can execute right away. */
1680 cycles = idesc->timing->units[unit_num].done;
1681
1682 ps = CPU_PROFILE_STATE (cpu);
1683 insn = idesc->idata;
1684
1685 /* The latency of the registers may be less than previously recorded,
1686 depending on how they were used previously.
1687 See Table 13-8 in the LSI. */
1688 if (in_FRj >= 0)
1689 {
1690 if (use_is_fp_load (cpu, in_FRj))
1691 {
1692 busy_adjustment[0] = 1;
1693 decrease_FR_busy (cpu, in_FRj, busy_adjustment[0]);
1694 }
1695 else
1696 enforce_full_fr_latency (cpu, in_FRj);
1697 }
1698
1699 /* The post processing must wait if there is a dependency on a FR
1700 which is not ready yet. */
1701 ps->post_wait = cycles;
1702 post_wait_for_ACC (cpu, in_ACC40Si);
1703 post_wait_for_ACC (cpu, out_ACC40Sk);
1704 post_wait_for_FR (cpu, in_FRj);
1705 post_wait_for_FR (cpu, out_FRk);
1706
1707 /* Restore the busy cycles of the registers we used. */
1708 fr = ps->fr_busy;
1709
1710 /* The latency of the output register will be at least the latency of the
1711 other inputs. Once initiated, post-processing will take 1 cycle. */
1712 if (out_FRk >= 0)
1713 {
1714 update_FR_latency (cpu, out_FRk, ps->post_wait);
1715 update_FR_ptime (cpu, out_FRk, 1);
1716 /* Mark this use of the register as media unit 4. */
1717 set_use_is_media_p4 (cpu, out_FRk);
1718 }
1719 else if (out_ACC40Sk >= 0)
1720 {
1721 update_ACC_latency (cpu, out_ACC40Sk, ps->post_wait);
1722 update_ACC_ptime (cpu, out_ACC40Sk, 1);
1723 /* Mark this use of the register as media unit 4. */
1724 set_acc_use_is_media_p4 (cpu, out_ACC40Sk);
1725 }
1726
1727 return cycles;
1728 }
1729
1730 int
1731 frvbf_model_fr400_u_media_4_accg (SIM_CPU *cpu, const IDESC *idesc,
1732 int unit_num, int referenced,
1733 INT in_ACCGi, INT in_FRinti,
1734 INT out_ACCGk, INT out_FRintk)
1735 {
1736 /* Modelling is the same as media-4 unit except use accumulator guards
1737 as input instead of accumulators. */
1738 return frvbf_model_fr400_u_media_4 (cpu, idesc, unit_num, referenced,
1739 in_ACCGi, in_FRinti,
1740 out_ACCGk, out_FRintk);
1741 }
1742
1743 int
1744 frvbf_model_fr400_u_media_4_acc_dual (SIM_CPU *cpu, const IDESC *idesc,
1745 int unit_num, int referenced,
1746 INT in_ACC40Si, INT out_FRk)
1747 {
1748 int cycles;
1749 FRV_PROFILE_STATE *ps;
1750 const CGEN_INSN *insn;
1751 INT ACC40Si_1;
1752 INT FRk_1;
1753
1754 if (model_insn == FRV_INSN_MODEL_PASS_1)
1755 return 0;
1756
1757 /* The preprocessing can execute right away. */
1758 cycles = idesc->timing->units[unit_num].done;
1759
1760 ps = CPU_PROFILE_STATE (cpu);
1761 ACC40Si_1 = DUAL_REG (in_ACC40Si);
1762 FRk_1 = DUAL_REG (out_FRk);
1763
1764 insn = idesc->idata;
1765
1766 /* The post processing must wait if there is a dependency on a FR
1767 which is not ready yet. */
1768 ps->post_wait = cycles;
1769 post_wait_for_ACC (cpu, in_ACC40Si);
1770 post_wait_for_ACC (cpu, ACC40Si_1);
1771 post_wait_for_FR (cpu, out_FRk);
1772 post_wait_for_FR (cpu, FRk_1);
1773
1774 /* The latency of the output register will be at least the latency of the
1775 other inputs. Once initiated, post-processing will take 1 cycle. */
1776 if (out_FRk >= 0)
1777 {
1778 update_FR_latency (cpu, out_FRk, ps->post_wait);
1779 update_FR_ptime (cpu, out_FRk, 1);
1780 /* Mark this use of the register as media unit 4. */
1781 set_use_is_media_p4 (cpu, out_FRk);
1782 }
1783 if (FRk_1 >= 0)
1784 {
1785 update_FR_latency (cpu, FRk_1, ps->post_wait);
1786 update_FR_ptime (cpu, FRk_1, 1);
1787 /* Mark this use of the register as media unit 4. */
1788 set_use_is_media_p4 (cpu, FRk_1);
1789 }
1790
1791 return cycles;
1792 }
1793
1794 int
1795 frvbf_model_fr400_u_media_6 (SIM_CPU *cpu, const IDESC *idesc,
1796 int unit_num, int referenced,
1797 INT in_FRi, INT out_FRk)
1798 {
1799 int cycles;
1800 FRV_PROFILE_STATE *ps;
1801 const CGEN_INSN *insn;
1802 int busy_adjustment[] = {0};
1803 int *fr;
1804
1805 if (model_insn == FRV_INSN_MODEL_PASS_1)
1806 return 0;
1807
1808 /* The preprocessing can execute right away. */
1809 cycles = idesc->timing->units[unit_num].done;
1810
1811 ps = CPU_PROFILE_STATE (cpu);
1812 insn = idesc->idata;
1813
1814 /* The latency of the registers may be less than previously recorded,
1815 depending on how they were used previously.
1816 See Table 13-8 in the LSI. */
1817 if (in_FRi >= 0)
1818 {
1819 if (use_is_fp_load (cpu, in_FRi))
1820 {
1821 busy_adjustment[0] = 1;
1822 decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
1823 }
1824 else
1825 enforce_full_fr_latency (cpu, in_FRi);
1826 }
1827
1828 /* The post processing must wait if there is a dependency on a FR
1829 which is not ready yet. */
1830 ps->post_wait = cycles;
1831 post_wait_for_FR (cpu, in_FRi);
1832 post_wait_for_FR (cpu, out_FRk);
1833
1834 /* Restore the busy cycles of the registers we used. */
1835 fr = ps->fr_busy;
1836 if (in_FRi >= 0)
1837 fr[in_FRi] += busy_adjustment[0];
1838
1839 /* The latency of the output register will be at least the latency of the
1840 other inputs. Once initiated, post-processing will take 1 cycle. */
1841 if (out_FRk >= 0)
1842 {
1843 update_FR_latency (cpu, out_FRk, ps->post_wait);
1844 update_FR_ptime (cpu, out_FRk, 1);
1845
1846 /* Mark this use of the register as media unit 1. */
1847 set_use_is_media_p6 (cpu, out_FRk);
1848 }
1849
1850 return cycles;
1851 }
1852
1853 int
1854 frvbf_model_fr400_u_media_7 (SIM_CPU *cpu, const IDESC *idesc,
1855 int unit_num, int referenced,
1856 INT in_FRinti, INT in_FRintj,
1857 INT out_FCCk)
1858 {
1859 int cycles;
1860 FRV_PROFILE_STATE *ps;
1861 int busy_adjustment[] = {0, 0};
1862 int *fr;
1863
1864 if (model_insn == FRV_INSN_MODEL_PASS_1)
1865 return 0;
1866
1867 /* The preprocessing can execute right away. */
1868 cycles = idesc->timing->units[unit_num].done;
1869
1870 /* The post processing must wait if there is a dependency on a FR
1871 which is not ready yet. */
1872 ps = CPU_PROFILE_STATE (cpu);
1873
1874 /* The latency of the registers may be less than previously recorded,
1875 depending on how they were used previously.
1876 See Table 13-8 in the LSI. */
1877 if (in_FRinti >= 0)
1878 {
1879 if (use_is_fp_load (cpu, in_FRinti))
1880 {
1881 busy_adjustment[0] = 1;
1882 decrease_FR_busy (cpu, in_FRinti, busy_adjustment[0]);
1883 }
1884 else
1885 enforce_full_fr_latency (cpu, in_FRinti);
1886 }
1887 if (in_FRintj >= 0 && in_FRintj != in_FRinti)
1888 {
1889 if (use_is_fp_load (cpu, in_FRintj))
1890 {
1891 busy_adjustment[1] = 1;
1892 decrease_FR_busy (cpu, in_FRintj, busy_adjustment[1]);
1893 }
1894 else
1895 enforce_full_fr_latency (cpu, in_FRintj);
1896 }
1897
1898 ps->post_wait = cycles;
1899 post_wait_for_FR (cpu, in_FRinti);
1900 post_wait_for_FR (cpu, in_FRintj);
1901 post_wait_for_CCR (cpu, out_FCCk);
1902
1903 /* Restore the busy cycles of the registers we used. */
1904 fr = ps->fr_busy;
1905 if (in_FRinti >= 0)
1906 fr[in_FRinti] += busy_adjustment[0];
1907 if (in_FRintj >= 0)
1908 fr[in_FRintj] += busy_adjustment[1];
1909
1910 /* The latency of FCCi_2 will be the latency of the other inputs plus 1
1911 cycle. */
1912 update_CCR_latency (cpu, out_FCCk, ps->post_wait + 1);
1913
1914 return cycles;
1915 }
1916
1917 int
1918 frvbf_model_fr400_u_media_dual_expand (SIM_CPU *cpu, const IDESC *idesc,
1919 int unit_num, int referenced,
1920 INT in_FRi,
1921 INT out_FRk)
1922 {
1923 /* Insns using this unit are media-3 class insns, with a dual FRk output. */
1924 int cycles;
1925 INT dual_FRk;
1926 FRV_PROFILE_STATE *ps;
1927 int busy_adjustment[] = {0};
1928 int *fr;
1929
1930 if (model_insn == FRV_INSN_MODEL_PASS_1)
1931 return 0;
1932
1933 /* The preprocessing can execute right away. */
1934 cycles = idesc->timing->units[unit_num].done;
1935
1936 /* If the previous use of the registers was a media op,
1937 then their latency will be less than previously recorded.
1938 See Table 13-13 in the LSI. */
1939 dual_FRk = DUAL_REG (out_FRk);
1940 ps = CPU_PROFILE_STATE (cpu);
1941 if (use_is_fp_load (cpu, in_FRi))
1942 {
1943 busy_adjustment[0] = 1;
1944 decrease_FR_busy (cpu, in_FRi, busy_adjustment[0]);
1945 }
1946 else
1947 enforce_full_fr_latency (cpu, in_FRi);
1948
1949 /* The post processing must wait if there is a dependency on a FR
1950 which is not ready yet. */
1951 ps->post_wait = cycles;
1952 post_wait_for_FR (cpu, in_FRi);
1953 post_wait_for_FR (cpu, out_FRk);
1954 post_wait_for_FR (cpu, dual_FRk);
1955
1956 /* Restore the busy cycles of the registers we used. */
1957 fr = ps->fr_busy;
1958 fr[in_FRi] += busy_adjustment[0];
1959
1960 /* The latency of the output register will be at least the latency of the
1961 other inputs. Once initiated, post-processing has no latency. */
1962 update_FR_latency (cpu, out_FRk, ps->post_wait);
1963 update_FR_ptime (cpu, out_FRk, 0);
1964
1965 if (dual_FRk >= 0)
1966 {
1967 update_FR_latency (cpu, dual_FRk, ps->post_wait);
1968 update_FR_ptime (cpu, dual_FRk, 0);
1969 }
1970
1971 return cycles;
1972 }
1973
1974 int
1975 frvbf_model_fr400_u_media_dual_htob (SIM_CPU *cpu, const IDESC *idesc,
1976 int unit_num, int referenced,
1977 INT in_FRj,
1978 INT out_FRk)
1979 {
1980 /* Insns using this unit are media-3 class insns, with a dual FRj input. */
1981 int cycles;
1982 INT dual_FRj;
1983 FRV_PROFILE_STATE *ps;
1984 int busy_adjustment[] = {0, 0};
1985 int *fr;
1986
1987 if (model_insn == FRV_INSN_MODEL_PASS_1)
1988 return 0;
1989
1990 /* The preprocessing can execute right away. */
1991 cycles = idesc->timing->units[unit_num].done;
1992
1993 /* If the previous use of the registers was a media op,
1994 then their latency will be less than previously recorded.
1995 See Table 13-13 in the LSI. */
1996 dual_FRj = DUAL_REG (in_FRj);
1997 ps = CPU_PROFILE_STATE (cpu);
1998 if (use_is_fp_load (cpu, in_FRj))
1999 {
2000 busy_adjustment[0] = 1;
2001 decrease_FR_busy (cpu, in_FRj, busy_adjustment[0]);
2002 }
2003 else
2004 enforce_full_fr_latency (cpu, in_FRj);
2005 if (dual_FRj >= 0)
2006 {
2007 if (use_is_fp_load (cpu, dual_FRj))
2008 {
2009 busy_adjustment[1] = 1;
2010 decrease_FR_busy (cpu, dual_FRj, busy_adjustment[1]);
2011 }
2012 else
2013 enforce_full_fr_latency (cpu, dual_FRj);
2014 }
2015
2016 /* The post processing must wait if there is a dependency on a FR
2017 which is not ready yet. */
2018 ps->post_wait = cycles;
2019 post_wait_for_FR (cpu, in_FRj);
2020 post_wait_for_FR (cpu, dual_FRj);
2021 post_wait_for_FR (cpu, out_FRk);
2022
2023 /* Restore the busy cycles of the registers we used. */
2024 fr = ps->fr_busy;
2025 fr[in_FRj] += busy_adjustment[0];
2026 if (dual_FRj >= 0)
2027 fr[dual_FRj] += busy_adjustment[1];
2028
2029 /* The latency of the output register will be at least the latency of the
2030 other inputs. */
2031 update_FR_latency (cpu, out_FRk, ps->post_wait);
2032
2033 /* Once initiated, post-processing has no latency. */
2034 update_FR_ptime (cpu, out_FRk, 0);
2035
2036 return cycles;
2037 }
2038
2039 int
2040 frvbf_model_fr400_u_ici (SIM_CPU *cpu, const IDESC *idesc,
2041 int unit_num, int referenced,
2042 INT in_GRi, INT in_GRj)
2043 {
2044 /* Modelling for this unit is the same as for fr500. */
2045 return frvbf_model_fr500_u_ici (cpu, idesc, unit_num, referenced,
2046 in_GRi, in_GRj);
2047 }
2048
2049 int
2050 frvbf_model_fr400_u_dci (SIM_CPU *cpu, const IDESC *idesc,
2051 int unit_num, int referenced,
2052 INT in_GRi, INT in_GRj)
2053 {
2054 /* Modelling for this unit is the same as for fr500. */
2055 return frvbf_model_fr500_u_dci (cpu, idesc, unit_num, referenced,
2056 in_GRi, in_GRj);
2057 }
2058
2059 int
2060 frvbf_model_fr400_u_dcf (SIM_CPU *cpu, const IDESC *idesc,
2061 int unit_num, int referenced,
2062 INT in_GRi, INT in_GRj)
2063 {
2064 /* Modelling for this unit is the same as for fr500. */
2065 return frvbf_model_fr500_u_dcf (cpu, idesc, unit_num, referenced,
2066 in_GRi, in_GRj);
2067 }
2068
2069 int
2070 frvbf_model_fr400_u_icpl (SIM_CPU *cpu, const IDESC *idesc,
2071 int unit_num, int referenced,
2072 INT in_GRi, INT in_GRj)
2073 {
2074 /* Modelling for this unit is the same as for fr500. */
2075 return frvbf_model_fr500_u_icpl (cpu, idesc, unit_num, referenced,
2076 in_GRi, in_GRj);
2077 }
2078
2079 int
2080 frvbf_model_fr400_u_dcpl (SIM_CPU *cpu, const IDESC *idesc,
2081 int unit_num, int referenced,
2082 INT in_GRi, INT in_GRj)
2083 {
2084 /* Modelling for this unit is the same as for fr500. */
2085 return frvbf_model_fr500_u_dcpl (cpu, idesc, unit_num, referenced,
2086 in_GRi, in_GRj);
2087 }
2088
2089 int
2090 frvbf_model_fr400_u_icul (SIM_CPU *cpu, const IDESC *idesc,
2091 int unit_num, int referenced,
2092 INT in_GRi, INT in_GRj)
2093 {
2094 /* Modelling for this unit is the same as for fr500. */
2095 return frvbf_model_fr500_u_icul (cpu, idesc, unit_num, referenced,
2096 in_GRi, in_GRj);
2097 }
2098
2099 int
2100 frvbf_model_fr400_u_dcul (SIM_CPU *cpu, const IDESC *idesc,
2101 int unit_num, int referenced,
2102 INT in_GRi, INT in_GRj)
2103 {
2104 /* Modelling for this unit is the same as for fr500. */
2105 return frvbf_model_fr500_u_dcul (cpu, idesc, unit_num, referenced,
2106 in_GRi, in_GRj);
2107 }
2108
2109 int
2110 frvbf_model_fr400_u_barrier (SIM_CPU *cpu, const IDESC *idesc,
2111 int unit_num, int referenced)
2112 {
2113 /* Modelling for this unit is the same as for fr500. */
2114 return frvbf_model_fr500_u_barrier (cpu, idesc, unit_num, referenced);
2115 }
2116
2117 int
2118 frvbf_model_fr400_u_membar (SIM_CPU *cpu, const IDESC *idesc,
2119 int unit_num, int referenced)
2120 {
2121 /* Modelling for this unit is the same as for fr500. */
2122 return frvbf_model_fr500_u_membar (cpu, idesc, unit_num, referenced);
2123 }
2124
2125 #endif /* WITH_PROFILE_MODEL_P */
The GNU Binutils are a collection of binary tools.