?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Automatic date update in version.in
[binutils-gdb.git] / sim / m32r / decode2.c
blobca0f18a78207930e267dc2a746c9639f7b0a1836
1 /* Simulator instruction decoder for m32r2f.
2
3 THIS FILE IS MACHINE GENERATED WITH CGEN.
4
5 Copyright (C) 1996-2024 Free Software Foundation, Inc.
6
7 This file is part of the GNU simulators.
8
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.
22
23 */
24
25 #define WANT_CPU m32r2f
26 #define WANT_CPU_M32R2F
27
28 #include "sim-main.h"
29 #include "sim-assert.h"
30 #include "cgen-mem.h"
31 #include "cgen-ops.h"
32
33 /* Insn can't be executed in parallel.
34 Or is that "do NOt Pass to Air defense Radar"? :-) */
35 #define NOPAR (-1)
36
37 /* The instruction descriptor array.
38 This is computed at runtime. Space for it is not malloc'd to save a
39 teensy bit of cpu in the decoder. Moving it to malloc space is trivial
40 but won't be done until necessary (we don't currently support the runtime
41 addition of instructions nor an SMP machine with different cpus). */
42 static IDESC m32r2f_insn_data[M32R2F_INSN__MAX];
43
44 /* Commas between elements are contained in the macros.
45 Some of these are conditionally compiled out. */
46
47 static const struct insn_sem m32r2f_insn_sem[] =
48 {
49 { VIRTUAL_INSN_X_INVALID, M32R2F_INSN_X_INVALID, M32R2F_SFMT_EMPTY, NOPAR, NOPAR },
50 { VIRTUAL_INSN_X_AFTER, M32R2F_INSN_X_AFTER, M32R2F_SFMT_EMPTY, NOPAR, NOPAR },
51 { VIRTUAL_INSN_X_BEFORE, M32R2F_INSN_X_BEFORE, M32R2F_SFMT_EMPTY, NOPAR, NOPAR },
52 { VIRTUAL_INSN_X_CTI_CHAIN, M32R2F_INSN_X_CTI_CHAIN, M32R2F_SFMT_EMPTY, NOPAR, NOPAR },
53 { VIRTUAL_INSN_X_CHAIN, M32R2F_INSN_X_CHAIN, M32R2F_SFMT_EMPTY, NOPAR, NOPAR },
54 { VIRTUAL_INSN_X_BEGIN, M32R2F_INSN_X_BEGIN, M32R2F_SFMT_EMPTY, NOPAR, NOPAR },
55 { M32R_INSN_ADD, M32R2F_INSN_ADD, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_ADD, M32R2F_INSN_WRITE_ADD },
56 { M32R_INSN_ADD3, M32R2F_INSN_ADD3, M32R2F_SFMT_ADD3, NOPAR, NOPAR },
57 { M32R_INSN_AND, M32R2F_INSN_AND, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_AND, M32R2F_INSN_WRITE_AND },
58 { M32R_INSN_AND3, M32R2F_INSN_AND3, M32R2F_SFMT_AND3, NOPAR, NOPAR },
59 { M32R_INSN_OR, M32R2F_INSN_OR, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_OR, M32R2F_INSN_WRITE_OR },
60 { M32R_INSN_OR3, M32R2F_INSN_OR3, M32R2F_SFMT_OR3, NOPAR, NOPAR },
61 { M32R_INSN_XOR, M32R2F_INSN_XOR, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_XOR, M32R2F_INSN_WRITE_XOR },
62 { M32R_INSN_XOR3, M32R2F_INSN_XOR3, M32R2F_SFMT_AND3, NOPAR, NOPAR },
63 { M32R_INSN_ADDI, M32R2F_INSN_ADDI, M32R2F_SFMT_ADDI, M32R2F_INSN_PAR_ADDI, M32R2F_INSN_WRITE_ADDI },
64 { M32R_INSN_ADDV, M32R2F_INSN_ADDV, M32R2F_SFMT_ADDV, M32R2F_INSN_PAR_ADDV, M32R2F_INSN_WRITE_ADDV },
65 { M32R_INSN_ADDV3, M32R2F_INSN_ADDV3, M32R2F_SFMT_ADDV3, NOPAR, NOPAR },
66 { M32R_INSN_ADDX, M32R2F_INSN_ADDX, M32R2F_SFMT_ADDX, M32R2F_INSN_PAR_ADDX, M32R2F_INSN_WRITE_ADDX },
67 { M32R_INSN_BC8, M32R2F_INSN_BC8, M32R2F_SFMT_BC8, M32R2F_INSN_PAR_BC8, M32R2F_INSN_WRITE_BC8 },
68 { M32R_INSN_BC24, M32R2F_INSN_BC24, M32R2F_SFMT_BC24, NOPAR, NOPAR },
69 { M32R_INSN_BEQ, M32R2F_INSN_BEQ, M32R2F_SFMT_BEQ, NOPAR, NOPAR },
70 { M32R_INSN_BEQZ, M32R2F_INSN_BEQZ, M32R2F_SFMT_BEQZ, NOPAR, NOPAR },
71 { M32R_INSN_BGEZ, M32R2F_INSN_BGEZ, M32R2F_SFMT_BEQZ, NOPAR, NOPAR },
72 { M32R_INSN_BGTZ, M32R2F_INSN_BGTZ, M32R2F_SFMT_BEQZ, NOPAR, NOPAR },
73 { M32R_INSN_BLEZ, M32R2F_INSN_BLEZ, M32R2F_SFMT_BEQZ, NOPAR, NOPAR },
74 { M32R_INSN_BLTZ, M32R2F_INSN_BLTZ, M32R2F_SFMT_BEQZ, NOPAR, NOPAR },
75 { M32R_INSN_BNEZ, M32R2F_INSN_BNEZ, M32R2F_SFMT_BEQZ, NOPAR, NOPAR },
76 { M32R_INSN_BL8, M32R2F_INSN_BL8, M32R2F_SFMT_BL8, M32R2F_INSN_PAR_BL8, M32R2F_INSN_WRITE_BL8 },
77 { M32R_INSN_BL24, M32R2F_INSN_BL24, M32R2F_SFMT_BL24, NOPAR, NOPAR },
78 { M32R_INSN_BCL8, M32R2F_INSN_BCL8, M32R2F_SFMT_BCL8, M32R2F_INSN_PAR_BCL8, M32R2F_INSN_WRITE_BCL8 },
79 { M32R_INSN_BCL24, M32R2F_INSN_BCL24, M32R2F_SFMT_BCL24, NOPAR, NOPAR },
80 { M32R_INSN_BNC8, M32R2F_INSN_BNC8, M32R2F_SFMT_BC8, M32R2F_INSN_PAR_BNC8, M32R2F_INSN_WRITE_BNC8 },
81 { M32R_INSN_BNC24, M32R2F_INSN_BNC24, M32R2F_SFMT_BC24, NOPAR, NOPAR },
82 { M32R_INSN_BNE, M32R2F_INSN_BNE, M32R2F_SFMT_BEQ, NOPAR, NOPAR },
83 { M32R_INSN_BRA8, M32R2F_INSN_BRA8, M32R2F_SFMT_BRA8, M32R2F_INSN_PAR_BRA8, M32R2F_INSN_WRITE_BRA8 },
84 { M32R_INSN_BRA24, M32R2F_INSN_BRA24, M32R2F_SFMT_BRA24, NOPAR, NOPAR },
85 { M32R_INSN_BNCL8, M32R2F_INSN_BNCL8, M32R2F_SFMT_BCL8, M32R2F_INSN_PAR_BNCL8, M32R2F_INSN_WRITE_BNCL8 },
86 { M32R_INSN_BNCL24, M32R2F_INSN_BNCL24, M32R2F_SFMT_BCL24, NOPAR, NOPAR },
87 { M32R_INSN_CMP, M32R2F_INSN_CMP, M32R2F_SFMT_CMP, M32R2F_INSN_PAR_CMP, M32R2F_INSN_WRITE_CMP },
88 { M32R_INSN_CMPI, M32R2F_INSN_CMPI, M32R2F_SFMT_CMPI, NOPAR, NOPAR },
89 { M32R_INSN_CMPU, M32R2F_INSN_CMPU, M32R2F_SFMT_CMP, M32R2F_INSN_PAR_CMPU, M32R2F_INSN_WRITE_CMPU },
90 { M32R_INSN_CMPUI, M32R2F_INSN_CMPUI, M32R2F_SFMT_CMPI, NOPAR, NOPAR },
91 { M32R_INSN_CMPEQ, M32R2F_INSN_CMPEQ, M32R2F_SFMT_CMP, M32R2F_INSN_PAR_CMPEQ, M32R2F_INSN_WRITE_CMPEQ },
92 { M32R_INSN_CMPZ, M32R2F_INSN_CMPZ, M32R2F_SFMT_CMPZ, M32R2F_INSN_PAR_CMPZ, M32R2F_INSN_WRITE_CMPZ },
93 { M32R_INSN_DIV, M32R2F_INSN_DIV, M32R2F_SFMT_DIV, NOPAR, NOPAR },
94 { M32R_INSN_DIVU, M32R2F_INSN_DIVU, M32R2F_SFMT_DIV, NOPAR, NOPAR },
95 { M32R_INSN_REM, M32R2F_INSN_REM, M32R2F_SFMT_DIV, NOPAR, NOPAR },
96 { M32R_INSN_REMU, M32R2F_INSN_REMU, M32R2F_SFMT_DIV, NOPAR, NOPAR },
97 { M32R_INSN_REMH, M32R2F_INSN_REMH, M32R2F_SFMT_DIV, NOPAR, NOPAR },
98 { M32R_INSN_REMUH, M32R2F_INSN_REMUH, M32R2F_SFMT_DIV, NOPAR, NOPAR },
99 { M32R_INSN_REMB, M32R2F_INSN_REMB, M32R2F_SFMT_DIV, NOPAR, NOPAR },
100 { M32R_INSN_REMUB, M32R2F_INSN_REMUB, M32R2F_SFMT_DIV, NOPAR, NOPAR },
101 { M32R_INSN_DIVUH, M32R2F_INSN_DIVUH, M32R2F_SFMT_DIV, NOPAR, NOPAR },
102 { M32R_INSN_DIVB, M32R2F_INSN_DIVB, M32R2F_SFMT_DIV, NOPAR, NOPAR },
103 { M32R_INSN_DIVUB, M32R2F_INSN_DIVUB, M32R2F_SFMT_DIV, NOPAR, NOPAR },
104 { M32R_INSN_DIVH, M32R2F_INSN_DIVH, M32R2F_SFMT_DIV, NOPAR, NOPAR },
105 { M32R_INSN_JC, M32R2F_INSN_JC, M32R2F_SFMT_JC, M32R2F_INSN_PAR_JC, M32R2F_INSN_WRITE_JC },
106 { M32R_INSN_JNC, M32R2F_INSN_JNC, M32R2F_SFMT_JC, M32R2F_INSN_PAR_JNC, M32R2F_INSN_WRITE_JNC },
107 { M32R_INSN_JL, M32R2F_INSN_JL, M32R2F_SFMT_JL, M32R2F_INSN_PAR_JL, M32R2F_INSN_WRITE_JL },
108 { M32R_INSN_JMP, M32R2F_INSN_JMP, M32R2F_SFMT_JMP, M32R2F_INSN_PAR_JMP, M32R2F_INSN_WRITE_JMP },
109 { M32R_INSN_LD, M32R2F_INSN_LD, M32R2F_SFMT_LD, M32R2F_INSN_PAR_LD, M32R2F_INSN_WRITE_LD },
110 { M32R_INSN_LD_D, M32R2F_INSN_LD_D, M32R2F_SFMT_LD_D, NOPAR, NOPAR },
111 { M32R_INSN_LDB, M32R2F_INSN_LDB, M32R2F_SFMT_LDB, M32R2F_INSN_PAR_LDB, M32R2F_INSN_WRITE_LDB },
112 { M32R_INSN_LDB_D, M32R2F_INSN_LDB_D, M32R2F_SFMT_LDB_D, NOPAR, NOPAR },
113 { M32R_INSN_LDH, M32R2F_INSN_LDH, M32R2F_SFMT_LDH, M32R2F_INSN_PAR_LDH, M32R2F_INSN_WRITE_LDH },
114 { M32R_INSN_LDH_D, M32R2F_INSN_LDH_D, M32R2F_SFMT_LDH_D, NOPAR, NOPAR },
115 { M32R_INSN_LDUB, M32R2F_INSN_LDUB, M32R2F_SFMT_LDB, M32R2F_INSN_PAR_LDUB, M32R2F_INSN_WRITE_LDUB },
116 { M32R_INSN_LDUB_D, M32R2F_INSN_LDUB_D, M32R2F_SFMT_LDB_D, NOPAR, NOPAR },
117 { M32R_INSN_LDUH, M32R2F_INSN_LDUH, M32R2F_SFMT_LDH, M32R2F_INSN_PAR_LDUH, M32R2F_INSN_WRITE_LDUH },
118 { M32R_INSN_LDUH_D, M32R2F_INSN_LDUH_D, M32R2F_SFMT_LDH_D, NOPAR, NOPAR },
119 { M32R_INSN_LD_PLUS, M32R2F_INSN_LD_PLUS, M32R2F_SFMT_LD_PLUS, M32R2F_INSN_PAR_LD_PLUS, M32R2F_INSN_WRITE_LD_PLUS },
120 { M32R_INSN_LD24, M32R2F_INSN_LD24, M32R2F_SFMT_LD24, NOPAR, NOPAR },
121 { M32R_INSN_LDI8, M32R2F_INSN_LDI8, M32R2F_SFMT_LDI8, M32R2F_INSN_PAR_LDI8, M32R2F_INSN_WRITE_LDI8 },
122 { M32R_INSN_LDI16, M32R2F_INSN_LDI16, M32R2F_SFMT_LDI16, NOPAR, NOPAR },
123 { M32R_INSN_LOCK, M32R2F_INSN_LOCK, M32R2F_SFMT_LOCK, M32R2F_INSN_PAR_LOCK, M32R2F_INSN_WRITE_LOCK },
124 { M32R_INSN_MACHI_A, M32R2F_INSN_MACHI_A, M32R2F_SFMT_MACHI_A, M32R2F_INSN_PAR_MACHI_A, M32R2F_INSN_WRITE_MACHI_A },
125 { M32R_INSN_MACLO_A, M32R2F_INSN_MACLO_A, M32R2F_SFMT_MACHI_A, M32R2F_INSN_PAR_MACLO_A, M32R2F_INSN_WRITE_MACLO_A },
126 { M32R_INSN_MACWHI_A, M32R2F_INSN_MACWHI_A, M32R2F_SFMT_MACHI_A, M32R2F_INSN_PAR_MACWHI_A, M32R2F_INSN_WRITE_MACWHI_A },
127 { M32R_INSN_MACWLO_A, M32R2F_INSN_MACWLO_A, M32R2F_SFMT_MACHI_A, M32R2F_INSN_PAR_MACWLO_A, M32R2F_INSN_WRITE_MACWLO_A },
128 { M32R_INSN_MUL, M32R2F_INSN_MUL, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_MUL, M32R2F_INSN_WRITE_MUL },
129 { M32R_INSN_MULHI_A, M32R2F_INSN_MULHI_A, M32R2F_SFMT_MULHI_A, M32R2F_INSN_PAR_MULHI_A, M32R2F_INSN_WRITE_MULHI_A },
130 { M32R_INSN_MULLO_A, M32R2F_INSN_MULLO_A, M32R2F_SFMT_MULHI_A, M32R2F_INSN_PAR_MULLO_A, M32R2F_INSN_WRITE_MULLO_A },
131 { M32R_INSN_MULWHI_A, M32R2F_INSN_MULWHI_A, M32R2F_SFMT_MULHI_A, M32R2F_INSN_PAR_MULWHI_A, M32R2F_INSN_WRITE_MULWHI_A },
132 { M32R_INSN_MULWLO_A, M32R2F_INSN_MULWLO_A, M32R2F_SFMT_MULHI_A, M32R2F_INSN_PAR_MULWLO_A, M32R2F_INSN_WRITE_MULWLO_A },
133 { M32R_INSN_MV, M32R2F_INSN_MV, M32R2F_SFMT_MV, M32R2F_INSN_PAR_MV, M32R2F_INSN_WRITE_MV },
134 { M32R_INSN_MVFACHI_A, M32R2F_INSN_MVFACHI_A, M32R2F_SFMT_MVFACHI_A, M32R2F_INSN_PAR_MVFACHI_A, M32R2F_INSN_WRITE_MVFACHI_A },
135 { M32R_INSN_MVFACLO_A, M32R2F_INSN_MVFACLO_A, M32R2F_SFMT_MVFACHI_A, M32R2F_INSN_PAR_MVFACLO_A, M32R2F_INSN_WRITE_MVFACLO_A },
136 { M32R_INSN_MVFACMI_A, M32R2F_INSN_MVFACMI_A, M32R2F_SFMT_MVFACHI_A, M32R2F_INSN_PAR_MVFACMI_A, M32R2F_INSN_WRITE_MVFACMI_A },
137 { M32R_INSN_MVFC, M32R2F_INSN_MVFC, M32R2F_SFMT_MVFC, M32R2F_INSN_PAR_MVFC, M32R2F_INSN_WRITE_MVFC },
138 { M32R_INSN_MVTACHI_A, M32R2F_INSN_MVTACHI_A, M32R2F_SFMT_MVTACHI_A, M32R2F_INSN_PAR_MVTACHI_A, M32R2F_INSN_WRITE_MVTACHI_A },
139 { M32R_INSN_MVTACLO_A, M32R2F_INSN_MVTACLO_A, M32R2F_SFMT_MVTACHI_A, M32R2F_INSN_PAR_MVTACLO_A, M32R2F_INSN_WRITE_MVTACLO_A },
140 { M32R_INSN_MVTC, M32R2F_INSN_MVTC, M32R2F_SFMT_MVTC, M32R2F_INSN_PAR_MVTC, M32R2F_INSN_WRITE_MVTC },
141 { M32R_INSN_NEG, M32R2F_INSN_NEG, M32R2F_SFMT_MV, M32R2F_INSN_PAR_NEG, M32R2F_INSN_WRITE_NEG },
142 { M32R_INSN_NOP, M32R2F_INSN_NOP, M32R2F_SFMT_NOP, M32R2F_INSN_PAR_NOP, M32R2F_INSN_WRITE_NOP },
143 { M32R_INSN_NOT, M32R2F_INSN_NOT, M32R2F_SFMT_MV, M32R2F_INSN_PAR_NOT, M32R2F_INSN_WRITE_NOT },
144 { M32R_INSN_RAC_DSI, M32R2F_INSN_RAC_DSI, M32R2F_SFMT_RAC_DSI, M32R2F_INSN_PAR_RAC_DSI, M32R2F_INSN_WRITE_RAC_DSI },
145 { M32R_INSN_RACH_DSI, M32R2F_INSN_RACH_DSI, M32R2F_SFMT_RAC_DSI, M32R2F_INSN_PAR_RACH_DSI, M32R2F_INSN_WRITE_RACH_DSI },
146 { M32R_INSN_RTE, M32R2F_INSN_RTE, M32R2F_SFMT_RTE, M32R2F_INSN_PAR_RTE, M32R2F_INSN_WRITE_RTE },
147 { M32R_INSN_SETH, M32R2F_INSN_SETH, M32R2F_SFMT_SETH, NOPAR, NOPAR },
148 { M32R_INSN_SLL, M32R2F_INSN_SLL, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_SLL, M32R2F_INSN_WRITE_SLL },
149 { M32R_INSN_SLL3, M32R2F_INSN_SLL3, M32R2F_SFMT_SLL3, NOPAR, NOPAR },
150 { M32R_INSN_SLLI, M32R2F_INSN_SLLI, M32R2F_SFMT_SLLI, M32R2F_INSN_PAR_SLLI, M32R2F_INSN_WRITE_SLLI },
151 { M32R_INSN_SRA, M32R2F_INSN_SRA, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_SRA, M32R2F_INSN_WRITE_SRA },
152 { M32R_INSN_SRA3, M32R2F_INSN_SRA3, M32R2F_SFMT_SLL3, NOPAR, NOPAR },
153 { M32R_INSN_SRAI, M32R2F_INSN_SRAI, M32R2F_SFMT_SLLI, M32R2F_INSN_PAR_SRAI, M32R2F_INSN_WRITE_SRAI },
154 { M32R_INSN_SRL, M32R2F_INSN_SRL, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_SRL, M32R2F_INSN_WRITE_SRL },
155 { M32R_INSN_SRL3, M32R2F_INSN_SRL3, M32R2F_SFMT_SLL3, NOPAR, NOPAR },
156 { M32R_INSN_SRLI, M32R2F_INSN_SRLI, M32R2F_SFMT_SLLI, M32R2F_INSN_PAR_SRLI, M32R2F_INSN_WRITE_SRLI },
157 { M32R_INSN_ST, M32R2F_INSN_ST, M32R2F_SFMT_ST, M32R2F_INSN_PAR_ST, M32R2F_INSN_WRITE_ST },
158 { M32R_INSN_ST_D, M32R2F_INSN_ST_D, M32R2F_SFMT_ST_D, NOPAR, NOPAR },
159 { M32R_INSN_STB, M32R2F_INSN_STB, M32R2F_SFMT_STB, M32R2F_INSN_PAR_STB, M32R2F_INSN_WRITE_STB },
160 { M32R_INSN_STB_D, M32R2F_INSN_STB_D, M32R2F_SFMT_STB_D, NOPAR, NOPAR },
161 { M32R_INSN_STH, M32R2F_INSN_STH, M32R2F_SFMT_STH, M32R2F_INSN_PAR_STH, M32R2F_INSN_WRITE_STH },
162 { M32R_INSN_STH_D, M32R2F_INSN_STH_D, M32R2F_SFMT_STH_D, NOPAR, NOPAR },
163 { M32R_INSN_ST_PLUS, M32R2F_INSN_ST_PLUS, M32R2F_SFMT_ST_PLUS, M32R2F_INSN_PAR_ST_PLUS, M32R2F_INSN_WRITE_ST_PLUS },
164 { M32R_INSN_STH_PLUS, M32R2F_INSN_STH_PLUS, M32R2F_SFMT_STH_PLUS, M32R2F_INSN_PAR_STH_PLUS, M32R2F_INSN_WRITE_STH_PLUS },
165 { M32R_INSN_STB_PLUS, M32R2F_INSN_STB_PLUS, M32R2F_SFMT_STB_PLUS, M32R2F_INSN_PAR_STB_PLUS, M32R2F_INSN_WRITE_STB_PLUS },
166 { M32R_INSN_ST_MINUS, M32R2F_INSN_ST_MINUS, M32R2F_SFMT_ST_PLUS, M32R2F_INSN_PAR_ST_MINUS, M32R2F_INSN_WRITE_ST_MINUS },
167 { M32R_INSN_SUB, M32R2F_INSN_SUB, M32R2F_SFMT_ADD, M32R2F_INSN_PAR_SUB, M32R2F_INSN_WRITE_SUB },
168 { M32R_INSN_SUBV, M32R2F_INSN_SUBV, M32R2F_SFMT_ADDV, M32R2F_INSN_PAR_SUBV, M32R2F_INSN_WRITE_SUBV },
169 { M32R_INSN_SUBX, M32R2F_INSN_SUBX, M32R2F_SFMT_ADDX, M32R2F_INSN_PAR_SUBX, M32R2F_INSN_WRITE_SUBX },
170 { M32R_INSN_TRAP, M32R2F_INSN_TRAP, M32R2F_SFMT_TRAP, M32R2F_INSN_PAR_TRAP, M32R2F_INSN_WRITE_TRAP },
171 { M32R_INSN_UNLOCK, M32R2F_INSN_UNLOCK, M32R2F_SFMT_UNLOCK, M32R2F_INSN_PAR_UNLOCK, M32R2F_INSN_WRITE_UNLOCK },
172 { M32R_INSN_SATB, M32R2F_INSN_SATB, M32R2F_SFMT_SATB, NOPAR, NOPAR },
173 { M32R_INSN_SATH, M32R2F_INSN_SATH, M32R2F_SFMT_SATB, NOPAR, NOPAR },
174 { M32R_INSN_SAT, M32R2F_INSN_SAT, M32R2F_SFMT_SAT, NOPAR, NOPAR },
175 { M32R_INSN_PCMPBZ, M32R2F_INSN_PCMPBZ, M32R2F_SFMT_CMPZ, M32R2F_INSN_PAR_PCMPBZ, M32R2F_INSN_WRITE_PCMPBZ },
176 { M32R_INSN_SADD, M32R2F_INSN_SADD, M32R2F_SFMT_SADD, M32R2F_INSN_PAR_SADD, M32R2F_INSN_WRITE_SADD },
177 { M32R_INSN_MACWU1, M32R2F_INSN_MACWU1, M32R2F_SFMT_MACWU1, M32R2F_INSN_PAR_MACWU1, M32R2F_INSN_WRITE_MACWU1 },
178 { M32R_INSN_MSBLO, M32R2F_INSN_MSBLO, M32R2F_SFMT_MSBLO, M32R2F_INSN_PAR_MSBLO, M32R2F_INSN_WRITE_MSBLO },
179 { M32R_INSN_MULWU1, M32R2F_INSN_MULWU1, M32R2F_SFMT_MULWU1, M32R2F_INSN_PAR_MULWU1, M32R2F_INSN_WRITE_MULWU1 },
180 { M32R_INSN_MACLH1, M32R2F_INSN_MACLH1, M32R2F_SFMT_MACWU1, M32R2F_INSN_PAR_MACLH1, M32R2F_INSN_WRITE_MACLH1 },
181 { M32R_INSN_SC, M32R2F_INSN_SC, M32R2F_SFMT_SC, M32R2F_INSN_PAR_SC, M32R2F_INSN_WRITE_SC },
182 { M32R_INSN_SNC, M32R2F_INSN_SNC, M32R2F_SFMT_SC, M32R2F_INSN_PAR_SNC, M32R2F_INSN_WRITE_SNC },
183 { M32R_INSN_CLRPSW, M32R2F_INSN_CLRPSW, M32R2F_SFMT_CLRPSW, M32R2F_INSN_PAR_CLRPSW, M32R2F_INSN_WRITE_CLRPSW },
184 { M32R_INSN_SETPSW, M32R2F_INSN_SETPSW, M32R2F_SFMT_SETPSW, M32R2F_INSN_PAR_SETPSW, M32R2F_INSN_WRITE_SETPSW },
185 { M32R_INSN_BSET, M32R2F_INSN_BSET, M32R2F_SFMT_BSET, NOPAR, NOPAR },
186 { M32R_INSN_BCLR, M32R2F_INSN_BCLR, M32R2F_SFMT_BSET, NOPAR, NOPAR },
187 { M32R_INSN_BTST, M32R2F_INSN_BTST, M32R2F_SFMT_BTST, M32R2F_INSN_PAR_BTST, M32R2F_INSN_WRITE_BTST },
188 };
189
190 static const struct insn_sem m32r2f_insn_sem_invalid =
191 {
192 VIRTUAL_INSN_X_INVALID, M32R2F_INSN_X_INVALID, M32R2F_SFMT_EMPTY, NOPAR, NOPAR
193 };
194
195 /* Initialize an IDESC from the compile-time computable parts. */
196
197 static INLINE void
198 init_idesc (SIM_CPU *cpu, IDESC *id, const struct insn_sem *t)
199 {
200 const CGEN_INSN *insn_table = CGEN_CPU_INSN_TABLE (CPU_CPU_DESC (cpu))->init_entries;
201
202 id->num = t->index;
203 id->sfmt = t->sfmt;
204 if ((int) t->type <= 0)
205 id->idata = & cgen_virtual_insn_table[- (int) t->type];
206 else
207 id->idata = & insn_table[t->type];
208 id->attrs = CGEN_INSN_ATTRS (id->idata);
209 /* Oh my god, a magic number. */
210 id->length = CGEN_INSN_BITSIZE (id->idata) / 8;
211
212 #if WITH_PROFILE_MODEL_P
213 id->timing = & MODEL_TIMING (CPU_MODEL (cpu)) [t->index];
214 {
215 SIM_DESC sd = CPU_STATE (cpu);
216 SIM_ASSERT (t->index == id->timing->num);
217 }
218 #endif
219
220 /* Semantic pointers are initialized elsewhere. */
221 }
222
223 /* Initialize the instruction descriptor table. */
224
225 void
226 m32r2f_init_idesc_table (SIM_CPU *cpu)
227 {
228 IDESC *id,*tabend;
229 const struct insn_sem *t,*tend;
230 int tabsize = M32R2F_INSN__MAX;
231 IDESC *table = m32r2f_insn_data;
232
233 memset (table, 0, tabsize * sizeof (IDESC));
234
235 /* First set all entries to the `invalid insn'. */
236 t = & m32r2f_insn_sem_invalid;
237 for (id = table, tabend = table + tabsize; id < tabend; ++id)
238 init_idesc (cpu, id, t);
239
240 /* Now fill in the values for the chosen cpu. */
241 for (t = m32r2f_insn_sem, tend = t + ARRAY_SIZE (m32r2f_insn_sem);
242 t != tend; ++t)
243 {
244 init_idesc (cpu, & table[t->index], t);
245 if (t->par_index != NOPAR)
246 {
247 init_idesc (cpu, &table[t->par_index], t);
248 table[t->index].par_idesc = &table[t->par_index];
249 }
250 if (t->par_index != NOPAR)
251 {
252 init_idesc (cpu, &table[t->write_index], t);
253 table[t->par_index].par_idesc = &table[t->write_index];
254 }
255 }
256
257 /* Link the IDESC table into the cpu. */
258 CPU_IDESC (cpu) = table;
259 }
260
261 /* Given an instruction, return a pointer to its IDESC entry. */
262
263 const IDESC *
264 m32r2f_decode (SIM_CPU *current_cpu, IADDR pc,
265 CGEN_INSN_WORD base_insn, CGEN_INSN_WORD entire_insn,
266 ARGBUF *abuf)
267 {
268 /* Result of decoder. */
269 M32R2F_INSN_TYPE itype;
270
271 {
272 CGEN_INSN_WORD insn = base_insn;
273
274 {
275 unsigned int val0 = (((insn >> 8) & (15 << 4)) | ((insn >> 4) & (15 << 0)));
276 switch (val0)
277 {
278 case 0: itype = M32R2F_INSN_SUBV; goto extract_sfmt_addv;
279 case 1: itype = M32R2F_INSN_SUBX; goto extract_sfmt_addx;
280 case 2: itype = M32R2F_INSN_SUB; goto extract_sfmt_add;
281 case 3: itype = M32R2F_INSN_NEG; goto extract_sfmt_mv;
282 case 4: itype = M32R2F_INSN_CMP; goto extract_sfmt_cmp;
283 case 5: itype = M32R2F_INSN_CMPU; goto extract_sfmt_cmp;
284 case 6: itype = M32R2F_INSN_CMPEQ; goto extract_sfmt_cmp;
285 case 7:
286 {
287 unsigned int val1 = (((insn >> 8) & (3 << 0)));
288 switch (val1)
289 {
290 case 0:
291 if ((entire_insn & 0xfff0) == 0x70)
292 { itype = M32R2F_INSN_CMPZ; goto extract_sfmt_cmpz; }
293 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
294 case 3:
295 if ((entire_insn & 0xfff0) == 0x370)
296 { itype = M32R2F_INSN_PCMPBZ; goto extract_sfmt_cmpz; }
297 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
298 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
299 }
300 }
301 case 8: itype = M32R2F_INSN_ADDV; goto extract_sfmt_addv;
302 case 9: itype = M32R2F_INSN_ADDX; goto extract_sfmt_addx;
303 case 10: itype = M32R2F_INSN_ADD; goto extract_sfmt_add;
304 case 11: itype = M32R2F_INSN_NOT; goto extract_sfmt_mv;
305 case 12: itype = M32R2F_INSN_AND; goto extract_sfmt_add;
306 case 13: itype = M32R2F_INSN_XOR; goto extract_sfmt_add;
307 case 14: itype = M32R2F_INSN_OR; goto extract_sfmt_add;
308 case 15:
309 if ((entire_insn & 0xf8f0) == 0xf0)
310 { itype = M32R2F_INSN_BTST; goto extract_sfmt_btst; }
311 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
312 case 16: itype = M32R2F_INSN_SRL; goto extract_sfmt_add;
313 case 18: itype = M32R2F_INSN_SRA; goto extract_sfmt_add;
314 case 20: itype = M32R2F_INSN_SLL; goto extract_sfmt_add;
315 case 22: itype = M32R2F_INSN_MUL; goto extract_sfmt_add;
316 case 24: itype = M32R2F_INSN_MV; goto extract_sfmt_mv;
317 case 25: itype = M32R2F_INSN_MVFC; goto extract_sfmt_mvfc;
318 case 26: itype = M32R2F_INSN_MVTC; goto extract_sfmt_mvtc;
319 case 28:
320 {
321 unsigned int val1 = (((insn >> 8) & (3 << 0)));
322 switch (val1)
323 {
324 case 0:
325 if ((entire_insn & 0xfff0) == 0x1cc0)
326 { itype = M32R2F_INSN_JC; goto extract_sfmt_jc; }
327 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
328 case 1:
329 if ((entire_insn & 0xfff0) == 0x1dc0)
330 { itype = M32R2F_INSN_JNC; goto extract_sfmt_jc; }
331 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
332 case 2:
333 if ((entire_insn & 0xfff0) == 0x1ec0)
334 { itype = M32R2F_INSN_JL; goto extract_sfmt_jl; }
335 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
336 case 3:
337 if ((entire_insn & 0xfff0) == 0x1fc0)
338 { itype = M32R2F_INSN_JMP; goto extract_sfmt_jmp; }
339 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
340 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
341 }
342 }
343 case 29:
344 if ((entire_insn & 0xffff) == 0x10d6)
345 { itype = M32R2F_INSN_RTE; goto extract_sfmt_rte; }
346 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
347 case 31:
348 if ((entire_insn & 0xfff0) == 0x10f0)
349 { itype = M32R2F_INSN_TRAP; goto extract_sfmt_trap; }
350 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
351 case 32: itype = M32R2F_INSN_STB; goto extract_sfmt_stb;
352 case 33: itype = M32R2F_INSN_STB_PLUS; goto extract_sfmt_stb_plus;
353 case 34: itype = M32R2F_INSN_STH; goto extract_sfmt_sth;
354 case 35: itype = M32R2F_INSN_STH_PLUS; goto extract_sfmt_sth_plus;
355 case 36: itype = M32R2F_INSN_ST; goto extract_sfmt_st;
356 case 37: itype = M32R2F_INSN_UNLOCK; goto extract_sfmt_unlock;
357 case 38: itype = M32R2F_INSN_ST_PLUS; goto extract_sfmt_st_plus;
358 case 39: itype = M32R2F_INSN_ST_MINUS; goto extract_sfmt_st_plus;
359 case 40: itype = M32R2F_INSN_LDB; goto extract_sfmt_ldb;
360 case 41: itype = M32R2F_INSN_LDUB; goto extract_sfmt_ldb;
361 case 42: itype = M32R2F_INSN_LDH; goto extract_sfmt_ldh;
362 case 43: itype = M32R2F_INSN_LDUH; goto extract_sfmt_ldh;
363 case 44: itype = M32R2F_INSN_LD; goto extract_sfmt_ld;
364 case 45: itype = M32R2F_INSN_LOCK; goto extract_sfmt_lock;
365 case 46: itype = M32R2F_INSN_LD_PLUS; goto extract_sfmt_ld_plus;
366 case 48:
367 case 56: itype = M32R2F_INSN_MULHI_A; goto extract_sfmt_mulhi_a;
368 case 49:
369 case 57: itype = M32R2F_INSN_MULLO_A; goto extract_sfmt_mulhi_a;
370 case 50:
371 case 58: itype = M32R2F_INSN_MULWHI_A; goto extract_sfmt_mulhi_a;
372 case 51:
373 case 59: itype = M32R2F_INSN_MULWLO_A; goto extract_sfmt_mulhi_a;
374 case 52:
375 case 60: itype = M32R2F_INSN_MACHI_A; goto extract_sfmt_machi_a;
376 case 53:
377 case 61: itype = M32R2F_INSN_MACLO_A; goto extract_sfmt_machi_a;
378 case 54:
379 case 62: itype = M32R2F_INSN_MACWHI_A; goto extract_sfmt_machi_a;
380 case 55:
381 case 63: itype = M32R2F_INSN_MACWLO_A; goto extract_sfmt_machi_a;
382 case 64:
383 case 65:
384 case 66:
385 case 67:
386 case 68:
387 case 69:
388 case 70:
389 case 71:
390 case 72:
391 case 73:
392 case 74:
393 case 75:
394 case 76:
395 case 77:
396 case 78:
397 case 79: itype = M32R2F_INSN_ADDI; goto extract_sfmt_addi;
398 case 80:
399 case 81: itype = M32R2F_INSN_SRLI; goto extract_sfmt_slli;
400 case 82:
401 case 83: itype = M32R2F_INSN_SRAI; goto extract_sfmt_slli;
402 case 84:
403 case 85: itype = M32R2F_INSN_SLLI; goto extract_sfmt_slli;
404 case 87:
405 {
406 unsigned int val1 = (((insn >> 0) & (1 << 0)));
407 switch (val1)
408 {
409 case 0:
410 if ((entire_insn & 0xf0f3) == 0x5070)
411 { itype = M32R2F_INSN_MVTACHI_A; goto extract_sfmt_mvtachi_a; }
412 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
413 case 1:
414 if ((entire_insn & 0xf0f3) == 0x5071)
415 { itype = M32R2F_INSN_MVTACLO_A; goto extract_sfmt_mvtachi_a; }
416 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
417 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
418 }
419 }
420 case 88:
421 if ((entire_insn & 0xf3f2) == 0x5080)
422 { itype = M32R2F_INSN_RACH_DSI; goto extract_sfmt_rac_dsi; }
423 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
424 case 89:
425 if ((entire_insn & 0xf3f2) == 0x5090)
426 { itype = M32R2F_INSN_RAC_DSI; goto extract_sfmt_rac_dsi; }
427 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
428 case 90: itype = M32R2F_INSN_MULWU1; goto extract_sfmt_mulwu1;
429 case 91: itype = M32R2F_INSN_MACWU1; goto extract_sfmt_macwu1;
430 case 92: itype = M32R2F_INSN_MACLH1; goto extract_sfmt_macwu1;
431 case 93: itype = M32R2F_INSN_MSBLO; goto extract_sfmt_msblo;
432 case 94:
433 if ((entire_insn & 0xffff) == 0x50e4)
434 { itype = M32R2F_INSN_SADD; goto extract_sfmt_sadd; }
435 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
436 case 95:
437 {
438 unsigned int val1 = (((insn >> 0) & (3 << 0)));
439 switch (val1)
440 {
441 case 0: itype = M32R2F_INSN_MVFACHI_A; goto extract_sfmt_mvfachi_a;
442 case 1: itype = M32R2F_INSN_MVFACLO_A; goto extract_sfmt_mvfachi_a;
443 case 2: itype = M32R2F_INSN_MVFACMI_A; goto extract_sfmt_mvfachi_a;
444 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
445 }
446 }
447 case 96:
448 case 97:
449 case 98:
450 case 99:
451 case 100:
452 case 101:
453 case 102:
454 case 103:
455 case 104:
456 case 105:
457 case 106:
458 case 107:
459 case 108:
460 case 109:
461 case 110:
462 case 111: itype = M32R2F_INSN_LDI8; goto extract_sfmt_ldi8;
463 case 112:
464 {
465 unsigned int val1 = (((insn >> 7) & (15 << 1)) | ((insn >> 0) & (1 << 0)));
466 switch (val1)
467 {
468 case 0:
469 if ((entire_insn & 0xffff) == 0x7000)
470 { itype = M32R2F_INSN_NOP; goto extract_sfmt_nop; }
471 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
472 case 2:
473 case 3: itype = M32R2F_INSN_SETPSW; goto extract_sfmt_setpsw;
474 case 4:
475 case 5: itype = M32R2F_INSN_CLRPSW; goto extract_sfmt_clrpsw;
476 case 9:
477 if ((entire_insn & 0xffff) == 0x7401)
478 { itype = M32R2F_INSN_SC; goto extract_sfmt_sc; }
479 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
480 case 11:
481 if ((entire_insn & 0xffff) == 0x7501)
482 { itype = M32R2F_INSN_SNC; goto extract_sfmt_sc; }
483 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
484 case 16:
485 case 17: itype = M32R2F_INSN_BCL8; goto extract_sfmt_bcl8;
486 case 18:
487 case 19: itype = M32R2F_INSN_BNCL8; goto extract_sfmt_bcl8;
488 case 24:
489 case 25: itype = M32R2F_INSN_BC8; goto extract_sfmt_bc8;
490 case 26:
491 case 27: itype = M32R2F_INSN_BNC8; goto extract_sfmt_bc8;
492 case 28:
493 case 29: itype = M32R2F_INSN_BL8; goto extract_sfmt_bl8;
494 case 30:
495 case 31: itype = M32R2F_INSN_BRA8; goto extract_sfmt_bra8;
496 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
497 }
498 }
499 case 113:
500 case 114:
501 case 115:
502 case 116:
503 case 117:
504 case 118:
505 case 119:
506 case 120:
507 case 121:
508 case 122:
509 case 123:
510 case 124:
511 case 125:
512 case 126:
513 case 127:
514 {
515 unsigned int val1 = (((insn >> 8) & (15 << 0)));
516 switch (val1)
517 {
518 case 1: itype = M32R2F_INSN_SETPSW; goto extract_sfmt_setpsw;
519 case 2: itype = M32R2F_INSN_CLRPSW; goto extract_sfmt_clrpsw;
520 case 8: itype = M32R2F_INSN_BCL8; goto extract_sfmt_bcl8;
521 case 9: itype = M32R2F_INSN_BNCL8; goto extract_sfmt_bcl8;
522 case 12: itype = M32R2F_INSN_BC8; goto extract_sfmt_bc8;
523 case 13: itype = M32R2F_INSN_BNC8; goto extract_sfmt_bc8;
524 case 14: itype = M32R2F_INSN_BL8; goto extract_sfmt_bl8;
525 case 15: itype = M32R2F_INSN_BRA8; goto extract_sfmt_bra8;
526 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
527 }
528 }
529 case 132:
530 if ((entire_insn & 0xfff00000) == 0x80400000)
531 { itype = M32R2F_INSN_CMPI; goto extract_sfmt_cmpi; }
532 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
533 case 133:
534 if ((entire_insn & 0xfff00000) == 0x80500000)
535 { itype = M32R2F_INSN_CMPUI; goto extract_sfmt_cmpi; }
536 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
537 case 134:
538 {
539 unsigned int val1 = (((entire_insn >> 8) & (3 << 0)));
540 switch (val1)
541 {
542 case 0:
543 if ((entire_insn & 0xf0f0ffff) == 0x80600000)
544 { itype = M32R2F_INSN_SAT; goto extract_sfmt_sat; }
545 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
546 case 2:
547 if ((entire_insn & 0xf0f0ffff) == 0x80600200)
548 { itype = M32R2F_INSN_SATH; goto extract_sfmt_satb; }
549 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
550 case 3:
551 if ((entire_insn & 0xf0f0ffff) == 0x80600300)
552 { itype = M32R2F_INSN_SATB; goto extract_sfmt_satb; }
553 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
554 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
555 }
556 }
557 case 136: itype = M32R2F_INSN_ADDV3; goto extract_sfmt_addv3;
558 case 138: itype = M32R2F_INSN_ADD3; goto extract_sfmt_add3;
559 case 140: itype = M32R2F_INSN_AND3; goto extract_sfmt_and3;
560 case 141: itype = M32R2F_INSN_XOR3; goto extract_sfmt_and3;
561 case 142: itype = M32R2F_INSN_OR3; goto extract_sfmt_or3;
562 case 144:
563 {
564 unsigned int val1 = (((entire_insn >> 3) & (3 << 0)));
565 switch (val1)
566 {
567 case 0:
568 if ((entire_insn & 0xf0f0ffff) == 0x90000000)
569 { itype = M32R2F_INSN_DIV; goto extract_sfmt_div; }
570 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
571 case 2:
572 if ((entire_insn & 0xf0f0ffff) == 0x90000010)
573 { itype = M32R2F_INSN_DIVH; goto extract_sfmt_div; }
574 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
575 case 3:
576 if ((entire_insn & 0xf0f0ffff) == 0x90000018)
577 { itype = M32R2F_INSN_DIVB; goto extract_sfmt_div; }
578 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
579 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
580 }
581 }
582 case 145:
583 {
584 unsigned int val1 = (((entire_insn >> 3) & (3 << 0)));
585 switch (val1)
586 {
587 case 0:
588 if ((entire_insn & 0xf0f0ffff) == 0x90100000)
589 { itype = M32R2F_INSN_DIVU; goto extract_sfmt_div; }
590 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
591 case 2:
592 if ((entire_insn & 0xf0f0ffff) == 0x90100010)
593 { itype = M32R2F_INSN_DIVUH; goto extract_sfmt_div; }
594 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
595 case 3:
596 if ((entire_insn & 0xf0f0ffff) == 0x90100018)
597 { itype = M32R2F_INSN_DIVUB; goto extract_sfmt_div; }
598 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
599 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
600 }
601 }
602 case 146:
603 {
604 unsigned int val1 = (((entire_insn >> 3) & (3 << 0)));
605 switch (val1)
606 {
607 case 0:
608 if ((entire_insn & 0xf0f0ffff) == 0x90200000)
609 { itype = M32R2F_INSN_REM; goto extract_sfmt_div; }
610 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
611 case 2:
612 if ((entire_insn & 0xf0f0ffff) == 0x90200010)
613 { itype = M32R2F_INSN_REMH; goto extract_sfmt_div; }
614 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
615 case 3:
616 if ((entire_insn & 0xf0f0ffff) == 0x90200018)
617 { itype = M32R2F_INSN_REMB; goto extract_sfmt_div; }
618 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
619 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
620 }
621 }
622 case 147:
623 {
624 unsigned int val1 = (((entire_insn >> 3) & (3 << 0)));
625 switch (val1)
626 {
627 case 0:
628 if ((entire_insn & 0xf0f0ffff) == 0x90300000)
629 { itype = M32R2F_INSN_REMU; goto extract_sfmt_div; }
630 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
631 case 2:
632 if ((entire_insn & 0xf0f0ffff) == 0x90300010)
633 { itype = M32R2F_INSN_REMUH; goto extract_sfmt_div; }
634 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
635 case 3:
636 if ((entire_insn & 0xf0f0ffff) == 0x90300018)
637 { itype = M32R2F_INSN_REMUB; goto extract_sfmt_div; }
638 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
639 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
640 }
641 }
642 case 152: itype = M32R2F_INSN_SRL3; goto extract_sfmt_sll3;
643 case 154: itype = M32R2F_INSN_SRA3; goto extract_sfmt_sll3;
644 case 156: itype = M32R2F_INSN_SLL3; goto extract_sfmt_sll3;
645 case 159:
646 if ((entire_insn & 0xf0ff0000) == 0x90f00000)
647 { itype = M32R2F_INSN_LDI16; goto extract_sfmt_ldi16; }
648 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
649 case 160: itype = M32R2F_INSN_STB_D; goto extract_sfmt_stb_d;
650 case 162: itype = M32R2F_INSN_STH_D; goto extract_sfmt_sth_d;
651 case 164: itype = M32R2F_INSN_ST_D; goto extract_sfmt_st_d;
652 case 166:
653 if ((entire_insn & 0xf8f00000) == 0xa0600000)
654 { itype = M32R2F_INSN_BSET; goto extract_sfmt_bset; }
655 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
656 case 167:
657 if ((entire_insn & 0xf8f00000) == 0xa0700000)
658 { itype = M32R2F_INSN_BCLR; goto extract_sfmt_bset; }
659 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
660 case 168: itype = M32R2F_INSN_LDB_D; goto extract_sfmt_ldb_d;
661 case 169: itype = M32R2F_INSN_LDUB_D; goto extract_sfmt_ldb_d;
662 case 170: itype = M32R2F_INSN_LDH_D; goto extract_sfmt_ldh_d;
663 case 171: itype = M32R2F_INSN_LDUH_D; goto extract_sfmt_ldh_d;
664 case 172: itype = M32R2F_INSN_LD_D; goto extract_sfmt_ld_d;
665 case 176: itype = M32R2F_INSN_BEQ; goto extract_sfmt_beq;
666 case 177: itype = M32R2F_INSN_BNE; goto extract_sfmt_beq;
667 case 184:
668 if ((entire_insn & 0xfff00000) == 0xb0800000)
669 { itype = M32R2F_INSN_BEQZ; goto extract_sfmt_beqz; }
670 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
671 case 185:
672 if ((entire_insn & 0xfff00000) == 0xb0900000)
673 { itype = M32R2F_INSN_BNEZ; goto extract_sfmt_beqz; }
674 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
675 case 186:
676 if ((entire_insn & 0xfff00000) == 0xb0a00000)
677 { itype = M32R2F_INSN_BLTZ; goto extract_sfmt_beqz; }
678 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
679 case 187:
680 if ((entire_insn & 0xfff00000) == 0xb0b00000)
681 { itype = M32R2F_INSN_BGEZ; goto extract_sfmt_beqz; }
682 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
683 case 188:
684 if ((entire_insn & 0xfff00000) == 0xb0c00000)
685 { itype = M32R2F_INSN_BLEZ; goto extract_sfmt_beqz; }
686 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
687 case 189:
688 if ((entire_insn & 0xfff00000) == 0xb0d00000)
689 { itype = M32R2F_INSN_BGTZ; goto extract_sfmt_beqz; }
690 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
691 case 220:
692 if ((entire_insn & 0xf0ff0000) == 0xd0c00000)
693 { itype = M32R2F_INSN_SETH; goto extract_sfmt_seth; }
694 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
695 case 224:
696 case 225:
697 case 226:
698 case 227:
699 case 228:
700 case 229:
701 case 230:
702 case 231:
703 case 232:
704 case 233:
705 case 234:
706 case 235:
707 case 236:
708 case 237:
709 case 238:
710 case 239: itype = M32R2F_INSN_LD24; goto extract_sfmt_ld24;
711 case 240:
712 case 241:
713 case 242:
714 case 243:
715 case 244:
716 case 245:
717 case 246:
718 case 247:
719 case 248:
720 case 249:
721 case 250:
722 case 251:
723 case 252:
724 case 253:
725 case 254:
726 case 255:
727 {
728 unsigned int val1 = (((insn >> 8) & (7 << 0)));
729 switch (val1)
730 {
731 case 0:
732 if ((entire_insn & 0xff000000) == 0xf8000000)
733 { itype = M32R2F_INSN_BCL24; goto extract_sfmt_bcl24; }
734 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
735 case 1:
736 if ((entire_insn & 0xff000000) == 0xf9000000)
737 { itype = M32R2F_INSN_BNCL24; goto extract_sfmt_bcl24; }
738 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
739 case 4:
740 if ((entire_insn & 0xff000000) == 0xfc000000)
741 { itype = M32R2F_INSN_BC24; goto extract_sfmt_bc24; }
742 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
743 case 5:
744 if ((entire_insn & 0xff000000) == 0xfd000000)
745 { itype = M32R2F_INSN_BNC24; goto extract_sfmt_bc24; }
746 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
747 case 6:
748 if ((entire_insn & 0xff000000) == 0xfe000000)
749 { itype = M32R2F_INSN_BL24; goto extract_sfmt_bl24; }
750 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
751 case 7:
752 if ((entire_insn & 0xff000000) == 0xff000000)
753 { itype = M32R2F_INSN_BRA24; goto extract_sfmt_bra24; }
754 itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
755 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
756 }
757 }
758 default: itype = M32R2F_INSN_X_INVALID; goto extract_sfmt_empty;
759 }
760 }
761 }
762
763 /* The instruction has been decoded, now extract the fields. */
764
765 extract_sfmt_empty:
766 {
767 const IDESC *idesc = &m32r2f_insn_data[itype];
768 #define FLD(f) abuf->fields.sfmt_empty.f
769
770
771 /* Record the fields for the semantic handler. */
772 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_empty", (char *) 0));
773
774 #undef FLD
775 return idesc;
776 }
777
778 extract_sfmt_add:
779 {
780 const IDESC *idesc = &m32r2f_insn_data[itype];
781 CGEN_INSN_WORD insn = entire_insn;
782 #define FLD(f) abuf->fields.sfmt_add.f
783 UINT f_r1;
784 UINT f_r2;
785
786 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
787 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
788
789 /* Record the fields for the semantic handler. */
790 FLD (f_r1) = f_r1;
791 FLD (f_r2) = f_r2;
792 FLD (i_dr) = & CPU (h_gr)[f_r1];
793 FLD (i_sr) = & CPU (h_gr)[f_r2];
794 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_add", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
795
796 #if WITH_PROFILE_MODEL_P
797 /* Record the fields for profiling. */
798 if (PROFILE_MODEL_P (current_cpu))
799 {
800 FLD (in_dr) = f_r1;
801 FLD (in_sr) = f_r2;
802 FLD (out_dr) = f_r1;
803 }
804 #endif
805 #undef FLD
806 return idesc;
807 }
808
809 extract_sfmt_add3:
810 {
811 const IDESC *idesc = &m32r2f_insn_data[itype];
812 CGEN_INSN_WORD insn = entire_insn;
813 #define FLD(f) abuf->fields.sfmt_add3.f
814 UINT f_r1;
815 UINT f_r2;
816 INT f_simm16;
817
818 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
819 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
820 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
821
822 /* Record the fields for the semantic handler. */
823 FLD (f_simm16) = f_simm16;
824 FLD (f_r2) = f_r2;
825 FLD (f_r1) = f_r1;
826 FLD (i_sr) = & CPU (h_gr)[f_r2];
827 FLD (i_dr) = & CPU (h_gr)[f_r1];
828 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_add3", "f_simm16 0x%x", 'x', f_simm16, "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
829
830 #if WITH_PROFILE_MODEL_P
831 /* Record the fields for profiling. */
832 if (PROFILE_MODEL_P (current_cpu))
833 {
834 FLD (in_sr) = f_r2;
835 FLD (out_dr) = f_r1;
836 }
837 #endif
838 #undef FLD
839 return idesc;
840 }
841
842 extract_sfmt_and3:
843 {
844 const IDESC *idesc = &m32r2f_insn_data[itype];
845 CGEN_INSN_WORD insn = entire_insn;
846 #define FLD(f) abuf->fields.sfmt_and3.f
847 UINT f_r1;
848 UINT f_r2;
849 UINT f_uimm16;
850
851 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
852 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
853 f_uimm16 = EXTRACT_MSB0_UINT (insn, 32, 16, 16);
854
855 /* Record the fields for the semantic handler. */
856 FLD (f_r2) = f_r2;
857 FLD (f_uimm16) = f_uimm16;
858 FLD (f_r1) = f_r1;
859 FLD (i_sr) = & CPU (h_gr)[f_r2];
860 FLD (i_dr) = & CPU (h_gr)[f_r1];
861 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_and3", "f_r2 0x%x", 'x', f_r2, "f_uimm16 0x%x", 'x', f_uimm16, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
862
863 #if WITH_PROFILE_MODEL_P
864 /* Record the fields for profiling. */
865 if (PROFILE_MODEL_P (current_cpu))
866 {
867 FLD (in_sr) = f_r2;
868 FLD (out_dr) = f_r1;
869 }
870 #endif
871 #undef FLD
872 return idesc;
873 }
874
875 extract_sfmt_or3:
876 {
877 const IDESC *idesc = &m32r2f_insn_data[itype];
878 CGEN_INSN_WORD insn = entire_insn;
879 #define FLD(f) abuf->fields.sfmt_and3.f
880 UINT f_r1;
881 UINT f_r2;
882 UINT f_uimm16;
883
884 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
885 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
886 f_uimm16 = EXTRACT_MSB0_UINT (insn, 32, 16, 16);
887
888 /* Record the fields for the semantic handler. */
889 FLD (f_r2) = f_r2;
890 FLD (f_uimm16) = f_uimm16;
891 FLD (f_r1) = f_r1;
892 FLD (i_sr) = & CPU (h_gr)[f_r2];
893 FLD (i_dr) = & CPU (h_gr)[f_r1];
894 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_or3", "f_r2 0x%x", 'x', f_r2, "f_uimm16 0x%x", 'x', f_uimm16, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
895
896 #if WITH_PROFILE_MODEL_P
897 /* Record the fields for profiling. */
898 if (PROFILE_MODEL_P (current_cpu))
899 {
900 FLD (in_sr) = f_r2;
901 FLD (out_dr) = f_r1;
902 }
903 #endif
904 #undef FLD
905 return idesc;
906 }
907
908 extract_sfmt_addi:
909 {
910 const IDESC *idesc = &m32r2f_insn_data[itype];
911 CGEN_INSN_WORD insn = entire_insn;
912 #define FLD(f) abuf->fields.sfmt_addi.f
913 UINT f_r1;
914 INT f_simm8;
915
916 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
917 f_simm8 = EXTRACT_MSB0_SINT (insn, 16, 8, 8);
918
919 /* Record the fields for the semantic handler. */
920 FLD (f_r1) = f_r1;
921 FLD (f_simm8) = f_simm8;
922 FLD (i_dr) = & CPU (h_gr)[f_r1];
923 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addi", "f_r1 0x%x", 'x', f_r1, "f_simm8 0x%x", 'x', f_simm8, "dr 0x%x", 'x', f_r1, (char *) 0));
924
925 #if WITH_PROFILE_MODEL_P
926 /* Record the fields for profiling. */
927 if (PROFILE_MODEL_P (current_cpu))
928 {
929 FLD (in_dr) = f_r1;
930 FLD (out_dr) = f_r1;
931 }
932 #endif
933 #undef FLD
934 return idesc;
935 }
936
937 extract_sfmt_addv:
938 {
939 const IDESC *idesc = &m32r2f_insn_data[itype];
940 CGEN_INSN_WORD insn = entire_insn;
941 #define FLD(f) abuf->fields.sfmt_add.f
942 UINT f_r1;
943 UINT f_r2;
944
945 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
946 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
947
948 /* Record the fields for the semantic handler. */
949 FLD (f_r1) = f_r1;
950 FLD (f_r2) = f_r2;
951 FLD (i_dr) = & CPU (h_gr)[f_r1];
952 FLD (i_sr) = & CPU (h_gr)[f_r2];
953 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addv", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
954
955 #if WITH_PROFILE_MODEL_P
956 /* Record the fields for profiling. */
957 if (PROFILE_MODEL_P (current_cpu))
958 {
959 FLD (in_dr) = f_r1;
960 FLD (in_sr) = f_r2;
961 FLD (out_dr) = f_r1;
962 }
963 #endif
964 #undef FLD
965 return idesc;
966 }
967
968 extract_sfmt_addv3:
969 {
970 const IDESC *idesc = &m32r2f_insn_data[itype];
971 CGEN_INSN_WORD insn = entire_insn;
972 #define FLD(f) abuf->fields.sfmt_add3.f
973 UINT f_r1;
974 UINT f_r2;
975 INT f_simm16;
976
977 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
978 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
979 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
980
981 /* Record the fields for the semantic handler. */
982 FLD (f_simm16) = f_simm16;
983 FLD (f_r2) = f_r2;
984 FLD (f_r1) = f_r1;
985 FLD (i_sr) = & CPU (h_gr)[f_r2];
986 FLD (i_dr) = & CPU (h_gr)[f_r1];
987 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addv3", "f_simm16 0x%x", 'x', f_simm16, "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
988
989 #if WITH_PROFILE_MODEL_P
990 /* Record the fields for profiling. */
991 if (PROFILE_MODEL_P (current_cpu))
992 {
993 FLD (in_sr) = f_r2;
994 FLD (out_dr) = f_r1;
995 }
996 #endif
997 #undef FLD
998 return idesc;
999 }
1000
1001 extract_sfmt_addx:
1002 {
1003 const IDESC *idesc = &m32r2f_insn_data[itype];
1004 CGEN_INSN_WORD insn = entire_insn;
1005 #define FLD(f) abuf->fields.sfmt_add.f
1006 UINT f_r1;
1007 UINT f_r2;
1008
1009 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1010 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1011
1012 /* Record the fields for the semantic handler. */
1013 FLD (f_r1) = f_r1;
1014 FLD (f_r2) = f_r2;
1015 FLD (i_dr) = & CPU (h_gr)[f_r1];
1016 FLD (i_sr) = & CPU (h_gr)[f_r2];
1017 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_addx", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
1018
1019 #if WITH_PROFILE_MODEL_P
1020 /* Record the fields for profiling. */
1021 if (PROFILE_MODEL_P (current_cpu))
1022 {
1023 FLD (in_dr) = f_r1;
1024 FLD (in_sr) = f_r2;
1025 FLD (out_dr) = f_r1;
1026 }
1027 #endif
1028 #undef FLD
1029 return idesc;
1030 }
1031
1032 extract_sfmt_bc8:
1033 {
1034 const IDESC *idesc = &m32r2f_insn_data[itype];
1035 CGEN_INSN_WORD insn = entire_insn;
1036 #define FLD(f) abuf->fields.sfmt_bl8.f
1037 SI f_disp8;
1038
1039 f_disp8 = ((((EXTRACT_MSB0_SINT (insn, 16, 8, 8)) * (4))) + (((pc) & (-4))));
1040
1041 /* Record the fields for the semantic handler. */
1042 FLD (i_disp8) = f_disp8;
1043 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bc8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
1044
1045 #if WITH_PROFILE_MODEL_P
1046 /* Record the fields for profiling. */
1047 if (PROFILE_MODEL_P (current_cpu))
1048 {
1049 }
1050 #endif
1051 #undef FLD
1052 return idesc;
1053 }
1054
1055 extract_sfmt_bc24:
1056 {
1057 const IDESC *idesc = &m32r2f_insn_data[itype];
1058 CGEN_INSN_WORD insn = entire_insn;
1059 #define FLD(f) abuf->fields.sfmt_bl24.f
1060 SI f_disp24;
1061
1062 f_disp24 = ((((EXTRACT_MSB0_SINT (insn, 32, 8, 24)) * (4))) + (pc));
1063
1064 /* Record the fields for the semantic handler. */
1065 FLD (i_disp24) = f_disp24;
1066 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bc24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
1067
1068 #if WITH_PROFILE_MODEL_P
1069 /* Record the fields for profiling. */
1070 if (PROFILE_MODEL_P (current_cpu))
1071 {
1072 }
1073 #endif
1074 #undef FLD
1075 return idesc;
1076 }
1077
1078 extract_sfmt_beq:
1079 {
1080 const IDESC *idesc = &m32r2f_insn_data[itype];
1081 CGEN_INSN_WORD insn = entire_insn;
1082 #define FLD(f) abuf->fields.sfmt_beq.f
1083 UINT f_r1;
1084 UINT f_r2;
1085 SI f_disp16;
1086
1087 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
1088 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
1089 f_disp16 = ((((EXTRACT_MSB0_SINT (insn, 32, 16, 16)) * (4))) + (pc));
1090
1091 /* Record the fields for the semantic handler. */
1092 FLD (f_r1) = f_r1;
1093 FLD (f_r2) = f_r2;
1094 FLD (i_disp16) = f_disp16;
1095 FLD (i_src1) = & CPU (h_gr)[f_r1];
1096 FLD (i_src2) = & CPU (h_gr)[f_r2];
1097 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_beq", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "disp16 0x%x", 'x', f_disp16, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1098
1099 #if WITH_PROFILE_MODEL_P
1100 /* Record the fields for profiling. */
1101 if (PROFILE_MODEL_P (current_cpu))
1102 {
1103 FLD (in_src1) = f_r1;
1104 FLD (in_src2) = f_r2;
1105 }
1106 #endif
1107 #undef FLD
1108 return idesc;
1109 }
1110
1111 extract_sfmt_beqz:
1112 {
1113 const IDESC *idesc = &m32r2f_insn_data[itype];
1114 CGEN_INSN_WORD insn = entire_insn;
1115 #define FLD(f) abuf->fields.sfmt_beq.f
1116 UINT f_r2;
1117 SI f_disp16;
1118
1119 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
1120 f_disp16 = ((((EXTRACT_MSB0_SINT (insn, 32, 16, 16)) * (4))) + (pc));
1121
1122 /* Record the fields for the semantic handler. */
1123 FLD (f_r2) = f_r2;
1124 FLD (i_disp16) = f_disp16;
1125 FLD (i_src2) = & CPU (h_gr)[f_r2];
1126 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_beqz", "f_r2 0x%x", 'x', f_r2, "disp16 0x%x", 'x', f_disp16, "src2 0x%x", 'x', f_r2, (char *) 0));
1127
1128 #if WITH_PROFILE_MODEL_P
1129 /* Record the fields for profiling. */
1130 if (PROFILE_MODEL_P (current_cpu))
1131 {
1132 FLD (in_src2) = f_r2;
1133 }
1134 #endif
1135 #undef FLD
1136 return idesc;
1137 }
1138
1139 extract_sfmt_bl8:
1140 {
1141 const IDESC *idesc = &m32r2f_insn_data[itype];
1142 CGEN_INSN_WORD insn = entire_insn;
1143 #define FLD(f) abuf->fields.sfmt_bl8.f
1144 SI f_disp8;
1145
1146 f_disp8 = ((((EXTRACT_MSB0_SINT (insn, 16, 8, 8)) * (4))) + (((pc) & (-4))));
1147
1148 /* Record the fields for the semantic handler. */
1149 FLD (i_disp8) = f_disp8;
1150 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bl8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
1151
1152 #if WITH_PROFILE_MODEL_P
1153 /* Record the fields for profiling. */
1154 if (PROFILE_MODEL_P (current_cpu))
1155 {
1156 FLD (out_h_gr_SI_14) = 14;
1157 }
1158 #endif
1159 #undef FLD
1160 return idesc;
1161 }
1162
1163 extract_sfmt_bl24:
1164 {
1165 const IDESC *idesc = &m32r2f_insn_data[itype];
1166 CGEN_INSN_WORD insn = entire_insn;
1167 #define FLD(f) abuf->fields.sfmt_bl24.f
1168 SI f_disp24;
1169
1170 f_disp24 = ((((EXTRACT_MSB0_SINT (insn, 32, 8, 24)) * (4))) + (pc));
1171
1172 /* Record the fields for the semantic handler. */
1173 FLD (i_disp24) = f_disp24;
1174 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bl24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
1175
1176 #if WITH_PROFILE_MODEL_P
1177 /* Record the fields for profiling. */
1178 if (PROFILE_MODEL_P (current_cpu))
1179 {
1180 FLD (out_h_gr_SI_14) = 14;
1181 }
1182 #endif
1183 #undef FLD
1184 return idesc;
1185 }
1186
1187 extract_sfmt_bcl8:
1188 {
1189 const IDESC *idesc = &m32r2f_insn_data[itype];
1190 CGEN_INSN_WORD insn = entire_insn;
1191 #define FLD(f) abuf->fields.sfmt_bl8.f
1192 SI f_disp8;
1193
1194 f_disp8 = ((((EXTRACT_MSB0_SINT (insn, 16, 8, 8)) * (4))) + (((pc) & (-4))));
1195
1196 /* Record the fields for the semantic handler. */
1197 FLD (i_disp8) = f_disp8;
1198 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bcl8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
1199
1200 #if WITH_PROFILE_MODEL_P
1201 /* Record the fields for profiling. */
1202 if (PROFILE_MODEL_P (current_cpu))
1203 {
1204 FLD (out_h_gr_SI_14) = 14;
1205 }
1206 #endif
1207 #undef FLD
1208 return idesc;
1209 }
1210
1211 extract_sfmt_bcl24:
1212 {
1213 const IDESC *idesc = &m32r2f_insn_data[itype];
1214 CGEN_INSN_WORD insn = entire_insn;
1215 #define FLD(f) abuf->fields.sfmt_bl24.f
1216 SI f_disp24;
1217
1218 f_disp24 = ((((EXTRACT_MSB0_SINT (insn, 32, 8, 24)) * (4))) + (pc));
1219
1220 /* Record the fields for the semantic handler. */
1221 FLD (i_disp24) = f_disp24;
1222 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bcl24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
1223
1224 #if WITH_PROFILE_MODEL_P
1225 /* Record the fields for profiling. */
1226 if (PROFILE_MODEL_P (current_cpu))
1227 {
1228 FLD (out_h_gr_SI_14) = 14;
1229 }
1230 #endif
1231 #undef FLD
1232 return idesc;
1233 }
1234
1235 extract_sfmt_bra8:
1236 {
1237 const IDESC *idesc = &m32r2f_insn_data[itype];
1238 CGEN_INSN_WORD insn = entire_insn;
1239 #define FLD(f) abuf->fields.sfmt_bl8.f
1240 SI f_disp8;
1241
1242 f_disp8 = ((((EXTRACT_MSB0_SINT (insn, 16, 8, 8)) * (4))) + (((pc) & (-4))));
1243
1244 /* Record the fields for the semantic handler. */
1245 FLD (i_disp8) = f_disp8;
1246 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bra8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
1247
1248 #if WITH_PROFILE_MODEL_P
1249 /* Record the fields for profiling. */
1250 if (PROFILE_MODEL_P (current_cpu))
1251 {
1252 }
1253 #endif
1254 #undef FLD
1255 return idesc;
1256 }
1257
1258 extract_sfmt_bra24:
1259 {
1260 const IDESC *idesc = &m32r2f_insn_data[itype];
1261 CGEN_INSN_WORD insn = entire_insn;
1262 #define FLD(f) abuf->fields.sfmt_bl24.f
1263 SI f_disp24;
1264
1265 f_disp24 = ((((EXTRACT_MSB0_SINT (insn, 32, 8, 24)) * (4))) + (pc));
1266
1267 /* Record the fields for the semantic handler. */
1268 FLD (i_disp24) = f_disp24;
1269 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bra24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
1270
1271 #if WITH_PROFILE_MODEL_P
1272 /* Record the fields for profiling. */
1273 if (PROFILE_MODEL_P (current_cpu))
1274 {
1275 }
1276 #endif
1277 #undef FLD
1278 return idesc;
1279 }
1280
1281 extract_sfmt_cmp:
1282 {
1283 const IDESC *idesc = &m32r2f_insn_data[itype];
1284 CGEN_INSN_WORD insn = entire_insn;
1285 #define FLD(f) abuf->fields.sfmt_st_plus.f
1286 UINT f_r1;
1287 UINT f_r2;
1288
1289 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1290 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1291
1292 /* Record the fields for the semantic handler. */
1293 FLD (f_r1) = f_r1;
1294 FLD (f_r2) = f_r2;
1295 FLD (i_src1) = & CPU (h_gr)[f_r1];
1296 FLD (i_src2) = & CPU (h_gr)[f_r2];
1297 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_cmp", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1298
1299 #if WITH_PROFILE_MODEL_P
1300 /* Record the fields for profiling. */
1301 if (PROFILE_MODEL_P (current_cpu))
1302 {
1303 FLD (in_src1) = f_r1;
1304 FLD (in_src2) = f_r2;
1305 }
1306 #endif
1307 #undef FLD
1308 return idesc;
1309 }
1310
1311 extract_sfmt_cmpi:
1312 {
1313 const IDESC *idesc = &m32r2f_insn_data[itype];
1314 CGEN_INSN_WORD insn = entire_insn;
1315 #define FLD(f) abuf->fields.sfmt_st_d.f
1316 UINT f_r2;
1317 INT f_simm16;
1318
1319 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
1320 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
1321
1322 /* Record the fields for the semantic handler. */
1323 FLD (f_simm16) = f_simm16;
1324 FLD (f_r2) = f_r2;
1325 FLD (i_src2) = & CPU (h_gr)[f_r2];
1326 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_cmpi", "f_simm16 0x%x", 'x', f_simm16, "f_r2 0x%x", 'x', f_r2, "src2 0x%x", 'x', f_r2, (char *) 0));
1327
1328 #if WITH_PROFILE_MODEL_P
1329 /* Record the fields for profiling. */
1330 if (PROFILE_MODEL_P (current_cpu))
1331 {
1332 FLD (in_src2) = f_r2;
1333 }
1334 #endif
1335 #undef FLD
1336 return idesc;
1337 }
1338
1339 extract_sfmt_cmpz:
1340 {
1341 const IDESC *idesc = &m32r2f_insn_data[itype];
1342 CGEN_INSN_WORD insn = entire_insn;
1343 #define FLD(f) abuf->fields.sfmt_st_plus.f
1344 UINT f_r2;
1345
1346 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1347
1348 /* Record the fields for the semantic handler. */
1349 FLD (f_r2) = f_r2;
1350 FLD (i_src2) = & CPU (h_gr)[f_r2];
1351 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_cmpz", "f_r2 0x%x", 'x', f_r2, "src2 0x%x", 'x', f_r2, (char *) 0));
1352
1353 #if WITH_PROFILE_MODEL_P
1354 /* Record the fields for profiling. */
1355 if (PROFILE_MODEL_P (current_cpu))
1356 {
1357 FLD (in_src2) = f_r2;
1358 }
1359 #endif
1360 #undef FLD
1361 return idesc;
1362 }
1363
1364 extract_sfmt_div:
1365 {
1366 const IDESC *idesc = &m32r2f_insn_data[itype];
1367 CGEN_INSN_WORD insn = entire_insn;
1368 #define FLD(f) abuf->fields.sfmt_add.f
1369 UINT f_r1;
1370 UINT f_r2;
1371
1372 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
1373 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
1374
1375 /* Record the fields for the semantic handler. */
1376 FLD (f_r1) = f_r1;
1377 FLD (f_r2) = f_r2;
1378 FLD (i_dr) = & CPU (h_gr)[f_r1];
1379 FLD (i_sr) = & CPU (h_gr)[f_r2];
1380 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_div", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
1381
1382 #if WITH_PROFILE_MODEL_P
1383 /* Record the fields for profiling. */
1384 if (PROFILE_MODEL_P (current_cpu))
1385 {
1386 FLD (in_dr) = f_r1;
1387 FLD (in_sr) = f_r2;
1388 FLD (out_dr) = f_r1;
1389 }
1390 #endif
1391 #undef FLD
1392 return idesc;
1393 }
1394
1395 extract_sfmt_jc:
1396 {
1397 const IDESC *idesc = &m32r2f_insn_data[itype];
1398 CGEN_INSN_WORD insn = entire_insn;
1399 #define FLD(f) abuf->fields.sfmt_jl.f
1400 UINT f_r2;
1401
1402 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1403
1404 /* Record the fields for the semantic handler. */
1405 FLD (f_r2) = f_r2;
1406 FLD (i_sr) = & CPU (h_gr)[f_r2];
1407 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jc", "f_r2 0x%x", 'x', f_r2, "sr 0x%x", 'x', f_r2, (char *) 0));
1408
1409 #if WITH_PROFILE_MODEL_P
1410 /* Record the fields for profiling. */
1411 if (PROFILE_MODEL_P (current_cpu))
1412 {
1413 FLD (in_sr) = f_r2;
1414 }
1415 #endif
1416 #undef FLD
1417 return idesc;
1418 }
1419
1420 extract_sfmt_jl:
1421 {
1422 const IDESC *idesc = &m32r2f_insn_data[itype];
1423 CGEN_INSN_WORD insn = entire_insn;
1424 #define FLD(f) abuf->fields.sfmt_jl.f
1425 UINT f_r2;
1426
1427 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1428
1429 /* Record the fields for the semantic handler. */
1430 FLD (f_r2) = f_r2;
1431 FLD (i_sr) = & CPU (h_gr)[f_r2];
1432 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jl", "f_r2 0x%x", 'x', f_r2, "sr 0x%x", 'x', f_r2, (char *) 0));
1433
1434 #if WITH_PROFILE_MODEL_P
1435 /* Record the fields for profiling. */
1436 if (PROFILE_MODEL_P (current_cpu))
1437 {
1438 FLD (in_sr) = f_r2;
1439 FLD (out_h_gr_SI_14) = 14;
1440 }
1441 #endif
1442 #undef FLD
1443 return idesc;
1444 }
1445
1446 extract_sfmt_jmp:
1447 {
1448 const IDESC *idesc = &m32r2f_insn_data[itype];
1449 CGEN_INSN_WORD insn = entire_insn;
1450 #define FLD(f) abuf->fields.sfmt_jl.f
1451 UINT f_r2;
1452
1453 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1454
1455 /* Record the fields for the semantic handler. */
1456 FLD (f_r2) = f_r2;
1457 FLD (i_sr) = & CPU (h_gr)[f_r2];
1458 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_jmp", "f_r2 0x%x", 'x', f_r2, "sr 0x%x", 'x', f_r2, (char *) 0));
1459
1460 #if WITH_PROFILE_MODEL_P
1461 /* Record the fields for profiling. */
1462 if (PROFILE_MODEL_P (current_cpu))
1463 {
1464 FLD (in_sr) = f_r2;
1465 }
1466 #endif
1467 #undef FLD
1468 return idesc;
1469 }
1470
1471 extract_sfmt_ld:
1472 {
1473 const IDESC *idesc = &m32r2f_insn_data[itype];
1474 CGEN_INSN_WORD insn = entire_insn;
1475 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1476 UINT f_r1;
1477 UINT f_r2;
1478
1479 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1480 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1481
1482 /* Record the fields for the semantic handler. */
1483 FLD (f_r2) = f_r2;
1484 FLD (f_r1) = f_r1;
1485 FLD (i_sr) = & CPU (h_gr)[f_r2];
1486 FLD (i_dr) = & CPU (h_gr)[f_r1];
1487 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ld", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1488
1489 #if WITH_PROFILE_MODEL_P
1490 /* Record the fields for profiling. */
1491 if (PROFILE_MODEL_P (current_cpu))
1492 {
1493 FLD (in_sr) = f_r2;
1494 FLD (out_dr) = f_r1;
1495 }
1496 #endif
1497 #undef FLD
1498 return idesc;
1499 }
1500
1501 extract_sfmt_ld_d:
1502 {
1503 const IDESC *idesc = &m32r2f_insn_data[itype];
1504 CGEN_INSN_WORD insn = entire_insn;
1505 #define FLD(f) abuf->fields.sfmt_add3.f
1506 UINT f_r1;
1507 UINT f_r2;
1508 INT f_simm16;
1509
1510 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
1511 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
1512 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
1513
1514 /* Record the fields for the semantic handler. */
1515 FLD (f_simm16) = f_simm16;
1516 FLD (f_r2) = f_r2;
1517 FLD (f_r1) = f_r1;
1518 FLD (i_sr) = & CPU (h_gr)[f_r2];
1519 FLD (i_dr) = & CPU (h_gr)[f_r1];
1520 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ld_d", "f_simm16 0x%x", 'x', f_simm16, "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1521
1522 #if WITH_PROFILE_MODEL_P
1523 /* Record the fields for profiling. */
1524 if (PROFILE_MODEL_P (current_cpu))
1525 {
1526 FLD (in_sr) = f_r2;
1527 FLD (out_dr) = f_r1;
1528 }
1529 #endif
1530 #undef FLD
1531 return idesc;
1532 }
1533
1534 extract_sfmt_ldb:
1535 {
1536 const IDESC *idesc = &m32r2f_insn_data[itype];
1537 CGEN_INSN_WORD insn = entire_insn;
1538 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1539 UINT f_r1;
1540 UINT f_r2;
1541
1542 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1543 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1544
1545 /* Record the fields for the semantic handler. */
1546 FLD (f_r2) = f_r2;
1547 FLD (f_r1) = f_r1;
1548 FLD (i_sr) = & CPU (h_gr)[f_r2];
1549 FLD (i_dr) = & CPU (h_gr)[f_r1];
1550 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldb", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1551
1552 #if WITH_PROFILE_MODEL_P
1553 /* Record the fields for profiling. */
1554 if (PROFILE_MODEL_P (current_cpu))
1555 {
1556 FLD (in_sr) = f_r2;
1557 FLD (out_dr) = f_r1;
1558 }
1559 #endif
1560 #undef FLD
1561 return idesc;
1562 }
1563
1564 extract_sfmt_ldb_d:
1565 {
1566 const IDESC *idesc = &m32r2f_insn_data[itype];
1567 CGEN_INSN_WORD insn = entire_insn;
1568 #define FLD(f) abuf->fields.sfmt_add3.f
1569 UINT f_r1;
1570 UINT f_r2;
1571 INT f_simm16;
1572
1573 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
1574 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
1575 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
1576
1577 /* Record the fields for the semantic handler. */
1578 FLD (f_simm16) = f_simm16;
1579 FLD (f_r2) = f_r2;
1580 FLD (f_r1) = f_r1;
1581 FLD (i_sr) = & CPU (h_gr)[f_r2];
1582 FLD (i_dr) = & CPU (h_gr)[f_r1];
1583 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldb_d", "f_simm16 0x%x", 'x', f_simm16, "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1584
1585 #if WITH_PROFILE_MODEL_P
1586 /* Record the fields for profiling. */
1587 if (PROFILE_MODEL_P (current_cpu))
1588 {
1589 FLD (in_sr) = f_r2;
1590 FLD (out_dr) = f_r1;
1591 }
1592 #endif
1593 #undef FLD
1594 return idesc;
1595 }
1596
1597 extract_sfmt_ldh:
1598 {
1599 const IDESC *idesc = &m32r2f_insn_data[itype];
1600 CGEN_INSN_WORD insn = entire_insn;
1601 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1602 UINT f_r1;
1603 UINT f_r2;
1604
1605 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1606 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1607
1608 /* Record the fields for the semantic handler. */
1609 FLD (f_r2) = f_r2;
1610 FLD (f_r1) = f_r1;
1611 FLD (i_sr) = & CPU (h_gr)[f_r2];
1612 FLD (i_dr) = & CPU (h_gr)[f_r1];
1613 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldh", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1614
1615 #if WITH_PROFILE_MODEL_P
1616 /* Record the fields for profiling. */
1617 if (PROFILE_MODEL_P (current_cpu))
1618 {
1619 FLD (in_sr) = f_r2;
1620 FLD (out_dr) = f_r1;
1621 }
1622 #endif
1623 #undef FLD
1624 return idesc;
1625 }
1626
1627 extract_sfmt_ldh_d:
1628 {
1629 const IDESC *idesc = &m32r2f_insn_data[itype];
1630 CGEN_INSN_WORD insn = entire_insn;
1631 #define FLD(f) abuf->fields.sfmt_add3.f
1632 UINT f_r1;
1633 UINT f_r2;
1634 INT f_simm16;
1635
1636 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
1637 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
1638 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
1639
1640 /* Record the fields for the semantic handler. */
1641 FLD (f_simm16) = f_simm16;
1642 FLD (f_r2) = f_r2;
1643 FLD (f_r1) = f_r1;
1644 FLD (i_sr) = & CPU (h_gr)[f_r2];
1645 FLD (i_dr) = & CPU (h_gr)[f_r1];
1646 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldh_d", "f_simm16 0x%x", 'x', f_simm16, "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1647
1648 #if WITH_PROFILE_MODEL_P
1649 /* Record the fields for profiling. */
1650 if (PROFILE_MODEL_P (current_cpu))
1651 {
1652 FLD (in_sr) = f_r2;
1653 FLD (out_dr) = f_r1;
1654 }
1655 #endif
1656 #undef FLD
1657 return idesc;
1658 }
1659
1660 extract_sfmt_ld_plus:
1661 {
1662 const IDESC *idesc = &m32r2f_insn_data[itype];
1663 CGEN_INSN_WORD insn = entire_insn;
1664 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1665 UINT f_r1;
1666 UINT f_r2;
1667
1668 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1669 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1670
1671 /* Record the fields for the semantic handler. */
1672 FLD (f_r2) = f_r2;
1673 FLD (f_r1) = f_r1;
1674 FLD (i_sr) = & CPU (h_gr)[f_r2];
1675 FLD (i_dr) = & CPU (h_gr)[f_r1];
1676 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ld_plus", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1677
1678 #if WITH_PROFILE_MODEL_P
1679 /* Record the fields for profiling. */
1680 if (PROFILE_MODEL_P (current_cpu))
1681 {
1682 FLD (in_sr) = f_r2;
1683 FLD (out_dr) = f_r1;
1684 FLD (out_sr) = f_r2;
1685 }
1686 #endif
1687 #undef FLD
1688 return idesc;
1689 }
1690
1691 extract_sfmt_ld24:
1692 {
1693 const IDESC *idesc = &m32r2f_insn_data[itype];
1694 CGEN_INSN_WORD insn = entire_insn;
1695 #define FLD(f) abuf->fields.sfmt_ld24.f
1696 UINT f_r1;
1697 UINT f_uimm24;
1698
1699 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
1700 f_uimm24 = EXTRACT_MSB0_UINT (insn, 32, 8, 24);
1701
1702 /* Record the fields for the semantic handler. */
1703 FLD (f_r1) = f_r1;
1704 FLD (i_uimm24) = f_uimm24;
1705 FLD (i_dr) = & CPU (h_gr)[f_r1];
1706 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ld24", "f_r1 0x%x", 'x', f_r1, "uimm24 0x%x", 'x', f_uimm24, "dr 0x%x", 'x', f_r1, (char *) 0));
1707
1708 #if WITH_PROFILE_MODEL_P
1709 /* Record the fields for profiling. */
1710 if (PROFILE_MODEL_P (current_cpu))
1711 {
1712 FLD (out_dr) = f_r1;
1713 }
1714 #endif
1715 #undef FLD
1716 return idesc;
1717 }
1718
1719 extract_sfmt_ldi8:
1720 {
1721 const IDESC *idesc = &m32r2f_insn_data[itype];
1722 CGEN_INSN_WORD insn = entire_insn;
1723 #define FLD(f) abuf->fields.sfmt_addi.f
1724 UINT f_r1;
1725 INT f_simm8;
1726
1727 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1728 f_simm8 = EXTRACT_MSB0_SINT (insn, 16, 8, 8);
1729
1730 /* Record the fields for the semantic handler. */
1731 FLD (f_simm8) = f_simm8;
1732 FLD (f_r1) = f_r1;
1733 FLD (i_dr) = & CPU (h_gr)[f_r1];
1734 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldi8", "f_simm8 0x%x", 'x', f_simm8, "f_r1 0x%x", 'x', f_r1, "dr 0x%x", 'x', f_r1, (char *) 0));
1735
1736 #if WITH_PROFILE_MODEL_P
1737 /* Record the fields for profiling. */
1738 if (PROFILE_MODEL_P (current_cpu))
1739 {
1740 FLD (out_dr) = f_r1;
1741 }
1742 #endif
1743 #undef FLD
1744 return idesc;
1745 }
1746
1747 extract_sfmt_ldi16:
1748 {
1749 const IDESC *idesc = &m32r2f_insn_data[itype];
1750 CGEN_INSN_WORD insn = entire_insn;
1751 #define FLD(f) abuf->fields.sfmt_add3.f
1752 UINT f_r1;
1753 INT f_simm16;
1754
1755 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
1756 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
1757
1758 /* Record the fields for the semantic handler. */
1759 FLD (f_simm16) = f_simm16;
1760 FLD (f_r1) = f_r1;
1761 FLD (i_dr) = & CPU (h_gr)[f_r1];
1762 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_ldi16", "f_simm16 0x%x", 'x', f_simm16, "f_r1 0x%x", 'x', f_r1, "dr 0x%x", 'x', f_r1, (char *) 0));
1763
1764 #if WITH_PROFILE_MODEL_P
1765 /* Record the fields for profiling. */
1766 if (PROFILE_MODEL_P (current_cpu))
1767 {
1768 FLD (out_dr) = f_r1;
1769 }
1770 #endif
1771 #undef FLD
1772 return idesc;
1773 }
1774
1775 extract_sfmt_lock:
1776 {
1777 const IDESC *idesc = &m32r2f_insn_data[itype];
1778 CGEN_INSN_WORD insn = entire_insn;
1779 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1780 UINT f_r1;
1781 UINT f_r2;
1782
1783 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1784 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1785
1786 /* Record the fields for the semantic handler. */
1787 FLD (f_r2) = f_r2;
1788 FLD (f_r1) = f_r1;
1789 FLD (i_sr) = & CPU (h_gr)[f_r2];
1790 FLD (i_dr) = & CPU (h_gr)[f_r1];
1791 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_lock", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1792
1793 #if WITH_PROFILE_MODEL_P
1794 /* Record the fields for profiling. */
1795 if (PROFILE_MODEL_P (current_cpu))
1796 {
1797 FLD (in_sr) = f_r2;
1798 FLD (out_dr) = f_r1;
1799 }
1800 #endif
1801 #undef FLD
1802 return idesc;
1803 }
1804
1805 extract_sfmt_machi_a:
1806 {
1807 const IDESC *idesc = &m32r2f_insn_data[itype];
1808 CGEN_INSN_WORD insn = entire_insn;
1809 #define FLD(f) abuf->fields.sfmt_machi_a.f
1810 UINT f_r1;
1811 UINT f_acc;
1812 UINT f_r2;
1813
1814 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1815 f_acc = EXTRACT_MSB0_UINT (insn, 16, 8, 1);
1816 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1817
1818 /* Record the fields for the semantic handler. */
1819 FLD (f_acc) = f_acc;
1820 FLD (f_r1) = f_r1;
1821 FLD (f_r2) = f_r2;
1822 FLD (i_src1) = & CPU (h_gr)[f_r1];
1823 FLD (i_src2) = & CPU (h_gr)[f_r2];
1824 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_machi_a", "f_acc 0x%x", 'x', f_acc, "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1825
1826 #if WITH_PROFILE_MODEL_P
1827 /* Record the fields for profiling. */
1828 if (PROFILE_MODEL_P (current_cpu))
1829 {
1830 FLD (in_src1) = f_r1;
1831 FLD (in_src2) = f_r2;
1832 }
1833 #endif
1834 #undef FLD
1835 return idesc;
1836 }
1837
1838 extract_sfmt_mulhi_a:
1839 {
1840 const IDESC *idesc = &m32r2f_insn_data[itype];
1841 CGEN_INSN_WORD insn = entire_insn;
1842 #define FLD(f) abuf->fields.sfmt_machi_a.f
1843 UINT f_r1;
1844 UINT f_acc;
1845 UINT f_r2;
1846
1847 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1848 f_acc = EXTRACT_MSB0_UINT (insn, 16, 8, 1);
1849 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1850
1851 /* Record the fields for the semantic handler. */
1852 FLD (f_r1) = f_r1;
1853 FLD (f_r2) = f_r2;
1854 FLD (f_acc) = f_acc;
1855 FLD (i_src1) = & CPU (h_gr)[f_r1];
1856 FLD (i_src2) = & CPU (h_gr)[f_r2];
1857 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mulhi_a", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "f_acc 0x%x", 'x', f_acc, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1858
1859 #if WITH_PROFILE_MODEL_P
1860 /* Record the fields for profiling. */
1861 if (PROFILE_MODEL_P (current_cpu))
1862 {
1863 FLD (in_src1) = f_r1;
1864 FLD (in_src2) = f_r2;
1865 }
1866 #endif
1867 #undef FLD
1868 return idesc;
1869 }
1870
1871 extract_sfmt_mv:
1872 {
1873 const IDESC *idesc = &m32r2f_insn_data[itype];
1874 CGEN_INSN_WORD insn = entire_insn;
1875 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1876 UINT f_r1;
1877 UINT f_r2;
1878
1879 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1880 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1881
1882 /* Record the fields for the semantic handler. */
1883 FLD (f_r2) = f_r2;
1884 FLD (f_r1) = f_r1;
1885 FLD (i_sr) = & CPU (h_gr)[f_r2];
1886 FLD (i_dr) = & CPU (h_gr)[f_r1];
1887 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mv", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
1888
1889 #if WITH_PROFILE_MODEL_P
1890 /* Record the fields for profiling. */
1891 if (PROFILE_MODEL_P (current_cpu))
1892 {
1893 FLD (in_sr) = f_r2;
1894 FLD (out_dr) = f_r1;
1895 }
1896 #endif
1897 #undef FLD
1898 return idesc;
1899 }
1900
1901 extract_sfmt_mvfachi_a:
1902 {
1903 const IDESC *idesc = &m32r2f_insn_data[itype];
1904 CGEN_INSN_WORD insn = entire_insn;
1905 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
1906 UINT f_r1;
1907 UINT f_accs;
1908
1909 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1910 f_accs = EXTRACT_MSB0_UINT (insn, 16, 12, 2);
1911
1912 /* Record the fields for the semantic handler. */
1913 FLD (f_accs) = f_accs;
1914 FLD (f_r1) = f_r1;
1915 FLD (i_dr) = & CPU (h_gr)[f_r1];
1916 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mvfachi_a", "f_accs 0x%x", 'x', f_accs, "f_r1 0x%x", 'x', f_r1, "dr 0x%x", 'x', f_r1, (char *) 0));
1917
1918 #if WITH_PROFILE_MODEL_P
1919 /* Record the fields for profiling. */
1920 if (PROFILE_MODEL_P (current_cpu))
1921 {
1922 FLD (out_dr) = f_r1;
1923 }
1924 #endif
1925 #undef FLD
1926 return idesc;
1927 }
1928
1929 extract_sfmt_mvfc:
1930 {
1931 const IDESC *idesc = &m32r2f_insn_data[itype];
1932 CGEN_INSN_WORD insn = entire_insn;
1933 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1934 UINT f_r1;
1935 UINT f_r2;
1936
1937 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1938 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1939
1940 /* Record the fields for the semantic handler. */
1941 FLD (f_r2) = f_r2;
1942 FLD (f_r1) = f_r1;
1943 FLD (i_dr) = & CPU (h_gr)[f_r1];
1944 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mvfc", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "dr 0x%x", 'x', f_r1, (char *) 0));
1945
1946 #if WITH_PROFILE_MODEL_P
1947 /* Record the fields for profiling. */
1948 if (PROFILE_MODEL_P (current_cpu))
1949 {
1950 FLD (out_dr) = f_r1;
1951 }
1952 #endif
1953 #undef FLD
1954 return idesc;
1955 }
1956
1957 extract_sfmt_mvtachi_a:
1958 {
1959 const IDESC *idesc = &m32r2f_insn_data[itype];
1960 CGEN_INSN_WORD insn = entire_insn;
1961 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
1962 UINT f_r1;
1963 UINT f_accs;
1964
1965 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1966 f_accs = EXTRACT_MSB0_UINT (insn, 16, 12, 2);
1967
1968 /* Record the fields for the semantic handler. */
1969 FLD (f_accs) = f_accs;
1970 FLD (f_r1) = f_r1;
1971 FLD (i_src1) = & CPU (h_gr)[f_r1];
1972 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mvtachi_a", "f_accs 0x%x", 'x', f_accs, "f_r1 0x%x", 'x', f_r1, "src1 0x%x", 'x', f_r1, (char *) 0));
1973
1974 #if WITH_PROFILE_MODEL_P
1975 /* Record the fields for profiling. */
1976 if (PROFILE_MODEL_P (current_cpu))
1977 {
1978 FLD (in_src1) = f_r1;
1979 }
1980 #endif
1981 #undef FLD
1982 return idesc;
1983 }
1984
1985 extract_sfmt_mvtc:
1986 {
1987 const IDESC *idesc = &m32r2f_insn_data[itype];
1988 CGEN_INSN_WORD insn = entire_insn;
1989 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1990 UINT f_r1;
1991 UINT f_r2;
1992
1993 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
1994 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
1995
1996 /* Record the fields for the semantic handler. */
1997 FLD (f_r2) = f_r2;
1998 FLD (f_r1) = f_r1;
1999 FLD (i_sr) = & CPU (h_gr)[f_r2];
2000 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mvtc", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
2001
2002 #if WITH_PROFILE_MODEL_P
2003 /* Record the fields for profiling. */
2004 if (PROFILE_MODEL_P (current_cpu))
2005 {
2006 FLD (in_sr) = f_r2;
2007 }
2008 #endif
2009 #undef FLD
2010 return idesc;
2011 }
2012
2013 extract_sfmt_nop:
2014 {
2015 const IDESC *idesc = &m32r2f_insn_data[itype];
2016 #define FLD(f) abuf->fields.sfmt_empty.f
2017
2018
2019 /* Record the fields for the semantic handler. */
2020 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_nop", (char *) 0));
2021
2022 #undef FLD
2023 return idesc;
2024 }
2025
2026 extract_sfmt_rac_dsi:
2027 {
2028 const IDESC *idesc = &m32r2f_insn_data[itype];
2029 CGEN_INSN_WORD insn = entire_insn;
2030 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
2031 UINT f_accd;
2032 UINT f_accs;
2033 SI f_imm1;
2034
2035 f_accd = EXTRACT_MSB0_UINT (insn, 16, 4, 2);
2036 f_accs = EXTRACT_MSB0_UINT (insn, 16, 12, 2);
2037 f_imm1 = ((EXTRACT_MSB0_UINT (insn, 16, 15, 1)) + (1));
2038
2039 /* Record the fields for the semantic handler. */
2040 FLD (f_accs) = f_accs;
2041 FLD (f_imm1) = f_imm1;
2042 FLD (f_accd) = f_accd;
2043 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_rac_dsi", "f_accs 0x%x", 'x', f_accs, "f_imm1 0x%x", 'x', f_imm1, "f_accd 0x%x", 'x', f_accd, (char *) 0));
2044
2045 #undef FLD
2046 return idesc;
2047 }
2048
2049 extract_sfmt_rte:
2050 {
2051 const IDESC *idesc = &m32r2f_insn_data[itype];
2052 #define FLD(f) abuf->fields.sfmt_empty.f
2053
2054
2055 /* Record the fields for the semantic handler. */
2056 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_rte", (char *) 0));
2057
2058 #if WITH_PROFILE_MODEL_P
2059 /* Record the fields for profiling. */
2060 if (PROFILE_MODEL_P (current_cpu))
2061 {
2062 }
2063 #endif
2064 #undef FLD
2065 return idesc;
2066 }
2067
2068 extract_sfmt_seth:
2069 {
2070 const IDESC *idesc = &m32r2f_insn_data[itype];
2071 CGEN_INSN_WORD insn = entire_insn;
2072 #define FLD(f) abuf->fields.sfmt_seth.f
2073 UINT f_r1;
2074 UINT f_hi16;
2075
2076 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
2077 f_hi16 = EXTRACT_MSB0_UINT (insn, 32, 16, 16);
2078
2079 /* Record the fields for the semantic handler. */
2080 FLD (f_hi16) = f_hi16;
2081 FLD (f_r1) = f_r1;
2082 FLD (i_dr) = & CPU (h_gr)[f_r1];
2083 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_seth", "f_hi16 0x%x", 'x', f_hi16, "f_r1 0x%x", 'x', f_r1, "dr 0x%x", 'x', f_r1, (char *) 0));
2084
2085 #if WITH_PROFILE_MODEL_P
2086 /* Record the fields for profiling. */
2087 if (PROFILE_MODEL_P (current_cpu))
2088 {
2089 FLD (out_dr) = f_r1;
2090 }
2091 #endif
2092 #undef FLD
2093 return idesc;
2094 }
2095
2096 extract_sfmt_sll3:
2097 {
2098 const IDESC *idesc = &m32r2f_insn_data[itype];
2099 CGEN_INSN_WORD insn = entire_insn;
2100 #define FLD(f) abuf->fields.sfmt_add3.f
2101 UINT f_r1;
2102 UINT f_r2;
2103 INT f_simm16;
2104
2105 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
2106 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
2107 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
2108
2109 /* Record the fields for the semantic handler. */
2110 FLD (f_simm16) = f_simm16;
2111 FLD (f_r2) = f_r2;
2112 FLD (f_r1) = f_r1;
2113 FLD (i_sr) = & CPU (h_gr)[f_r2];
2114 FLD (i_dr) = & CPU (h_gr)[f_r1];
2115 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sll3", "f_simm16 0x%x", 'x', f_simm16, "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
2116
2117 #if WITH_PROFILE_MODEL_P
2118 /* Record the fields for profiling. */
2119 if (PROFILE_MODEL_P (current_cpu))
2120 {
2121 FLD (in_sr) = f_r2;
2122 FLD (out_dr) = f_r1;
2123 }
2124 #endif
2125 #undef FLD
2126 return idesc;
2127 }
2128
2129 extract_sfmt_slli:
2130 {
2131 const IDESC *idesc = &m32r2f_insn_data[itype];
2132 CGEN_INSN_WORD insn = entire_insn;
2133 #define FLD(f) abuf->fields.sfmt_slli.f
2134 UINT f_r1;
2135 UINT f_uimm5;
2136
2137 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2138 f_uimm5 = EXTRACT_MSB0_UINT (insn, 16, 11, 5);
2139
2140 /* Record the fields for the semantic handler. */
2141 FLD (f_r1) = f_r1;
2142 FLD (f_uimm5) = f_uimm5;
2143 FLD (i_dr) = & CPU (h_gr)[f_r1];
2144 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_slli", "f_r1 0x%x", 'x', f_r1, "f_uimm5 0x%x", 'x', f_uimm5, "dr 0x%x", 'x', f_r1, (char *) 0));
2145
2146 #if WITH_PROFILE_MODEL_P
2147 /* Record the fields for profiling. */
2148 if (PROFILE_MODEL_P (current_cpu))
2149 {
2150 FLD (in_dr) = f_r1;
2151 FLD (out_dr) = f_r1;
2152 }
2153 #endif
2154 #undef FLD
2155 return idesc;
2156 }
2157
2158 extract_sfmt_st:
2159 {
2160 const IDESC *idesc = &m32r2f_insn_data[itype];
2161 CGEN_INSN_WORD insn = entire_insn;
2162 #define FLD(f) abuf->fields.sfmt_st_plus.f
2163 UINT f_r1;
2164 UINT f_r2;
2165
2166 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2167 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2168
2169 /* Record the fields for the semantic handler. */
2170 FLD (f_r1) = f_r1;
2171 FLD (f_r2) = f_r2;
2172 FLD (i_src1) = & CPU (h_gr)[f_r1];
2173 FLD (i_src2) = & CPU (h_gr)[f_r2];
2174 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_st", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2175
2176 #if WITH_PROFILE_MODEL_P
2177 /* Record the fields for profiling. */
2178 if (PROFILE_MODEL_P (current_cpu))
2179 {
2180 FLD (in_src1) = f_r1;
2181 FLD (in_src2) = f_r2;
2182 }
2183 #endif
2184 #undef FLD
2185 return idesc;
2186 }
2187
2188 extract_sfmt_st_d:
2189 {
2190 const IDESC *idesc = &m32r2f_insn_data[itype];
2191 CGEN_INSN_WORD insn = entire_insn;
2192 #define FLD(f) abuf->fields.sfmt_st_d.f
2193 UINT f_r1;
2194 UINT f_r2;
2195 INT f_simm16;
2196
2197 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
2198 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
2199 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
2200
2201 /* Record the fields for the semantic handler. */
2202 FLD (f_simm16) = f_simm16;
2203 FLD (f_r1) = f_r1;
2204 FLD (f_r2) = f_r2;
2205 FLD (i_src1) = & CPU (h_gr)[f_r1];
2206 FLD (i_src2) = & CPU (h_gr)[f_r2];
2207 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_st_d", "f_simm16 0x%x", 'x', f_simm16, "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2208
2209 #if WITH_PROFILE_MODEL_P
2210 /* Record the fields for profiling. */
2211 if (PROFILE_MODEL_P (current_cpu))
2212 {
2213 FLD (in_src1) = f_r1;
2214 FLD (in_src2) = f_r2;
2215 }
2216 #endif
2217 #undef FLD
2218 return idesc;
2219 }
2220
2221 extract_sfmt_stb:
2222 {
2223 const IDESC *idesc = &m32r2f_insn_data[itype];
2224 CGEN_INSN_WORD insn = entire_insn;
2225 #define FLD(f) abuf->fields.sfmt_st_plus.f
2226 UINT f_r1;
2227 UINT f_r2;
2228
2229 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2230 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2231
2232 /* Record the fields for the semantic handler. */
2233 FLD (f_r1) = f_r1;
2234 FLD (f_r2) = f_r2;
2235 FLD (i_src1) = & CPU (h_gr)[f_r1];
2236 FLD (i_src2) = & CPU (h_gr)[f_r2];
2237 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stb", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2238
2239 #if WITH_PROFILE_MODEL_P
2240 /* Record the fields for profiling. */
2241 if (PROFILE_MODEL_P (current_cpu))
2242 {
2243 FLD (in_src1) = f_r1;
2244 FLD (in_src2) = f_r2;
2245 }
2246 #endif
2247 #undef FLD
2248 return idesc;
2249 }
2250
2251 extract_sfmt_stb_d:
2252 {
2253 const IDESC *idesc = &m32r2f_insn_data[itype];
2254 CGEN_INSN_WORD insn = entire_insn;
2255 #define FLD(f) abuf->fields.sfmt_st_d.f
2256 UINT f_r1;
2257 UINT f_r2;
2258 INT f_simm16;
2259
2260 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
2261 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
2262 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
2263
2264 /* Record the fields for the semantic handler. */
2265 FLD (f_simm16) = f_simm16;
2266 FLD (f_r1) = f_r1;
2267 FLD (f_r2) = f_r2;
2268 FLD (i_src1) = & CPU (h_gr)[f_r1];
2269 FLD (i_src2) = & CPU (h_gr)[f_r2];
2270 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stb_d", "f_simm16 0x%x", 'x', f_simm16, "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2271
2272 #if WITH_PROFILE_MODEL_P
2273 /* Record the fields for profiling. */
2274 if (PROFILE_MODEL_P (current_cpu))
2275 {
2276 FLD (in_src1) = f_r1;
2277 FLD (in_src2) = f_r2;
2278 }
2279 #endif
2280 #undef FLD
2281 return idesc;
2282 }
2283
2284 extract_sfmt_sth:
2285 {
2286 const IDESC *idesc = &m32r2f_insn_data[itype];
2287 CGEN_INSN_WORD insn = entire_insn;
2288 #define FLD(f) abuf->fields.sfmt_st_plus.f
2289 UINT f_r1;
2290 UINT f_r2;
2291
2292 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2293 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2294
2295 /* Record the fields for the semantic handler. */
2296 FLD (f_r1) = f_r1;
2297 FLD (f_r2) = f_r2;
2298 FLD (i_src1) = & CPU (h_gr)[f_r1];
2299 FLD (i_src2) = & CPU (h_gr)[f_r2];
2300 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sth", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2301
2302 #if WITH_PROFILE_MODEL_P
2303 /* Record the fields for profiling. */
2304 if (PROFILE_MODEL_P (current_cpu))
2305 {
2306 FLD (in_src1) = f_r1;
2307 FLD (in_src2) = f_r2;
2308 }
2309 #endif
2310 #undef FLD
2311 return idesc;
2312 }
2313
2314 extract_sfmt_sth_d:
2315 {
2316 const IDESC *idesc = &m32r2f_insn_data[itype];
2317 CGEN_INSN_WORD insn = entire_insn;
2318 #define FLD(f) abuf->fields.sfmt_st_d.f
2319 UINT f_r1;
2320 UINT f_r2;
2321 INT f_simm16;
2322
2323 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
2324 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
2325 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
2326
2327 /* Record the fields for the semantic handler. */
2328 FLD (f_simm16) = f_simm16;
2329 FLD (f_r1) = f_r1;
2330 FLD (f_r2) = f_r2;
2331 FLD (i_src1) = & CPU (h_gr)[f_r1];
2332 FLD (i_src2) = & CPU (h_gr)[f_r2];
2333 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sth_d", "f_simm16 0x%x", 'x', f_simm16, "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2334
2335 #if WITH_PROFILE_MODEL_P
2336 /* Record the fields for profiling. */
2337 if (PROFILE_MODEL_P (current_cpu))
2338 {
2339 FLD (in_src1) = f_r1;
2340 FLD (in_src2) = f_r2;
2341 }
2342 #endif
2343 #undef FLD
2344 return idesc;
2345 }
2346
2347 extract_sfmt_st_plus:
2348 {
2349 const IDESC *idesc = &m32r2f_insn_data[itype];
2350 CGEN_INSN_WORD insn = entire_insn;
2351 #define FLD(f) abuf->fields.sfmt_st_plus.f
2352 UINT f_r1;
2353 UINT f_r2;
2354
2355 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2356 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2357
2358 /* Record the fields for the semantic handler. */
2359 FLD (f_r1) = f_r1;
2360 FLD (f_r2) = f_r2;
2361 FLD (i_src1) = & CPU (h_gr)[f_r1];
2362 FLD (i_src2) = & CPU (h_gr)[f_r2];
2363 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_st_plus", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2364
2365 #if WITH_PROFILE_MODEL_P
2366 /* Record the fields for profiling. */
2367 if (PROFILE_MODEL_P (current_cpu))
2368 {
2369 FLD (in_src1) = f_r1;
2370 FLD (in_src2) = f_r2;
2371 FLD (out_src2) = f_r2;
2372 }
2373 #endif
2374 #undef FLD
2375 return idesc;
2376 }
2377
2378 extract_sfmt_sth_plus:
2379 {
2380 const IDESC *idesc = &m32r2f_insn_data[itype];
2381 CGEN_INSN_WORD insn = entire_insn;
2382 #define FLD(f) abuf->fields.sfmt_st_plus.f
2383 UINT f_r1;
2384 UINT f_r2;
2385
2386 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2387 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2388
2389 /* Record the fields for the semantic handler. */
2390 FLD (f_r1) = f_r1;
2391 FLD (f_r2) = f_r2;
2392 FLD (i_src1) = & CPU (h_gr)[f_r1];
2393 FLD (i_src2) = & CPU (h_gr)[f_r2];
2394 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sth_plus", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2395
2396 #if WITH_PROFILE_MODEL_P
2397 /* Record the fields for profiling. */
2398 if (PROFILE_MODEL_P (current_cpu))
2399 {
2400 FLD (in_src1) = f_r1;
2401 FLD (in_src2) = f_r2;
2402 FLD (out_src2) = f_r2;
2403 }
2404 #endif
2405 #undef FLD
2406 return idesc;
2407 }
2408
2409 extract_sfmt_stb_plus:
2410 {
2411 const IDESC *idesc = &m32r2f_insn_data[itype];
2412 CGEN_INSN_WORD insn = entire_insn;
2413 #define FLD(f) abuf->fields.sfmt_st_plus.f
2414 UINT f_r1;
2415 UINT f_r2;
2416
2417 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2418 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2419
2420 /* Record the fields for the semantic handler. */
2421 FLD (f_r1) = f_r1;
2422 FLD (f_r2) = f_r2;
2423 FLD (i_src1) = & CPU (h_gr)[f_r1];
2424 FLD (i_src2) = & CPU (h_gr)[f_r2];
2425 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_stb_plus", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2426
2427 #if WITH_PROFILE_MODEL_P
2428 /* Record the fields for profiling. */
2429 if (PROFILE_MODEL_P (current_cpu))
2430 {
2431 FLD (in_src1) = f_r1;
2432 FLD (in_src2) = f_r2;
2433 FLD (out_src2) = f_r2;
2434 }
2435 #endif
2436 #undef FLD
2437 return idesc;
2438 }
2439
2440 extract_sfmt_trap:
2441 {
2442 const IDESC *idesc = &m32r2f_insn_data[itype];
2443 CGEN_INSN_WORD insn = entire_insn;
2444 #define FLD(f) abuf->fields.sfmt_trap.f
2445 UINT f_uimm4;
2446
2447 f_uimm4 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2448
2449 /* Record the fields for the semantic handler. */
2450 FLD (f_uimm4) = f_uimm4;
2451 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_trap", "f_uimm4 0x%x", 'x', f_uimm4, (char *) 0));
2452
2453 #if WITH_PROFILE_MODEL_P
2454 /* Record the fields for profiling. */
2455 if (PROFILE_MODEL_P (current_cpu))
2456 {
2457 }
2458 #endif
2459 #undef FLD
2460 return idesc;
2461 }
2462
2463 extract_sfmt_unlock:
2464 {
2465 const IDESC *idesc = &m32r2f_insn_data[itype];
2466 CGEN_INSN_WORD insn = entire_insn;
2467 #define FLD(f) abuf->fields.sfmt_st_plus.f
2468 UINT f_r1;
2469 UINT f_r2;
2470
2471 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2472 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2473
2474 /* Record the fields for the semantic handler. */
2475 FLD (f_r1) = f_r1;
2476 FLD (f_r2) = f_r2;
2477 FLD (i_src1) = & CPU (h_gr)[f_r1];
2478 FLD (i_src2) = & CPU (h_gr)[f_r2];
2479 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_unlock", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2480
2481 #if WITH_PROFILE_MODEL_P
2482 /* Record the fields for profiling. */
2483 if (PROFILE_MODEL_P (current_cpu))
2484 {
2485 FLD (in_src1) = f_r1;
2486 FLD (in_src2) = f_r2;
2487 }
2488 #endif
2489 #undef FLD
2490 return idesc;
2491 }
2492
2493 extract_sfmt_satb:
2494 {
2495 const IDESC *idesc = &m32r2f_insn_data[itype];
2496 CGEN_INSN_WORD insn = entire_insn;
2497 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2498 UINT f_r1;
2499 UINT f_r2;
2500
2501 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
2502 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
2503
2504 /* Record the fields for the semantic handler. */
2505 FLD (f_r2) = f_r2;
2506 FLD (f_r1) = f_r1;
2507 FLD (i_sr) = & CPU (h_gr)[f_r2];
2508 FLD (i_dr) = & CPU (h_gr)[f_r1];
2509 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_satb", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
2510
2511 #if WITH_PROFILE_MODEL_P
2512 /* Record the fields for profiling. */
2513 if (PROFILE_MODEL_P (current_cpu))
2514 {
2515 FLD (in_sr) = f_r2;
2516 FLD (out_dr) = f_r1;
2517 }
2518 #endif
2519 #undef FLD
2520 return idesc;
2521 }
2522
2523 extract_sfmt_sat:
2524 {
2525 const IDESC *idesc = &m32r2f_insn_data[itype];
2526 CGEN_INSN_WORD insn = entire_insn;
2527 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2528 UINT f_r1;
2529 UINT f_r2;
2530
2531 f_r1 = EXTRACT_MSB0_UINT (insn, 32, 4, 4);
2532 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
2533
2534 /* Record the fields for the semantic handler. */
2535 FLD (f_r2) = f_r2;
2536 FLD (f_r1) = f_r1;
2537 FLD (i_sr) = & CPU (h_gr)[f_r2];
2538 FLD (i_dr) = & CPU (h_gr)[f_r1];
2539 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sat", "f_r2 0x%x", 'x', f_r2, "f_r1 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "dr 0x%x", 'x', f_r1, (char *) 0));
2540
2541 #if WITH_PROFILE_MODEL_P
2542 /* Record the fields for profiling. */
2543 if (PROFILE_MODEL_P (current_cpu))
2544 {
2545 FLD (in_sr) = f_r2;
2546 FLD (out_dr) = f_r1;
2547 }
2548 #endif
2549 #undef FLD
2550 return idesc;
2551 }
2552
2553 extract_sfmt_sadd:
2554 {
2555 const IDESC *idesc = &m32r2f_insn_data[itype];
2556 #define FLD(f) abuf->fields.sfmt_empty.f
2557
2558
2559 /* Record the fields for the semantic handler. */
2560 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sadd", (char *) 0));
2561
2562 #undef FLD
2563 return idesc;
2564 }
2565
2566 extract_sfmt_macwu1:
2567 {
2568 const IDESC *idesc = &m32r2f_insn_data[itype];
2569 CGEN_INSN_WORD insn = entire_insn;
2570 #define FLD(f) abuf->fields.sfmt_st_plus.f
2571 UINT f_r1;
2572 UINT f_r2;
2573
2574 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2575 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2576
2577 /* Record the fields for the semantic handler. */
2578 FLD (f_r1) = f_r1;
2579 FLD (f_r2) = f_r2;
2580 FLD (i_src1) = & CPU (h_gr)[f_r1];
2581 FLD (i_src2) = & CPU (h_gr)[f_r2];
2582 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_macwu1", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2583
2584 #if WITH_PROFILE_MODEL_P
2585 /* Record the fields for profiling. */
2586 if (PROFILE_MODEL_P (current_cpu))
2587 {
2588 FLD (in_src1) = f_r1;
2589 FLD (in_src2) = f_r2;
2590 }
2591 #endif
2592 #undef FLD
2593 return idesc;
2594 }
2595
2596 extract_sfmt_msblo:
2597 {
2598 const IDESC *idesc = &m32r2f_insn_data[itype];
2599 CGEN_INSN_WORD insn = entire_insn;
2600 #define FLD(f) abuf->fields.sfmt_st_plus.f
2601 UINT f_r1;
2602 UINT f_r2;
2603
2604 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2605 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2606
2607 /* Record the fields for the semantic handler. */
2608 FLD (f_r1) = f_r1;
2609 FLD (f_r2) = f_r2;
2610 FLD (i_src1) = & CPU (h_gr)[f_r1];
2611 FLD (i_src2) = & CPU (h_gr)[f_r2];
2612 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_msblo", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2613
2614 #if WITH_PROFILE_MODEL_P
2615 /* Record the fields for profiling. */
2616 if (PROFILE_MODEL_P (current_cpu))
2617 {
2618 FLD (in_src1) = f_r1;
2619 FLD (in_src2) = f_r2;
2620 }
2621 #endif
2622 #undef FLD
2623 return idesc;
2624 }
2625
2626 extract_sfmt_mulwu1:
2627 {
2628 const IDESC *idesc = &m32r2f_insn_data[itype];
2629 CGEN_INSN_WORD insn = entire_insn;
2630 #define FLD(f) abuf->fields.sfmt_st_plus.f
2631 UINT f_r1;
2632 UINT f_r2;
2633
2634 f_r1 = EXTRACT_MSB0_UINT (insn, 16, 4, 4);
2635 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2636
2637 /* Record the fields for the semantic handler. */
2638 FLD (f_r1) = f_r1;
2639 FLD (f_r2) = f_r2;
2640 FLD (i_src1) = & CPU (h_gr)[f_r1];
2641 FLD (i_src2) = & CPU (h_gr)[f_r2];
2642 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_mulwu1", "f_r1 0x%x", 'x', f_r1, "f_r2 0x%x", 'x', f_r2, "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
2643
2644 #if WITH_PROFILE_MODEL_P
2645 /* Record the fields for profiling. */
2646 if (PROFILE_MODEL_P (current_cpu))
2647 {
2648 FLD (in_src1) = f_r1;
2649 FLD (in_src2) = f_r2;
2650 }
2651 #endif
2652 #undef FLD
2653 return idesc;
2654 }
2655
2656 extract_sfmt_sc:
2657 {
2658 const IDESC *idesc = &m32r2f_insn_data[itype];
2659 #define FLD(f) abuf->fields.sfmt_empty.f
2660
2661
2662 /* Record the fields for the semantic handler. */
2663 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_sc", (char *) 0));
2664
2665 #undef FLD
2666 return idesc;
2667 }
2668
2669 extract_sfmt_clrpsw:
2670 {
2671 const IDESC *idesc = &m32r2f_insn_data[itype];
2672 CGEN_INSN_WORD insn = entire_insn;
2673 #define FLD(f) abuf->fields.sfmt_clrpsw.f
2674 UINT f_uimm8;
2675
2676 f_uimm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
2677
2678 /* Record the fields for the semantic handler. */
2679 FLD (f_uimm8) = f_uimm8;
2680 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_clrpsw", "f_uimm8 0x%x", 'x', f_uimm8, (char *) 0));
2681
2682 #undef FLD
2683 return idesc;
2684 }
2685
2686 extract_sfmt_setpsw:
2687 {
2688 const IDESC *idesc = &m32r2f_insn_data[itype];
2689 CGEN_INSN_WORD insn = entire_insn;
2690 #define FLD(f) abuf->fields.sfmt_clrpsw.f
2691 UINT f_uimm8;
2692
2693 f_uimm8 = EXTRACT_MSB0_UINT (insn, 16, 8, 8);
2694
2695 /* Record the fields for the semantic handler. */
2696 FLD (f_uimm8) = f_uimm8;
2697 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_setpsw", "f_uimm8 0x%x", 'x', f_uimm8, (char *) 0));
2698
2699 #undef FLD
2700 return idesc;
2701 }
2702
2703 extract_sfmt_bset:
2704 {
2705 const IDESC *idesc = &m32r2f_insn_data[itype];
2706 CGEN_INSN_WORD insn = entire_insn;
2707 #define FLD(f) abuf->fields.sfmt_bset.f
2708 UINT f_uimm3;
2709 UINT f_r2;
2710 INT f_simm16;
2711
2712 f_uimm3 = EXTRACT_MSB0_UINT (insn, 32, 5, 3);
2713 f_r2 = EXTRACT_MSB0_UINT (insn, 32, 12, 4);
2714 f_simm16 = EXTRACT_MSB0_SINT (insn, 32, 16, 16);
2715
2716 /* Record the fields for the semantic handler. */
2717 FLD (f_simm16) = f_simm16;
2718 FLD (f_r2) = f_r2;
2719 FLD (f_uimm3) = f_uimm3;
2720 FLD (i_sr) = & CPU (h_gr)[f_r2];
2721 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_bset", "f_simm16 0x%x", 'x', f_simm16, "f_r2 0x%x", 'x', f_r2, "f_uimm3 0x%x", 'x', f_uimm3, "sr 0x%x", 'x', f_r2, (char *) 0));
2722
2723 #if WITH_PROFILE_MODEL_P
2724 /* Record the fields for profiling. */
2725 if (PROFILE_MODEL_P (current_cpu))
2726 {
2727 FLD (in_sr) = f_r2;
2728 }
2729 #endif
2730 #undef FLD
2731 return idesc;
2732 }
2733
2734 extract_sfmt_btst:
2735 {
2736 const IDESC *idesc = &m32r2f_insn_data[itype];
2737 CGEN_INSN_WORD insn = entire_insn;
2738 #define FLD(f) abuf->fields.sfmt_bset.f
2739 UINT f_uimm3;
2740 UINT f_r2;
2741
2742 f_uimm3 = EXTRACT_MSB0_UINT (insn, 16, 5, 3);
2743 f_r2 = EXTRACT_MSB0_UINT (insn, 16, 12, 4);
2744
2745 /* Record the fields for the semantic handler. */
2746 FLD (f_r2) = f_r2;
2747 FLD (f_uimm3) = f_uimm3;
2748 FLD (i_sr) = & CPU (h_gr)[f_r2];
2749 CGEN_TRACE_EXTRACT (current_cpu, abuf, (current_cpu, pc, "sfmt_btst", "f_r2 0x%x", 'x', f_r2, "f_uimm3 0x%x", 'x', f_uimm3, "sr 0x%x", 'x', f_r2, (char *) 0));
2750
2751 #if WITH_PROFILE_MODEL_P
2752 /* Record the fields for profiling. */
2753 if (PROFILE_MODEL_P (current_cpu))
2754 {
2755 FLD (in_sr) = f_r2;
2756 }
2757 #endif
2758 #undef FLD
2759 return idesc;
2760 }
2761
2762 }
The GNU Binutils are a collection of binary tools.