← Back to branch summary

~ubuntu-branches/debian/jessie/gdb/jessie

« back to all changes in this revision

Viewing changes to sim/sh64/decode-media.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Jacobowitz
  • Date: 2010-03-20 01:21:29 UTC
  • mfrom: (1.3.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20100320012129-t7h25y8zgr8c2369
Tags: 7.1-1
http://bugs.debian.org/346409
http://bugs.debian.org/570875
http://bugs.debian.org/569551
http://bugs.debian.org/571132
http://bugs.debian.org/568489
* New upstream release, including:
  - PIE support (Closes: #346409).
  - C++ improvements, including static_cast<> et al, namespace imports,
    and bug fixes in printing virtual base classes.
  - Multi-program debugging.  One GDB can now debug multiple programs
    at the same time.
  - Python scripting improvements, including gdb.parse_and_eval.
  - Updated MIPS Linux signal frame layout (Closes: #570875).
  - No internal error stepping over _dl_debug_state (Closes: #569551).
* Update to Standards-Version: 3.8.4 (no changes required).
* Include more relevant (and smaller) docs in the gdbserver package
  (Closes: #571132).
* Do not duplicate documentation in gdb64, gdb-source, and libgdb-dev.
* Fix crash when switching into TUI mode (Closes: #568489).

Show diffs side-by-side

added added

removed removed

Lines of Context:
sim/sh64/decode-media.c
2
2
 
3
3
THIS FILE IS MACHINE GENERATED WITH CGEN.
4
4
 
5
 
Copyright 1996-2005 Free Software Foundation, Inc.
 
5
Copyright 1996-2010 Free Software Foundation, Inc.
6
6
 
7
7
This file is part of the GNU simulators.
8
8
 
9
 
This program is free software; you can redistribute it and/or modify
10
 
it under the terms of the GNU General Public License as published by
11
 
the Free Software Foundation; either version 3 of the License, or
12
 
(at your option) any later version.
13
 
 
14
 
This program is distributed in the hope that it will be useful,
15
 
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
 
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
 
GNU General Public License for more details.
18
 
 
19
 
You should have received a copy of the GNU General Public License
20
 
along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
9
   This file is free software; you can redistribute it and/or modify
 
10
   it under the terms of the GNU General Public License as published by
 
11
   the Free Software Foundation; either version 3, or (at your option)
 
12
   any later version.
 
13
 
 
14
   It is distributed in the hope that it will be useful, but WITHOUT
 
15
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 
16
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
 
17
   License for more details.
 
18
 
 
19
   You should have received a copy of the GNU General Public License along
 
20
   with this program; if not, write to the Free Software Foundation, Inc.,
 
21
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
21
22
 
22
23
*/
23
24
 
62
63
  { SH_INSN_BGTU, SH64_MEDIA_INSN_BGTU, SH64_MEDIA_SFMT_BEQ },
63
64
  { SH_INSN_BLINK, SH64_MEDIA_INSN_BLINK, SH64_MEDIA_SFMT_BLINK },
64
65
  { SH_INSN_BNE, SH64_MEDIA_INSN_BNE, SH64_MEDIA_SFMT_BEQ },
65
 
  { SH_INSN_BNEI, SH64_MEDIA_INSN_BNEI, SH64_MEDIA_SFMT_BEQI },
 
66
  { SH_INSN_BNEI, SH64_MEDIA_INSN_BNEI, SH64_MEDIA_SFMT_BNEI },
66
67
  { SH_INSN_BRK, SH64_MEDIA_INSN_BRK, SH64_MEDIA_SFMT_BRK },
67
68
  { SH_INSN_BYTEREV, SH64_MEDIA_INSN_BYTEREV, SH64_MEDIA_SFMT_BYTEREV },
68
69
  { SH_INSN_CMPEQ, SH64_MEDIA_INSN_CMPEQ, SH64_MEDIA_SFMT_ADD },
118
119
  { SH_INSN_FSTXD, SH64_MEDIA_INSN_FSTXD, SH64_MEDIA_SFMT_FSTXD },
119
120
  { SH_INSN_FSTXP, SH64_MEDIA_INSN_FSTXP, SH64_MEDIA_SFMT_FLDXP },
120
121
  { SH_INSN_FSTXS, SH64_MEDIA_INSN_FSTXS, SH64_MEDIA_SFMT_FSTXS },
121
 
  { SH_INSN_FSUBD, SH64_MEDIA_INSN_FSUBD, SH64_MEDIA_SFMT_FADDD },
 
122
  { SH_INSN_FSUBD, SH64_MEDIA_INSN_FSUBD, SH64_MEDIA_SFMT_FSUBD },
122
123
  { SH_INSN_FSUBS, SH64_MEDIA_INSN_FSUBS, SH64_MEDIA_SFMT_FADDS },
123
124
  { SH_INSN_FTRCDL, SH64_MEDIA_INSN_FTRCDL, SH64_MEDIA_SFMT_FCNVDS },
124
125
  { SH_INSN_FTRCSL, SH64_MEDIA_INSN_FTRCSL, SH64_MEDIA_SFMT_FABSS },
125
 
  { SH_INSN_FTRCDQ, SH64_MEDIA_INSN_FTRCDQ, SH64_MEDIA_SFMT_FABSD },
 
126
  { SH_INSN_FTRCDQ, SH64_MEDIA_INSN_FTRCDQ, SH64_MEDIA_SFMT_FTRCDQ },
126
127
  { SH_INSN_FTRCSQ, SH64_MEDIA_INSN_FTRCSQ, SH64_MEDIA_SFMT_FCNVSD },
127
128
  { SH_INSN_FTRVS, SH64_MEDIA_INSN_FTRVS, SH64_MEDIA_SFMT_FTRVS },
128
129
  { SH_INSN_GETCFG, SH64_MEDIA_INSN_GETCFG, SH64_MEDIA_SFMT_GETCFG },
170
171
  { SH_INSN_MEXTR6, SH64_MEDIA_INSN_MEXTR6, SH64_MEDIA_SFMT_ADD },
171
172
  { SH_INSN_MEXTR7, SH64_MEDIA_INSN_MEXTR7, SH64_MEDIA_SFMT_ADD },
172
173
  { SH_INSN_MMACFXWL, SH64_MEDIA_INSN_MMACFXWL, SH64_MEDIA_SFMT_MCMV },
173
 
  { SH_INSN_MMACNFX_WL, SH64_MEDIA_INSN_MMACNFX_WL, SH64_MEDIA_SFMT_MCMV },
 
174
  { SH_INSN_MMACNFX_WL, SH64_MEDIA_INSN_MMACNFX_WL, SH64_MEDIA_SFMT_MMACNFX_WL },
174
175
  { SH_INSN_MMULL, SH64_MEDIA_INSN_MMULL, SH64_MEDIA_SFMT_ADD },
175
176
  { SH_INSN_MMULW, SH64_MEDIA_INSN_MMULW, SH64_MEDIA_SFMT_ADD },
176
177
  { SH_INSN_MMULFXL, SH64_MEDIA_INSN_MMULFXL, SH64_MEDIA_SFMT_ADD },
180
181
  { SH_INSN_MMULLOWL, SH64_MEDIA_INSN_MMULLOWL, SH64_MEDIA_SFMT_ADD },
181
182
  { SH_INSN_MMULSUMWQ, SH64_MEDIA_INSN_MMULSUMWQ, SH64_MEDIA_SFMT_MCMV },
182
183
  { SH_INSN_MOVI, SH64_MEDIA_INSN_MOVI, SH64_MEDIA_SFMT_MOVI },
183
 
  { SH_INSN_MPERMW, SH64_MEDIA_INSN_MPERMW, SH64_MEDIA_SFMT_MPERMW },
 
184
  { SH_INSN_MPERMW, SH64_MEDIA_INSN_MPERMW, SH64_MEDIA_SFMT_ADD },
184
185
  { SH_INSN_MSADUBQ, SH64_MEDIA_INSN_MSADUBQ, SH64_MEDIA_SFMT_MCMV },
185
186
  { SH_INSN_MSHALDSL, SH64_MEDIA_INSN_MSHALDSL, SH64_MEDIA_SFMT_ADD },
186
187
  { SH_INSN_MSHALDSW, SH64_MEDIA_INSN_MSHALDSW, SH64_MEDIA_SFMT_ADD },
211
212
  { SH_INSN_OCBWB, SH64_MEDIA_INSN_OCBWB, SH64_MEDIA_SFMT_ALLOCO },
212
213
  { SH_INSN_OR, SH64_MEDIA_INSN_OR, SH64_MEDIA_SFMT_ADD },
213
214
  { SH_INSN_ORI, SH64_MEDIA_INSN_ORI, SH64_MEDIA_SFMT_ORI },
214
 
  { SH_INSN_PREFI, SH64_MEDIA_INSN_PREFI, SH64_MEDIA_SFMT_ALLOCO },
 
215
  { SH_INSN_PREFI, SH64_MEDIA_INSN_PREFI, SH64_MEDIA_SFMT_PREFI },
215
216
  { SH_INSN_PTA, SH64_MEDIA_INSN_PTA, SH64_MEDIA_SFMT_PTA },
216
217
  { SH_INSN_PTABS, SH64_MEDIA_INSN_PTABS, SH64_MEDIA_SFMT_PTABS },
217
218
  { SH_INSN_PTB, SH64_MEDIA_INSN_PTB, SH64_MEDIA_SFMT_PTA },
222
223
  { SH_INSN_SHARD, SH64_MEDIA_INSN_SHARD, SH64_MEDIA_SFMT_ADD },
223
224
  { SH_INSN_SHARDL, SH64_MEDIA_INSN_SHARDL, SH64_MEDIA_SFMT_ADD },
224
225
  { SH_INSN_SHARI, SH64_MEDIA_INSN_SHARI, SH64_MEDIA_SFMT_SHARI },
225
 
  { SH_INSN_SHARIL, SH64_MEDIA_INSN_SHARIL, SH64_MEDIA_SFMT_SHARIL },
 
226
  { SH_INSN_SHARIL, SH64_MEDIA_INSN_SHARIL, SH64_MEDIA_SFMT_SHARI },
226
227
  { SH_INSN_SHLLD, SH64_MEDIA_INSN_SHLLD, SH64_MEDIA_SFMT_ADD },
227
228
  { SH_INSN_SHLLDL, SH64_MEDIA_INSN_SHLLDL, SH64_MEDIA_SFMT_ADD },
228
229
  { SH_INSN_SHLLI, SH64_MEDIA_INSN_SHLLI, SH64_MEDIA_SFMT_SHARI },
229
 
  { SH_INSN_SHLLIL, SH64_MEDIA_INSN_SHLLIL, SH64_MEDIA_SFMT_SHARIL },
 
230
  { SH_INSN_SHLLIL, SH64_MEDIA_INSN_SHLLIL, SH64_MEDIA_SFMT_SHARI },
230
231
  { SH_INSN_SHLRD, SH64_MEDIA_INSN_SHLRD, SH64_MEDIA_SFMT_ADD },
231
232
  { SH_INSN_SHLRDL, SH64_MEDIA_INSN_SHLRDL, SH64_MEDIA_SFMT_ADD },
232
233
  { SH_INSN_SHLRI, SH64_MEDIA_INSN_SHLRI, SH64_MEDIA_SFMT_SHARI },
233
 
  { SH_INSN_SHLRIL, SH64_MEDIA_INSN_SHLRIL, SH64_MEDIA_SFMT_SHARIL },
 
234
  { SH_INSN_SHLRIL, SH64_MEDIA_INSN_SHLRIL, SH64_MEDIA_SFMT_SHARI },
234
235
  { SH_INSN_SHORI, SH64_MEDIA_INSN_SHORI, SH64_MEDIA_SFMT_SHORI },
235
236
  { SH_INSN_SLEEP, SH64_MEDIA_INSN_SLEEP, SH64_MEDIA_SFMT_NOP },
236
237
  { SH_INSN_STB, SH64_MEDIA_INSN_STB, SH64_MEDIA_SFMT_STB },
255
256
  { SH_INSN_XORI, SH64_MEDIA_INSN_XORI, SH64_MEDIA_SFMT_XORI },
256
257
};
257
258
 
258
 
static const struct insn_sem sh64_media_insn_sem_invalid = {
 
259
static const struct insn_sem sh64_media_insn_sem_invalid =
 
260
{
259
261
  VIRTUAL_INSN_X_INVALID, SH64_MEDIA_INSN_X_INVALID, SH64_MEDIA_SFMT_EMPTY
260
262
};
261
263
 
319
321
 
320
322
const IDESC *
321
323
sh64_media_decode (SIM_CPU *current_cpu, IADDR pc,
322
 
              CGEN_INSN_INT base_insn, CGEN_INSN_INT entire_insn,
 
324
              CGEN_INSN_WORD base_insn, CGEN_INSN_WORD entire_insn,
323
325
              ARGBUF *abuf)
324
326
{
325
327
  /* Result of decoder.  */
326
328
  SH64_MEDIA_INSN_TYPE itype;
327
329
 
328
330
  {
329
 
    CGEN_INSN_INT insn = base_insn;
 
331
    CGEN_INSN_WORD insn = base_insn;
330
332
 
331
333
    {
332
334
      unsigned int val = (((insn >> 22) & (63 << 4)) | ((insn >> 16) & (15 << 0)));
602
604
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
603
605
      case 173 :
604
606
        if ((entire_insn & 0xfc0f000f) == 0x280d0000)
605
 
          { itype = SH64_MEDIA_INSN_MPERMW; goto extract_sfmt_mpermw; }
 
607
          { itype = SH64_MEDIA_INSN_MPERMW; goto extract_sfmt_add; }
606
608
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
607
609
      case 175 :
608
610
        if ((entire_insn & 0xfc0f000f) == 0x280f0000)
706
708
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
707
709
      case 211 :
708
710
        if ((entire_insn & 0xfc0f000f) == 0x34030000)
709
 
          { itype = SH64_MEDIA_INSN_FSUBD; goto extract_sfmt_faddd; }
 
711
          { itype = SH64_MEDIA_INSN_FSUBD; goto extract_sfmt_fsubd; }
710
712
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
711
713
      case 212 :
712
714
        if ((entire_insn & 0xfc0f000f) == 0x34040000)
758
760
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
759
761
      case 233 :
760
762
        if ((entire_insn & 0xfc0f000f) == 0x38090000)
761
 
          { itype = SH64_MEDIA_INSN_FTRCDQ; goto extract_sfmt_fabsd; }
 
763
          { itype = SH64_MEDIA_INSN_FTRCDQ; goto extract_sfmt_ftrcdq; }
762
764
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
763
765
      case 234 :
764
766
        if ((entire_insn & 0xfc0f000f) == 0x380a0000)
842
844
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
843
845
      case 293 :
844
846
        if ((entire_insn & 0xfc0f000f) == 0x48050000)
845
 
          { itype = SH64_MEDIA_INSN_MMACNFX_WL; goto extract_sfmt_mcmv; }
 
847
          { itype = SH64_MEDIA_INSN_MMACNFX_WL; goto extract_sfmt_mmacnfx_wl; }
846
848
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
847
849
      case 297 :
848
850
        if ((entire_insn & 0xfc0f000f) == 0x48090000)
1294
1296
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1295
1297
      case 784 :
1296
1298
        if ((entire_insn & 0xfc0f000f) == 0xc4000000)
1297
 
          { itype = SH64_MEDIA_INSN_SHLLIL; goto extract_sfmt_sharil; }
 
1299
          { itype = SH64_MEDIA_INSN_SHLLIL; goto extract_sfmt_shari; }
1298
1300
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1299
1301
      case 785 :
1300
1302
        if ((entire_insn & 0xfc0f000f) == 0xc4010000)
1302
1304
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1303
1305
      case 786 :
1304
1306
        if ((entire_insn & 0xfc0f000f) == 0xc4020000)
1305
 
          { itype = SH64_MEDIA_INSN_SHLRIL; goto extract_sfmt_sharil; }
 
1307
          { itype = SH64_MEDIA_INSN_SHLRIL; goto extract_sfmt_shari; }
1306
1308
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1307
1309
      case 787 :
1308
1310
        if ((entire_insn & 0xfc0f000f) == 0xc4030000)
1310
1312
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1311
1313
      case 790 :
1312
1314
        if ((entire_insn & 0xfc0f000f) == 0xc4060000)
1313
 
          { itype = SH64_MEDIA_INSN_SHARIL; goto extract_sfmt_sharil; }
 
1315
          { itype = SH64_MEDIA_INSN_SHARIL; goto extract_sfmt_shari; }
1314
1316
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1315
1317
      case 791 :
1316
1318
        if ((entire_insn & 0xfc0f000f) == 0xc4070000)
1436
1438
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1437
1439
      case 897 :
1438
1440
        if ((entire_insn & 0xfc0ffc0f) == 0xe001fc00)
1439
 
          { itype = SH64_MEDIA_INSN_PREFI; goto extract_sfmt_alloco; }
 
1441
          { itype = SH64_MEDIA_INSN_PREFI; goto extract_sfmt_prefi; }
1440
1442
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1441
1443
      case 898 :
1442
1444
        if ((entire_insn & 0xfc0f000f) == 0xe0020000)
1484
1486
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1485
1487
      case 917 :
1486
1488
        if ((entire_insn & 0xfc0f018f) == 0xe4050000)
1487
 
          { itype = SH64_MEDIA_INSN_BNEI; goto extract_sfmt_beqi; }
 
1489
          { itype = SH64_MEDIA_INSN_BNEI; goto extract_sfmt_bnei; }
1488
1490
        itype = SH64_MEDIA_INSN_X_INVALID; goto extract_sfmt_empty;
1489
1491
      case 928 : /* fall through */
1490
1492
      case 929 : /* fall through */
1534
1536
 extract_sfmt_empty:
1535
1537
  {
1536
1538
    const IDESC *idesc = &sh64_media_insn_data[itype];
1537
 
#define FLD(f) abuf->fields.fmt_empty.f
 
1539
#define FLD(f) abuf->fields.sfmt_empty.f
1538
1540
 
1539
1541
 
1540
1542
  /* Record the fields for the semantic handler.  */
1547
1549
 extract_sfmt_add:
1548
1550
  {
1549
1551
    const IDESC *idesc = &sh64_media_insn_data[itype];
1550
 
    CGEN_INSN_INT insn = entire_insn;
 
1552
    CGEN_INSN_WORD insn = entire_insn;
1551
1553
#define FLD(f) abuf->fields.sfmt_add.f
1552
1554
    UINT f_left;
1553
1555
    UINT f_right;
1579
1581
 extract_sfmt_addi:
1580
1582
  {
1581
1583
    const IDESC *idesc = &sh64_media_insn_data[itype];
1582
 
    CGEN_INSN_INT insn = entire_insn;
 
1584
    CGEN_INSN_WORD insn = entire_insn;
1583
1585
#define FLD(f) abuf->fields.sfmt_addi.f
1584
1586
    UINT f_left;
1585
1587
    INT f_disp10;
1586
1588
    UINT f_dest;
1587
1589
 
1588
1590
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1589
 
    f_disp10 = EXTRACT_MSB0_INT (insn, 32, 12, 10);
 
1591
    f_disp10 = EXTRACT_MSB0_SINT (insn, 32, 12, 10);
1590
1592
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
1591
1593
 
1592
1594
  /* Record the fields for the semantic handler.  */
1610
1612
 extract_sfmt_alloco:
1611
1613
  {
1612
1614
    const IDESC *idesc = &sh64_media_insn_data[itype];
1613
 
    CGEN_INSN_INT insn = entire_insn;
 
1615
    CGEN_INSN_WORD insn = entire_insn;
1614
1616
#define FLD(f) abuf->fields.sfmt_xori.f
1615
1617
    UINT f_left;
1616
1618
 
1635
1637
 extract_sfmt_beq:
1636
1638
  {
1637
1639
    const IDESC *idesc = &sh64_media_insn_data[itype];
1638
 
    CGEN_INSN_INT insn = entire_insn;
 
1640
    CGEN_INSN_WORD insn = entire_insn;
1639
1641
#define FLD(f) abuf->fields.sfmt_beq.f
1640
1642
    UINT f_left;
1641
1643
    UINT f_right;
1667
1669
 extract_sfmt_beqi:
1668
1670
  {
1669
1671
    const IDESC *idesc = &sh64_media_insn_data[itype];
1670
 
    CGEN_INSN_INT insn = entire_insn;
 
1672
    CGEN_INSN_WORD insn = entire_insn;
1671
1673
#define FLD(f) abuf->fields.sfmt_beqi.f
1672
1674
    UINT f_left;
1673
1675
    INT f_imm6;
1674
1676
    UINT f_tra;
1675
1677
 
1676
1678
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
1677
 
    f_imm6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
1679
    f_imm6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
1678
1680
    f_tra = EXTRACT_MSB0_UINT (insn, 32, 25, 3);
1679
1681
 
1680
1682
  /* Record the fields for the semantic handler.  */
1698
1700
 extract_sfmt_blink:
1699
1701
  {
1700
1702
    const IDESC *idesc = &sh64_media_insn_data[itype];
1701
 
    CGEN_INSN_INT insn = entire_insn;
 
1703
    CGEN_INSN_WORD insn = entire_insn;
1702
1704
#define FLD(f) abuf->fields.sfmt_blink.f
1703
1705
    UINT f_trb;
1704
1706
    UINT f_dest;
1723
1725
    return idesc;
1724
1726
  }
1725
1727
 
 
1728
 extract_sfmt_bnei:
 
1729
  {
 
1730
    const IDESC *idesc = &sh64_media_insn_data[itype];
 
1731
    CGEN_INSN_WORD insn = entire_insn;
 
1732
#define FLD(f) abuf->fields.sfmt_beqi.f
 
1733
    UINT f_left;
 
1734
    INT f_imm6;
 
1735
    UINT f_tra;
 
1736
 
 
1737
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
 
1738
    f_imm6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
 
1739
    f_tra = EXTRACT_MSB0_UINT (insn, 32, 25, 3);
 
1740
 
 
1741
  /* Record the fields for the semantic handler.  */
 
1742
  FLD (f_imm6) = f_imm6;
 
1743
  FLD (f_left) = f_left;
 
1744
  FLD (f_tra) = f_tra;
 
1745
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bnei", "f_imm6 0x%x", 'x', f_imm6, "f_left 0x%x", 'x', f_left, "f_tra 0x%x", 'x', f_tra, (char *) 0));
 
1746
 
 
1747
#if WITH_PROFILE_MODEL_P
 
1748
  /* Record the fields for profiling.  */
 
1749
  if (PROFILE_MODEL_P (current_cpu))
 
1750
    {
 
1751
      FLD (in_rm) = f_left;
 
1752
      FLD (in_tra) = f_tra;
 
1753
    }
 
1754
#endif
 
1755
#undef FLD
 
1756
    return idesc;
 
1757
  }
 
1758
 
1726
1759
 extract_sfmt_brk:
1727
1760
  {
1728
1761
    const IDESC *idesc = &sh64_media_insn_data[itype];
1729
 
#define FLD(f) abuf->fields.fmt_empty.f
 
1762
#define FLD(f) abuf->fields.sfmt_empty.f
1730
1763
 
1731
1764
 
1732
1765
  /* Record the fields for the semantic handler.  */
1745
1778
 extract_sfmt_byterev:
1746
1779
  {
1747
1780
    const IDESC *idesc = &sh64_media_insn_data[itype];
1748
 
    CGEN_INSN_INT insn = entire_insn;
 
1781
    CGEN_INSN_WORD insn = entire_insn;
1749
1782
#define FLD(f) abuf->fields.sfmt_xori.f
1750
1783
    UINT f_left;
1751
1784
    UINT f_dest;
1773
1806
 extract_sfmt_cmveq:
1774
1807
  {
1775
1808
    const IDESC *idesc = &sh64_media_insn_data[itype];
1776
 
    CGEN_INSN_INT insn = entire_insn;
 
1809
    CGEN_INSN_WORD insn = entire_insn;
1777
1810
#define FLD(f) abuf->fields.sfmt_add.f
1778
1811
    UINT f_left;
1779
1812
    UINT f_right;
1805
1838
 extract_sfmt_fabsd:
1806
1839
  {
1807
1840
    const IDESC *idesc = &sh64_media_insn_data[itype];
1808
 
    CGEN_INSN_INT insn = entire_insn;
 
1841
    CGEN_INSN_WORD insn = entire_insn;
1809
1842
#define FLD(f) abuf->fields.sfmt_fabsd.f
1810
1843
    UINT f_left;
1811
1844
    UINT f_right;
1837
1870
 extract_sfmt_fabss:
1838
1871
  {
1839
1872
    const IDESC *idesc = &sh64_media_insn_data[itype];
1840
 
    CGEN_INSN_INT insn = entire_insn;
 
1873
    CGEN_INSN_WORD insn = entire_insn;
1841
1874
#define FLD(f) abuf->fields.sfmt_fabsd.f
1842
1875
    UINT f_left;
1843
1876
    UINT f_right;
1869
1902
 extract_sfmt_faddd:
1870
1903
  {
1871
1904
    const IDESC *idesc = &sh64_media_insn_data[itype];
1872
 
    CGEN_INSN_INT insn = entire_insn;
 
1905
    CGEN_INSN_WORD insn = entire_insn;
1873
1906
#define FLD(f) abuf->fields.sfmt_add.f
1874
1907
    UINT f_left;
1875
1908
    UINT f_right;
1901
1934
 extract_sfmt_fadds:
1902
1935
  {
1903
1936
    const IDESC *idesc = &sh64_media_insn_data[itype];
1904
 
    CGEN_INSN_INT insn = entire_insn;
 
1937
    CGEN_INSN_WORD insn = entire_insn;
1905
1938
#define FLD(f) abuf->fields.sfmt_add.f
1906
1939
    UINT f_left;
1907
1940
    UINT f_right;
1933
1966
 extract_sfmt_fcmpeqd:
1934
1967
  {
1935
1968
    const IDESC *idesc = &sh64_media_insn_data[itype];
1936
 
    CGEN_INSN_INT insn = entire_insn;
 
1969
    CGEN_INSN_WORD insn = entire_insn;
1937
1970
#define FLD(f) abuf->fields.sfmt_add.f
1938
1971
    UINT f_left;
1939
1972
    UINT f_right;
1965
1998
 extract_sfmt_fcmpeqs:
1966
1999
  {
1967
2000
    const IDESC *idesc = &sh64_media_insn_data[itype];
1968
 
    CGEN_INSN_INT insn = entire_insn;
 
2001
    CGEN_INSN_WORD insn = entire_insn;
1969
2002
#define FLD(f) abuf->fields.sfmt_add.f
1970
2003
    UINT f_left;
1971
2004
    UINT f_right;
1997
2030
 extract_sfmt_fcnvds:
1998
2031
  {
1999
2032
    const IDESC *idesc = &sh64_media_insn_data[itype];
2000
 
    CGEN_INSN_INT insn = entire_insn;
 
2033
    CGEN_INSN_WORD insn = entire_insn;
2001
2034
#define FLD(f) abuf->fields.sfmt_fabsd.f
2002
2035
    UINT f_left;
2003
2036
    UINT f_right;
2029
2062
 extract_sfmt_fcnvsd:
2030
2063
  {
2031
2064
    const IDESC *idesc = &sh64_media_insn_data[itype];
2032
 
    CGEN_INSN_INT insn = entire_insn;
 
2065
    CGEN_INSN_WORD insn = entire_insn;
2033
2066
#define FLD(f) abuf->fields.sfmt_fabsd.f
2034
2067
    UINT f_left;
2035
2068
    UINT f_right;
2061
2094
 extract_sfmt_fgetscr:
2062
2095
  {
2063
2096
    const IDESC *idesc = &sh64_media_insn_data[itype];
2064
 
    CGEN_INSN_INT insn = entire_insn;
 
2097
    CGEN_INSN_WORD insn = entire_insn;
2065
2098
#define FLD(f) abuf->fields.sfmt_shori.f
2066
2099
    UINT f_dest;
2067
2100
 
2085
2118
 extract_sfmt_fiprs:
2086
2119
  {
2087
2120
    const IDESC *idesc = &sh64_media_insn_data[itype];
2088
 
    CGEN_INSN_INT insn = entire_insn;
 
2121
    CGEN_INSN_WORD insn = entire_insn;
2089
2122
#define FLD(f) abuf->fields.sfmt_add.f
2090
2123
    UINT f_left;
2091
2124
    UINT f_right;
2119
2152
 extract_sfmt_fldd:
2120
2153
  {
2121
2154
    const IDESC *idesc = &sh64_media_insn_data[itype];
2122
 
    CGEN_INSN_INT insn = entire_insn;
 
2155
    CGEN_INSN_WORD insn = entire_insn;
2123
2156
#define FLD(f) abuf->fields.sfmt_fldd.f
2124
2157
    UINT f_left;
2125
2158
    SI f_disp10x8;
2126
2159
    UINT f_dest;
2127
2160
 
2128
2161
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2129
 
    f_disp10x8 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (3));
 
2162
    f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
2130
2163
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2131
2164
 
2132
2165
  /* Record the fields for the semantic handler.  */
2150
2183
 extract_sfmt_fldp:
2151
2184
  {
2152
2185
    const IDESC *idesc = &sh64_media_insn_data[itype];
2153
 
    CGEN_INSN_INT insn = entire_insn;
 
2186
    CGEN_INSN_WORD insn = entire_insn;
2154
2187
#define FLD(f) abuf->fields.sfmt_fldd.f
2155
2188
    UINT f_left;
2156
2189
    SI f_disp10x8;
2157
2190
    UINT f_dest;
2158
2191
 
2159
2192
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2160
 
    f_disp10x8 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (3));
 
2193
    f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
2161
2194
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2162
2195
 
2163
2196
  /* Record the fields for the semantic handler.  */
2182
2215
 extract_sfmt_flds:
2183
2216
  {
2184
2217
    const IDESC *idesc = &sh64_media_insn_data[itype];
2185
 
    CGEN_INSN_INT insn = entire_insn;
 
2218
    CGEN_INSN_WORD insn = entire_insn;
2186
2219
#define FLD(f) abuf->fields.sfmt_flds.f
2187
2220
    UINT f_left;
2188
2221
    SI f_disp10x4;
2189
2222
    UINT f_dest;
2190
2223
 
2191
2224
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2192
 
    f_disp10x4 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (2));
 
2225
    f_disp10x4 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (2));
2193
2226
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2194
2227
 
2195
2228
  /* Record the fields for the semantic handler.  */
2213
2246
 extract_sfmt_fldxd:
2214
2247
  {
2215
2248
    const IDESC *idesc = &sh64_media_insn_data[itype];
2216
 
    CGEN_INSN_INT insn = entire_insn;
 
2249
    CGEN_INSN_WORD insn = entire_insn;
2217
2250
#define FLD(f) abuf->fields.sfmt_add.f
2218
2251
    UINT f_left;
2219
2252
    UINT f_right;
2245
2278
 extract_sfmt_fldxp:
2246
2279
  {
2247
2280
    const IDESC *idesc = &sh64_media_insn_data[itype];
2248
 
    CGEN_INSN_INT insn = entire_insn;
 
2281
    CGEN_INSN_WORD insn = entire_insn;
2249
2282
#define FLD(f) abuf->fields.sfmt_add.f
2250
2283
    UINT f_left;
2251
2284
    UINT f_right;
2278
2311
 extract_sfmt_fldxs:
2279
2312
  {
2280
2313
    const IDESC *idesc = &sh64_media_insn_data[itype];
2281
 
    CGEN_INSN_INT insn = entire_insn;
 
2314
    CGEN_INSN_WORD insn = entire_insn;
2282
2315
#define FLD(f) abuf->fields.sfmt_add.f
2283
2316
    UINT f_left;
2284
2317
    UINT f_right;
2310
2343
 extract_sfmt_fmacs:
2311
2344
  {
2312
2345
    const IDESC *idesc = &sh64_media_insn_data[itype];
2313
 
    CGEN_INSN_INT insn = entire_insn;
 
2346
    CGEN_INSN_WORD insn = entire_insn;
2314
2347
#define FLD(f) abuf->fields.sfmt_add.f
2315
2348
    UINT f_left;
2316
2349
    UINT f_right;
2343
2376
 extract_sfmt_fmovdq:
2344
2377
  {
2345
2378
    const IDESC *idesc = &sh64_media_insn_data[itype];
2346
 
    CGEN_INSN_INT insn = entire_insn;
 
2379
    CGEN_INSN_WORD insn = entire_insn;
2347
2380
#define FLD(f) abuf->fields.sfmt_fabsd.f
2348
2381
    UINT f_left;
2349
2382
    UINT f_right;
2375
2408
 extract_sfmt_fmovls:
2376
2409
  {
2377
2410
    const IDESC *idesc = &sh64_media_insn_data[itype];
2378
 
    CGEN_INSN_INT insn = entire_insn;
 
2411
    CGEN_INSN_WORD insn = entire_insn;
2379
2412
#define FLD(f) abuf->fields.sfmt_xori.f
2380
2413
    UINT f_left;
2381
2414
    UINT f_dest;
2403
2436
 extract_sfmt_fmovqd:
2404
2437
  {
2405
2438
    const IDESC *idesc = &sh64_media_insn_data[itype];
2406
 
    CGEN_INSN_INT insn = entire_insn;
 
2439
    CGEN_INSN_WORD insn = entire_insn;
2407
2440
#define FLD(f) abuf->fields.sfmt_xori.f
2408
2441
    UINT f_left;
2409
2442
    UINT f_dest;
2431
2464
 extract_sfmt_fmovsl:
2432
2465
  {
2433
2466
    const IDESC *idesc = &sh64_media_insn_data[itype];
2434
 
    CGEN_INSN_INT insn = entire_insn;
 
2467
    CGEN_INSN_WORD insn = entire_insn;
2435
2468
#define FLD(f) abuf->fields.sfmt_fabsd.f
2436
2469
    UINT f_left;
2437
2470
    UINT f_right;
2463
2496
 extract_sfmt_fputscr:
2464
2497
  {
2465
2498
    const IDESC *idesc = &sh64_media_insn_data[itype];
2466
 
    CGEN_INSN_INT insn = entire_insn;
 
2499
    CGEN_INSN_WORD insn = entire_insn;
2467
2500
#define FLD(f) abuf->fields.sfmt_fabsd.f
2468
2501
    UINT f_left;
2469
2502
    UINT f_right;
2491
2524
 extract_sfmt_fstd:
2492
2525
  {
2493
2526
    const IDESC *idesc = &sh64_media_insn_data[itype];
2494
 
    CGEN_INSN_INT insn = entire_insn;
 
2527
    CGEN_INSN_WORD insn = entire_insn;
2495
2528
#define FLD(f) abuf->fields.sfmt_fldd.f
2496
2529
    UINT f_left;
2497
2530
    SI f_disp10x8;
2498
2531
    UINT f_dest;
2499
2532
 
2500
2533
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2501
 
    f_disp10x8 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (3));
 
2534
    f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
2502
2535
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2503
2536
 
2504
2537
  /* Record the fields for the semantic handler.  */
2522
2555
 extract_sfmt_fsts:
2523
2556
  {
2524
2557
    const IDESC *idesc = &sh64_media_insn_data[itype];
2525
 
    CGEN_INSN_INT insn = entire_insn;
 
2558
    CGEN_INSN_WORD insn = entire_insn;
2526
2559
#define FLD(f) abuf->fields.sfmt_flds.f
2527
2560
    UINT f_left;
2528
2561
    SI f_disp10x4;
2529
2562
    UINT f_dest;
2530
2563
 
2531
2564
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2532
 
    f_disp10x4 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (2));
 
2565
    f_disp10x4 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (2));
2533
2566
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2534
2567
 
2535
2568
  /* Record the fields for the semantic handler.  */
2553
2586
 extract_sfmt_fstxd:
2554
2587
  {
2555
2588
    const IDESC *idesc = &sh64_media_insn_data[itype];
2556
 
    CGEN_INSN_INT insn = entire_insn;
 
2589
    CGEN_INSN_WORD insn = entire_insn;
2557
2590
#define FLD(f) abuf->fields.sfmt_add.f
2558
2591
    UINT f_left;
2559
2592
    UINT f_right;
2585
2618
 extract_sfmt_fstxs:
2586
2619
  {
2587
2620
    const IDESC *idesc = &sh64_media_insn_data[itype];
2588
 
    CGEN_INSN_INT insn = entire_insn;
 
2621
    CGEN_INSN_WORD insn = entire_insn;
2589
2622
#define FLD(f) abuf->fields.sfmt_add.f
2590
2623
    UINT f_left;
2591
2624
    UINT f_right;
2614
2647
    return idesc;
2615
2648
  }
2616
2649
 
 
2650
 extract_sfmt_fsubd:
 
2651
  {
 
2652
    const IDESC *idesc = &sh64_media_insn_data[itype];
 
2653
    CGEN_INSN_WORD insn = entire_insn;
 
2654
#define FLD(f) abuf->fields.sfmt_add.f
 
2655
    UINT f_left;
 
2656
    UINT f_right;
 
2657
    UINT f_dest;
 
2658
 
 
2659
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
 
2660
    f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
 
2661
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
 
2662
 
 
2663
  /* Record the fields for the semantic handler.  */
 
2664
  FLD (f_left) = f_left;
 
2665
  FLD (f_right) = f_right;
 
2666
  FLD (f_dest) = f_dest;
 
2667
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_fsubd", "f_left 0x%x", 'x', f_left, "f_right 0x%x", 'x', f_right, "f_dest 0x%x", 'x', f_dest, (char *) 0));
 
2668
 
 
2669
#if WITH_PROFILE_MODEL_P
 
2670
  /* Record the fields for profiling.  */
 
2671
  if (PROFILE_MODEL_P (current_cpu))
 
2672
    {
 
2673
      FLD (in_drg) = f_left;
 
2674
      FLD (in_drh) = f_right;
 
2675
      FLD (out_drf) = f_dest;
 
2676
    }
 
2677
#endif
 
2678
#undef FLD
 
2679
    return idesc;
 
2680
  }
 
2681
 
 
2682
 extract_sfmt_ftrcdq:
 
2683
  {
 
2684
    const IDESC *idesc = &sh64_media_insn_data[itype];
 
2685
    CGEN_INSN_WORD insn = entire_insn;
 
2686
#define FLD(f) abuf->fields.sfmt_fabsd.f
 
2687
    UINT f_left;
 
2688
    UINT f_right;
 
2689
    UINT f_dest;
 
2690
    UINT f_left_right;
 
2691
 
 
2692
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
 
2693
    f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
 
2694
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
 
2695
  f_left_right = f_left;
 
2696
 
 
2697
  /* Record the fields for the semantic handler.  */
 
2698
  FLD (f_left_right) = f_left_right;
 
2699
  FLD (f_dest) = f_dest;
 
2700
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ftrcdq", "f_left_right 0x%x", 'x', f_left_right, "f_dest 0x%x", 'x', f_dest, (char *) 0));
 
2701
 
 
2702
#if WITH_PROFILE_MODEL_P
 
2703
  /* Record the fields for profiling.  */
 
2704
  if (PROFILE_MODEL_P (current_cpu))
 
2705
    {
 
2706
      FLD (in_drgh) = f_left_right;
 
2707
      FLD (out_drf) = f_dest;
 
2708
    }
 
2709
#endif
 
2710
#undef FLD
 
2711
    return idesc;
 
2712
  }
 
2713
 
2617
2714
 extract_sfmt_ftrvs:
2618
2715
  {
2619
2716
    const IDESC *idesc = &sh64_media_insn_data[itype];
2620
 
    CGEN_INSN_INT insn = entire_insn;
 
2717
    CGEN_INSN_WORD insn = entire_insn;
2621
2718
#define FLD(f) abuf->fields.sfmt_add.f
2622
2719
    UINT f_left;
2623
2720
    UINT f_right;
2652
2749
 extract_sfmt_getcfg:
2653
2750
  {
2654
2751
    const IDESC *idesc = &sh64_media_insn_data[itype];
2655
 
    CGEN_INSN_INT insn = entire_insn;
 
2752
    CGEN_INSN_WORD insn = entire_insn;
2656
2753
#define FLD(f) abuf->fields.sfmt_getcfg.f
2657
2754
    UINT f_left;
2658
2755
    INT f_disp6;
2659
2756
    UINT f_dest;
2660
2757
 
2661
2758
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2662
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
2759
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
2663
2760
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2664
2761
 
2665
2762
  /* Record the fields for the semantic handler.  */
2683
2780
 extract_sfmt_getcon:
2684
2781
  {
2685
2782
    const IDESC *idesc = &sh64_media_insn_data[itype];
2686
 
    CGEN_INSN_INT insn = entire_insn;
 
2783
    CGEN_INSN_WORD insn = entire_insn;
2687
2784
#define FLD(f) abuf->fields.sfmt_xori.f
2688
2785
    UINT f_left;
2689
2786
    UINT f_dest;
2710
2807
 extract_sfmt_gettr:
2711
2808
  {
2712
2809
    const IDESC *idesc = &sh64_media_insn_data[itype];
2713
 
    CGEN_INSN_INT insn = entire_insn;
 
2810
    CGEN_INSN_WORD insn = entire_insn;
2714
2811
#define FLD(f) abuf->fields.sfmt_blink.f
2715
2812
    UINT f_trb;
2716
2813
    UINT f_dest;
2738
2835
 extract_sfmt_ldb:
2739
2836
  {
2740
2837
    const IDESC *idesc = &sh64_media_insn_data[itype];
2741
 
    CGEN_INSN_INT insn = entire_insn;
 
2838
    CGEN_INSN_WORD insn = entire_insn;
2742
2839
#define FLD(f) abuf->fields.sfmt_addi.f
2743
2840
    UINT f_left;
2744
2841
    INT f_disp10;
2745
2842
    UINT f_dest;
2746
2843
 
2747
2844
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2748
 
    f_disp10 = EXTRACT_MSB0_INT (insn, 32, 12, 10);
 
2845
    f_disp10 = EXTRACT_MSB0_SINT (insn, 32, 12, 10);
2749
2846
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2750
2847
 
2751
2848
  /* Record the fields for the semantic handler.  */
2769
2866
 extract_sfmt_ldl:
2770
2867
  {
2771
2868
    const IDESC *idesc = &sh64_media_insn_data[itype];
2772
 
    CGEN_INSN_INT insn = entire_insn;
 
2869
    CGEN_INSN_WORD insn = entire_insn;
2773
2870
#define FLD(f) abuf->fields.sfmt_flds.f
2774
2871
    UINT f_left;
2775
2872
    SI f_disp10x4;
2776
2873
    UINT f_dest;
2777
2874
 
2778
2875
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2779
 
    f_disp10x4 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (2));
 
2876
    f_disp10x4 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (2));
2780
2877
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2781
2878
 
2782
2879
  /* Record the fields for the semantic handler.  */
2800
2897
 extract_sfmt_ldq:
2801
2898
  {
2802
2899
    const IDESC *idesc = &sh64_media_insn_data[itype];
2803
 
    CGEN_INSN_INT insn = entire_insn;
 
2900
    CGEN_INSN_WORD insn = entire_insn;
2804
2901
#define FLD(f) abuf->fields.sfmt_fldd.f
2805
2902
    UINT f_left;
2806
2903
    SI f_disp10x8;
2807
2904
    UINT f_dest;
2808
2905
 
2809
2906
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2810
 
    f_disp10x8 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (3));
 
2907
    f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
2811
2908
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2812
2909
 
2813
2910
  /* Record the fields for the semantic handler.  */
2831
2928
 extract_sfmt_lduw:
2832
2929
  {
2833
2930
    const IDESC *idesc = &sh64_media_insn_data[itype];
2834
 
    CGEN_INSN_INT insn = entire_insn;
 
2931
    CGEN_INSN_WORD insn = entire_insn;
2835
2932
#define FLD(f) abuf->fields.sfmt_lduw.f
2836
2933
    UINT f_left;
2837
2934
    SI f_disp10x2;
2838
2935
    UINT f_dest;
2839
2936
 
2840
2937
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2841
 
    f_disp10x2 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (1));
 
2938
    f_disp10x2 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (1));
2842
2939
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2843
2940
 
2844
2941
  /* Record the fields for the semantic handler.  */
2862
2959
 extract_sfmt_ldhil:
2863
2960
  {
2864
2961
    const IDESC *idesc = &sh64_media_insn_data[itype];
2865
 
    CGEN_INSN_INT insn = entire_insn;
 
2962
    CGEN_INSN_WORD insn = entire_insn;
2866
2963
#define FLD(f) abuf->fields.sfmt_getcfg.f
2867
2964
    UINT f_left;
2868
2965
    INT f_disp6;
2869
2966
    UINT f_dest;
2870
2967
 
2871
2968
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2872
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
2969
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
2873
2970
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2874
2971
 
2875
2972
  /* Record the fields for the semantic handler.  */
2893
2990
 extract_sfmt_ldhiq:
2894
2991
  {
2895
2992
    const IDESC *idesc = &sh64_media_insn_data[itype];
2896
 
    CGEN_INSN_INT insn = entire_insn;
 
2993
    CGEN_INSN_WORD insn = entire_insn;
2897
2994
#define FLD(f) abuf->fields.sfmt_getcfg.f
2898
2995
    UINT f_left;
2899
2996
    INT f_disp6;
2900
2997
    UINT f_dest;
2901
2998
 
2902
2999
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2903
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
3000
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
2904
3001
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2905
3002
 
2906
3003
  /* Record the fields for the semantic handler.  */
2924
3021
 extract_sfmt_ldlol:
2925
3022
  {
2926
3023
    const IDESC *idesc = &sh64_media_insn_data[itype];
2927
 
    CGEN_INSN_INT insn = entire_insn;
 
3024
    CGEN_INSN_WORD insn = entire_insn;
2928
3025
#define FLD(f) abuf->fields.sfmt_getcfg.f
2929
3026
    UINT f_left;
2930
3027
    INT f_disp6;
2931
3028
    UINT f_dest;
2932
3029
 
2933
3030
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2934
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
3031
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
2935
3032
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2936
3033
 
2937
3034
  /* Record the fields for the semantic handler.  */
2955
3052
 extract_sfmt_ldloq:
2956
3053
  {
2957
3054
    const IDESC *idesc = &sh64_media_insn_data[itype];
2958
 
    CGEN_INSN_INT insn = entire_insn;
 
3055
    CGEN_INSN_WORD insn = entire_insn;
2959
3056
#define FLD(f) abuf->fields.sfmt_getcfg.f
2960
3057
    UINT f_left;
2961
3058
    INT f_disp6;
2962
3059
    UINT f_dest;
2963
3060
 
2964
3061
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
2965
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
3062
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
2966
3063
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
2967
3064
 
2968
3065
  /* Record the fields for the semantic handler.  */
2986
3083
 extract_sfmt_ldxb:
2987
3084
  {
2988
3085
    const IDESC *idesc = &sh64_media_insn_data[itype];
2989
 
    CGEN_INSN_INT insn = entire_insn;
 
3086
    CGEN_INSN_WORD insn = entire_insn;
2990
3087
#define FLD(f) abuf->fields.sfmt_add.f
2991
3088
    UINT f_left;
2992
3089
    UINT f_right;
3018
3115
 extract_sfmt_ldxl:
3019
3116
  {
3020
3117
    const IDESC *idesc = &sh64_media_insn_data[itype];
3021
 
    CGEN_INSN_INT insn = entire_insn;
 
3118
    CGEN_INSN_WORD insn = entire_insn;
3022
3119
#define FLD(f) abuf->fields.sfmt_add.f
3023
3120
    UINT f_left;
3024
3121
    UINT f_right;
3050
3147
 extract_sfmt_ldxq:
3051
3148
  {
3052
3149
    const IDESC *idesc = &sh64_media_insn_data[itype];
3053
 
    CGEN_INSN_INT insn = entire_insn;
 
3150
    CGEN_INSN_WORD insn = entire_insn;
3054
3151
#define FLD(f) abuf->fields.sfmt_add.f
3055
3152
    UINT f_left;
3056
3153
    UINT f_right;
3082
3179
 extract_sfmt_ldxub:
3083
3180
  {
3084
3181
    const IDESC *idesc = &sh64_media_insn_data[itype];
3085
 
    CGEN_INSN_INT insn = entire_insn;
 
3182
    CGEN_INSN_WORD insn = entire_insn;
3086
3183
#define FLD(f) abuf->fields.sfmt_add.f
3087
3184
    UINT f_left;
3088
3185
    UINT f_right;
3114
3211
 extract_sfmt_ldxuw:
3115
3212
  {
3116
3213
    const IDESC *idesc = &sh64_media_insn_data[itype];
3117
 
    CGEN_INSN_INT insn = entire_insn;
 
3214
    CGEN_INSN_WORD insn = entire_insn;
3118
3215
#define FLD(f) abuf->fields.sfmt_add.f
3119
3216
    UINT f_left;
3120
3217
    UINT f_right;
3146
3243
 extract_sfmt_ldxw:
3147
3244
  {
3148
3245
    const IDESC *idesc = &sh64_media_insn_data[itype];
3149
 
    CGEN_INSN_INT insn = entire_insn;
 
3246
    CGEN_INSN_WORD insn = entire_insn;
3150
3247
#define FLD(f) abuf->fields.sfmt_add.f
3151
3248
    UINT f_left;
3152
3249
    UINT f_right;
3178
3275
 extract_sfmt_mcmv:
3179
3276
  {
3180
3277
    const IDESC *idesc = &sh64_media_insn_data[itype];
3181
 
    CGEN_INSN_INT insn = entire_insn;
 
3278
    CGEN_INSN_WORD insn = entire_insn;
3182
3279
#define FLD(f) abuf->fields.sfmt_add.f
3183
3280
    UINT f_left;
3184
3281
    UINT f_right;
3208
3305
    return idesc;
3209
3306
  }
3210
3307
 
 
3308
 extract_sfmt_mmacnfx_wl:
 
3309
  {
 
3310
    const IDESC *idesc = &sh64_media_insn_data[itype];
 
3311
    CGEN_INSN_WORD insn = entire_insn;
 
3312
#define FLD(f) abuf->fields.sfmt_add.f
 
3313
    UINT f_left;
 
3314
    UINT f_right;
 
3315
    UINT f_dest;
 
3316
 
 
3317
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
 
3318
    f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
 
3319
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
 
3320
 
 
3321
  /* Record the fields for the semantic handler.  */
 
3322
  FLD (f_dest) = f_dest;
 
3323
  FLD (f_left) = f_left;
 
3324
  FLD (f_right) = f_right;
 
3325
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mmacnfx_wl", "f_dest 0x%x", 'x', f_dest, "f_left 0x%x", 'x', f_left, "f_right 0x%x", 'x', f_right, (char *) 0));
 
3326
 
 
3327
#if WITH_PROFILE_MODEL_P
 
3328
  /* Record the fields for profiling.  */
 
3329
  if (PROFILE_MODEL_P (current_cpu))
 
3330
    {
 
3331
      FLD (in_rd) = f_dest;
 
3332
      FLD (in_rm) = f_left;
 
3333
      FLD (in_rn) = f_right;
 
3334
      FLD (out_rd) = f_dest;
 
3335
    }
 
3336
#endif
 
3337
#undef FLD
 
3338
    return idesc;
 
3339
  }
 
3340
 
3211
3341
 extract_sfmt_movi:
3212
3342
  {
3213
3343
    const IDESC *idesc = &sh64_media_insn_data[itype];
3214
 
    CGEN_INSN_INT insn = entire_insn;
 
3344
    CGEN_INSN_WORD insn = entire_insn;
3215
3345
#define FLD(f) abuf->fields.sfmt_movi.f
3216
3346
    INT f_imm16;
3217
3347
    UINT f_dest;
3218
3348
 
3219
 
    f_imm16 = EXTRACT_MSB0_INT (insn, 32, 6, 16);
 
3349
    f_imm16 = EXTRACT_MSB0_SINT (insn, 32, 6, 16);
3220
3350
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3221
3351
 
3222
3352
  /* Record the fields for the semantic handler.  */
3235
3365
    return idesc;
3236
3366
  }
3237
3367
 
3238
 
 extract_sfmt_mpermw:
3239
 
  {
3240
 
    const IDESC *idesc = &sh64_media_insn_data[itype];
3241
 
    CGEN_INSN_INT insn = entire_insn;
3242
 
#define FLD(f) abuf->fields.sfmt_add.f
3243
 
    UINT f_left;
3244
 
    UINT f_right;
3245
 
    UINT f_dest;
3246
 
 
3247
 
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3248
 
    f_right = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3249
 
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3250
 
 
3251
 
  /* Record the fields for the semantic handler.  */
3252
 
  FLD (f_left) = f_left;
3253
 
  FLD (f_right) = f_right;
3254
 
  FLD (f_dest) = f_dest;
3255
 
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mpermw", "f_left 0x%x", 'x', f_left, "f_right 0x%x", 'x', f_right, "f_dest 0x%x", 'x', f_dest, (char *) 0));
3256
 
 
3257
 
#if WITH_PROFILE_MODEL_P
3258
 
  /* Record the fields for profiling.  */
3259
 
  if (PROFILE_MODEL_P (current_cpu))
3260
 
    {
3261
 
      FLD (in_rm) = f_left;
3262
 
      FLD (in_rn) = f_right;
3263
 
      FLD (out_rd) = f_dest;
3264
 
    }
3265
 
#endif
3266
 
#undef FLD
3267
 
    return idesc;
3268
 
  }
3269
 
 
3270
3368
 extract_sfmt_nop:
3271
3369
  {
3272
3370
    const IDESC *idesc = &sh64_media_insn_data[itype];
3273
 
#define FLD(f) abuf->fields.fmt_empty.f
 
3371
#define FLD(f) abuf->fields.sfmt_empty.f
3274
3372
 
3275
3373
 
3276
3374
  /* Record the fields for the semantic handler.  */
3283
3381
 extract_sfmt_ori:
3284
3382
  {
3285
3383
    const IDESC *idesc = &sh64_media_insn_data[itype];
3286
 
    CGEN_INSN_INT insn = entire_insn;
 
3384
    CGEN_INSN_WORD insn = entire_insn;
3287
3385
#define FLD(f) abuf->fields.sfmt_ori.f
3288
3386
    UINT f_left;
3289
3387
    INT f_imm10;
3290
3388
    UINT f_dest;
3291
3389
 
3292
3390
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3293
 
    f_imm10 = EXTRACT_MSB0_INT (insn, 32, 12, 10);
 
3391
    f_imm10 = EXTRACT_MSB0_SINT (insn, 32, 12, 10);
3294
3392
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3295
3393
 
3296
3394
  /* Record the fields for the semantic handler.  */
3311
3409
    return idesc;
3312
3410
  }
3313
3411
 
 
3412
 extract_sfmt_prefi:
 
3413
  {
 
3414
    const IDESC *idesc = &sh64_media_insn_data[itype];
 
3415
    CGEN_INSN_WORD insn = entire_insn;
 
3416
#define FLD(f) abuf->fields.sfmt_xori.f
 
3417
    UINT f_left;
 
3418
 
 
3419
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
 
3420
 
 
3421
  /* Record the fields for the semantic handler.  */
 
3422
  FLD (f_left) = f_left;
 
3423
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_prefi", "f_left 0x%x", 'x', f_left, (char *) 0));
 
3424
 
 
3425
#if WITH_PROFILE_MODEL_P
 
3426
  /* Record the fields for profiling.  */
 
3427
  if (PROFILE_MODEL_P (current_cpu))
 
3428
    {
 
3429
      FLD (in_rm) = f_left;
 
3430
      FLD (out_rm) = f_left;
 
3431
    }
 
3432
#endif
 
3433
#undef FLD
 
3434
    return idesc;
 
3435
  }
 
3436
 
3314
3437
 extract_sfmt_pta:
3315
3438
  {
3316
3439
    const IDESC *idesc = &sh64_media_insn_data[itype];
3317
 
    CGEN_INSN_INT insn = entire_insn;
 
3440
    CGEN_INSN_WORD insn = entire_insn;
3318
3441
#define FLD(f) abuf->fields.sfmt_pta.f
3319
3442
    DI f_disp16;
3320
3443
    UINT f_tra;
3321
3444
 
3322
 
    f_disp16 = ((((EXTRACT_MSB0_INT (insn, 32, 6, 16)) << (2))) + (pc));
 
3445
    f_disp16 = ((((EXTRACT_MSB0_SINT (insn, 32, 6, 16)) << (2))) + (pc));
3323
3446
    f_tra = EXTRACT_MSB0_UINT (insn, 32, 25, 3);
3324
3447
 
3325
3448
  /* Record the fields for the semantic handler.  */
3341
3464
 extract_sfmt_ptabs:
3342
3465
  {
3343
3466
    const IDESC *idesc = &sh64_media_insn_data[itype];
3344
 
    CGEN_INSN_INT insn = entire_insn;
 
3467
    CGEN_INSN_WORD insn = entire_insn;
3345
3468
#define FLD(f) abuf->fields.sfmt_beq.f
3346
3469
    UINT f_right;
3347
3470
    UINT f_tra;
3369
3492
 extract_sfmt_ptrel:
3370
3493
  {
3371
3494
    const IDESC *idesc = &sh64_media_insn_data[itype];
3372
 
    CGEN_INSN_INT insn = entire_insn;
 
3495
    CGEN_INSN_WORD insn = entire_insn;
3373
3496
#define FLD(f) abuf->fields.sfmt_beq.f
3374
3497
    UINT f_right;
3375
3498
    UINT f_tra;
3397
3520
 extract_sfmt_putcfg:
3398
3521
  {
3399
3522
    const IDESC *idesc = &sh64_media_insn_data[itype];
3400
 
    CGEN_INSN_INT insn = entire_insn;
 
3523
    CGEN_INSN_WORD insn = entire_insn;
3401
3524
#define FLD(f) abuf->fields.sfmt_getcfg.f
3402
3525
    UINT f_left;
3403
3526
    INT f_disp6;
3404
3527
    UINT f_dest;
3405
3528
 
3406
3529
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3407
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
3530
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3408
3531
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3409
3532
 
3410
3533
  /* Record the fields for the semantic handler.  */
3428
3551
 extract_sfmt_putcon:
3429
3552
  {
3430
3553
    const IDESC *idesc = &sh64_media_insn_data[itype];
3431
 
    CGEN_INSN_INT insn = entire_insn;
 
3554
    CGEN_INSN_WORD insn = entire_insn;
3432
3555
#define FLD(f) abuf->fields.sfmt_xori.f
3433
3556
    UINT f_left;
3434
3557
    UINT f_dest;
3455
3578
 extract_sfmt_shari:
3456
3579
  {
3457
3580
    const IDESC *idesc = &sh64_media_insn_data[itype];
3458
 
    CGEN_INSN_INT insn = entire_insn;
 
3581
    CGEN_INSN_WORD insn = entire_insn;
3459
3582
#define FLD(f) abuf->fields.sfmt_shari.f
3460
3583
    UINT f_left;
3461
3584
    UINT f_uimm6;
3483
3606
    return idesc;
3484
3607
  }
3485
3608
 
3486
 
 extract_sfmt_sharil:
3487
 
  {
3488
 
    const IDESC *idesc = &sh64_media_insn_data[itype];
3489
 
    CGEN_INSN_INT insn = entire_insn;
3490
 
#define FLD(f) abuf->fields.sfmt_shari.f
3491
 
    UINT f_left;
3492
 
    UINT f_uimm6;
3493
 
    UINT f_dest;
3494
 
 
3495
 
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3496
 
    f_uimm6 = EXTRACT_MSB0_UINT (insn, 32, 16, 6);
3497
 
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3498
 
 
3499
 
  /* Record the fields for the semantic handler.  */
3500
 
  FLD (f_left) = f_left;
3501
 
  FLD (f_uimm6) = f_uimm6;
3502
 
  FLD (f_dest) = f_dest;
3503
 
  TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sharil", "f_left 0x%x", 'x', f_left, "f_uimm6 0x%x", 'x', f_uimm6, "f_dest 0x%x", 'x', f_dest, (char *) 0));
3504
 
 
3505
 
#if WITH_PROFILE_MODEL_P
3506
 
  /* Record the fields for profiling.  */
3507
 
  if (PROFILE_MODEL_P (current_cpu))
3508
 
    {
3509
 
      FLD (in_rm) = f_left;
3510
 
      FLD (out_rd) = f_dest;
3511
 
    }
3512
 
#endif
3513
 
#undef FLD
3514
 
    return idesc;
3515
 
  }
3516
 
 
3517
3609
 extract_sfmt_shori:
3518
3610
  {
3519
3611
    const IDESC *idesc = &sh64_media_insn_data[itype];
3520
 
    CGEN_INSN_INT insn = entire_insn;
 
3612
    CGEN_INSN_WORD insn = entire_insn;
3521
3613
#define FLD(f) abuf->fields.sfmt_shori.f
3522
3614
    UINT f_uimm16;
3523
3615
    UINT f_dest;
3545
3637
 extract_sfmt_stb:
3546
3638
  {
3547
3639
    const IDESC *idesc = &sh64_media_insn_data[itype];
3548
 
    CGEN_INSN_INT insn = entire_insn;
 
3640
    CGEN_INSN_WORD insn = entire_insn;
3549
3641
#define FLD(f) abuf->fields.sfmt_addi.f
3550
3642
    UINT f_left;
3551
3643
    INT f_disp10;
3552
3644
    UINT f_dest;
3553
3645
 
3554
3646
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3555
 
    f_disp10 = EXTRACT_MSB0_INT (insn, 32, 12, 10);
 
3647
    f_disp10 = EXTRACT_MSB0_SINT (insn, 32, 12, 10);
3556
3648
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3557
3649
 
3558
3650
  /* Record the fields for the semantic handler.  */
3576
3668
 extract_sfmt_stl:
3577
3669
  {
3578
3670
    const IDESC *idesc = &sh64_media_insn_data[itype];
3579
 
    CGEN_INSN_INT insn = entire_insn;
 
3671
    CGEN_INSN_WORD insn = entire_insn;
3580
3672
#define FLD(f) abuf->fields.sfmt_flds.f
3581
3673
    UINT f_left;
3582
3674
    SI f_disp10x4;
3583
3675
    UINT f_dest;
3584
3676
 
3585
3677
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3586
 
    f_disp10x4 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (2));
 
3678
    f_disp10x4 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (2));
3587
3679
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3588
3680
 
3589
3681
  /* Record the fields for the semantic handler.  */
3607
3699
 extract_sfmt_stq:
3608
3700
  {
3609
3701
    const IDESC *idesc = &sh64_media_insn_data[itype];
3610
 
    CGEN_INSN_INT insn = entire_insn;
 
3702
    CGEN_INSN_WORD insn = entire_insn;
3611
3703
#define FLD(f) abuf->fields.sfmt_fldd.f
3612
3704
    UINT f_left;
3613
3705
    SI f_disp10x8;
3614
3706
    UINT f_dest;
3615
3707
 
3616
3708
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3617
 
    f_disp10x8 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (3));
 
3709
    f_disp10x8 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (3));
3618
3710
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3619
3711
 
3620
3712
  /* Record the fields for the semantic handler.  */
3638
3730
 extract_sfmt_stw:
3639
3731
  {
3640
3732
    const IDESC *idesc = &sh64_media_insn_data[itype];
3641
 
    CGEN_INSN_INT insn = entire_insn;
 
3733
    CGEN_INSN_WORD insn = entire_insn;
3642
3734
#define FLD(f) abuf->fields.sfmt_lduw.f
3643
3735
    UINT f_left;
3644
3736
    SI f_disp10x2;
3645
3737
    UINT f_dest;
3646
3738
 
3647
3739
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3648
 
    f_disp10x2 = ((EXTRACT_MSB0_INT (insn, 32, 12, 10)) << (1));
 
3740
    f_disp10x2 = ((EXTRACT_MSB0_SINT (insn, 32, 12, 10)) << (1));
3649
3741
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3650
3742
 
3651
3743
  /* Record the fields for the semantic handler.  */
3669
3761
 extract_sfmt_sthil:
3670
3762
  {
3671
3763
    const IDESC *idesc = &sh64_media_insn_data[itype];
3672
 
    CGEN_INSN_INT insn = entire_insn;
 
3764
    CGEN_INSN_WORD insn = entire_insn;
3673
3765
#define FLD(f) abuf->fields.sfmt_getcfg.f
3674
3766
    UINT f_left;
3675
3767
    INT f_disp6;
3676
3768
    UINT f_dest;
3677
3769
 
3678
3770
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3679
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
3771
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3680
3772
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3681
3773
 
3682
3774
  /* Record the fields for the semantic handler.  */
3700
3792
 extract_sfmt_sthiq:
3701
3793
  {
3702
3794
    const IDESC *idesc = &sh64_media_insn_data[itype];
3703
 
    CGEN_INSN_INT insn = entire_insn;
 
3795
    CGEN_INSN_WORD insn = entire_insn;
3704
3796
#define FLD(f) abuf->fields.sfmt_getcfg.f
3705
3797
    UINT f_left;
3706
3798
    INT f_disp6;
3707
3799
    UINT f_dest;
3708
3800
 
3709
3801
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3710
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
3802
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3711
3803
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3712
3804
 
3713
3805
  /* Record the fields for the semantic handler.  */
3731
3823
 extract_sfmt_stlol:
3732
3824
  {
3733
3825
    const IDESC *idesc = &sh64_media_insn_data[itype];
3734
 
    CGEN_INSN_INT insn = entire_insn;
 
3826
    CGEN_INSN_WORD insn = entire_insn;
3735
3827
#define FLD(f) abuf->fields.sfmt_getcfg.f
3736
3828
    UINT f_left;
3737
3829
    INT f_disp6;
3738
3830
    UINT f_dest;
3739
3831
 
3740
3832
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3741
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
3833
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3742
3834
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3743
3835
 
3744
3836
  /* Record the fields for the semantic handler.  */
3762
3854
 extract_sfmt_stloq:
3763
3855
  {
3764
3856
    const IDESC *idesc = &sh64_media_insn_data[itype];
3765
 
    CGEN_INSN_INT insn = entire_insn;
 
3857
    CGEN_INSN_WORD insn = entire_insn;
3766
3858
#define FLD(f) abuf->fields.sfmt_getcfg.f
3767
3859
    UINT f_left;
3768
3860
    INT f_disp6;
3769
3861
    UINT f_dest;
3770
3862
 
3771
3863
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3772
 
    f_disp6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
3864
    f_disp6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3773
3865
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3774
3866
 
3775
3867
  /* Record the fields for the semantic handler.  */
3793
3885
 extract_sfmt_stxb:
3794
3886
  {
3795
3887
    const IDESC *idesc = &sh64_media_insn_data[itype];
3796
 
    CGEN_INSN_INT insn = entire_insn;
 
3888
    CGEN_INSN_WORD insn = entire_insn;
3797
3889
#define FLD(f) abuf->fields.sfmt_add.f
3798
3890
    UINT f_left;
3799
3891
    UINT f_right;
3825
3917
 extract_sfmt_stxl:
3826
3918
  {
3827
3919
    const IDESC *idesc = &sh64_media_insn_data[itype];
3828
 
    CGEN_INSN_INT insn = entire_insn;
 
3920
    CGEN_INSN_WORD insn = entire_insn;
3829
3921
#define FLD(f) abuf->fields.sfmt_add.f
3830
3922
    UINT f_left;
3831
3923
    UINT f_right;
3857
3949
 extract_sfmt_stxq:
3858
3950
  {
3859
3951
    const IDESC *idesc = &sh64_media_insn_data[itype];
3860
 
    CGEN_INSN_INT insn = entire_insn;
 
3952
    CGEN_INSN_WORD insn = entire_insn;
3861
3953
#define FLD(f) abuf->fields.sfmt_add.f
3862
3954
    UINT f_left;
3863
3955
    UINT f_right;
3889
3981
 extract_sfmt_stxw:
3890
3982
  {
3891
3983
    const IDESC *idesc = &sh64_media_insn_data[itype];
3892
 
    CGEN_INSN_INT insn = entire_insn;
 
3984
    CGEN_INSN_WORD insn = entire_insn;
3893
3985
#define FLD(f) abuf->fields.sfmt_add.f
3894
3986
    UINT f_left;
3895
3987
    UINT f_right;
3921
4013
 extract_sfmt_swapq:
3922
4014
  {
3923
4015
    const IDESC *idesc = &sh64_media_insn_data[itype];
3924
 
    CGEN_INSN_INT insn = entire_insn;
 
4016
    CGEN_INSN_WORD insn = entire_insn;
3925
4017
#define FLD(f) abuf->fields.sfmt_add.f
3926
4018
    UINT f_left;
3927
4019
    UINT f_right;
3954
4046
 extract_sfmt_trapa:
3955
4047
  {
3956
4048
    const IDESC *idesc = &sh64_media_insn_data[itype];
3957
 
    CGEN_INSN_INT insn = entire_insn;
 
4049
    CGEN_INSN_WORD insn = entire_insn;
3958
4050
#define FLD(f) abuf->fields.sfmt_xori.f
3959
4051
    UINT f_left;
3960
4052
 
3978
4070
 extract_sfmt_xori:
3979
4071
  {
3980
4072
    const IDESC *idesc = &sh64_media_insn_data[itype];
3981
 
    CGEN_INSN_INT insn = entire_insn;
 
4073
    CGEN_INSN_WORD insn = entire_insn;
3982
4074
#define FLD(f) abuf->fields.sfmt_xori.f
3983
4075
    UINT f_left;
3984
4076
    INT f_imm6;
3985
4077
    UINT f_dest;
3986
4078
 
3987
4079
    f_left = EXTRACT_MSB0_UINT (insn, 32, 6, 6);
3988
 
    f_imm6 = EXTRACT_MSB0_INT (insn, 32, 16, 6);
 
4080
    f_imm6 = EXTRACT_MSB0_SINT (insn, 32, 16, 6);
3989
4081
    f_dest = EXTRACT_MSB0_UINT (insn, 32, 22, 6);
3990
4082
 
3991
4083
  /* Record the fields for the semantic handler.  */