[PATCH 22/57][Arm][GAS] Add support for MVE instructions: vmlaldav, vmlalv, vmlsldav...
[binutils-gdb.git] / sim / mn10300 / am33-2.igen
blobbcf68b46e2b7a0cd2a1610d238e5db87f8ec33cd
1 // data cache pre-fetch:
3 // 1111 1001 1010 0110 Rm.. 0000; dcpf (Rm)
4 8.0xf9+8.0xa6+4.RN2,4.0000:D1a:::dcpf
5 "dcpf"
6 *am33_2
8   int srcreg;
10   PC = cia;
12   srcreg = translate_rreg (SD_, RN2);
13   load_word (State.regs[srcreg]);
16 // 1111 1001 1010 0111 0000 0000; dcpf (sp)
17 8.0xf9+8.0xa7+8.0x00:D1b:::dcpf
18 "dcpf"
19 *am33_2
21   PC = cia;
23   load_word (SP);
26 // 1111 1011 1010 0110 Ri.. Rm.. 0000 0000; dcpf (Ri,Rm)
27 8.0xfb+8.0xa6+4.RN2,4.RN0+8.0x00:D2a:::dcpf
28 "dcpf"
29 *am33_2
31   int srci, srcm;
33   PC = cia;
35   srci = translate_rreg (SD_, RN2);
36   srcm = translate_rreg (SD_, RN0);
38   load_word (State.regs[srci] + State.regs[srcm]);
41 // 1111 1011 1010 0111 Rm.. 0000 IMM8; dcpf (d8,Rm)
42 8.0xfb+8.0xa7+4.RN2,4.0000+8.IMM8:D2b:::dcpf
43 "dcpf"
44 *am33_2
46   int srcreg;
48   PC = cia;
50   srcreg = translate_rreg (SD_, RN2);
52   load_word (State.regs[srcreg] + EXTEND8 (IMM8));
55 // 1111 1101 1010 0111 Rm.. 0000 IMM24; dcpf (d24,Rm)
56 8.0xfd+8.0xa7+4.RN2,4.0000+8.IMM24A+8.IMM24B+8.IMM24C:D4a:::dcpf
57 "dcpf"
58 *am33_2
60   int srcreg;
62   PC = cia;
64   srcreg = translate_rreg (SD_, RN2);
66   load_word (State.regs[srcreg] + EXTEND24 (FETCH24 (IMM24A,
67                                                      IMM24B, IMM24C)));
70 // 1111 1110 0100 0110 Rm.. 0000 IMM32; dcpf (d32,Rm)
71 8.0xfe+8.0x46+4.RN2,4.0000+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5a:::dcpf
72 "dcpf"
73 *am33_2
75   int srcreg;
77   PC = cia;
79   srcreg = translate_rreg (SD_, RN2);
81   load_word (State.regs[srcreg]
82              + FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D));
85 // bit operations with imm8,(abs16) addressing mode:
87 // 1111 1110 1000 0010 ABS16 IMM8; btst imm8,(abs16)
88 8.0xfe+8.0x82+8.IMM16A+8.IMM16B+8.IMM8:D3:::btst
89 "btst"
90 *am33_2
92   PC = cia;
93   genericBtst (IMM8, FETCH16 (IMM16A, IMM16B));
96 // 1111 1110 1000 0000 ABS16 IMM8; bset imm8,(abs16)
97 8.0xfe+8.0x80+8.IMM16A+8.IMM16B+8.IMM8:D3:::bset
98 "bset"
99 *am33_2
101   unsigned32 temp;
102   int z;
103   
104   PC = cia;
105   temp = load_byte (FETCH16 (IMM16A, IMM16B));
106   z = (temp & IMM8) == 0;
107   temp |= IMM8;
108   store_byte (FETCH16 (IMM16A, IMM16B), temp);
109   PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
110   PSW |= (z ? PSW_Z : 0);
113 // 1111 1110 1000 0001 ABS16 IMM8; bclr imm8,(abs16)
114 8.0xfe+8.0x81+8.IMM16A+8.IMM16B+8.IMM8:D3:::bclr
115 "bclr"
116 *am33_2
118   unsigned32 temp;
119   int z;
120   
121   PC = cia;
122   temp = load_byte (FETCH16 (IMM16A, IMM16B));
123   z = (temp & IMM8) == 0;
124   temp = temp & ~(IMM8);
125   store_byte (FETCH16 (IMM16A, IMM16B), temp);
126   PSW &= ~(PSW_Z | PSW_N | PSW_C | PSW_V);
127   PSW |= (z ? PSW_Z : 0);
130 // single precision fmov:
132 // 1111 1001 0010 000X Rm.. Sn..; fmov (Rm),FSn
133 8.0xf9+4.2,3.0,1.X+4.Rm,4.Sn:D1a:::fmov
134 "fmov"
135 *am33_2
137   PC = cia;
139   if (FPU_DISABLED)
140     fpu_disabled_exception (SD, CPU, cia);
141   else
142     {
143       int reg = translate_rreg (SD_, Rm);
144       XS2FS (X,Sn) = load_word (State.regs[reg]);
145     }
148 // 1111 1001 0010 001X Rm.. Sn..; fmov (Rm+),FSn
149 8.0xf9+4.2,3.1,1.X+4.Rm,4.Sn:D1b:::fmov
150 "fmov"
151 *am33_2
153   PC = cia;
155   if (FPU_DISABLED)
156     fpu_disabled_exception (SD, CPU, cia);
157   else
158     {
159       int reg = translate_rreg (SD_, Rm);
160       XS2FS (X,Sn) = load_word (State.regs[reg]);
161       State.regs[reg] += 4;
162     }
165 // 1111 1001 0010 010X ---- Sn..; fmov (SP),FSn
166 8.0xf9+4.2,3.2,1.X+4.0,4.Sn:D1c:::fmov
167 "fmov"
168 *am33_2
170   PC = cia;
172   if (FPU_DISABLED)
173     fpu_disabled_exception (SD, CPU, cia);
174   else
175     {
176       int reg = REG_SP;
177       XS2FS (X,Sn) = load_word (State.regs[reg]);
178     }
181 // 1111 1001 0010 011X Rm.. Sn..; fmov Rm,FSn
182 8.0xf9+4.2,3.3,1.X+4.Rm,4.Sn:D1d:::fmov
183 "fmov"
184 *am33_2
186   PC = cia;
188   if (FPU_DISABLED)
189     fpu_disabled_exception (SD, CPU, cia);
190   else
191     {
192       int reg = translate_rreg (SD_, Rm);
193       XS2FS (X,Sn) = State.regs[reg];
194     }
197 // 1111 1001 0011 00Y0 Sm.. Rn..; fmov FSm,(Rn)
198 8.0xf9+4.3,2.0,1.Y,1.0+4.Sm,4.Rn:D1e:::fmov
199 "fmov"
200 *am33_2
202   PC = cia;
204   if (FPU_DISABLED)
205     fpu_disabled_exception (SD, CPU, cia);
206   else
207     {
208       int reg = translate_rreg (SD_, Rn);
209       store_word (State.regs[reg], XS2FS (Y,Sm));
210     }
213 // 1111 1001 0011 00Y1 Sm.. Rn..; fmov FSm,(Rn+)
214 8.0xf9+4.3,2.0,1.Y,1.1+4.Sm,4.Rn:D1f:::fmov
215 "fmov"
216 *am33_2
218   PC = cia;
220   if (FPU_DISABLED)
221     fpu_disabled_exception (SD, CPU, cia);
222   else
223     {
224       int reg = translate_rreg (SD_, Rn);
225       store_word (State.regs[reg], XS2FS (Y,Sm));
226       State.regs[reg] += 4;
227     }
230 // 1111 1001 0011 01Y0 Sm.. ----; fmov FSm,(SP)
231 8.0xf9+4.3,2.1,1.Y,1.0+4.Sm,4.0:D1g:::fmov
232 "fmov"
233 *am33_2
235   PC = cia;
237   if (FPU_DISABLED)
238     fpu_disabled_exception (SD, CPU, cia);
239   else
240     {
241       int reg = REG_SP;
242       store_word (State.regs[reg], XS2FS (Y,Sm));
243     }
246 // 1111 1001 0011 01Y1 Sm.. Rn..; fmov FSm,Rn
247 8.0xf9+4.3,2.1,1.Y,1.1+4.Sm,4.Rn:D1h:::fmov
248 "fmov"
249 *am33_2
251   PC = cia;
253   if (FPU_DISABLED)
254     fpu_disabled_exception (SD, CPU, cia);
255   else
256     {
257       int reg = translate_rreg (SD_, Rn);
258       State.regs[reg] = XS2FS (Y,Sm);
259     }
262 // 1111 1001 0100 00YX Sm.. Sn..; fmov FSm,FSn
263 8.0xf9+4.4,2.0,1.Y,1.X+4.Sm,4.Sn:D1i:::fmov
264 "fmov"
265 *am33_2
267   PC = cia;
269   if (FPU_DISABLED)
270     fpu_disabled_exception (SD, CPU, cia);
271   else
272     XS2FS (X,Sn) = XS2FS (Y,Sm);
275 // 1111 1011 0010 000X Rm.. Sn.. d8; fmov (d8,Rm),FSn
276 8.0xfb+4.2,3.0,1.X+4.Rm,4.Sn+8.IMM8:D2a:::fmov
277 "fmov"
278 *am33_2
280   PC = cia;
282   if (FPU_DISABLED)
283     fpu_disabled_exception (SD, CPU, cia);
284   else
285     {
286       int reg = translate_rreg (SD_, Rm);
287       XS2FS (X, Sn) = load_word (State.regs[reg] + EXTEND8 (IMM8));
288     }
291 // 1111 1011 0010 001X Rm.. Sn.. d8; fmov (Rm+,imm8),FSn
292 8.0xfb+4.2,3.1,1.X+4.Rm,4.Sn+8.IMM8:D2b:::fmov
293 "fmov"
294 *am33_2
296   PC = cia;
298   if (FPU_DISABLED)
299     fpu_disabled_exception (SD, CPU, cia);
300   else
301     {
302       int reg = translate_rreg (SD_, Rm);
303       XS2FS (X, Sn) = load_word (State.regs[reg] + EXTEND8 (IMM8));
304       State.regs[reg] += 4;
305     }
308 // 1111 1011 0010 010X ---- Sn.. d8; fmov (d8,SP),FSn
309 8.0xfb+4.2,3.2,1.X+4.0,4.Sn+8.IMM8:D2c:::fmov
310 "fmov"
311 *am33_2
313   PC = cia;
315   if (FPU_DISABLED)
316     fpu_disabled_exception (SD, CPU, cia);
317   else
318     {
319       int reg = REG_SP;
320       XS2FS (X, Sn) = load_word (State.regs[reg] + IMM8);
321     }
324 // 1111 1011 0010 0111 Ri.. Rm.. Sn.. --Z-; fmov (Ri,Rm),FSn
325 8.0xfb+8.0x27+4.Ri,4.Rm+4.Sn,2.0,1.Z,1.0:D2d:::fmov
326 "fmov"
327 *am33_2
329   PC = cia;
331   if (FPU_DISABLED)
332     fpu_disabled_exception (SD, CPU, cia);
333   else
334     {
335       int ri = translate_rreg (SD_, Ri);
336       int rm = translate_rreg (SD_, Rm);
337       XS2FS (Z, Sn) = load_word (State.regs[ri] + State.regs[rm]);
338     }
341 // 1111 1011 0011 00Y0 Sm.. Rn.. d8; fmov FSm,(d8,Rn)
342 8.0xfb+4.3,2.0,1.Y,1.0+4.Sm,4.Rn+8.IMM8:D2e:::fmov
343 "fmov"
344 *am33_2
346   PC = cia;
348   if (FPU_DISABLED)
349     fpu_disabled_exception (SD, CPU, cia);
350   else
351     {
352       int reg = translate_rreg (SD_, Rn);
353       store_word (State.regs[reg] + EXTEND8 (IMM8), XS2FS (Y, Sm));
354     }
357 // 1111 1011 0011 00Y1 Sm.. Rn.. d8; fmov FSm,(Rn+,d8)
358 8.0xfb+4.3,2.0,1.Y,1.1+4.Sm,4.Rn+8.IMM8:D2f:::fmov
359 "fmov"
360 *am33_2
362   PC = cia;
364   if (FPU_DISABLED)
365     fpu_disabled_exception (SD, CPU, cia);
366   else
367     {
368       int reg = translate_rreg (SD_, Rn);
369       store_word (State.regs[reg] + EXTEND8 (IMM8), XS2FS (Y, Sm));
370       State.regs[reg] += 4;
371     }
374 // 1111 1011 0011 01Y0 Sm.. ---- d8; fmov FSm,(d8,SP)
375 8.0xfb+4.3,2.1,1.Y,1.0+4.Sm,4.0+8.IMM8:D2g:::fmov
376 "fmov"
377 *am33_2
379   PC = cia;
381   if (FPU_DISABLED)
382     fpu_disabled_exception (SD, CPU, cia);
383   else
384     {
385       int reg = REG_SP;
386       store_word (State.regs[reg] + IMM8, XS2FS (Y, Sm));
387     }
390 // 1111 1011 0011 0111 Ri.. Rm.. Sm.. --Z-; fmov FSm,(Ri,Rm)
391 8.0xfb+8.0x37+4.Ri,4.Rm+4.Sm,2.0,1.Z,1.0:D2h:::fmov
392 "fmov"
393 *am33_2
395   PC = cia;
397   if (FPU_DISABLED)
398     fpu_disabled_exception (SD, CPU, cia);
399   else
400     {
401       int ri = translate_rreg (SD_, Ri);
402       int rm = translate_rreg (SD_, Rm);
403       store_word (State.regs[ri] + State.regs[rm], XS2FS (Z, Sm));
404     }
407 // 1111 1101 0010 000X Rm.. Sn.. d24; fmov (d24,Rm),FSn
408 8.0xfd+4.2,3.0,1.X+4.Rm,4.Sn+8.IMM24A+8.IMM24B+8.IMM24C:D4a:::fmov
409 "fmov"
410 *am33_2
412   PC = cia;
414   if (FPU_DISABLED)
415     fpu_disabled_exception (SD, CPU, cia);
416   else
417     {
418       int reg = translate_rreg (SD_, Rm);
419       XS2FS (X, Sn) = load_word (State.regs[reg]
420                                  + EXTEND24 (FETCH24 (IMM24A,
421                                                       IMM24B, IMM24C)));
422     }
425 // 1111 1101 0010 001X Rm.. Sn.. d24; fmov (Rm+,imm24),FSn
426 8.0xfd+4.2,3.1,1.X+4.Rm,4.Sn+8.IMM24A+8.IMM24B+8.IMM24C:D4b:::fmov
427 "fmov"
428 *am33_2
430   PC = cia;
432   if (FPU_DISABLED)
433     fpu_disabled_exception (SD, CPU, cia);
434   else
435     {
436       int reg = translate_rreg (SD_, Rm);
437       XS2FS (X, Sn) = load_word (State.regs[reg]
438                                  + EXTEND24 (FETCH24 (IMM24A,
439                                                       IMM24B, IMM24C)));
440       State.regs[reg] += 4;
441     }
444 // 1111 1101 0010 010X ---- Sn.. d24; fmov (d24,SP),FSn
445 8.0xfd+4.2,3.2,1.X+4.0,4.Sn+8.IMM24A+8.IMM24B+8.IMM24C:D4c:::fmov
446 "fmov"
447 *am33_2
449   PC = cia;
451   if (FPU_DISABLED)
452     fpu_disabled_exception (SD, CPU, cia);
453   else
454     {
455       int reg = REG_SP;
456       XS2FS (X, Sn) = load_word (State.regs[reg] + FETCH24 (IMM24A,
457                                                             IMM24B, IMM24C));
458     }
461 // 1111 1101 0011 00Y0 Sm.. Rn.. d24; fmov FSm,(d24,Rn)
462 8.0xfd+4.3,2.0,1.Y,1.0+4.Sm,4.Rn+8.IMM24A+8.IMM24B+8.IMM24C:D4e:::fmov
463 "fmov"
464 *am33_2
466   PC = cia;
468   if (FPU_DISABLED)
469     fpu_disabled_exception (SD, CPU, cia);
470   else
471     {
472       int reg = translate_rreg (SD_, Rn);
473       store_word (State.regs[reg]
474                   + EXTEND24 (FETCH24 (IMM24A,
475                                        IMM24B, IMM24C)), XS2FS (Y, Sm));
476     }
479 // 1111 1101 0011 00Y1 Sm.. Rn.. d24; fmov FSm,(Rn+,d24)
480 8.0xfd+4.3,2.0,1.Y,1.1+4.Sm,4.Rn+8.IMM24A+8.IMM24B+8.IMM24C:D4f:::fmov
481 "fmov"
482 *am33_2
484   PC = cia;
486   if (FPU_DISABLED)
487     fpu_disabled_exception (SD, CPU, cia);
488   else
489     {
490       int reg = translate_rreg (SD_, Rn);
491       store_word (State.regs[reg]
492                   + EXTEND24 (FETCH24 (IMM24A,
493                                        IMM24B, IMM24C)), XS2FS (Y, Sm));
494       State.regs[reg] += 4;
495     }
498 // 1111 1101 0011 01Y0 Sm.. ---- d24; fmov FSm,(d24,SP)
499 8.0xfd+4.3,2.1,1.Y,1.0+4.Sm,4.0+8.IMM24A+8.IMM24B+8.IMM24C:D4g:::fmov
500 "fmov"
501 *am33_2
503   PC = cia;
505   if (FPU_DISABLED)
506     fpu_disabled_exception (SD, CPU, cia);
507   else
508     {
509       int reg = REG_SP;
510       store_word (State.regs[reg]
511                   + FETCH24 (IMM24A,
512                              IMM24B, IMM24C), XS2FS (Y, Sm));
513     }
516 // 1111 1110 0010 000X Rm.. Sn.. d32; fmov (d32,Rm),FSn
517 8.0xfe+4.2,3.0,1.X+4.Rm,4.Sn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5a:::fmov
518 "fmov"
519 *am33_2
521   PC = cia;
523   if (FPU_DISABLED)
524     fpu_disabled_exception (SD, CPU, cia);
525   else
526     {
527       int reg = translate_rreg (SD_, Rm);
528       XS2FS (X, Sn) = load_word (State.regs[reg]
529                                  + EXTEND32 (FETCH32 (IMM32A, IMM32B,
530                                                       IMM32C, IMM32D)));
531     }
534 // 1111 1110 0010 001X Rm.. Sn.. d32; fmov (Rm+,imm32),FSn
535 8.0xfe+4.2,3.1,1.X+4.Rm,4.Sn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5b:::fmov
536 "fmov"
537 *am33_2
539   PC = cia;
541   if (FPU_DISABLED)
542     fpu_disabled_exception (SD, CPU, cia);
543   else
544     {
545       int reg = translate_rreg (SD_, Rm);
546       XS2FS (X, Sn) = load_word (State.regs[reg]
547                                  + EXTEND32 (FETCH32 (IMM32A, IMM32B,
548                                                       IMM32C, IMM32D)));
549       State.regs[reg] += 4;
550     }
553 // 1111 1110 0010 010X ---- Sn.. d32; fmov (d32,SP),FSn
554 8.0xfe+4.2,3.2,1.X+4.0,4.Sn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5c:::fmov
555 "fmov"
556 *am33_2
558   PC = cia;
560   if (FPU_DISABLED)
561     fpu_disabled_exception (SD, CPU, cia);
562   else
563     {
564       int reg = REG_SP;
565       XS2FS (X, Sn) = load_word (State.regs[reg]
566                                  + FETCH32 (IMM32A, IMM32B,
567                                             IMM32C, IMM32D));
568     }
571 // 1111 1110 0010 011X ---- Sn.. d32; fmov imm32,FSn
572 8.0xfe+4.2,3.3,1.X+4.0,4.Sn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5d:::fmov
573 "fmov"
574 *am33_2
576   PC = cia;
578   if (FPU_DISABLED)
579     fpu_disabled_exception (SD, CPU, cia);
580   else
581     XS2FS (X, Sn) = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
584 // 1111 1110 0011 00Y0 Sm.. Rn.. d32; fmov FSm,(d32,Rn)
585 8.0xfe+4.3,2.0,1.Y,1.0+4.Sm,4.Rn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5e:::fmov
586 "fmov"
587 *am33_2
589   PC = cia;
591   if (FPU_DISABLED)
592     fpu_disabled_exception (SD, CPU, cia);
593   else
594     {
595       int reg = translate_rreg (SD_, Rn);
596       store_word (State.regs[reg]
597                   + EXTEND32 (FETCH32 (IMM32A, IMM32B,
598                                        IMM32C, IMM32D)), XS2FS (Y, Sm));
599     }
602 // 1111 1110 0011 00Y1 Sm.. Rn.. d32; fmov FSm,(Rn+,d32)
603 8.0xfe+4.3,2.0,1.Y,1.1+4.Sm,4.Rn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5f:::fmov
604 "fmov"
605 *am33_2
607   PC = cia;
609   if (FPU_DISABLED)
610     fpu_disabled_exception (SD, CPU, cia);
611   else
612     {
613       int reg = translate_rreg (SD_, Rn);
614       store_word (State.regs[reg]
615                   + EXTEND32 (FETCH32 (IMM32A, IMM32B,
616                                        IMM32C, IMM32D)), XS2FS (Y, Sm));
617       State.regs[reg] += 4;
618     }
621 // 1111 1110 0011 01Y0 Sm.. ---- d32; fmov FSm,(d32,SP)
622 8.0xfe+4.3,2.1,1.Y,1.0+4.Sm,4.0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5g:::fmov
623 "fmov"
624 *am33_2
626   PC = cia;
628   if (FPU_DISABLED)
629     fpu_disabled_exception (SD, CPU, cia);
630   else
631     {
632       int reg = REG_SP;
633       store_word (State.regs[reg]
634                   + FETCH32 (IMM32A, IMM32B,
635                              IMM32C, IMM32D), XS2FS (Y, Sm));
636     }
639 // double precision fmov:
641 // 1111 1001 1010 000X Rm.. fn.-; fmov (Rm),FDn
642 8.0xf9+4.0xa,3.0,1.X+4.Rm,3.fn,1.0:D1j:::fmov
643 "fmov"
644 *am33_2
646   PC = cia;
648   if (FPU_DISABLED)
649     fpu_disabled_exception (SD, CPU, cia);
650   else
651     {
652       int reg = translate_rreg (SD_, Rm);
653       Xf2FD (X,fn) = load_dword (State.regs[reg]);
654     }
657 // 1111 1001 1010 001X Rm.. fn.-; fmov (Rm+),FDn
658 8.0xf9+4.0xa,3.1,1.X+4.Rm,3.fn,1.0:D1k:::fmov
659 "fmov"
660 *am33_2
662   PC = cia;
664   if (FPU_DISABLED)
665     fpu_disabled_exception (SD, CPU, cia);
666   else
667     {
668       int reg = translate_rreg (SD_, Rm);
669       Xf2FD (X,fn) = load_dword (State.regs[reg]);
670       State.regs[reg] += 8;
671     }
674 // 1111 1001 1010 010X ---- fn.-; fmov (SP),FDn
675 8.0xf9+4.0xa,3.2,1.X+4.0,3.fn,1.0:D1l:::fmov
676 "fmov"
677 *am33_2
679   PC = cia;
681   if (FPU_DISABLED)
682     fpu_disabled_exception (SD, CPU, cia);
683   else
684     {
685       int reg = REG_SP;
686       Xf2FD (X,fn) = load_dword (State.regs[reg]);
687     }
690 // 1111 1001 1011 00Y0 fm.- Rn..; fmov FDm,(Rn)
691 8.0xf9+4.0xb,2.0,1.Y,1.0+3.fm,1.0,4.Rn:D1m:::fmov
692 "fmov"
693 *am33_2
695   PC = cia;
697   if (FPU_DISABLED)
698     fpu_disabled_exception (SD, CPU, cia);
699   else
700     {
701       int reg = translate_rreg (SD_, Rn);
702       store_dword (State.regs[reg], Xf2FD (Y,fm));
703     }
706 // 1111 1001 1011 00Y1 fm.- Rn..; fmov FDm,(Rn+)
707 8.0xf9+4.0xb,2.0,1.Y,1.1+3.fm,1.0,4.Rn:D1n:::fmov
708 "fmov"
709 *am33_2
711   PC = cia;
713   if (FPU_DISABLED)
714     fpu_disabled_exception (SD, CPU, cia);
715   else
716     {
717       int reg = translate_rreg (SD_, Rn);
718       store_dword (State.regs[reg], Xf2FD (Y,fm));
719       State.regs[reg] += 8;
720     }
723 // 1111 1001 1011 01Y0 fm.- ----; fmov FDm,(SP)
724 8.0xf9+4.0xb,2.1,1.Y,1.0+3.fm,1.0,4.0:D1o:::fmov
725 "fmov"
726 *am33_2
728   PC = cia;
730   if (FPU_DISABLED)
731     fpu_disabled_exception (SD, CPU, cia);
732   else
733     {
734       int reg = REG_SP;
735       store_dword (State.regs[reg], Xf2FD (Y,fm));
736     }
739 // 1111 1001 1100 00YX fm.- fn.-; fmov FDm,FDn
740 8.0xf9+4.0xc,2.0,1.Y,1.X+3.fm,1.0,3.fn,1.0:D1p:::fmov
741 "fmov"
742 *am33_2
744   PC = cia;
746   if (FPU_DISABLED)
747     fpu_disabled_exception (SD, CPU, cia);
748   else
749     fpu_unimp_exception (SD, CPU, cia);
752 // 1111 1011 0100 0111 Ri.. Rm.. fn.- --Z-; fmov (Ri,Rm),FDn
753 8.0xfb+8.0x47+4.Ri,4.Rm+3.fn,1.0,2.0,1.Z,1.0:D2i:::fmov
754 "fmov"
755 *am33_2
757   PC = cia;
759   if (FPU_DISABLED)
760     fpu_disabled_exception (SD, CPU, cia);
761   else
762     {
763       int ri = translate_rreg (SD_, Ri);
764       int rm = translate_rreg (SD_, Rm);
765       Xf2FD (Z,fn) = load_dword (State.regs[ri] + State.regs[rm]);
766     }
768       
769 // 1111 1011 0101 0111 Ri.. Rn.. fm.- --Z-; fmov FDm,(Ri,Rn)
770 8.0xfb+8.0x57+4.Ri,4.Rn+3.fm,1.0,2.0,1.Z,1.0:D2j:::fmov
771 "fmov"
772 *am33_2
774   PC = cia;
776   if (FPU_DISABLED)
777     fpu_disabled_exception (SD, CPU, cia);
778   else
779     {
780       int ri = translate_rreg (SD_, Ri);
781       int rn = translate_rreg (SD_, Rn);
782       store_dword (State.regs[ri] + State.regs[rn], Xf2FD (Z,fm));
783     }
785       
786 // 1111 1011 1010 000X Rm.. fn.- d8; fmov (d8,Rm),FDn
787 8.0xfb+4.0xa,3.0,1.X+4.Rm,4.fn+8.IMM8:D2k:::fmov
788 "fmov"
789 *am33_2
791   PC = cia;
793   if (FPU_DISABLED)
794     fpu_disabled_exception (SD, CPU, cia);
795   else
796     {
797       int reg = translate_rreg (SD_, Rm);
798       Xf2FD (X, fn) = load_dword (State.regs[reg] + EXTEND8 (IMM8));
799     }
802 // 1111 1011 1010 001X Rm.. fn.- d8; fmov (Rm+,imm8),FDn
803 8.0xfb+4.0xa,3.1,1.X+4.Rm,4.fn+8.IMM8:D2l:::fmov
804 "fmov"
805 *am33_2
807   PC = cia;
809   if (FPU_DISABLED)
810     fpu_disabled_exception (SD, CPU, cia);
811   else
812     {
813       int reg = translate_rreg (SD_, Rm);
814       Xf2FD (X, fn) = load_dword (State.regs[reg] + EXTEND8 (IMM8));
815       State.regs[reg] += 8;
816     }
819 // 1111 1011 1010 010X ---- fn.- d8; fmov (d8,SP),FDn
820 8.0xfb+4.0xa,3.2,1.X+4.0,4.fn+8.IMM8:D2m:::fmov
821 "fmov"
822 *am33_2
824   PC = cia;
826   if (FPU_DISABLED)
827     fpu_disabled_exception (SD, CPU, cia);
828   else
829     {
830       int reg = REG_SP;
831       Xf2FD (X, fn) = load_dword (State.regs[reg] + IMM8);
832     }
835 // 1111 1011 1011 00Y0 fm.- Rn.. d8; fmov FDm,(d8,Rn)
836 8.0xfb+4.0xb,2.0,1.Y,1.0+4.fm,4.Rn+8.IMM8:D2n:::fmov
837 "fmov"
838 *am33_2
840   PC = cia;
842   if (FPU_DISABLED)
843     fpu_disabled_exception (SD, CPU, cia);
844   else
845     {
846       int reg = translate_rreg (SD_, Rn);
847       store_dword (State.regs[reg] + EXTEND8 (IMM8), Xf2FD (Y, fm));
848     }
851 // 1111 1011 1011 00Y1 fm.- Rn.. d8; fmov FDm,(Rn+,d8)
852 8.0xfb+4.0xb,2.0,1.Y,1.1+4.fm,4.Rn+8.IMM8:D2o:::fmov
853 "fmov"
854 *am33_2
856   PC = cia;
858   if (FPU_DISABLED)
859     fpu_disabled_exception (SD, CPU, cia);
860   else
861     {
862       int reg = translate_rreg (SD_, Rn);
863       store_dword (State.regs[reg] + EXTEND8 (IMM8), Xf2FD (Y, fm));
864       State.regs[reg] += 8;
865     }
868 // 1111 1011 1011 01Y0 fm.- ---- d8; fmov FDm,(d8,SP)
869 8.0xfb+4.0xb,2.1,1.Y,1.0+4.fm,4.0+8.IMM8:D2p:::fmov
870 "fmov"
871 *am33_2
873   PC = cia;
875   if (FPU_DISABLED)
876     fpu_disabled_exception (SD, CPU, cia);
877   else
878     {
879       int reg = REG_SP;
880       store_dword (State.regs[reg] + IMM8, Xf2FD (Y, fm));
881     }
884 // 1111 1101 1010 000X Rm.. fn.- d24; fmov (d24,Rm),FDn
885 8.0xfd+4.0xa,3.0,1.X+4.Rm,4.fn+8.IMM24A+8.IMM24B+8.IMM24C:D4k:::fmov
886 "fmov"
887 *am33_2
889   PC = cia;
891   if (FPU_DISABLED)
892     fpu_disabled_exception (SD, CPU, cia);
893   else
894     {
895       int reg = translate_rreg (SD_, Rm);
896       Xf2FD (X, fn) = load_dword (State.regs[reg]
897                                   + EXTEND24 (FETCH24 (IMM24A,
898                                                        IMM24B, IMM24C)));
899     }
902 // 1111 1101 1010 001X Rm.. fn.- d24; fmov (Rm+,imm24),FDn
903 8.0xfd+4.0xa,3.1,1.X+4.Rm,4.fn+8.IMM24A+8.IMM24B+8.IMM24C:D4l:::fmov
904 "fmov"
905 *am33_2
907   PC = cia;
909   if (FPU_DISABLED)
910     fpu_disabled_exception (SD, CPU, cia);
911   else
912     {
913       int reg = translate_rreg (SD_, Rm);
914       Xf2FD (X, fn) = load_dword (State.regs[reg]
915                                   + EXTEND24 (FETCH24 (IMM24A,
916                                                        IMM24B, IMM24C)));
917       State.regs[reg] += 8;
918     }
921 // 1111 1101 1010 010X ---- fn.- d24; fmov (d24,SP),FDn
922 8.0xfd+4.0xa,3.2,1.X+4.0,4.fn+8.IMM24A+8.IMM24B+8.IMM24C:D4m:::fmov
923 "fmov"
924 *am33_2
926   PC = cia;
928   if (FPU_DISABLED)
929     fpu_disabled_exception (SD, CPU, cia);
930   else
931     {
932       int reg = REG_SP;
933       Xf2FD (X, fn) = load_dword (State.regs[reg]
934                                   + FETCH24 (IMM24A,
935                                              IMM24B, IMM24C));
936     }
939 // 1111 1101 1011 00Y0 fm.- Rn.. d24; fmov FDm,(d24,Rn)
940 8.0xfd+4.0xb,2.0,1.Y,1.0+4.fm,4.Rn+8.IMM24A+8.IMM24B+8.IMM24C:D4n:::fmov
941 "fmov"
942 *am33_2
944   PC = cia;
946   if (FPU_DISABLED)
947     fpu_disabled_exception (SD, CPU, cia);
948   else
949     {
950       int reg = translate_rreg (SD_, Rn);
951       store_dword (State.regs[reg]
952                    + EXTEND24 (FETCH24 (IMM24A,
953                                         IMM24B, IMM24C)), Xf2FD (Y, fm));
954     }
957 // 1111 1101 1011 00Y1 fm.- Rn.. d24; fmov FDm,(Rn+,d24)
958 8.0xfd+4.0xb,2.0,1.Y,1.1+4.fm,4.Rn+8.IMM24A+8.IMM24B+8.IMM24C:D4o:::fmov
959 "fmov"
960 *am33_2
962   PC = cia;
964   if (FPU_DISABLED)
965     fpu_disabled_exception (SD, CPU, cia);
966   else
967     {
968       int reg = translate_rreg (SD_, Rn);
969       store_dword (State.regs[reg]
970                    + EXTEND24 (FETCH24 (IMM24A,
971                                         IMM24B, IMM24C)), Xf2FD (Y, fm));
972       State.regs[reg] += 8;
973     }
976 // 1111 1101 1011 01Y0 fm.- ---- d24; fmov FDm,(d24,SP)
977 8.0xfd+4.0xb,2.1,1.Y,1.0+4.fm,4.0+8.IMM24A+8.IMM24B+8.IMM24C:D4p:::fmov
978 "fmov"
979 *am33_2
981   PC = cia;
983   if (FPU_DISABLED)
984     fpu_disabled_exception (SD, CPU, cia);
985   else
986     {
987       int reg = REG_SP;
988       store_dword (State.regs[reg] + FETCH24 (IMM24A,
989                                               IMM24B, IMM24C), Xf2FD (Y, fm));
990     }
993 // 1111 1110 1010 000X Rm.. fn.- d32; fmov (d32,Rm),FDn
994 8.0xfe+4.0xa,3.0,1.X+4.Rm,4.fn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5k:::fmov
995 "fmov"
996 *am33_2
998   PC = cia;
1000   if (FPU_DISABLED)
1001     fpu_disabled_exception (SD, CPU, cia);
1002   else
1003     {
1004       int reg = translate_rreg (SD_, Rm);
1005       Xf2FD (X, fn) = load_dword (State.regs[reg]
1006                                   + EXTEND32 (FETCH32 (IMM32A, IMM32B,
1007                                                        IMM32C, IMM32D)));
1008     }
1011 // 1111 1110 1010 001X Rm.. fn.- d32; fmov (Rm+,imm32),FDn
1012 8.0xfe+4.0xa,3.1,1.X+4.Rm,4.fn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5l:::fmov
1013 "fmov"
1014 *am33_2
1016   PC = cia;
1018   if (FPU_DISABLED)
1019     fpu_disabled_exception (SD, CPU, cia);
1020   else
1021     {
1022       int reg = translate_rreg (SD_, Rm);
1023       Xf2FD (X, fn) = load_dword (State.regs[reg]
1024                                   + EXTEND32 (FETCH32 (IMM32A, IMM32B,
1025                                                        IMM32C, IMM32D)));
1026       State.regs[reg] += 8;
1027     }
1030 // 1111 1110 1010 010X ---- fn.- d32; fmov (d32,SP),FDn
1031 8.0xfe+4.0xa,3.2,1.X+4.0,4.fn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5m:::fmov
1032 "fmov"
1033 *am33_2
1035   PC = cia;
1037   if (FPU_DISABLED)
1038     fpu_disabled_exception (SD, CPU, cia);
1039   else
1040     {
1041       int reg = REG_SP;
1042       Xf2FD (X, fn) = load_dword (State.regs[reg]
1043                                   + FETCH32 (IMM32A, IMM32B,
1044                                              IMM32C, IMM32D));
1045     }
1048 // 1111 1110 1011 00Y0 fm.- Rn.. d32; fmov FDm,(d32,Rn)
1049 8.0xfe+4.0xb,2.0,1.Y,1.0+4.fm,4.Rn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5n:::fmov
1050 "fmov"
1051 *am33_2
1053   PC = cia;
1055   if (FPU_DISABLED)
1056     fpu_disabled_exception (SD, CPU, cia);
1057   else
1058     {
1059       int reg = translate_rreg (SD_, Rn);
1060       store_dword (State.regs[reg]
1061                    + EXTEND32 (FETCH32 (IMM32A, IMM32B,
1062                                         IMM32C, IMM32D)), Xf2FD (Y, fm));
1063     }
1066 // 1111 1110 1011 00Y1 fm.- Rn.. d32; fmov FDm,(Rn+,d32)
1067 8.0xfe+4.0xb,2.0,1.Y,1.1+4.fm,4.Rn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5o:::fmov
1068 "fmov"
1069 *am33_2
1071   PC = cia;
1073   if (FPU_DISABLED)
1074     fpu_disabled_exception (SD, CPU, cia);
1075   else
1076     {
1077       int reg = translate_rreg (SD_, Rn);
1078       store_dword (State.regs[reg]
1079                    + EXTEND32 (FETCH32 (IMM32A, IMM32B,
1080                                         IMM32C, IMM32D)), Xf2FD (Y, fm));
1081       State.regs[reg] += 8;
1082     }
1085 // 1111 1110 1011 01Y0 fm.- ---- d32; fmov FDm,(d32,SP)
1086 8.0xfe+4.0xb,2.1,1.Y,1.0+4.fm,4.0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5p:::fmov
1087 "fmov"
1088 *am33_2
1090   PC = cia;
1092   if (FPU_DISABLED)
1093     fpu_disabled_exception (SD, CPU, cia);
1094   else
1095     {
1096       int reg = REG_SP;
1097       store_dword (State.regs[reg]
1098                    + FETCH32 (IMM32A, IMM32B,
1099                               IMM32C, IMM32D), Xf2FD (Y, fm));
1100     }
1103 // FPCR fmov:
1105 // 1111 1001 1011 0101 Rm.. ----; fmov Rm,FPCR
1106 8.0xf9+8.0xb5+4.Rm,4.0:D1q:::fmov
1107 "fmov"
1108 *am33_2
1110   PC = cia;
1112   if (FPU_DISABLED)
1113     fpu_disabled_exception (SD, CPU, cia);
1114   else
1115     {
1116       int reg = translate_rreg (SD_, Rm);
1117       unsigned32 val = State.regs[reg];
1118       FPCR = (val & (EC_MASK | EE_MASK | FCC_MASK))
1119         | ((FPCR & ~val) & EF_MASK);
1120     }
1123 // 1111 1001 1011 0111 ---- Rn..; fmov FPCR,Rn
1124 8.0xf9+8.0xb7+4.0,4.Rn:D1r:::fmov
1125 "fmov"
1126 *am33_2
1128   PC = cia;
1130   if (FPU_DISABLED)
1131     fpu_disabled_exception (SD, CPU, cia);
1132   else
1133     {
1134       int reg = translate_rreg (SD_, Rn);
1135       State.regs[reg] = FPCR & FPCR_MASK;
1136     }
1139 // 1111 1101 1011 0101 imm32; fmov imm32,FPCR
1140 8.0xfd+8.0xb5+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::fmov
1141 "fmov"
1142 *am33_2
1144   PC = cia;
1146   if (FPU_DISABLED)
1147     fpu_disabled_exception (SD, CPU, cia);
1148   else
1149     {
1150       unsigned32 val = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
1151       FPCR = (val & (EC_MASK | EE_MASK | FCC_MASK))
1152         | ((FPCR & ~val) & EF_MASK);
1153     }
1156 // fabs:
1158 // 1111 1001 0100 010X ---- Sn..; fabs FSn
1159 8.0xf9+4.4,3.2,1.X+4.0,4.Sn:D1a:::fabs
1160 "fabs"
1161 *am33_2
1163   PC = cia;
1165   if (FPU_DISABLED)
1166     fpu_disabled_exception (SD, CPU, cia);
1167   else
1168     {
1169       sim_fpu in, out;
1171       FS2FPU (XS2FS (X,Sn), in);
1172       sim_fpu_abs (&out, &in);
1173       FPU2FS (out, XS2FS (X,Sn));
1174     }
1177 // 1111 1001 1100 010X ---- Sn..; fabs FDn
1178 8.0xf9+4.0xc,3.2,1.X+4.0,3.fn,1.0:D1b:::fabs
1179 "fabs"
1180 *am33_2
1182   PC = cia;
1184   if (FPU_DISABLED)
1185     fpu_disabled_exception (SD, CPU, cia);
1186   else
1187     fpu_unimp_exception (SD, CPU, cia);
1190 // 1111 1011 0100 0100 Sm.. ---- Sn.. X-Z-; fabs FSm,FSn
1191 8.0xfb+8.0x44+4.Sm,4.0+4.Sn,1.X,1.0,1.Z,1.0:D2a:::fabs
1192 "fabs"
1193 *am33_2
1195   PC = cia;
1197   if (FPU_DISABLED)
1198     fpu_disabled_exception (SD, CPU, cia);
1199   else
1200     {
1201       sim_fpu in, out;
1203       FS2FPU (XS2FS (X,Sm), in);
1204       sim_fpu_abs (&out, &in);
1205       FPU2FS (out, XS2FS (Z,Sn));
1206     }
1209 // 1111 1011 1100 0100 fm.- ---- fn.- X-Z-; fabs FDm,FDn
1210 8.0xfb+8.0xc4+3.fm,1.0,4.0+3.fn,1.0,1.X,1.0,1.Z,1.0:D2b:::fabs
1211 "fabs"
1212 *am33_2
1214   PC = cia;
1216   if (FPU_DISABLED)
1217     fpu_disabled_exception (SD, CPU, cia);
1218   else
1219     fpu_unimp_exception (SD, CPU, cia);
1222 // 1111 1001 0100 011X ---- Sn..; fneg FSn
1223 8.0xf9+4.4,3.3,1.X+4.0,4.Sn:D1a:::fneg
1224 "fneg"
1225 *am33_2
1227   PC = cia;
1229   if (FPU_DISABLED)
1230     fpu_disabled_exception (SD, CPU, cia);
1231   else
1232     {
1233       sim_fpu in, out;
1235       FS2FPU (XS2FS (X,Sn), in);
1236       sim_fpu_neg (&out, &in);
1237       FPU2FS (out, XS2FS (X,Sn));
1238     }
1241 // 1111 1001 1100 011X ---- Sn..; fneg FDn
1242 8.0xf9+4.0xc,3.3,1.X+4.0,3.fn,1.0:D1b:::fneg
1243 "fneg"
1244 *am33_2
1246   PC = cia;
1248   if (FPU_DISABLED)
1249     fpu_disabled_exception (SD, CPU, cia);
1250   else
1251     fpu_unimp_exception (SD, CPU, cia);
1254 // 1111 1011 0100 0110 Sm.. ---- Sn.. X-Z-; fneg FSm,FSn
1255 8.0xfb+8.0x46+4.Sm,4.0+4.Sn,1.X,1.0,1.Z,1.0:D2a:::fneg
1256 "fneg"
1257 *am33_2
1259   PC = cia;
1261   if (FPU_DISABLED)
1262     fpu_disabled_exception (SD, CPU, cia);
1263   else
1264     {
1265       sim_fpu in, out;
1267       FS2FPU (XS2FS (X,Sm), in);
1268       sim_fpu_neg (&out, &in);
1269       FPU2FS (out, XS2FS (Z,Sn));
1270     }
1273 // 1111 1011 1100 0110 fm.- ---- fn.- X-Z-; fneg FDm,FDn
1274 8.0xfb+8.0xc6+3.fm,1.0,4.0+3.fn,1.0,1.X,1.0,1.Z,1.0:D2b:::fneg
1275 "fneg"
1276 *am33_2
1278   PC = cia;
1280   if (FPU_DISABLED)
1281     fpu_disabled_exception (SD, CPU, cia);
1282   else
1283     fpu_unimp_exception (SD, CPU, cia);
1286 // 1111 1001 0101 000X ---- Sn..; frsqrt FSn
1287 8.0xf9+4.5,3.0,1.X+4.0,4.Sn:D1a:::frsqrt
1288 "frsqrt"
1289 *am33_2
1291   PC = cia;
1293   if (FPU_DISABLED)
1294     fpu_disabled_exception (SD, CPU, cia);
1295   else
1296     fpu_rsqrt (SD, CPU, cia, &XS2FS (X,Sn), &XS2FS (X,Sn), FP_SINGLE);
1299 // 1111 1001 1101 000X ---- fn.-; frsqrt FDn
1300 8.0xf9+4.0xd,3.0,1.X+4.0,3.fn,1.0:D1b:::frsqrt
1301 "frsqrt"
1302 *am33_2
1304   PC = cia;
1306   if (FPU_DISABLED)
1307     fpu_disabled_exception (SD, CPU, cia);
1308   else
1309     fpu_unimp_exception (SD, CPU, cia);
1312 // 1111 1011 0101 0000 Sm.. ---- Sn.. X-Z-; frsqrt FSm,FSn
1313 8.0xfb+8.0x50+4.Sm,4.0+4.Sn,1.X,1.0,1.Z,1.0:D2a:::frsqrt
1314 "frsqrt"
1315 *am33_2
1317   PC = cia;
1319   if (FPU_DISABLED)
1320     fpu_disabled_exception (SD, CPU, cia);
1321   else
1322     fpu_rsqrt (SD, CPU, cia, &XS2FS (X,Sm), &XS2FS (Z,Sn), FP_SINGLE);
1325 // 1111 1011 1101 0000 fm.- ---- fn.- X-Z-; frsqrt FDm,FDn
1326 8.0xfb+8.0xd0+3.fm,1.0,4.0+3.fn,1.0,1.X,1.0,1.Z,1.0:D2b:::frsqrt
1327 "frsqrt"
1328 *am33_2
1330   PC = cia;
1332   if (FPU_DISABLED)
1333     fpu_disabled_exception (SD, CPU, cia);
1334   else
1335     fpu_unimp_exception (SD, CPU, cia);
1338 // 1111 1001 0101 001X ---- Sn..; fsqrt FSn
1339 8.0xf9+4.5,3.1,1.X+4.0,4.Sn:D1a:::fsqrt
1340 "fsqrt"
1341 *am33_2
1343   PC = cia;
1345   if (FPU_DISABLED)
1346     fpu_disabled_exception (SD, CPU, cia);
1347   else
1348     fpu_unimp_exception (SD, CPU, cia);
1351 // 1111 1001 1101 001X ---- fn.-; fsqrt FDn
1352 8.0xf9+4.0xd,3.1,1.X+4.0,3.fn,1.0:D1b:::fsqrt
1353 "fsqrt"
1354 *am33_2
1356   PC = cia;
1358   if (FPU_DISABLED)
1359     fpu_disabled_exception (SD, CPU, cia);
1360   else
1361     fpu_unimp_exception (SD, CPU, cia);
1364 // 1111 1011 0101 0100 Sm.. ---- Sn.. X-Z-; fsqrt FSm,FSn
1365 8.0xfb+8.0x54+4.Sm,4.0+4.Sn,1.X,1.0,1.Z,1.0:D2a:::fsqrt
1366 "fsqrt"
1367 *am33_2
1369   PC = cia;
1371   if (FPU_DISABLED)
1372     fpu_disabled_exception (SD, CPU, cia);
1373   else
1374     fpu_unimp_exception (SD, CPU, cia);
1377 // 1111 1011 1101 0100 fm.- ---- fn.- X-Z-; fsqrt FDm,FDn
1378 8.0xfb+8.0xd4+3.fm,1.0,4.0+3.fn,1.0,1.X,1.0,1.Z,1.0:D2b:::fsqrt
1379 "fsqrt"
1380 *am33_2
1382   PC = cia;
1384   if (FPU_DISABLED)
1385     fpu_disabled_exception (SD, CPU, cia);
1386   else
1387     fpu_unimp_exception (SD, CPU, cia);
1390 // 1111 1001 0101 01YX Sm.. Sn..; fcmp FSm, FSn
1391 8.0xf9+4.5,2.1,1.Y,1.X+4.Sm,4.Sn:D1a:::fcmp
1392 "fcmp"
1393 *am33_2
1395   PC = cia;
1397   if (FPU_DISABLED)
1398     fpu_disabled_exception (SD, CPU, cia);
1399   else
1400     fpu_cmp (SD, CPU, cia, &XS2FS (X,Sn), &XS2FS (Y,Sm), FP_SINGLE);
1403 // 1111 1001 1101 01YX fm.- fn.-; fcmp FDm, FDn
1404 8.0xf9+4.0xd,2.1,1.Y,1.X+3.fm,1.0,3.fn,1.0:D1b:::fcmp
1405 "fcmp"
1406 *am33_2
1408   PC = cia;
1410   if (FPU_DISABLED)
1411     fpu_disabled_exception (SD, CPU, cia);
1412   else
1413     fpu_unimp_exception (SD, CPU, cia);
1416 // 1111 1110 0011 01Y1 Sm.. ---- IMM32; fcmp imm32, FSm
1417 8.0xfe+4.3,2.1,1.Y,1.1+4.Sm,4.0+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::fcmp
1418 "fcmp"
1419 *am33_2
1421   PC = cia;
1423   if (FPU_DISABLED)
1424     fpu_disabled_exception (SD, CPU, cia);
1425   else
1426     {
1427       uint32 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
1429       fpu_cmp (SD, CPU, cia, &XS2FS (Y,Sm), &imm, FP_SINGLE);
1430     }
1433 // 1111 1001 0110 00YX Sm.. Sn..; fadd FSm, FSn
1434 8.0xf9+4.6,2.0,1.Y,1.X+4.Sm,4.Sn:D1a:::fadd
1435 "fadd"
1436 *am33_2
1438   PC = cia;
1440   if (FPU_DISABLED)
1441     fpu_disabled_exception (SD, CPU, cia);
1442   else
1443     fpu_add (SD, CPU, cia,
1444              &XS2FS (Y,Sm), &XS2FS (X,Sn), &XS2FS (X,Sn), FP_SINGLE);
1447 // 1111 1001 1110 00YX fm.- fn.-; fadd FDm, FDn
1448 8.0xf9+4.0xe,2.0,1.Y,1.X+3.fm,1.0,3.fn,1.0:D1b:::fadd
1449 "fadd"
1450 *am33_2
1452   PC = cia;
1454   if (FPU_DISABLED)
1455     fpu_disabled_exception (SD, CPU, cia);
1456   else
1457     fpu_unimp_exception (SD, CPU, cia);
1460 // 1111 1011 0110 0000 Sm1. Sm2. Sn.. XYZ-; fadd FSm1, FSm2, FSn
1461 8.0xfb+8.0x60+4.Sm1,4.Sm2+4.Sn,1.X,1.Y,1.Z,1.0:D2a:::fadd
1462 "fadd"
1463 *am33_2
1465   PC = cia;
1467   if (FPU_DISABLED)
1468     fpu_disabled_exception (SD, CPU, cia);
1469   else
1470     fpu_add (SD, CPU, cia,
1471              &XS2FS (X,Sm1), &XS2FS (Y,Sm2), &XS2FS (Z,Sn), FP_SINGLE);
1474 // 1111 1011 1110 0000 fm1- fm2- fn.- XYZ-; fadd FDm1, FDm2, FDn
1475 8.0xfb+8.0xe0+3.fm1,1.0,3.fm2,1.0+3.fn,1.0,1.X,1.Y,1.Z,1.0:D2b:::fadd
1476 "fadd"
1477 *am33_2
1479   PC = cia;
1481   if (FPU_DISABLED)
1482     fpu_disabled_exception (SD, CPU, cia);
1483   else
1484     fpu_unimp_exception (SD, CPU, cia);
1488 // 1111 1110 0110 00YX Sm.. Sn.. IMM32; fadd imm32, FSm, FSn
1489 8.0xfe+4.6,2.0,1.Y,1.X+4.Sm,4.Sn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::fadd
1490 "fadd"
1491 *am33_2
1493   PC = cia;
1495   if (FPU_DISABLED)
1496     fpu_disabled_exception (SD, CPU, cia);
1497   else
1498     {
1499       uint32 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
1501       fpu_add (SD, CPU, cia,
1502                &XS2FS (Y,Sm), &imm, &XS2FS (X,Sn), FP_SINGLE);
1503     }
1506 // 1111 1001 0110 01YX Sm.. Sn..; fsub FSm, FSn
1507 8.0xf9+4.6,2.1,1.Y,1.X+4.Sm,4.Sn:D1a:::fsub
1508 "fsub"
1509 *am33_2
1511   PC = cia;
1513   if (FPU_DISABLED)
1514     fpu_disabled_exception (SD, CPU, cia);
1515   else
1516     fpu_sub (SD, CPU, cia,
1517              &XS2FS (X,Sn), &XS2FS (Y,Sm), &XS2FS (X,Sn), FP_SINGLE);
1520 // 1111 1001 1110 01YX fm.- fn.-; fsub FDm, FDn
1521 8.0xf9+4.0xe,2.1,1.Y,1.X+3.fm,1.0,3.fn,1.0:D1b:::fsub
1522 "fsub"
1523 *am33_2
1525   PC = cia;
1527   if (FPU_DISABLED)
1528     fpu_disabled_exception (SD, CPU, cia);
1529   else
1530     fpu_unimp_exception (SD, CPU, cia);
1533 // 1111 1011 0110 0100 Sm1. Sm2. Sn.. XYZ-; fsub FSm1, FSm2, FSn
1534 8.0xfb+8.0x64+4.Sm1,4.Sm2+4.Sn,1.X,1.Y,1.Z,1.0:D2a:::fsub
1535 "fsub"
1536 *am33_2
1538   PC = cia;
1540   if (FPU_DISABLED)
1541     fpu_disabled_exception (SD, CPU, cia);
1542   else
1543     fpu_sub (SD, CPU, cia,
1544              &XS2FS (Y,Sm2), &XS2FS (X,Sm1), &XS2FS (Z,Sn), FP_SINGLE);
1547 // 1111 1011 1110 0100 fm1- fm2- fn.- XYZ-; fsub FDm1, FDm2, FDn
1548 8.0xfb+8.0xe4+3.fm1,1.0,3.fm2,1.0+3.fn,1.0,1.X,1.Y,1.Z,1.0:D2b:::fsub
1549 "fsub"
1550 *am33_2
1552   PC = cia;
1554   if (FPU_DISABLED)
1555     fpu_disabled_exception (SD, CPU, cia);
1556   else
1557     fpu_unimp_exception (SD, CPU, cia);
1561 // 1111 1110 0110 01YX Sm.. Sn.. IMM32; fsub imm32, FSm, FSn
1562 8.0xfe+4.6,2.1,1.Y,1.X+4.Sm,4.Sn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::fsub
1563 "fsub"
1564 *am33_2
1566   PC = cia;
1568   if (FPU_DISABLED)
1569     fpu_disabled_exception (SD, CPU, cia);
1570   else
1571     {
1572       uint32 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
1574       fpu_sub (SD, CPU, cia,
1575                &XS2FS (Y,Sm), &imm, &XS2FS (X,Sn), FP_SINGLE);
1576     }
1579 // 1111 1001 0111 00YX Sm.. Sn..; fmul FSm, FSn
1580 8.0xf9+4.7,2.0,1.Y,1.X+4.Sm,4.Sn:D1a:::fmul
1581 "fmul"
1582 *am33_2
1584   PC = cia;
1586   if (FPU_DISABLED)
1587     fpu_disabled_exception (SD, CPU, cia);
1588   else
1589     fpu_mul (SD, CPU, cia,
1590              &XS2FS (Y,Sm), &XS2FS (X,Sn), &XS2FS (X,Sn), FP_SINGLE);
1593 // 1111 1001 1111 00YX fm.- fn.-; fmul FDm, FDn
1594 8.0xf9+4.0xf,2.0,1.Y,1.X+3.fm,1.0,3.fn,1.0:D1b:::fmul
1595 "fmul"
1596 *am33_2
1598   PC = cia;
1600   if (FPU_DISABLED)
1601     fpu_disabled_exception (SD, CPU, cia);
1602   else
1603     fpu_unimp_exception (SD, CPU, cia);
1606 // 1111 1011 0111 0000 Sm1. Sm2. Sn.. XYZ-; fmul FSm1, FSm2, FSn
1607 8.0xfb+8.0x70+4.Sm1,4.Sm2+4.Sn,1.X,1.Y,1.Z,1.0:D2a:::fmul
1608 "fmul"
1609 *am33_2
1611   PC = cia;
1613   if (FPU_DISABLED)
1614     fpu_disabled_exception (SD, CPU, cia);
1615   else
1616     fpu_mul (SD, CPU, cia,
1617              &XS2FS (X,Sm1), &XS2FS (Y,Sm2), &XS2FS (Z,Sn), FP_SINGLE);
1620 // 1111 1011 1111 0000 fm1- fm2- fn.- XYZ-; fmul FDm1, FDm2, FDn
1621 8.0xfb+8.0xf0+3.fm1,1.0,3.fm2,1.0+3.fn,1.0,1.X,1.Y,1.Z,1.0:D2b:::fmul
1622 "fmul"
1623 *am33_2
1625   PC = cia;
1627   if (FPU_DISABLED)
1628     fpu_disabled_exception (SD, CPU, cia);
1629   else
1630     fpu_unimp_exception (SD, CPU, cia);
1634 // 1111 1110 0111 00YX Sm.. Sn.. IMM32; fmul imm32, FSm, FSn
1635 8.0xfe+4.7,2.0,1.Y,1.X+4.Sm,4.Sn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::fmul
1636 "fmul"
1637 *am33_2
1639   PC = cia;
1641   if (FPU_DISABLED)
1642     fpu_disabled_exception (SD, CPU, cia);
1643   else
1644     {
1645       uint32 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
1647       fpu_mul (SD, CPU, cia,
1648                &imm, &XS2FS (Y,Sm), &XS2FS (X,Sn), FP_SINGLE);
1649     }
1652 // 1111 1001 0111 01YX Sm.. Sn..; fdiv FSm, FSn
1653 8.0xf9+4.7,2.1,1.Y,1.X+4.Sm,4.Sn:D1a:::fdiv
1654 "fdiv"
1655 *am33_2
1657   PC = cia;
1659   if (FPU_DISABLED)
1660     fpu_disabled_exception (SD, CPU, cia);
1661   else
1662     fpu_div (SD, CPU, cia,
1663              &XS2FS (X,Sn), &XS2FS (Y,Sm), &XS2FS (X,Sn), FP_SINGLE);
1666 // 1111 1001 1111 01YX fm.- fn.-; fdiv FDm, FDn
1667 8.0xf9+4.0xf,2.1,1.Y,1.X+3.fm,1.0,3.fn,1.0:D1b:::fdiv
1668 "fdiv"
1669 *am33_2
1671   PC = cia;
1673   if (FPU_DISABLED)
1674     fpu_disabled_exception (SD, CPU, cia);
1675   else
1676     fpu_unimp_exception (SD, CPU, cia);
1679 // 1111 1011 0111 0100 Sm1. Sm2. Sn.. XYZ-; fdiv FSm1, FSm2, FSn
1680 8.0xfb+8.0x74+4.Sm1,4.Sm2+4.Sn,1.X,1.Y,1.Z,1.0:D2a:::fdiv
1681 "fdiv"
1682 *am33_2
1684   PC = cia;
1686   if (FPU_DISABLED)
1687     fpu_disabled_exception (SD, CPU, cia);
1688   else
1689     fpu_div (SD, CPU, cia,
1690              &XS2FS (Y,Sm2), &XS2FS (X,Sm1), &XS2FS (Z,Sn), FP_SINGLE);
1693 // 1111 1011 1111 0100 fm1- fm2- fn.- XYZ-; fdiv FDm1, FDm2, FDn
1694 8.0xfb+8.0xf4+3.fm1,1.0,3.fm2,1.0+3.fn,1.0,1.X,1.Y,1.Z,1.0:D2b:::fdiv
1695 "fdiv"
1696 *am33_2
1698   PC = cia;
1700   if (FPU_DISABLED)
1701     fpu_disabled_exception (SD, CPU, cia);
1702   else
1703     fpu_unimp_exception (SD, CPU, cia);
1707 // 1111 1110 0111 01YX Sm.. Sn.. IMM32; fdiv imm32, FSm, FSn
1708 8.0xfe+4.7,2.1,1.Y,1.X+4.Sm,4.Sn+8.IMM32A+8.IMM32B+8.IMM32C+8.IMM32D:D5:::fdiv
1709 "fdiv"
1710 *am33_2
1712   PC = cia;
1714   if (FPU_DISABLED)
1715     fpu_disabled_exception (SD, CPU, cia);
1716   else
1717     {
1718       uint32 imm = FETCH32 (IMM32A, IMM32B, IMM32C, IMM32D);
1720       fpu_div (SD, CPU, cia,
1721                &XS2FS (Y,Sm), &imm, &XS2FS (X,Sn), FP_SINGLE);
1722     }
1725 // 1111 1011 1000 00Sn Sm1. Sm2. Sm3. XYZA; fmadd FSm1, FSm2, FSm3, FSn
1726 8.0xfb+4.8,2.0,2.Sn+4.Sm1,4.Sm2+4.Sm3,1.X,1.Y,1.Z,1.A:D2:::fmadd
1727 "fmadd"
1728 *am33_2
1730   PC = cia;
1732   if (FPU_DISABLED)
1733     fpu_disabled_exception (SD, CPU, cia);
1734   else
1735     fpu_fmadd (SD, CPU, cia,
1736                &XS2FS (X,Sm1), &XS2FS (Y,Sm2), &XS2FS (Z,Sm3),
1737                &AS2FS (A,Sn), FP_SINGLE);
1739     
1740 // 1111 1011 1000 01Sn Sm1. Sm2. Sm3. XYZA; fmsub FSm1, FSm2, FSm3, FSn
1741 8.0xfb+4.8,2.1,2.Sn+4.Sm1,4.Sm2+4.Sm3,1.X,1.Y,1.Z,1.A:D2:::fmsub
1742 "fmsub"
1743 *am33_2
1745   PC = cia;
1747   if (FPU_DISABLED)
1748     fpu_disabled_exception (SD, CPU, cia);
1749   else
1750     fpu_fmsub (SD, CPU, cia,
1751                &XS2FS (X,Sm1), &XS2FS (Y,Sm2), &XS2FS (Z,Sm3),
1752                &AS2FS (A,Sn), FP_SINGLE);
1755 // 1111 1011 1001 00Sn Sm1. Sm2. Sm3. XYZA; fnmadd FSm1, FSm2, FSm3, FSn
1756 8.0xfb+4.9,2.0,2.Sn+4.Sm1,4.Sm2+4.Sm3,1.X,1.Y,1.Z,1.A:D2:::fnmadd
1757 "fnmadd"
1758 *am33_2
1760   PC = cia;
1762   if (FPU_DISABLED)
1763     fpu_disabled_exception (SD, CPU, cia);
1764   else
1765     fpu_fnmadd (SD, CPU, cia,
1766                 &XS2FS (X,Sm1), &XS2FS (Y,Sm2), &XS2FS (Z,Sm3),
1767                 &AS2FS (A,Sn), FP_SINGLE);
1769     
1770 // 1111 1011 1001 01Sn Sm1. Sm2. Sm3. XYZA; fnmsub FSm1, FSm2, FSm3, FSn
1771 8.0xfb+4.9,2.1,2.Sn+4.Sm1,4.Sm2+4.Sm3,1.X,1.Y,1.Z,1.A:D2:::fnmsub
1772 "fnmsub"
1773 *am33_2
1775   PC = cia;
1777   if (FPU_DISABLED)
1778     fpu_disabled_exception (SD, CPU, cia);
1779   else
1780     fpu_fnmsub (SD, CPU, cia,
1781                 &XS2FS (X,Sm1), &XS2FS (Y,Sm2), &XS2FS (Z,Sm3),
1782                 &AS2FS (A,Sn), FP_SINGLE);
1785 // conversion:
1787 // 1111 1011 0100 0000 Sm.. ---- Sn.. X-Z-; ftoi FSm,FSn
1788 8.0xfb+8.0x40+4.Sm,4.0+4.Sn,1.X,1.0,1.Z,1.0:D2:::ftoi
1789 "ftoi"
1790 *am33_2
1792   PC = cia;
1794   if (FPU_DISABLED)
1795     fpu_disabled_exception (SD, CPU, cia);
1796   else
1797     fpu_unimp_exception (SD, CPU, cia);
1800 // 1111 1011 0100 0010 Sm.. ---- Sn.. X-Z-; itof FSm,FSn
1801 8.0xfb+8.0x42+4.Sm,4.0+4.Sn,1.X,1.0,1.Z,1.0:D2:::itof
1802 "itof"
1803 *am33_2
1805   PC = cia;
1807   if (FPU_DISABLED)
1808     fpu_disabled_exception (SD, CPU, cia);
1809   else
1810     fpu_unimp_exception (SD, CPU, cia);
1813 // 1111 1011 0101 0010 Sm.. ---- fn.- X-Z-; ftod FSm,FDn
1814 8.0xfb+8.0x52+4.Sm,4.0+3.fn,1.0,1.X,1.0,1.Z,1.0:D2:::ftod
1815 "ftod"
1816 *am33_2
1818   PC = cia;
1820   if (FPU_DISABLED)
1821     fpu_disabled_exception (SD, CPU, cia);
1822   else
1823     fpu_unimp_exception (SD, CPU, cia);
1826 // 1111 1011 0101 0110 fm.- ---- Sn.. X-Z-; dtof FDm,FSn
1827 8.0xfb+8.0x56+3.fm,1.0,4.0+4.Sn,1.X,1.0,1.Z,1.0:D2:::dtof
1828 "dtof"
1829 *am33_2
1831   PC = cia;
1833   if (FPU_DISABLED)
1834     fpu_disabled_exception (SD, CPU, cia);
1835   else
1836     fpu_unimp_exception (SD, CPU, cia);
1839 // branching:
1841 // 1111 1000 1101 0000 d8; fbeq (d8,PC) (d8 is sign-extended)
1842 8.0xf8+8.0xd0+8.D8:D1:::fbeq
1843 "fbeq"
1844 *am33_2
1846   PC = cia;
1848   if (FPU_DISABLED)
1849     fpu_disabled_exception (SD, CPU, cia);
1850   else if ((FPCR & FCC_E))
1851     {
1852       State.regs[REG_PC] += EXTEND8 (D8);
1853       nia = PC;
1854     }
1857 // 1111 1000 1101 0001 d8; fbne (d8,PC) (d8 is sign-extended)
1858 8.0xf8+8.0xd1+8.D8:D1:::fbne
1859 "fbne"
1860 *am33_2
1862   PC = cia;
1864   if (FPU_DISABLED)
1865     fpu_disabled_exception (SD, CPU, cia);
1866   else if ((FPCR & (FCC_U | FCC_L | FCC_G)))
1867     {
1868       State.regs[REG_PC] += EXTEND8 (D8);
1869       nia = PC;
1870     }
1873 // 1111 1000 1101 0010 d8; fbgt (d8,PC) (d8 is sign-extended)
1874 8.0xf8+8.0xd2+8.D8:D1:::fbgt
1875 "fbgt"
1876 *am33_2
1878   PC = cia;
1880   if (FPU_DISABLED)
1881     fpu_disabled_exception (SD, CPU, cia);
1882   else if ((FPCR & FCC_G))
1883     {
1884       State.regs[REG_PC] += EXTEND8 (D8);
1885       nia = PC;
1886     }
1889 // 1111 1000 1101 0011 d8; fbge (d8,PC) (d8 is sign-extended)
1890 8.0xf8+8.0xd3+8.D8:D1:::fbge
1891 "fbge"
1892 *am33_2
1894   PC = cia;
1896   if (FPU_DISABLED)
1897     fpu_disabled_exception (SD, CPU, cia);
1898   else if ((FPCR & (FCC_G | FCC_E)))
1899     {
1900       State.regs[REG_PC] += EXTEND8 (D8);
1901       nia = PC;
1902     }
1905 // 1111 1000 1101 0100 d8; fblt (d8,PC) (d8 is sign-extended)
1906 8.0xf8+8.0xd4+8.D8:D1:::fblt
1907 "fblt"
1908 *am33_2
1910   PC = cia;
1912   if (FPU_DISABLED)
1913     fpu_disabled_exception (SD, CPU, cia);
1914   else if ((FPCR & FCC_L))
1915     {
1916       State.regs[REG_PC] += EXTEND8 (D8);
1917       nia = PC;
1918     }
1921 // 1111 1000 1101 0101 d8; fble (d8,PC) (d8 is sign-extended)
1922 8.0xf8+8.0xd5+8.D8:D1:::fble
1923 "fble"
1924 *am33_2
1926   PC = cia;
1928   if (FPU_DISABLED)
1929     fpu_disabled_exception (SD, CPU, cia);
1930   else if ((FPCR & (FCC_L | FCC_E)))
1931     {
1932       State.regs[REG_PC] += EXTEND8 (D8);
1933       nia = PC;
1934     }
1937 // 1111 1000 1101 0110 d8; fbuo (d8,PC) (d8 is sign-extended)
1938 8.0xf8+8.0xd6+8.D8:D1:::fbuo
1939 "fbuo"
1940 *am33_2
1942   PC = cia;
1944   if (FPU_DISABLED)
1945     fpu_disabled_exception (SD, CPU, cia);
1946   else if ((FPCR & FCC_U))
1947     {
1948       State.regs[REG_PC] += EXTEND8 (D8);
1949       nia = PC;
1950     }
1953 // 1111 1000 1101 0111 d8; fblg (d8,PC) (d8 is sign-extended)
1954 8.0xf8+8.0xd7+8.D8:D1:::fblg
1955 "fblg"
1956 *am33_2
1958   PC = cia;
1960   if (FPU_DISABLED)
1961     fpu_disabled_exception (SD, CPU, cia);
1962   else if ((FPCR & (FCC_L | FCC_G)))
1963     {
1964       State.regs[REG_PC] += EXTEND8 (D8);
1965       nia = PC;
1966     }
1968 // 1111 1000 1101 1000 d8; fbleg (d8,PC) (d8 is sign-extended)
1969 8.0xf8+8.0xd8+8.D8:D1:::fbleg
1970 "fbleg"
1971 *am33_2
1973   PC = cia;
1975   if (FPU_DISABLED)
1976     fpu_disabled_exception (SD, CPU, cia);
1977   else if ((FPCR & (FCC_L | FCC_E | FCC_G)))
1978     {
1979       State.regs[REG_PC] += EXTEND8 (D8);
1980       nia = PC;
1981     }
1984 // 1111 1000 1101 1001 d8; fbug (d8,PC) (d8 is sign-extended)
1985 8.0xf8+8.0xd9+8.D8:D1:::fbug
1986 "fbug"
1987 *am33_2
1989   PC = cia;
1991   if (FPU_DISABLED)
1992     fpu_disabled_exception (SD, CPU, cia);
1993   else if ((FPCR & (FCC_U | FCC_G)))
1994     {
1995       State.regs[REG_PC] += EXTEND8 (D8);
1996       nia = PC;
1997     }
2000 // 1111 1000 1101 1010 d8; fbuge (d8,PC) (d8 is sign-extended)
2001 8.0xf8+8.0xda+8.D8:D1:::fbuge
2002 "fbuge"
2003 *am33_2
2005   PC = cia;
2007   if (FPU_DISABLED)
2008     fpu_disabled_exception (SD, CPU, cia);
2009   else if ((FPCR & (FCC_U | FCC_G | FCC_E)))
2010     {
2011       State.regs[REG_PC] += EXTEND8 (D8);
2012       nia = PC;
2013     }
2016 // 1111 1000 1101 1011 d8; fbul (d8,PC) (d8 is sign-extended)
2017 8.0xf8+8.0xdb+8.D8:D1:::fbul
2018 "fbul"
2019 *am33_2
2021   PC = cia;
2023   if (FPU_DISABLED)
2024     fpu_disabled_exception (SD, CPU, cia);
2025   else if ((FPCR & (FCC_U | FCC_L)))
2026     {
2027       State.regs[REG_PC] += EXTEND8 (D8);
2028       nia = PC;
2029     }
2032 // 1111 1000 1101 1100 d8; fbule (d8,PC) (d8 is sign-extended)
2033 8.0xf8+8.0xdc+8.D8:D1:::fbule
2034 "fbule"
2035 *am33_2
2037   PC = cia;
2039   if (FPU_DISABLED)
2040     fpu_disabled_exception (SD, CPU, cia);
2041   else if ((FPCR & (FCC_U | FCC_L | FCC_E)))
2042     {
2043       State.regs[REG_PC] += EXTEND8 (D8);
2044       nia = PC;
2045     }
2048 // 1111 1000 1101 1101 d8; fbue (d8,PC) (d8 is sign-extended)
2049 8.0xf8+8.0xdd+8.D8:D1:::fbue
2050 "fbue"
2051 *am33_2
2053   PC = cia;
2055   if (FPU_DISABLED)
2056     fpu_disabled_exception (SD, CPU, cia);
2057   else if ((FPCR & (FCC_U | FCC_E)))
2058     {
2059       State.regs[REG_PC] += EXTEND8 (D8);
2060       nia = PC;
2061     }
2064 // 1111 0000 1101 0000; fleq
2065 8.0xf0+8.0xd0:D0:::fleq
2066 "fleq"
2067 *am33_2
2069   PC = cia;
2071   if (FPU_DISABLED)
2072     fpu_disabled_exception (SD, CPU, cia);
2073   else if ((FPCR & FCC_E))
2074     {
2075       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2076       nia = PC;
2077     }
2080 // 1111 0000 1101 0001; flne
2081 8.0xf0+8.0xd1:D0:::flne
2082 "flne"
2083 *am33_2
2085   PC = cia;
2087   if (FPU_DISABLED)
2088     fpu_disabled_exception (SD, CPU, cia);
2089   else if ((FPCR & (FCC_U | FCC_L | FCC_G)))
2090     {
2091       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2092       nia = PC;
2093     }
2096 // 1111 0000 1101 0010; flgt
2097 8.0xf0+8.0xd2:D0:::flgt
2098 "flgt"
2099 *am33_2
2101   PC = cia;
2103   if (FPU_DISABLED)
2104     fpu_disabled_exception (SD, CPU, cia);
2105   else if ((FPCR & FCC_G))
2106     {
2107       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2108       nia = PC;
2109     }
2112 // 1111 0000 1101 0011; flge
2113 8.0xf0+8.0xd3:D0:::flge
2114 "flge"
2115 *am33_2
2117   PC = cia;
2119   if (FPU_DISABLED)
2120     fpu_disabled_exception (SD, CPU, cia);
2121   else if ((FPCR & (FCC_G | FCC_E)))
2122     {
2123       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2124       nia = PC;
2125     }
2128 // 1111 0000 1101 0100; fllt
2129 8.0xf0+8.0xd4:D0:::fllt
2130 "fllt"
2131 *am33_2
2133   PC = cia;
2135   if (FPU_DISABLED)
2136     fpu_disabled_exception (SD, CPU, cia);
2137   else if ((FPCR & FCC_L))
2138     {
2139       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2140       nia = PC;
2141     }
2144 // 1111 0000 1101 0101; flle
2145 8.0xf0+8.0xd5:D0:::flle
2146 "flle"
2147 *am33_2
2149   PC = cia;
2151   if (FPU_DISABLED)
2152     fpu_disabled_exception (SD, CPU, cia);
2153   else if ((FPCR & (FCC_L | FCC_E)))
2154     {
2155       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2156       nia = PC;
2157     }
2160 // 1111 0000 1101 0110; fluo
2161 8.0xf0+8.0xd6:D0:::fluo
2162 "fluo"
2163 *am33_2
2165   PC = cia;
2167   if (FPU_DISABLED)
2168     fpu_disabled_exception (SD, CPU, cia);
2169   else if ((FPCR & FCC_U))
2170     {
2171       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2172       nia = PC;
2173     }
2176 // 1111 0000 1101 0111; fllg
2177 8.0xf0+8.0xd7:D0:::fllg
2178 "fllg"
2179 *am33_2
2181   PC = cia;
2183   if (FPU_DISABLED)
2184     fpu_disabled_exception (SD, CPU, cia);
2185   else if ((FPCR & (FCC_L | FCC_G)))
2186     {
2187       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2188       nia = PC;
2189     }
2191 // 1111 0000 1101 1000; flleg
2192 8.0xf0+8.0xd8:D0:::flleg
2193 "flleg"
2194 *am33_2
2196   PC = cia;
2198   if (FPU_DISABLED)
2199     fpu_disabled_exception (SD, CPU, cia);
2200   else if ((FPCR & (FCC_L | FCC_E | FCC_G)))
2201     {
2202       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2203       nia = PC;
2204     }
2207 // 1111 0000 1101 1001; flug
2208 8.0xf0+8.0xd9:D0:::flug
2209 "flug"
2210 *am33_2
2212   PC = cia;
2214   if (FPU_DISABLED)
2215     fpu_disabled_exception (SD, CPU, cia);
2216   else if ((FPCR & (FCC_U | FCC_G)))
2217     {
2218       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2219       nia = PC;
2220     }
2223 // 1111 0000 1101 1010; fluge
2224 8.0xf0+8.0xda:D0:::fluge
2225 "fluge"
2226 *am33_2
2228   PC = cia;
2230   if (FPU_DISABLED)
2231     fpu_disabled_exception (SD, CPU, cia);
2232   else if ((FPCR & (FCC_U | FCC_G | FCC_E)))
2233     {
2234       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2235       nia = PC;
2236     }
2239 // 1111 0000 1101 1011; flul
2240 8.0xf0+8.0xdb:D0:::flul
2241 "flul"
2242 *am33_2
2244   PC = cia;
2246   if (FPU_DISABLED)
2247     fpu_disabled_exception (SD, CPU, cia);
2248   else if ((FPCR & (FCC_U | FCC_L)))
2249     {
2250       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2251       nia = PC;
2252     }
2255 // 1111 0000 1101 1100; flule
2256 8.0xf0+8.0xdc:D0:::flule
2257 "flule"
2258 *am33_2
2260   PC = cia;
2262   if (FPU_DISABLED)
2263     fpu_disabled_exception (SD, CPU, cia);
2264   else if ((FPCR & (FCC_U | FCC_L | FCC_E)))
2265     {
2266       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2267       nia = PC;
2268     }
2271 // 1111 0000 1101 1101; flue
2272 8.0xf0+8.0xdd:D0:::flue
2273 "flue"
2274 *am33_2
2276   PC = cia;
2278   if (FPU_DISABLED)
2279     fpu_disabled_exception (SD, CPU, cia);
2280   else if ((FPCR & (FCC_U | FCC_E)))
2281     {
2282       State.regs[REG_PC] = State.regs[REG_LAR] - 4;
2283       nia = PC;
2284     }