?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* ppc-linux-nat.c (have_ptrace_getsetregs): New variable.
[gdb/SamB.git] / sim / m32r / sem2-switch.c
blob090880ecee290e26cee9a8c32b09b20bd48a8b46
1 /* Simulator instruction semantics for m32r2f.
2
3 THIS FILE IS MACHINE GENERATED WITH CGEN.
4
5 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
6
7 This file is part of the GNU simulators.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
21
22 */
23
24 #ifdef DEFINE_LABELS
25
26 /* The labels have the case they have because the enum of insn types
27 is all uppercase and in the non-stdc case the insn symbol is built
28 into the enum name. */
29
30 static struct {
31 int index;
32 void *label;
33 } labels[] = {
34 { M32R2F_INSN_X_INVALID, && case_sem_INSN_X_INVALID },
35 { M32R2F_INSN_X_AFTER, && case_sem_INSN_X_AFTER },
36 { M32R2F_INSN_X_BEFORE, && case_sem_INSN_X_BEFORE },
37 { M32R2F_INSN_X_CTI_CHAIN, && case_sem_INSN_X_CTI_CHAIN },
38 { M32R2F_INSN_X_CHAIN, && case_sem_INSN_X_CHAIN },
39 { M32R2F_INSN_X_BEGIN, && case_sem_INSN_X_BEGIN },
40 { M32R2F_INSN_ADD, && case_sem_INSN_ADD },
41 { M32R2F_INSN_ADD3, && case_sem_INSN_ADD3 },
42 { M32R2F_INSN_AND, && case_sem_INSN_AND },
43 { M32R2F_INSN_AND3, && case_sem_INSN_AND3 },
44 { M32R2F_INSN_OR, && case_sem_INSN_OR },
45 { M32R2F_INSN_OR3, && case_sem_INSN_OR3 },
46 { M32R2F_INSN_XOR, && case_sem_INSN_XOR },
47 { M32R2F_INSN_XOR3, && case_sem_INSN_XOR3 },
48 { M32R2F_INSN_ADDI, && case_sem_INSN_ADDI },
49 { M32R2F_INSN_ADDV, && case_sem_INSN_ADDV },
50 { M32R2F_INSN_ADDV3, && case_sem_INSN_ADDV3 },
51 { M32R2F_INSN_ADDX, && case_sem_INSN_ADDX },
52 { M32R2F_INSN_BC8, && case_sem_INSN_BC8 },
53 { M32R2F_INSN_BC24, && case_sem_INSN_BC24 },
54 { M32R2F_INSN_BEQ, && case_sem_INSN_BEQ },
55 { M32R2F_INSN_BEQZ, && case_sem_INSN_BEQZ },
56 { M32R2F_INSN_BGEZ, && case_sem_INSN_BGEZ },
57 { M32R2F_INSN_BGTZ, && case_sem_INSN_BGTZ },
58 { M32R2F_INSN_BLEZ, && case_sem_INSN_BLEZ },
59 { M32R2F_INSN_BLTZ, && case_sem_INSN_BLTZ },
60 { M32R2F_INSN_BNEZ, && case_sem_INSN_BNEZ },
61 { M32R2F_INSN_BL8, && case_sem_INSN_BL8 },
62 { M32R2F_INSN_BL24, && case_sem_INSN_BL24 },
63 { M32R2F_INSN_BCL8, && case_sem_INSN_BCL8 },
64 { M32R2F_INSN_BCL24, && case_sem_INSN_BCL24 },
65 { M32R2F_INSN_BNC8, && case_sem_INSN_BNC8 },
66 { M32R2F_INSN_BNC24, && case_sem_INSN_BNC24 },
67 { M32R2F_INSN_BNE, && case_sem_INSN_BNE },
68 { M32R2F_INSN_BRA8, && case_sem_INSN_BRA8 },
69 { M32R2F_INSN_BRA24, && case_sem_INSN_BRA24 },
70 { M32R2F_INSN_BNCL8, && case_sem_INSN_BNCL8 },
71 { M32R2F_INSN_BNCL24, && case_sem_INSN_BNCL24 },
72 { M32R2F_INSN_CMP, && case_sem_INSN_CMP },
73 { M32R2F_INSN_CMPI, && case_sem_INSN_CMPI },
74 { M32R2F_INSN_CMPU, && case_sem_INSN_CMPU },
75 { M32R2F_INSN_CMPUI, && case_sem_INSN_CMPUI },
76 { M32R2F_INSN_CMPEQ, && case_sem_INSN_CMPEQ },
77 { M32R2F_INSN_CMPZ, && case_sem_INSN_CMPZ },
78 { M32R2F_INSN_DIV, && case_sem_INSN_DIV },
79 { M32R2F_INSN_DIVU, && case_sem_INSN_DIVU },
80 { M32R2F_INSN_REM, && case_sem_INSN_REM },
81 { M32R2F_INSN_REMU, && case_sem_INSN_REMU },
82 { M32R2F_INSN_REMH, && case_sem_INSN_REMH },
83 { M32R2F_INSN_REMUH, && case_sem_INSN_REMUH },
84 { M32R2F_INSN_REMB, && case_sem_INSN_REMB },
85 { M32R2F_INSN_REMUB, && case_sem_INSN_REMUB },
86 { M32R2F_INSN_DIVUH, && case_sem_INSN_DIVUH },
87 { M32R2F_INSN_DIVB, && case_sem_INSN_DIVB },
88 { M32R2F_INSN_DIVUB, && case_sem_INSN_DIVUB },
89 { M32R2F_INSN_DIVH, && case_sem_INSN_DIVH },
90 { M32R2F_INSN_JC, && case_sem_INSN_JC },
91 { M32R2F_INSN_JNC, && case_sem_INSN_JNC },
92 { M32R2F_INSN_JL, && case_sem_INSN_JL },
93 { M32R2F_INSN_JMP, && case_sem_INSN_JMP },
94 { M32R2F_INSN_LD, && case_sem_INSN_LD },
95 { M32R2F_INSN_LD_D, && case_sem_INSN_LD_D },
96 { M32R2F_INSN_LDB, && case_sem_INSN_LDB },
97 { M32R2F_INSN_LDB_D, && case_sem_INSN_LDB_D },
98 { M32R2F_INSN_LDH, && case_sem_INSN_LDH },
99 { M32R2F_INSN_LDH_D, && case_sem_INSN_LDH_D },
100 { M32R2F_INSN_LDUB, && case_sem_INSN_LDUB },
101 { M32R2F_INSN_LDUB_D, && case_sem_INSN_LDUB_D },
102 { M32R2F_INSN_LDUH, && case_sem_INSN_LDUH },
103 { M32R2F_INSN_LDUH_D, && case_sem_INSN_LDUH_D },
104 { M32R2F_INSN_LD_PLUS, && case_sem_INSN_LD_PLUS },
105 { M32R2F_INSN_LD24, && case_sem_INSN_LD24 },
106 { M32R2F_INSN_LDI8, && case_sem_INSN_LDI8 },
107 { M32R2F_INSN_LDI16, && case_sem_INSN_LDI16 },
108 { M32R2F_INSN_LOCK, && case_sem_INSN_LOCK },
109 { M32R2F_INSN_MACHI_A, && case_sem_INSN_MACHI_A },
110 { M32R2F_INSN_MACLO_A, && case_sem_INSN_MACLO_A },
111 { M32R2F_INSN_MACWHI_A, && case_sem_INSN_MACWHI_A },
112 { M32R2F_INSN_MACWLO_A, && case_sem_INSN_MACWLO_A },
113 { M32R2F_INSN_MUL, && case_sem_INSN_MUL },
114 { M32R2F_INSN_MULHI_A, && case_sem_INSN_MULHI_A },
115 { M32R2F_INSN_MULLO_A, && case_sem_INSN_MULLO_A },
116 { M32R2F_INSN_MULWHI_A, && case_sem_INSN_MULWHI_A },
117 { M32R2F_INSN_MULWLO_A, && case_sem_INSN_MULWLO_A },
118 { M32R2F_INSN_MV, && case_sem_INSN_MV },
119 { M32R2F_INSN_MVFACHI_A, && case_sem_INSN_MVFACHI_A },
120 { M32R2F_INSN_MVFACLO_A, && case_sem_INSN_MVFACLO_A },
121 { M32R2F_INSN_MVFACMI_A, && case_sem_INSN_MVFACMI_A },
122 { M32R2F_INSN_MVFC, && case_sem_INSN_MVFC },
123 { M32R2F_INSN_MVTACHI_A, && case_sem_INSN_MVTACHI_A },
124 { M32R2F_INSN_MVTACLO_A, && case_sem_INSN_MVTACLO_A },
125 { M32R2F_INSN_MVTC, && case_sem_INSN_MVTC },
126 { M32R2F_INSN_NEG, && case_sem_INSN_NEG },
127 { M32R2F_INSN_NOP, && case_sem_INSN_NOP },
128 { M32R2F_INSN_NOT, && case_sem_INSN_NOT },
129 { M32R2F_INSN_RAC_DSI, && case_sem_INSN_RAC_DSI },
130 { M32R2F_INSN_RACH_DSI, && case_sem_INSN_RACH_DSI },
131 { M32R2F_INSN_RTE, && case_sem_INSN_RTE },
132 { M32R2F_INSN_SETH, && case_sem_INSN_SETH },
133 { M32R2F_INSN_SLL, && case_sem_INSN_SLL },
134 { M32R2F_INSN_SLL3, && case_sem_INSN_SLL3 },
135 { M32R2F_INSN_SLLI, && case_sem_INSN_SLLI },
136 { M32R2F_INSN_SRA, && case_sem_INSN_SRA },
137 { M32R2F_INSN_SRA3, && case_sem_INSN_SRA3 },
138 { M32R2F_INSN_SRAI, && case_sem_INSN_SRAI },
139 { M32R2F_INSN_SRL, && case_sem_INSN_SRL },
140 { M32R2F_INSN_SRL3, && case_sem_INSN_SRL3 },
141 { M32R2F_INSN_SRLI, && case_sem_INSN_SRLI },
142 { M32R2F_INSN_ST, && case_sem_INSN_ST },
143 { M32R2F_INSN_ST_D, && case_sem_INSN_ST_D },
144 { M32R2F_INSN_STB, && case_sem_INSN_STB },
145 { M32R2F_INSN_STB_D, && case_sem_INSN_STB_D },
146 { M32R2F_INSN_STH, && case_sem_INSN_STH },
147 { M32R2F_INSN_STH_D, && case_sem_INSN_STH_D },
148 { M32R2F_INSN_ST_PLUS, && case_sem_INSN_ST_PLUS },
149 { M32R2F_INSN_STH_PLUS, && case_sem_INSN_STH_PLUS },
150 { M32R2F_INSN_STB_PLUS, && case_sem_INSN_STB_PLUS },
151 { M32R2F_INSN_ST_MINUS, && case_sem_INSN_ST_MINUS },
152 { M32R2F_INSN_SUB, && case_sem_INSN_SUB },
153 { M32R2F_INSN_SUBV, && case_sem_INSN_SUBV },
154 { M32R2F_INSN_SUBX, && case_sem_INSN_SUBX },
155 { M32R2F_INSN_TRAP, && case_sem_INSN_TRAP },
156 { M32R2F_INSN_UNLOCK, && case_sem_INSN_UNLOCK },
157 { M32R2F_INSN_SATB, && case_sem_INSN_SATB },
158 { M32R2F_INSN_SATH, && case_sem_INSN_SATH },
159 { M32R2F_INSN_SAT, && case_sem_INSN_SAT },
160 { M32R2F_INSN_PCMPBZ, && case_sem_INSN_PCMPBZ },
161 { M32R2F_INSN_SADD, && case_sem_INSN_SADD },
162 { M32R2F_INSN_MACWU1, && case_sem_INSN_MACWU1 },
163 { M32R2F_INSN_MSBLO, && case_sem_INSN_MSBLO },
164 { M32R2F_INSN_MULWU1, && case_sem_INSN_MULWU1 },
165 { M32R2F_INSN_MACLH1, && case_sem_INSN_MACLH1 },
166 { M32R2F_INSN_SC, && case_sem_INSN_SC },
167 { M32R2F_INSN_SNC, && case_sem_INSN_SNC },
168 { M32R2F_INSN_CLRPSW, && case_sem_INSN_CLRPSW },
169 { M32R2F_INSN_SETPSW, && case_sem_INSN_SETPSW },
170 { M32R2F_INSN_BSET, && case_sem_INSN_BSET },
171 { M32R2F_INSN_BCLR, && case_sem_INSN_BCLR },
172 { M32R2F_INSN_BTST, && case_sem_INSN_BTST },
173 { M32R2F_INSN_PAR_ADD, && case_sem_INSN_PAR_ADD },
174 { M32R2F_INSN_WRITE_ADD, && case_sem_INSN_WRITE_ADD },
175 { M32R2F_INSN_PAR_AND, && case_sem_INSN_PAR_AND },
176 { M32R2F_INSN_WRITE_AND, && case_sem_INSN_WRITE_AND },
177 { M32R2F_INSN_PAR_OR, && case_sem_INSN_PAR_OR },
178 { M32R2F_INSN_WRITE_OR, && case_sem_INSN_WRITE_OR },
179 { M32R2F_INSN_PAR_XOR, && case_sem_INSN_PAR_XOR },
180 { M32R2F_INSN_WRITE_XOR, && case_sem_INSN_WRITE_XOR },
181 { M32R2F_INSN_PAR_ADDI, && case_sem_INSN_PAR_ADDI },
182 { M32R2F_INSN_WRITE_ADDI, && case_sem_INSN_WRITE_ADDI },
183 { M32R2F_INSN_PAR_ADDV, && case_sem_INSN_PAR_ADDV },
184 { M32R2F_INSN_WRITE_ADDV, && case_sem_INSN_WRITE_ADDV },
185 { M32R2F_INSN_PAR_ADDX, && case_sem_INSN_PAR_ADDX },
186 { M32R2F_INSN_WRITE_ADDX, && case_sem_INSN_WRITE_ADDX },
187 { M32R2F_INSN_PAR_BC8, && case_sem_INSN_PAR_BC8 },
188 { M32R2F_INSN_WRITE_BC8, && case_sem_INSN_WRITE_BC8 },
189 { M32R2F_INSN_PAR_BL8, && case_sem_INSN_PAR_BL8 },
190 { M32R2F_INSN_WRITE_BL8, && case_sem_INSN_WRITE_BL8 },
191 { M32R2F_INSN_PAR_BCL8, && case_sem_INSN_PAR_BCL8 },
192 { M32R2F_INSN_WRITE_BCL8, && case_sem_INSN_WRITE_BCL8 },
193 { M32R2F_INSN_PAR_BNC8, && case_sem_INSN_PAR_BNC8 },
194 { M32R2F_INSN_WRITE_BNC8, && case_sem_INSN_WRITE_BNC8 },
195 { M32R2F_INSN_PAR_BRA8, && case_sem_INSN_PAR_BRA8 },
196 { M32R2F_INSN_WRITE_BRA8, && case_sem_INSN_WRITE_BRA8 },
197 { M32R2F_INSN_PAR_BNCL8, && case_sem_INSN_PAR_BNCL8 },
198 { M32R2F_INSN_WRITE_BNCL8, && case_sem_INSN_WRITE_BNCL8 },
199 { M32R2F_INSN_PAR_CMP, && case_sem_INSN_PAR_CMP },
200 { M32R2F_INSN_WRITE_CMP, && case_sem_INSN_WRITE_CMP },
201 { M32R2F_INSN_PAR_CMPU, && case_sem_INSN_PAR_CMPU },
202 { M32R2F_INSN_WRITE_CMPU, && case_sem_INSN_WRITE_CMPU },
203 { M32R2F_INSN_PAR_CMPEQ, && case_sem_INSN_PAR_CMPEQ },
204 { M32R2F_INSN_WRITE_CMPEQ, && case_sem_INSN_WRITE_CMPEQ },
205 { M32R2F_INSN_PAR_CMPZ, && case_sem_INSN_PAR_CMPZ },
206 { M32R2F_INSN_WRITE_CMPZ, && case_sem_INSN_WRITE_CMPZ },
207 { M32R2F_INSN_PAR_JC, && case_sem_INSN_PAR_JC },
208 { M32R2F_INSN_WRITE_JC, && case_sem_INSN_WRITE_JC },
209 { M32R2F_INSN_PAR_JNC, && case_sem_INSN_PAR_JNC },
210 { M32R2F_INSN_WRITE_JNC, && case_sem_INSN_WRITE_JNC },
211 { M32R2F_INSN_PAR_JL, && case_sem_INSN_PAR_JL },
212 { M32R2F_INSN_WRITE_JL, && case_sem_INSN_WRITE_JL },
213 { M32R2F_INSN_PAR_JMP, && case_sem_INSN_PAR_JMP },
214 { M32R2F_INSN_WRITE_JMP, && case_sem_INSN_WRITE_JMP },
215 { M32R2F_INSN_PAR_LD, && case_sem_INSN_PAR_LD },
216 { M32R2F_INSN_WRITE_LD, && case_sem_INSN_WRITE_LD },
217 { M32R2F_INSN_PAR_LDB, && case_sem_INSN_PAR_LDB },
218 { M32R2F_INSN_WRITE_LDB, && case_sem_INSN_WRITE_LDB },
219 { M32R2F_INSN_PAR_LDH, && case_sem_INSN_PAR_LDH },
220 { M32R2F_INSN_WRITE_LDH, && case_sem_INSN_WRITE_LDH },
221 { M32R2F_INSN_PAR_LDUB, && case_sem_INSN_PAR_LDUB },
222 { M32R2F_INSN_WRITE_LDUB, && case_sem_INSN_WRITE_LDUB },
223 { M32R2F_INSN_PAR_LDUH, && case_sem_INSN_PAR_LDUH },
224 { M32R2F_INSN_WRITE_LDUH, && case_sem_INSN_WRITE_LDUH },
225 { M32R2F_INSN_PAR_LD_PLUS, && case_sem_INSN_PAR_LD_PLUS },
226 { M32R2F_INSN_WRITE_LD_PLUS, && case_sem_INSN_WRITE_LD_PLUS },
227 { M32R2F_INSN_PAR_LDI8, && case_sem_INSN_PAR_LDI8 },
228 { M32R2F_INSN_WRITE_LDI8, && case_sem_INSN_WRITE_LDI8 },
229 { M32R2F_INSN_PAR_LOCK, && case_sem_INSN_PAR_LOCK },
230 { M32R2F_INSN_WRITE_LOCK, && case_sem_INSN_WRITE_LOCK },
231 { M32R2F_INSN_PAR_MACHI_A, && case_sem_INSN_PAR_MACHI_A },
232 { M32R2F_INSN_WRITE_MACHI_A, && case_sem_INSN_WRITE_MACHI_A },
233 { M32R2F_INSN_PAR_MACLO_A, && case_sem_INSN_PAR_MACLO_A },
234 { M32R2F_INSN_WRITE_MACLO_A, && case_sem_INSN_WRITE_MACLO_A },
235 { M32R2F_INSN_PAR_MACWHI_A, && case_sem_INSN_PAR_MACWHI_A },
236 { M32R2F_INSN_WRITE_MACWHI_A, && case_sem_INSN_WRITE_MACWHI_A },
237 { M32R2F_INSN_PAR_MACWLO_A, && case_sem_INSN_PAR_MACWLO_A },
238 { M32R2F_INSN_WRITE_MACWLO_A, && case_sem_INSN_WRITE_MACWLO_A },
239 { M32R2F_INSN_PAR_MUL, && case_sem_INSN_PAR_MUL },
240 { M32R2F_INSN_WRITE_MUL, && case_sem_INSN_WRITE_MUL },
241 { M32R2F_INSN_PAR_MULHI_A, && case_sem_INSN_PAR_MULHI_A },
242 { M32R2F_INSN_WRITE_MULHI_A, && case_sem_INSN_WRITE_MULHI_A },
243 { M32R2F_INSN_PAR_MULLO_A, && case_sem_INSN_PAR_MULLO_A },
244 { M32R2F_INSN_WRITE_MULLO_A, && case_sem_INSN_WRITE_MULLO_A },
245 { M32R2F_INSN_PAR_MULWHI_A, && case_sem_INSN_PAR_MULWHI_A },
246 { M32R2F_INSN_WRITE_MULWHI_A, && case_sem_INSN_WRITE_MULWHI_A },
247 { M32R2F_INSN_PAR_MULWLO_A, && case_sem_INSN_PAR_MULWLO_A },
248 { M32R2F_INSN_WRITE_MULWLO_A, && case_sem_INSN_WRITE_MULWLO_A },
249 { M32R2F_INSN_PAR_MV, && case_sem_INSN_PAR_MV },
250 { M32R2F_INSN_WRITE_MV, && case_sem_INSN_WRITE_MV },
251 { M32R2F_INSN_PAR_MVFACHI_A, && case_sem_INSN_PAR_MVFACHI_A },
252 { M32R2F_INSN_WRITE_MVFACHI_A, && case_sem_INSN_WRITE_MVFACHI_A },
253 { M32R2F_INSN_PAR_MVFACLO_A, && case_sem_INSN_PAR_MVFACLO_A },
254 { M32R2F_INSN_WRITE_MVFACLO_A, && case_sem_INSN_WRITE_MVFACLO_A },
255 { M32R2F_INSN_PAR_MVFACMI_A, && case_sem_INSN_PAR_MVFACMI_A },
256 { M32R2F_INSN_WRITE_MVFACMI_A, && case_sem_INSN_WRITE_MVFACMI_A },
257 { M32R2F_INSN_PAR_MVFC, && case_sem_INSN_PAR_MVFC },
258 { M32R2F_INSN_WRITE_MVFC, && case_sem_INSN_WRITE_MVFC },
259 { M32R2F_INSN_PAR_MVTACHI_A, && case_sem_INSN_PAR_MVTACHI_A },
260 { M32R2F_INSN_WRITE_MVTACHI_A, && case_sem_INSN_WRITE_MVTACHI_A },
261 { M32R2F_INSN_PAR_MVTACLO_A, && case_sem_INSN_PAR_MVTACLO_A },
262 { M32R2F_INSN_WRITE_MVTACLO_A, && case_sem_INSN_WRITE_MVTACLO_A },
263 { M32R2F_INSN_PAR_MVTC, && case_sem_INSN_PAR_MVTC },
264 { M32R2F_INSN_WRITE_MVTC, && case_sem_INSN_WRITE_MVTC },
265 { M32R2F_INSN_PAR_NEG, && case_sem_INSN_PAR_NEG },
266 { M32R2F_INSN_WRITE_NEG, && case_sem_INSN_WRITE_NEG },
267 { M32R2F_INSN_PAR_NOP, && case_sem_INSN_PAR_NOP },
268 { M32R2F_INSN_WRITE_NOP, && case_sem_INSN_WRITE_NOP },
269 { M32R2F_INSN_PAR_NOT, && case_sem_INSN_PAR_NOT },
270 { M32R2F_INSN_WRITE_NOT, && case_sem_INSN_WRITE_NOT },
271 { M32R2F_INSN_PAR_RAC_DSI, && case_sem_INSN_PAR_RAC_DSI },
272 { M32R2F_INSN_WRITE_RAC_DSI, && case_sem_INSN_WRITE_RAC_DSI },
273 { M32R2F_INSN_PAR_RACH_DSI, && case_sem_INSN_PAR_RACH_DSI },
274 { M32R2F_INSN_WRITE_RACH_DSI, && case_sem_INSN_WRITE_RACH_DSI },
275 { M32R2F_INSN_PAR_RTE, && case_sem_INSN_PAR_RTE },
276 { M32R2F_INSN_WRITE_RTE, && case_sem_INSN_WRITE_RTE },
277 { M32R2F_INSN_PAR_SLL, && case_sem_INSN_PAR_SLL },
278 { M32R2F_INSN_WRITE_SLL, && case_sem_INSN_WRITE_SLL },
279 { M32R2F_INSN_PAR_SLLI, && case_sem_INSN_PAR_SLLI },
280 { M32R2F_INSN_WRITE_SLLI, && case_sem_INSN_WRITE_SLLI },
281 { M32R2F_INSN_PAR_SRA, && case_sem_INSN_PAR_SRA },
282 { M32R2F_INSN_WRITE_SRA, && case_sem_INSN_WRITE_SRA },
283 { M32R2F_INSN_PAR_SRAI, && case_sem_INSN_PAR_SRAI },
284 { M32R2F_INSN_WRITE_SRAI, && case_sem_INSN_WRITE_SRAI },
285 { M32R2F_INSN_PAR_SRL, && case_sem_INSN_PAR_SRL },
286 { M32R2F_INSN_WRITE_SRL, && case_sem_INSN_WRITE_SRL },
287 { M32R2F_INSN_PAR_SRLI, && case_sem_INSN_PAR_SRLI },
288 { M32R2F_INSN_WRITE_SRLI, && case_sem_INSN_WRITE_SRLI },
289 { M32R2F_INSN_PAR_ST, && case_sem_INSN_PAR_ST },
290 { M32R2F_INSN_WRITE_ST, && case_sem_INSN_WRITE_ST },
291 { M32R2F_INSN_PAR_STB, && case_sem_INSN_PAR_STB },
292 { M32R2F_INSN_WRITE_STB, && case_sem_INSN_WRITE_STB },
293 { M32R2F_INSN_PAR_STH, && case_sem_INSN_PAR_STH },
294 { M32R2F_INSN_WRITE_STH, && case_sem_INSN_WRITE_STH },
295 { M32R2F_INSN_PAR_ST_PLUS, && case_sem_INSN_PAR_ST_PLUS },
296 { M32R2F_INSN_WRITE_ST_PLUS, && case_sem_INSN_WRITE_ST_PLUS },
297 { M32R2F_INSN_PAR_STH_PLUS, && case_sem_INSN_PAR_STH_PLUS },
298 { M32R2F_INSN_WRITE_STH_PLUS, && case_sem_INSN_WRITE_STH_PLUS },
299 { M32R2F_INSN_PAR_STB_PLUS, && case_sem_INSN_PAR_STB_PLUS },
300 { M32R2F_INSN_WRITE_STB_PLUS, && case_sem_INSN_WRITE_STB_PLUS },
301 { M32R2F_INSN_PAR_ST_MINUS, && case_sem_INSN_PAR_ST_MINUS },
302 { M32R2F_INSN_WRITE_ST_MINUS, && case_sem_INSN_WRITE_ST_MINUS },
303 { M32R2F_INSN_PAR_SUB, && case_sem_INSN_PAR_SUB },
304 { M32R2F_INSN_WRITE_SUB, && case_sem_INSN_WRITE_SUB },
305 { M32R2F_INSN_PAR_SUBV, && case_sem_INSN_PAR_SUBV },
306 { M32R2F_INSN_WRITE_SUBV, && case_sem_INSN_WRITE_SUBV },
307 { M32R2F_INSN_PAR_SUBX, && case_sem_INSN_PAR_SUBX },
308 { M32R2F_INSN_WRITE_SUBX, && case_sem_INSN_WRITE_SUBX },
309 { M32R2F_INSN_PAR_TRAP, && case_sem_INSN_PAR_TRAP },
310 { M32R2F_INSN_WRITE_TRAP, && case_sem_INSN_WRITE_TRAP },
311 { M32R2F_INSN_PAR_UNLOCK, && case_sem_INSN_PAR_UNLOCK },
312 { M32R2F_INSN_WRITE_UNLOCK, && case_sem_INSN_WRITE_UNLOCK },
313 { M32R2F_INSN_PAR_PCMPBZ, && case_sem_INSN_PAR_PCMPBZ },
314 { M32R2F_INSN_WRITE_PCMPBZ, && case_sem_INSN_WRITE_PCMPBZ },
315 { M32R2F_INSN_PAR_SADD, && case_sem_INSN_PAR_SADD },
316 { M32R2F_INSN_WRITE_SADD, && case_sem_INSN_WRITE_SADD },
317 { M32R2F_INSN_PAR_MACWU1, && case_sem_INSN_PAR_MACWU1 },
318 { M32R2F_INSN_WRITE_MACWU1, && case_sem_INSN_WRITE_MACWU1 },
319 { M32R2F_INSN_PAR_MSBLO, && case_sem_INSN_PAR_MSBLO },
320 { M32R2F_INSN_WRITE_MSBLO, && case_sem_INSN_WRITE_MSBLO },
321 { M32R2F_INSN_PAR_MULWU1, && case_sem_INSN_PAR_MULWU1 },
322 { M32R2F_INSN_WRITE_MULWU1, && case_sem_INSN_WRITE_MULWU1 },
323 { M32R2F_INSN_PAR_MACLH1, && case_sem_INSN_PAR_MACLH1 },
324 { M32R2F_INSN_WRITE_MACLH1, && case_sem_INSN_WRITE_MACLH1 },
325 { M32R2F_INSN_PAR_SC, && case_sem_INSN_PAR_SC },
326 { M32R2F_INSN_WRITE_SC, && case_sem_INSN_WRITE_SC },
327 { M32R2F_INSN_PAR_SNC, && case_sem_INSN_PAR_SNC },
328 { M32R2F_INSN_WRITE_SNC, && case_sem_INSN_WRITE_SNC },
329 { M32R2F_INSN_PAR_CLRPSW, && case_sem_INSN_PAR_CLRPSW },
330 { M32R2F_INSN_WRITE_CLRPSW, && case_sem_INSN_WRITE_CLRPSW },
331 { M32R2F_INSN_PAR_SETPSW, && case_sem_INSN_PAR_SETPSW },
332 { M32R2F_INSN_WRITE_SETPSW, && case_sem_INSN_WRITE_SETPSW },
333 { M32R2F_INSN_PAR_BTST, && case_sem_INSN_PAR_BTST },
334 { M32R2F_INSN_WRITE_BTST, && case_sem_INSN_WRITE_BTST },
335 { 0, 0 }
336 };
337 int i;
338
339 for (i = 0; labels[i].label != 0; ++i)
340 {
341 #if FAST_P
342 CPU_IDESC (current_cpu) [labels[i].index].sem_fast_lab = labels[i].label;
343 #else
344 CPU_IDESC (current_cpu) [labels[i].index].sem_full_lab = labels[i].label;
345 #endif
346 }
347
348 #undef DEFINE_LABELS
349 #endif /* DEFINE_LABELS */
350
351 #ifdef DEFINE_SWITCH
352
353 /* If hyper-fast [well not unnecessarily slow] execution is selected, turn
354 off frills like tracing and profiling. */
355 /* FIXME: A better way would be to have TRACE_RESULT check for something
356 that can cause it to be optimized out. Another way would be to emit
357 special handlers into the instruction "stream". */
358
359 #if FAST_P
360 #undef TRACE_RESULT
361 #define TRACE_RESULT(cpu, abuf, name, type, val)
362 #endif
363
364 #undef GET_ATTR
365 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
366 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
367 #else
368 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_/**/attr)
369 #endif
370
371 {
372
373 #if WITH_SCACHE_PBB
374
375 /* Branch to next handler without going around main loop. */
376 #define NEXT(vpc) goto * SEM_ARGBUF (vpc) -> semantic.sem_case
377 SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
378
379 #else /* ! WITH_SCACHE_PBB */
380
381 #define NEXT(vpc) BREAK (sem)
382 #ifdef __GNUC__
383 #if FAST_P
384 SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_fast_lab)
385 #else
386 SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_full_lab)
387 #endif
388 #else
389 SWITCH (sem, SEM_ARGBUF (sc) -> idesc->num)
390 #endif
391
392 #endif /* ! WITH_SCACHE_PBB */
393
394 {
395
396 CASE (sem, INSN_X_INVALID) : /* --invalid-- */
397 {
398 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
399 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
400 #define FLD(f) abuf->fields.fmt_empty.f
401 int UNUSED written = 0;
402 IADDR UNUSED pc = abuf->addr;
403 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
404
405 {
406 /* Update the recorded pc in the cpu state struct.
407 Only necessary for WITH_SCACHE case, but to avoid the
408 conditional compilation .... */
409 SET_H_PC (pc);
410 /* Virtual insns have zero size. Overwrite vpc with address of next insn
411 using the default-insn-bitsize spec. When executing insns in parallel
412 we may want to queue the fault and continue execution. */
413 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
414 vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
415 }
416
417 #undef FLD
418 }
419 NEXT (vpc);
420
421 CASE (sem, INSN_X_AFTER) : /* --after-- */
422 {
423 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
424 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
425 #define FLD(f) abuf->fields.fmt_empty.f
426 int UNUSED written = 0;
427 IADDR UNUSED pc = abuf->addr;
428 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
429
430 {
431 #if WITH_SCACHE_PBB_M32R2F
432 m32r2f_pbb_after (current_cpu, sem_arg);
433 #endif
434 }
435
436 #undef FLD
437 }
438 NEXT (vpc);
439
440 CASE (sem, INSN_X_BEFORE) : /* --before-- */
441 {
442 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
443 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
444 #define FLD(f) abuf->fields.fmt_empty.f
445 int UNUSED written = 0;
446 IADDR UNUSED pc = abuf->addr;
447 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
448
449 {
450 #if WITH_SCACHE_PBB_M32R2F
451 m32r2f_pbb_before (current_cpu, sem_arg);
452 #endif
453 }
454
455 #undef FLD
456 }
457 NEXT (vpc);
458
459 CASE (sem, INSN_X_CTI_CHAIN) : /* --cti-chain-- */
460 {
461 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
462 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
463 #define FLD(f) abuf->fields.fmt_empty.f
464 int UNUSED written = 0;
465 IADDR UNUSED pc = abuf->addr;
466 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
467
468 {
469 #if WITH_SCACHE_PBB_M32R2F
470 #ifdef DEFINE_SWITCH
471 vpc = m32r2f_pbb_cti_chain (current_cpu, sem_arg,
472 pbb_br_type, pbb_br_npc);
473 BREAK (sem);
474 #else
475 /* FIXME: Allow provision of explicit ifmt spec in insn spec. */
476 vpc = m32r2f_pbb_cti_chain (current_cpu, sem_arg,
477 CPU_PBB_BR_TYPE (current_cpu),
478 CPU_PBB_BR_NPC (current_cpu));
479 #endif
480 #endif
481 }
482
483 #undef FLD
484 }
485 NEXT (vpc);
486
487 CASE (sem, INSN_X_CHAIN) : /* --chain-- */
488 {
489 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
490 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
491 #define FLD(f) abuf->fields.fmt_empty.f
492 int UNUSED written = 0;
493 IADDR UNUSED pc = abuf->addr;
494 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
495
496 {
497 #if WITH_SCACHE_PBB_M32R2F
498 vpc = m32r2f_pbb_chain (current_cpu, sem_arg);
499 #ifdef DEFINE_SWITCH
500 BREAK (sem);
501 #endif
502 #endif
503 }
504
505 #undef FLD
506 }
507 NEXT (vpc);
508
509 CASE (sem, INSN_X_BEGIN) : /* --begin-- */
510 {
511 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
512 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
513 #define FLD(f) abuf->fields.fmt_empty.f
514 int UNUSED written = 0;
515 IADDR UNUSED pc = abuf->addr;
516 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
517
518 {
519 #if WITH_SCACHE_PBB_M32R2F
520 #if defined DEFINE_SWITCH || defined FAST_P
521 /* In the switch case FAST_P is a constant, allowing several optimizations
522 in any called inline functions. */
523 vpc = m32r2f_pbb_begin (current_cpu, FAST_P);
524 #else
525 #if 0 /* cgen engine can't handle dynamic fast/full switching yet. */
526 vpc = m32r2f_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
527 #else
528 vpc = m32r2f_pbb_begin (current_cpu, 0);
529 #endif
530 #endif
531 #endif
532 }
533
534 #undef FLD
535 }
536 NEXT (vpc);
537
538 CASE (sem, INSN_ADD) : /* add $dr,$sr */
539 {
540 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
541 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
542 #define FLD(f) abuf->fields.sfmt_add.f
543 int UNUSED written = 0;
544 IADDR UNUSED pc = abuf->addr;
545 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
546
547 {
548 SI opval = ADDSI (* FLD (i_dr), * FLD (i_sr));
549 * FLD (i_dr) = opval;
550 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
551 }
552
553 #undef FLD
554 }
555 NEXT (vpc);
556
557 CASE (sem, INSN_ADD3) : /* add3 $dr,$sr,$hash$slo16 */
558 {
559 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
560 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
561 #define FLD(f) abuf->fields.sfmt_add3.f
562 int UNUSED written = 0;
563 IADDR UNUSED pc = abuf->addr;
564 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
565
566 {
567 SI opval = ADDSI (* FLD (i_sr), FLD (f_simm16));
568 * FLD (i_dr) = opval;
569 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
570 }
571
572 #undef FLD
573 }
574 NEXT (vpc);
575
576 CASE (sem, INSN_AND) : /* and $dr,$sr */
577 {
578 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
579 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
580 #define FLD(f) abuf->fields.sfmt_add.f
581 int UNUSED written = 0;
582 IADDR UNUSED pc = abuf->addr;
583 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
584
585 {
586 SI opval = ANDSI (* FLD (i_dr), * FLD (i_sr));
587 * FLD (i_dr) = opval;
588 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
589 }
590
591 #undef FLD
592 }
593 NEXT (vpc);
594
595 CASE (sem, INSN_AND3) : /* and3 $dr,$sr,$uimm16 */
596 {
597 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
598 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
599 #define FLD(f) abuf->fields.sfmt_and3.f
600 int UNUSED written = 0;
601 IADDR UNUSED pc = abuf->addr;
602 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
603
604 {
605 SI opval = ANDSI (* FLD (i_sr), FLD (f_uimm16));
606 * FLD (i_dr) = opval;
607 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
608 }
609
610 #undef FLD
611 }
612 NEXT (vpc);
613
614 CASE (sem, INSN_OR) : /* or $dr,$sr */
615 {
616 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
617 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
618 #define FLD(f) abuf->fields.sfmt_add.f
619 int UNUSED written = 0;
620 IADDR UNUSED pc = abuf->addr;
621 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
622
623 {
624 SI opval = ORSI (* FLD (i_dr), * FLD (i_sr));
625 * FLD (i_dr) = opval;
626 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
627 }
628
629 #undef FLD
630 }
631 NEXT (vpc);
632
633 CASE (sem, INSN_OR3) : /* or3 $dr,$sr,$hash$ulo16 */
634 {
635 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
636 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
637 #define FLD(f) abuf->fields.sfmt_and3.f
638 int UNUSED written = 0;
639 IADDR UNUSED pc = abuf->addr;
640 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
641
642 {
643 SI opval = ORSI (* FLD (i_sr), FLD (f_uimm16));
644 * FLD (i_dr) = opval;
645 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
646 }
647
648 #undef FLD
649 }
650 NEXT (vpc);
651
652 CASE (sem, INSN_XOR) : /* xor $dr,$sr */
653 {
654 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
655 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
656 #define FLD(f) abuf->fields.sfmt_add.f
657 int UNUSED written = 0;
658 IADDR UNUSED pc = abuf->addr;
659 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
660
661 {
662 SI opval = XORSI (* FLD (i_dr), * FLD (i_sr));
663 * FLD (i_dr) = opval;
664 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
665 }
666
667 #undef FLD
668 }
669 NEXT (vpc);
670
671 CASE (sem, INSN_XOR3) : /* xor3 $dr,$sr,$uimm16 */
672 {
673 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
674 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
675 #define FLD(f) abuf->fields.sfmt_and3.f
676 int UNUSED written = 0;
677 IADDR UNUSED pc = abuf->addr;
678 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
679
680 {
681 SI opval = XORSI (* FLD (i_sr), FLD (f_uimm16));
682 * FLD (i_dr) = opval;
683 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
684 }
685
686 #undef FLD
687 }
688 NEXT (vpc);
689
690 CASE (sem, INSN_ADDI) : /* addi $dr,$simm8 */
691 {
692 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
693 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
694 #define FLD(f) abuf->fields.sfmt_addi.f
695 int UNUSED written = 0;
696 IADDR UNUSED pc = abuf->addr;
697 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
698
699 {
700 SI opval = ADDSI (* FLD (i_dr), FLD (f_simm8));
701 * FLD (i_dr) = opval;
702 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
703 }
704
705 #undef FLD
706 }
707 NEXT (vpc);
708
709 CASE (sem, INSN_ADDV) : /* addv $dr,$sr */
710 {
711 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
712 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
713 #define FLD(f) abuf->fields.sfmt_add.f
714 int UNUSED written = 0;
715 IADDR UNUSED pc = abuf->addr;
716 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
717
718 {
719 SI temp0;BI temp1;
720 temp0 = ADDSI (* FLD (i_dr), * FLD (i_sr));
721 temp1 = ADDOFSI (* FLD (i_dr), * FLD (i_sr), 0);
722 {
723 SI opval = temp0;
724 * FLD (i_dr) = opval;
725 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
726 }
727 {
728 BI opval = temp1;
729 CPU (h_cond) = opval;
730 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
731 }
732 }
733
734 #undef FLD
735 }
736 NEXT (vpc);
737
738 CASE (sem, INSN_ADDV3) : /* addv3 $dr,$sr,$simm16 */
739 {
740 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
741 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
742 #define FLD(f) abuf->fields.sfmt_add3.f
743 int UNUSED written = 0;
744 IADDR UNUSED pc = abuf->addr;
745 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
746
747 {
748 SI temp0;BI temp1;
749 temp0 = ADDSI (* FLD (i_sr), FLD (f_simm16));
750 temp1 = ADDOFSI (* FLD (i_sr), FLD (f_simm16), 0);
751 {
752 SI opval = temp0;
753 * FLD (i_dr) = opval;
754 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
755 }
756 {
757 BI opval = temp1;
758 CPU (h_cond) = opval;
759 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
760 }
761 }
762
763 #undef FLD
764 }
765 NEXT (vpc);
766
767 CASE (sem, INSN_ADDX) : /* addx $dr,$sr */
768 {
769 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
770 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
771 #define FLD(f) abuf->fields.sfmt_add.f
772 int UNUSED written = 0;
773 IADDR UNUSED pc = abuf->addr;
774 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
775
776 {
777 SI temp0;BI temp1;
778 temp0 = ADDCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
779 temp1 = ADDCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
780 {
781 SI opval = temp0;
782 * FLD (i_dr) = opval;
783 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
784 }
785 {
786 BI opval = temp1;
787 CPU (h_cond) = opval;
788 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
789 }
790 }
791
792 #undef FLD
793 }
794 NEXT (vpc);
795
796 CASE (sem, INSN_BC8) : /* bc.s $disp8 */
797 {
798 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
799 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
800 #define FLD(f) abuf->fields.sfmt_bl8.f
801 int UNUSED written = 0;
802 IADDR UNUSED pc = abuf->addr;
803 SEM_BRANCH_INIT
804 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
805
806 if (CPU (h_cond)) {
807 {
808 USI opval = FLD (i_disp8);
809 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
810 written |= (1 << 2);
811 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
812 }
813 }
814
815 abuf->written = written;
816 SEM_BRANCH_FINI (vpc);
817 #undef FLD
818 }
819 NEXT (vpc);
820
821 CASE (sem, INSN_BC24) : /* bc.l $disp24 */
822 {
823 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
824 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
825 #define FLD(f) abuf->fields.sfmt_bl24.f
826 int UNUSED written = 0;
827 IADDR UNUSED pc = abuf->addr;
828 SEM_BRANCH_INIT
829 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
830
831 if (CPU (h_cond)) {
832 {
833 USI opval = FLD (i_disp24);
834 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
835 written |= (1 << 2);
836 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
837 }
838 }
839
840 abuf->written = written;
841 SEM_BRANCH_FINI (vpc);
842 #undef FLD
843 }
844 NEXT (vpc);
845
846 CASE (sem, INSN_BEQ) : /* beq $src1,$src2,$disp16 */
847 {
848 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
849 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
850 #define FLD(f) abuf->fields.sfmt_beq.f
851 int UNUSED written = 0;
852 IADDR UNUSED pc = abuf->addr;
853 SEM_BRANCH_INIT
854 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
855
856 if (EQSI (* FLD (i_src1), * FLD (i_src2))) {
857 {
858 USI opval = FLD (i_disp16);
859 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
860 written |= (1 << 3);
861 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
862 }
863 }
864
865 abuf->written = written;
866 SEM_BRANCH_FINI (vpc);
867 #undef FLD
868 }
869 NEXT (vpc);
870
871 CASE (sem, INSN_BEQZ) : /* beqz $src2,$disp16 */
872 {
873 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
874 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
875 #define FLD(f) abuf->fields.sfmt_beq.f
876 int UNUSED written = 0;
877 IADDR UNUSED pc = abuf->addr;
878 SEM_BRANCH_INIT
879 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
880
881 if (EQSI (* FLD (i_src2), 0)) {
882 {
883 USI opval = FLD (i_disp16);
884 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
885 written |= (1 << 2);
886 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
887 }
888 }
889
890 abuf->written = written;
891 SEM_BRANCH_FINI (vpc);
892 #undef FLD
893 }
894 NEXT (vpc);
895
896 CASE (sem, INSN_BGEZ) : /* bgez $src2,$disp16 */
897 {
898 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
899 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
900 #define FLD(f) abuf->fields.sfmt_beq.f
901 int UNUSED written = 0;
902 IADDR UNUSED pc = abuf->addr;
903 SEM_BRANCH_INIT
904 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
905
906 if (GESI (* FLD (i_src2), 0)) {
907 {
908 USI opval = FLD (i_disp16);
909 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
910 written |= (1 << 2);
911 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
912 }
913 }
914
915 abuf->written = written;
916 SEM_BRANCH_FINI (vpc);
917 #undef FLD
918 }
919 NEXT (vpc);
920
921 CASE (sem, INSN_BGTZ) : /* bgtz $src2,$disp16 */
922 {
923 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
924 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
925 #define FLD(f) abuf->fields.sfmt_beq.f
926 int UNUSED written = 0;
927 IADDR UNUSED pc = abuf->addr;
928 SEM_BRANCH_INIT
929 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
930
931 if (GTSI (* FLD (i_src2), 0)) {
932 {
933 USI opval = FLD (i_disp16);
934 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
935 written |= (1 << 2);
936 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
937 }
938 }
939
940 abuf->written = written;
941 SEM_BRANCH_FINI (vpc);
942 #undef FLD
943 }
944 NEXT (vpc);
945
946 CASE (sem, INSN_BLEZ) : /* blez $src2,$disp16 */
947 {
948 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
949 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
950 #define FLD(f) abuf->fields.sfmt_beq.f
951 int UNUSED written = 0;
952 IADDR UNUSED pc = abuf->addr;
953 SEM_BRANCH_INIT
954 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
955
956 if (LESI (* FLD (i_src2), 0)) {
957 {
958 USI opval = FLD (i_disp16);
959 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
960 written |= (1 << 2);
961 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
962 }
963 }
964
965 abuf->written = written;
966 SEM_BRANCH_FINI (vpc);
967 #undef FLD
968 }
969 NEXT (vpc);
970
971 CASE (sem, INSN_BLTZ) : /* bltz $src2,$disp16 */
972 {
973 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
974 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
975 #define FLD(f) abuf->fields.sfmt_beq.f
976 int UNUSED written = 0;
977 IADDR UNUSED pc = abuf->addr;
978 SEM_BRANCH_INIT
979 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
980
981 if (LTSI (* FLD (i_src2), 0)) {
982 {
983 USI opval = FLD (i_disp16);
984 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
985 written |= (1 << 2);
986 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
987 }
988 }
989
990 abuf->written = written;
991 SEM_BRANCH_FINI (vpc);
992 #undef FLD
993 }
994 NEXT (vpc);
995
996 CASE (sem, INSN_BNEZ) : /* bnez $src2,$disp16 */
997 {
998 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
999 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1000 #define FLD(f) abuf->fields.sfmt_beq.f
1001 int UNUSED written = 0;
1002 IADDR UNUSED pc = abuf->addr;
1003 SEM_BRANCH_INIT
1004 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1005
1006 if (NESI (* FLD (i_src2), 0)) {
1007 {
1008 USI opval = FLD (i_disp16);
1009 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1010 written |= (1 << 2);
1011 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1012 }
1013 }
1014
1015 abuf->written = written;
1016 SEM_BRANCH_FINI (vpc);
1017 #undef FLD
1018 }
1019 NEXT (vpc);
1020
1021 CASE (sem, INSN_BL8) : /* bl.s $disp8 */
1022 {
1023 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1024 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1025 #define FLD(f) abuf->fields.sfmt_bl8.f
1026 int UNUSED written = 0;
1027 IADDR UNUSED pc = abuf->addr;
1028 SEM_BRANCH_INIT
1029 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1030
1031 {
1032 {
1033 SI opval = ADDSI (ANDSI (pc, -4), 4);
1034 CPU (h_gr[((UINT) 14)]) = opval;
1035 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1036 }
1037 {
1038 USI opval = FLD (i_disp8);
1039 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1040 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1041 }
1042 }
1043
1044 SEM_BRANCH_FINI (vpc);
1045 #undef FLD
1046 }
1047 NEXT (vpc);
1048
1049 CASE (sem, INSN_BL24) : /* bl.l $disp24 */
1050 {
1051 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1052 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1053 #define FLD(f) abuf->fields.sfmt_bl24.f
1054 int UNUSED written = 0;
1055 IADDR UNUSED pc = abuf->addr;
1056 SEM_BRANCH_INIT
1057 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1058
1059 {
1060 {
1061 SI opval = ADDSI (pc, 4);
1062 CPU (h_gr[((UINT) 14)]) = opval;
1063 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1064 }
1065 {
1066 USI opval = FLD (i_disp24);
1067 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1068 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1069 }
1070 }
1071
1072 SEM_BRANCH_FINI (vpc);
1073 #undef FLD
1074 }
1075 NEXT (vpc);
1076
1077 CASE (sem, INSN_BCL8) : /* bcl.s $disp8 */
1078 {
1079 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1080 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1081 #define FLD(f) abuf->fields.sfmt_bl8.f
1082 int UNUSED written = 0;
1083 IADDR UNUSED pc = abuf->addr;
1084 SEM_BRANCH_INIT
1085 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1086
1087 if (CPU (h_cond)) {
1088 {
1089 {
1090 SI opval = ADDSI (ANDSI (pc, -4), 4);
1091 CPU (h_gr[((UINT) 14)]) = opval;
1092 written |= (1 << 3);
1093 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1094 }
1095 {
1096 USI opval = FLD (i_disp8);
1097 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1098 written |= (1 << 4);
1099 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1100 }
1101 }
1102 }
1103
1104 abuf->written = written;
1105 SEM_BRANCH_FINI (vpc);
1106 #undef FLD
1107 }
1108 NEXT (vpc);
1109
1110 CASE (sem, INSN_BCL24) : /* bcl.l $disp24 */
1111 {
1112 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1113 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1114 #define FLD(f) abuf->fields.sfmt_bl24.f
1115 int UNUSED written = 0;
1116 IADDR UNUSED pc = abuf->addr;
1117 SEM_BRANCH_INIT
1118 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1119
1120 if (CPU (h_cond)) {
1121 {
1122 {
1123 SI opval = ADDSI (pc, 4);
1124 CPU (h_gr[((UINT) 14)]) = opval;
1125 written |= (1 << 3);
1126 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1127 }
1128 {
1129 USI opval = FLD (i_disp24);
1130 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1131 written |= (1 << 4);
1132 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1133 }
1134 }
1135 }
1136
1137 abuf->written = written;
1138 SEM_BRANCH_FINI (vpc);
1139 #undef FLD
1140 }
1141 NEXT (vpc);
1142
1143 CASE (sem, INSN_BNC8) : /* bnc.s $disp8 */
1144 {
1145 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1146 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1147 #define FLD(f) abuf->fields.sfmt_bl8.f
1148 int UNUSED written = 0;
1149 IADDR UNUSED pc = abuf->addr;
1150 SEM_BRANCH_INIT
1151 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1152
1153 if (NOTBI (CPU (h_cond))) {
1154 {
1155 USI opval = FLD (i_disp8);
1156 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1157 written |= (1 << 2);
1158 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1159 }
1160 }
1161
1162 abuf->written = written;
1163 SEM_BRANCH_FINI (vpc);
1164 #undef FLD
1165 }
1166 NEXT (vpc);
1167
1168 CASE (sem, INSN_BNC24) : /* bnc.l $disp24 */
1169 {
1170 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1171 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1172 #define FLD(f) abuf->fields.sfmt_bl24.f
1173 int UNUSED written = 0;
1174 IADDR UNUSED pc = abuf->addr;
1175 SEM_BRANCH_INIT
1176 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1177
1178 if (NOTBI (CPU (h_cond))) {
1179 {
1180 USI opval = FLD (i_disp24);
1181 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1182 written |= (1 << 2);
1183 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1184 }
1185 }
1186
1187 abuf->written = written;
1188 SEM_BRANCH_FINI (vpc);
1189 #undef FLD
1190 }
1191 NEXT (vpc);
1192
1193 CASE (sem, INSN_BNE) : /* bne $src1,$src2,$disp16 */
1194 {
1195 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1196 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1197 #define FLD(f) abuf->fields.sfmt_beq.f
1198 int UNUSED written = 0;
1199 IADDR UNUSED pc = abuf->addr;
1200 SEM_BRANCH_INIT
1201 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1202
1203 if (NESI (* FLD (i_src1), * FLD (i_src2))) {
1204 {
1205 USI opval = FLD (i_disp16);
1206 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1207 written |= (1 << 3);
1208 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1209 }
1210 }
1211
1212 abuf->written = written;
1213 SEM_BRANCH_FINI (vpc);
1214 #undef FLD
1215 }
1216 NEXT (vpc);
1217
1218 CASE (sem, INSN_BRA8) : /* bra.s $disp8 */
1219 {
1220 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1221 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1222 #define FLD(f) abuf->fields.sfmt_bl8.f
1223 int UNUSED written = 0;
1224 IADDR UNUSED pc = abuf->addr;
1225 SEM_BRANCH_INIT
1226 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1227
1228 {
1229 USI opval = FLD (i_disp8);
1230 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1231 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1232 }
1233
1234 SEM_BRANCH_FINI (vpc);
1235 #undef FLD
1236 }
1237 NEXT (vpc);
1238
1239 CASE (sem, INSN_BRA24) : /* bra.l $disp24 */
1240 {
1241 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1242 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1243 #define FLD(f) abuf->fields.sfmt_bl24.f
1244 int UNUSED written = 0;
1245 IADDR UNUSED pc = abuf->addr;
1246 SEM_BRANCH_INIT
1247 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1248
1249 {
1250 USI opval = FLD (i_disp24);
1251 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1252 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1253 }
1254
1255 SEM_BRANCH_FINI (vpc);
1256 #undef FLD
1257 }
1258 NEXT (vpc);
1259
1260 CASE (sem, INSN_BNCL8) : /* bncl.s $disp8 */
1261 {
1262 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1263 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1264 #define FLD(f) abuf->fields.sfmt_bl8.f
1265 int UNUSED written = 0;
1266 IADDR UNUSED pc = abuf->addr;
1267 SEM_BRANCH_INIT
1268 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1269
1270 if (NOTBI (CPU (h_cond))) {
1271 {
1272 {
1273 SI opval = ADDSI (ANDSI (pc, -4), 4);
1274 CPU (h_gr[((UINT) 14)]) = opval;
1275 written |= (1 << 3);
1276 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1277 }
1278 {
1279 USI opval = FLD (i_disp8);
1280 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1281 written |= (1 << 4);
1282 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1283 }
1284 }
1285 }
1286
1287 abuf->written = written;
1288 SEM_BRANCH_FINI (vpc);
1289 #undef FLD
1290 }
1291 NEXT (vpc);
1292
1293 CASE (sem, INSN_BNCL24) : /* bncl.l $disp24 */
1294 {
1295 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1296 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1297 #define FLD(f) abuf->fields.sfmt_bl24.f
1298 int UNUSED written = 0;
1299 IADDR UNUSED pc = abuf->addr;
1300 SEM_BRANCH_INIT
1301 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1302
1303 if (NOTBI (CPU (h_cond))) {
1304 {
1305 {
1306 SI opval = ADDSI (pc, 4);
1307 CPU (h_gr[((UINT) 14)]) = opval;
1308 written |= (1 << 3);
1309 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1310 }
1311 {
1312 USI opval = FLD (i_disp24);
1313 SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1314 written |= (1 << 4);
1315 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1316 }
1317 }
1318 }
1319
1320 abuf->written = written;
1321 SEM_BRANCH_FINI (vpc);
1322 #undef FLD
1323 }
1324 NEXT (vpc);
1325
1326 CASE (sem, INSN_CMP) : /* cmp $src1,$src2 */
1327 {
1328 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1329 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1330 #define FLD(f) abuf->fields.sfmt_st_plus.f
1331 int UNUSED written = 0;
1332 IADDR UNUSED pc = abuf->addr;
1333 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1334
1335 {
1336 BI opval = LTSI (* FLD (i_src1), * FLD (i_src2));
1337 CPU (h_cond) = opval;
1338 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1339 }
1340
1341 #undef FLD
1342 }
1343 NEXT (vpc);
1344
1345 CASE (sem, INSN_CMPI) : /* cmpi $src2,$simm16 */
1346 {
1347 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1348 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1349 #define FLD(f) abuf->fields.sfmt_st_d.f
1350 int UNUSED written = 0;
1351 IADDR UNUSED pc = abuf->addr;
1352 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1353
1354 {
1355 BI opval = LTSI (* FLD (i_src2), FLD (f_simm16));
1356 CPU (h_cond) = opval;
1357 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1358 }
1359
1360 #undef FLD
1361 }
1362 NEXT (vpc);
1363
1364 CASE (sem, INSN_CMPU) : /* cmpu $src1,$src2 */
1365 {
1366 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1367 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1368 #define FLD(f) abuf->fields.sfmt_st_plus.f
1369 int UNUSED written = 0;
1370 IADDR UNUSED pc = abuf->addr;
1371 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1372
1373 {
1374 BI opval = LTUSI (* FLD (i_src1), * FLD (i_src2));
1375 CPU (h_cond) = opval;
1376 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1377 }
1378
1379 #undef FLD
1380 }
1381 NEXT (vpc);
1382
1383 CASE (sem, INSN_CMPUI) : /* cmpui $src2,$simm16 */
1384 {
1385 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1386 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1387 #define FLD(f) abuf->fields.sfmt_st_d.f
1388 int UNUSED written = 0;
1389 IADDR UNUSED pc = abuf->addr;
1390 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1391
1392 {
1393 BI opval = LTUSI (* FLD (i_src2), FLD (f_simm16));
1394 CPU (h_cond) = opval;
1395 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1396 }
1397
1398 #undef FLD
1399 }
1400 NEXT (vpc);
1401
1402 CASE (sem, INSN_CMPEQ) : /* cmpeq $src1,$src2 */
1403 {
1404 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1405 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1406 #define FLD(f) abuf->fields.sfmt_st_plus.f
1407 int UNUSED written = 0;
1408 IADDR UNUSED pc = abuf->addr;
1409 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1410
1411 {
1412 BI opval = EQSI (* FLD (i_src1), * FLD (i_src2));
1413 CPU (h_cond) = opval;
1414 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1415 }
1416
1417 #undef FLD
1418 }
1419 NEXT (vpc);
1420
1421 CASE (sem, INSN_CMPZ) : /* cmpz $src2 */
1422 {
1423 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1424 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1425 #define FLD(f) abuf->fields.sfmt_st_plus.f
1426 int UNUSED written = 0;
1427 IADDR UNUSED pc = abuf->addr;
1428 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1429
1430 {
1431 BI opval = EQSI (* FLD (i_src2), 0);
1432 CPU (h_cond) = opval;
1433 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1434 }
1435
1436 #undef FLD
1437 }
1438 NEXT (vpc);
1439
1440 CASE (sem, INSN_DIV) : /* div $dr,$sr */
1441 {
1442 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1443 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1444 #define FLD(f) abuf->fields.sfmt_add.f
1445 int UNUSED written = 0;
1446 IADDR UNUSED pc = abuf->addr;
1447 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1448
1449 if (NESI (* FLD (i_sr), 0)) {
1450 {
1451 SI opval = DIVSI (* FLD (i_dr), * FLD (i_sr));
1452 * FLD (i_dr) = opval;
1453 written |= (1 << 2);
1454 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1455 }
1456 }
1457
1458 abuf->written = written;
1459 #undef FLD
1460 }
1461 NEXT (vpc);
1462
1463 CASE (sem, INSN_DIVU) : /* divu $dr,$sr */
1464 {
1465 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1466 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1467 #define FLD(f) abuf->fields.sfmt_add.f
1468 int UNUSED written = 0;
1469 IADDR UNUSED pc = abuf->addr;
1470 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1471
1472 if (NESI (* FLD (i_sr), 0)) {
1473 {
1474 SI opval = UDIVSI (* FLD (i_dr), * FLD (i_sr));
1475 * FLD (i_dr) = opval;
1476 written |= (1 << 2);
1477 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1478 }
1479 }
1480
1481 abuf->written = written;
1482 #undef FLD
1483 }
1484 NEXT (vpc);
1485
1486 CASE (sem, INSN_REM) : /* rem $dr,$sr */
1487 {
1488 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1489 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1490 #define FLD(f) abuf->fields.sfmt_add.f
1491 int UNUSED written = 0;
1492 IADDR UNUSED pc = abuf->addr;
1493 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1494
1495 if (NESI (* FLD (i_sr), 0)) {
1496 {
1497 SI opval = MODSI (* FLD (i_dr), * FLD (i_sr));
1498 * FLD (i_dr) = opval;
1499 written |= (1 << 2);
1500 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1501 }
1502 }
1503
1504 abuf->written = written;
1505 #undef FLD
1506 }
1507 NEXT (vpc);
1508
1509 CASE (sem, INSN_REMU) : /* remu $dr,$sr */
1510 {
1511 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1512 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1513 #define FLD(f) abuf->fields.sfmt_add.f
1514 int UNUSED written = 0;
1515 IADDR UNUSED pc = abuf->addr;
1516 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1517
1518 if (NESI (* FLD (i_sr), 0)) {
1519 {
1520 SI opval = UMODSI (* FLD (i_dr), * FLD (i_sr));
1521 * FLD (i_dr) = opval;
1522 written |= (1 << 2);
1523 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1524 }
1525 }
1526
1527 abuf->written = written;
1528 #undef FLD
1529 }
1530 NEXT (vpc);
1531
1532 CASE (sem, INSN_REMH) : /* remh $dr,$sr */
1533 {
1534 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1535 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1536 #define FLD(f) abuf->fields.sfmt_add.f
1537 int UNUSED written = 0;
1538 IADDR UNUSED pc = abuf->addr;
1539 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1540
1541 if (NESI (* FLD (i_sr), 0)) {
1542 {
1543 SI opval = MODSI (EXTHISI (TRUNCSIHI (* FLD (i_dr))), * FLD (i_sr));
1544 * FLD (i_dr) = opval;
1545 written |= (1 << 2);
1546 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1547 }
1548 }
1549
1550 abuf->written = written;
1551 #undef FLD
1552 }
1553 NEXT (vpc);
1554
1555 CASE (sem, INSN_REMUH) : /* remuh $dr,$sr */
1556 {
1557 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1558 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1559 #define FLD(f) abuf->fields.sfmt_add.f
1560 int UNUSED written = 0;
1561 IADDR UNUSED pc = abuf->addr;
1562 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1563
1564 if (NESI (* FLD (i_sr), 0)) {
1565 {
1566 SI opval = UMODSI (* FLD (i_dr), * FLD (i_sr));
1567 * FLD (i_dr) = opval;
1568 written |= (1 << 2);
1569 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1570 }
1571 }
1572
1573 abuf->written = written;
1574 #undef FLD
1575 }
1576 NEXT (vpc);
1577
1578 CASE (sem, INSN_REMB) : /* remb $dr,$sr */
1579 {
1580 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1581 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1582 #define FLD(f) abuf->fields.sfmt_add.f
1583 int UNUSED written = 0;
1584 IADDR UNUSED pc = abuf->addr;
1585 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1586
1587 if (NESI (* FLD (i_sr), 0)) {
1588 {
1589 SI opval = MODSI (EXTBISI (TRUNCSIBI (* FLD (i_dr))), * FLD (i_sr));
1590 * FLD (i_dr) = opval;
1591 written |= (1 << 2);
1592 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1593 }
1594 }
1595
1596 abuf->written = written;
1597 #undef FLD
1598 }
1599 NEXT (vpc);
1600
1601 CASE (sem, INSN_REMUB) : /* remub $dr,$sr */
1602 {
1603 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1604 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1605 #define FLD(f) abuf->fields.sfmt_add.f
1606 int UNUSED written = 0;
1607 IADDR UNUSED pc = abuf->addr;
1608 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1609
1610 if (NESI (* FLD (i_sr), 0)) {
1611 {
1612 SI opval = UMODSI (* FLD (i_dr), * FLD (i_sr));
1613 * FLD (i_dr) = opval;
1614 written |= (1 << 2);
1615 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1616 }
1617 }
1618
1619 abuf->written = written;
1620 #undef FLD
1621 }
1622 NEXT (vpc);
1623
1624 CASE (sem, INSN_DIVUH) : /* divuh $dr,$sr */
1625 {
1626 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1627 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1628 #define FLD(f) abuf->fields.sfmt_add.f
1629 int UNUSED written = 0;
1630 IADDR UNUSED pc = abuf->addr;
1631 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1632
1633 if (NESI (* FLD (i_sr), 0)) {
1634 {
1635 SI opval = UDIVSI (* FLD (i_dr), * FLD (i_sr));
1636 * FLD (i_dr) = opval;
1637 written |= (1 << 2);
1638 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1639 }
1640 }
1641
1642 abuf->written = written;
1643 #undef FLD
1644 }
1645 NEXT (vpc);
1646
1647 CASE (sem, INSN_DIVB) : /* divb $dr,$sr */
1648 {
1649 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1650 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1651 #define FLD(f) abuf->fields.sfmt_add.f
1652 int UNUSED written = 0;
1653 IADDR UNUSED pc = abuf->addr;
1654 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1655
1656 if (NESI (* FLD (i_sr), 0)) {
1657 {
1658 SI opval = DIVSI (EXTBISI (TRUNCSIBI (* FLD (i_dr))), * FLD (i_sr));
1659 * FLD (i_dr) = opval;
1660 written |= (1 << 2);
1661 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1662 }
1663 }
1664
1665 abuf->written = written;
1666 #undef FLD
1667 }
1668 NEXT (vpc);
1669
1670 CASE (sem, INSN_DIVUB) : /* divub $dr,$sr */
1671 {
1672 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1673 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1674 #define FLD(f) abuf->fields.sfmt_add.f
1675 int UNUSED written = 0;
1676 IADDR UNUSED pc = abuf->addr;
1677 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1678
1679 if (NESI (* FLD (i_sr), 0)) {
1680 {
1681 SI opval = UDIVSI (* FLD (i_dr), * FLD (i_sr));
1682 * FLD (i_dr) = opval;
1683 written |= (1 << 2);
1684 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1685 }
1686 }
1687
1688 abuf->written = written;
1689 #undef FLD
1690 }
1691 NEXT (vpc);
1692
1693 CASE (sem, INSN_DIVH) : /* divh $dr,$sr */
1694 {
1695 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1696 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1697 #define FLD(f) abuf->fields.sfmt_add.f
1698 int UNUSED written = 0;
1699 IADDR UNUSED pc = abuf->addr;
1700 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1701
1702 if (NESI (* FLD (i_sr), 0)) {
1703 {
1704 SI opval = DIVSI (EXTHISI (TRUNCSIHI (* FLD (i_dr))), * FLD (i_sr));
1705 * FLD (i_dr) = opval;
1706 written |= (1 << 2);
1707 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1708 }
1709 }
1710
1711 abuf->written = written;
1712 #undef FLD
1713 }
1714 NEXT (vpc);
1715
1716 CASE (sem, INSN_JC) : /* jc $sr */
1717 {
1718 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1719 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1720 #define FLD(f) abuf->fields.sfmt_jl.f
1721 int UNUSED written = 0;
1722 IADDR UNUSED pc = abuf->addr;
1723 SEM_BRANCH_INIT
1724 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1725
1726 if (CPU (h_cond)) {
1727 {
1728 USI opval = ANDSI (* FLD (i_sr), -4);
1729 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1730 written |= (1 << 2);
1731 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1732 }
1733 }
1734
1735 abuf->written = written;
1736 SEM_BRANCH_FINI (vpc);
1737 #undef FLD
1738 }
1739 NEXT (vpc);
1740
1741 CASE (sem, INSN_JNC) : /* jnc $sr */
1742 {
1743 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1744 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1745 #define FLD(f) abuf->fields.sfmt_jl.f
1746 int UNUSED written = 0;
1747 IADDR UNUSED pc = abuf->addr;
1748 SEM_BRANCH_INIT
1749 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1750
1751 if (NOTBI (CPU (h_cond))) {
1752 {
1753 USI opval = ANDSI (* FLD (i_sr), -4);
1754 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1755 written |= (1 << 2);
1756 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1757 }
1758 }
1759
1760 abuf->written = written;
1761 SEM_BRANCH_FINI (vpc);
1762 #undef FLD
1763 }
1764 NEXT (vpc);
1765
1766 CASE (sem, INSN_JL) : /* jl $sr */
1767 {
1768 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1769 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1770 #define FLD(f) abuf->fields.sfmt_jl.f
1771 int UNUSED written = 0;
1772 IADDR UNUSED pc = abuf->addr;
1773 SEM_BRANCH_INIT
1774 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1775
1776 {
1777 SI temp0;USI temp1;
1778 temp0 = ADDSI (ANDSI (pc, -4), 4);
1779 temp1 = ANDSI (* FLD (i_sr), -4);
1780 {
1781 SI opval = temp0;
1782 CPU (h_gr[((UINT) 14)]) = opval;
1783 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1784 }
1785 {
1786 USI opval = temp1;
1787 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1788 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1789 }
1790 }
1791
1792 SEM_BRANCH_FINI (vpc);
1793 #undef FLD
1794 }
1795 NEXT (vpc);
1796
1797 CASE (sem, INSN_JMP) : /* jmp $sr */
1798 {
1799 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1800 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1801 #define FLD(f) abuf->fields.sfmt_jl.f
1802 int UNUSED written = 0;
1803 IADDR UNUSED pc = abuf->addr;
1804 SEM_BRANCH_INIT
1805 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1806
1807 {
1808 USI opval = ANDSI (* FLD (i_sr), -4);
1809 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1810 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1811 }
1812
1813 SEM_BRANCH_FINI (vpc);
1814 #undef FLD
1815 }
1816 NEXT (vpc);
1817
1818 CASE (sem, INSN_LD) : /* ld $dr,@$sr */
1819 {
1820 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1821 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1822 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1823 int UNUSED written = 0;
1824 IADDR UNUSED pc = abuf->addr;
1825 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1826
1827 {
1828 SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
1829 * FLD (i_dr) = opval;
1830 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1831 }
1832
1833 #undef FLD
1834 }
1835 NEXT (vpc);
1836
1837 CASE (sem, INSN_LD_D) : /* ld $dr,@($slo16,$sr) */
1838 {
1839 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1840 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1841 #define FLD(f) abuf->fields.sfmt_add3.f
1842 int UNUSED written = 0;
1843 IADDR UNUSED pc = abuf->addr;
1844 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1845
1846 {
1847 SI opval = GETMEMSI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)));
1848 * FLD (i_dr) = opval;
1849 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1850 }
1851
1852 #undef FLD
1853 }
1854 NEXT (vpc);
1855
1856 CASE (sem, INSN_LDB) : /* ldb $dr,@$sr */
1857 {
1858 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1859 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1860 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1861 int UNUSED written = 0;
1862 IADDR UNUSED pc = abuf->addr;
1863 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1864
1865 {
1866 SI opval = EXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
1867 * FLD (i_dr) = opval;
1868 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1869 }
1870
1871 #undef FLD
1872 }
1873 NEXT (vpc);
1874
1875 CASE (sem, INSN_LDB_D) : /* ldb $dr,@($slo16,$sr) */
1876 {
1877 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1878 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1879 #define FLD(f) abuf->fields.sfmt_add3.f
1880 int UNUSED written = 0;
1881 IADDR UNUSED pc = abuf->addr;
1882 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1883
1884 {
1885 SI opval = EXTQISI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1886 * FLD (i_dr) = opval;
1887 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1888 }
1889
1890 #undef FLD
1891 }
1892 NEXT (vpc);
1893
1894 CASE (sem, INSN_LDH) : /* ldh $dr,@$sr */
1895 {
1896 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1897 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1898 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1899 int UNUSED written = 0;
1900 IADDR UNUSED pc = abuf->addr;
1901 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1902
1903 {
1904 SI opval = EXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
1905 * FLD (i_dr) = opval;
1906 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1907 }
1908
1909 #undef FLD
1910 }
1911 NEXT (vpc);
1912
1913 CASE (sem, INSN_LDH_D) : /* ldh $dr,@($slo16,$sr) */
1914 {
1915 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1916 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1917 #define FLD(f) abuf->fields.sfmt_add3.f
1918 int UNUSED written = 0;
1919 IADDR UNUSED pc = abuf->addr;
1920 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1921
1922 {
1923 SI opval = EXTHISI (GETMEMHI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1924 * FLD (i_dr) = opval;
1925 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1926 }
1927
1928 #undef FLD
1929 }
1930 NEXT (vpc);
1931
1932 CASE (sem, INSN_LDUB) : /* ldub $dr,@$sr */
1933 {
1934 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1935 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1936 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1937 int UNUSED written = 0;
1938 IADDR UNUSED pc = abuf->addr;
1939 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1940
1941 {
1942 SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
1943 * FLD (i_dr) = opval;
1944 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1945 }
1946
1947 #undef FLD
1948 }
1949 NEXT (vpc);
1950
1951 CASE (sem, INSN_LDUB_D) : /* ldub $dr,@($slo16,$sr) */
1952 {
1953 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1954 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1955 #define FLD(f) abuf->fields.sfmt_add3.f
1956 int UNUSED written = 0;
1957 IADDR UNUSED pc = abuf->addr;
1958 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1959
1960 {
1961 SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1962 * FLD (i_dr) = opval;
1963 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1964 }
1965
1966 #undef FLD
1967 }
1968 NEXT (vpc);
1969
1970 CASE (sem, INSN_LDUH) : /* lduh $dr,@$sr */
1971 {
1972 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1973 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1974 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1975 int UNUSED written = 0;
1976 IADDR UNUSED pc = abuf->addr;
1977 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1978
1979 {
1980 SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
1981 * FLD (i_dr) = opval;
1982 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1983 }
1984
1985 #undef FLD
1986 }
1987 NEXT (vpc);
1988
1989 CASE (sem, INSN_LDUH_D) : /* lduh $dr,@($slo16,$sr) */
1990 {
1991 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1992 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1993 #define FLD(f) abuf->fields.sfmt_add3.f
1994 int UNUSED written = 0;
1995 IADDR UNUSED pc = abuf->addr;
1996 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1997
1998 {
1999 SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
2000 * FLD (i_dr) = opval;
2001 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2002 }
2003
2004 #undef FLD
2005 }
2006 NEXT (vpc);
2007
2008 CASE (sem, INSN_LD_PLUS) : /* ld $dr,@$sr+ */
2009 {
2010 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2011 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2012 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2013 int UNUSED written = 0;
2014 IADDR UNUSED pc = abuf->addr;
2015 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2016
2017 {
2018 SI temp0;SI temp1;
2019 temp0 = GETMEMSI (current_cpu, pc, * FLD (i_sr));
2020 temp1 = ADDSI (* FLD (i_sr), 4);
2021 {
2022 SI opval = temp0;
2023 * FLD (i_dr) = opval;
2024 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2025 }
2026 {
2027 SI opval = temp1;
2028 * FLD (i_sr) = opval;
2029 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2030 }
2031 }
2032
2033 #undef FLD
2034 }
2035 NEXT (vpc);
2036
2037 CASE (sem, INSN_LD24) : /* ld24 $dr,$uimm24 */
2038 {
2039 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2040 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2041 #define FLD(f) abuf->fields.sfmt_ld24.f
2042 int UNUSED written = 0;
2043 IADDR UNUSED pc = abuf->addr;
2044 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2045
2046 {
2047 SI opval = FLD (i_uimm24);
2048 * FLD (i_dr) = opval;
2049 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2050 }
2051
2052 #undef FLD
2053 }
2054 NEXT (vpc);
2055
2056 CASE (sem, INSN_LDI8) : /* ldi8 $dr,$simm8 */
2057 {
2058 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2059 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2060 #define FLD(f) abuf->fields.sfmt_addi.f
2061 int UNUSED written = 0;
2062 IADDR UNUSED pc = abuf->addr;
2063 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2064
2065 {
2066 SI opval = FLD (f_simm8);
2067 * FLD (i_dr) = opval;
2068 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2069 }
2070
2071 #undef FLD
2072 }
2073 NEXT (vpc);
2074
2075 CASE (sem, INSN_LDI16) : /* ldi16 $dr,$hash$slo16 */
2076 {
2077 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2078 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2079 #define FLD(f) abuf->fields.sfmt_add3.f
2080 int UNUSED written = 0;
2081 IADDR UNUSED pc = abuf->addr;
2082 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2083
2084 {
2085 SI opval = FLD (f_simm16);
2086 * FLD (i_dr) = opval;
2087 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2088 }
2089
2090 #undef FLD
2091 }
2092 NEXT (vpc);
2093
2094 CASE (sem, INSN_LOCK) : /* lock $dr,@$sr */
2095 {
2096 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2097 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2098 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2099 int UNUSED written = 0;
2100 IADDR UNUSED pc = abuf->addr;
2101 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2102
2103 {
2104 {
2105 BI opval = 1;
2106 CPU (h_lock) = opval;
2107 TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
2108 }
2109 {
2110 SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
2111 * FLD (i_dr) = opval;
2112 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2113 }
2114 }
2115
2116 #undef FLD
2117 }
2118 NEXT (vpc);
2119
2120 CASE (sem, INSN_MACHI_A) : /* machi $src1,$src2,$acc */
2121 {
2122 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2123 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2124 #define FLD(f) abuf->fields.sfmt_machi_a.f
2125 int UNUSED written = 0;
2126 IADDR UNUSED pc = abuf->addr;
2127 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2128
2129 {
2130 DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))))), 8), 8);
2131 SET_H_ACCUMS (FLD (f_acc), opval);
2132 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2133 }
2134
2135 #undef FLD
2136 }
2137 NEXT (vpc);
2138
2139 CASE (sem, INSN_MACLO_A) : /* maclo $src1,$src2,$acc */
2140 {
2141 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2142 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2143 #define FLD(f) abuf->fields.sfmt_machi_a.f
2144 int UNUSED written = 0;
2145 IADDR UNUSED pc = abuf->addr;
2146 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2147
2148 {
2149 DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))))), 8), 8);
2150 SET_H_ACCUMS (FLD (f_acc), opval);
2151 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2152 }
2153
2154 #undef FLD
2155 }
2156 NEXT (vpc);
2157
2158 CASE (sem, INSN_MACWHI_A) : /* macwhi $src1,$src2,$acc */
2159 {
2160 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2161 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2162 #define FLD(f) abuf->fields.sfmt_machi_a.f
2163 int UNUSED written = 0;
2164 IADDR UNUSED pc = abuf->addr;
2165 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2166
2167 {
2168 DI opval = ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))));
2169 SET_H_ACCUMS (FLD (f_acc), opval);
2170 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2171 }
2172
2173 #undef FLD
2174 }
2175 NEXT (vpc);
2176
2177 CASE (sem, INSN_MACWLO_A) : /* macwlo $src1,$src2,$acc */
2178 {
2179 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2180 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2181 #define FLD(f) abuf->fields.sfmt_machi_a.f
2182 int UNUSED written = 0;
2183 IADDR UNUSED pc = abuf->addr;
2184 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2185
2186 {
2187 DI opval = ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))));
2188 SET_H_ACCUMS (FLD (f_acc), opval);
2189 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2190 }
2191
2192 #undef FLD
2193 }
2194 NEXT (vpc);
2195
2196 CASE (sem, INSN_MUL) : /* mul $dr,$sr */
2197 {
2198 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2199 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2200 #define FLD(f) abuf->fields.sfmt_add.f
2201 int UNUSED written = 0;
2202 IADDR UNUSED pc = abuf->addr;
2203 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2204
2205 {
2206 SI opval = MULSI (* FLD (i_dr), * FLD (i_sr));
2207 * FLD (i_dr) = opval;
2208 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2209 }
2210
2211 #undef FLD
2212 }
2213 NEXT (vpc);
2214
2215 CASE (sem, INSN_MULHI_A) : /* mulhi $src1,$src2,$acc */
2216 {
2217 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2218 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2219 #define FLD(f) abuf->fields.sfmt_machi_a.f
2220 int UNUSED written = 0;
2221 IADDR UNUSED pc = abuf->addr;
2222 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2223
2224 {
2225 DI opval = SRADI (SLLDI (MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))), 16), 16);
2226 SET_H_ACCUMS (FLD (f_acc), opval);
2227 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2228 }
2229
2230 #undef FLD
2231 }
2232 NEXT (vpc);
2233
2234 CASE (sem, INSN_MULLO_A) : /* mullo $src1,$src2,$acc */
2235 {
2236 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2237 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2238 #define FLD(f) abuf->fields.sfmt_machi_a.f
2239 int UNUSED written = 0;
2240 IADDR UNUSED pc = abuf->addr;
2241 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2242
2243 {
2244 DI opval = SRADI (SLLDI (MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 16), 16);
2245 SET_H_ACCUMS (FLD (f_acc), opval);
2246 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2247 }
2248
2249 #undef FLD
2250 }
2251 NEXT (vpc);
2252
2253 CASE (sem, INSN_MULWHI_A) : /* mulwhi $src1,$src2,$acc */
2254 {
2255 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2256 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2257 #define FLD(f) abuf->fields.sfmt_machi_a.f
2258 int UNUSED written = 0;
2259 IADDR UNUSED pc = abuf->addr;
2260 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2261
2262 {
2263 DI opval = MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))));
2264 SET_H_ACCUMS (FLD (f_acc), opval);
2265 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2266 }
2267
2268 #undef FLD
2269 }
2270 NEXT (vpc);
2271
2272 CASE (sem, INSN_MULWLO_A) : /* mulwlo $src1,$src2,$acc */
2273 {
2274 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2275 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2276 #define FLD(f) abuf->fields.sfmt_machi_a.f
2277 int UNUSED written = 0;
2278 IADDR UNUSED pc = abuf->addr;
2279 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2280
2281 {
2282 DI opval = MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))));
2283 SET_H_ACCUMS (FLD (f_acc), opval);
2284 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2285 }
2286
2287 #undef FLD
2288 }
2289 NEXT (vpc);
2290
2291 CASE (sem, INSN_MV) : /* mv $dr,$sr */
2292 {
2293 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2294 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2295 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2296 int UNUSED written = 0;
2297 IADDR UNUSED pc = abuf->addr;
2298 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2299
2300 {
2301 SI opval = * FLD (i_sr);
2302 * FLD (i_dr) = opval;
2303 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2304 }
2305
2306 #undef FLD
2307 }
2308 NEXT (vpc);
2309
2310 CASE (sem, INSN_MVFACHI_A) : /* mvfachi $dr,$accs */
2311 {
2312 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2313 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2314 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
2315 int UNUSED written = 0;
2316 IADDR UNUSED pc = abuf->addr;
2317 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2318
2319 {
2320 SI opval = TRUNCDISI (SRADI (GET_H_ACCUMS (FLD (f_accs)), 32));
2321 * FLD (i_dr) = opval;
2322 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2323 }
2324
2325 #undef FLD
2326 }
2327 NEXT (vpc);
2328
2329 CASE (sem, INSN_MVFACLO_A) : /* mvfaclo $dr,$accs */
2330 {
2331 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2332 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2333 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
2334 int UNUSED written = 0;
2335 IADDR UNUSED pc = abuf->addr;
2336 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2337
2338 {
2339 SI opval = TRUNCDISI (GET_H_ACCUMS (FLD (f_accs)));
2340 * FLD (i_dr) = opval;
2341 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2342 }
2343
2344 #undef FLD
2345 }
2346 NEXT (vpc);
2347
2348 CASE (sem, INSN_MVFACMI_A) : /* mvfacmi $dr,$accs */
2349 {
2350 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2351 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2352 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
2353 int UNUSED written = 0;
2354 IADDR UNUSED pc = abuf->addr;
2355 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2356
2357 {
2358 SI opval = TRUNCDISI (SRADI (GET_H_ACCUMS (FLD (f_accs)), 16));
2359 * FLD (i_dr) = opval;
2360 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2361 }
2362
2363 #undef FLD
2364 }
2365 NEXT (vpc);
2366
2367 CASE (sem, INSN_MVFC) : /* mvfc $dr,$scr */
2368 {
2369 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2370 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2371 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2372 int UNUSED written = 0;
2373 IADDR UNUSED pc = abuf->addr;
2374 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2375
2376 {
2377 SI opval = GET_H_CR (FLD (f_r2));
2378 * FLD (i_dr) = opval;
2379 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2380 }
2381
2382 #undef FLD
2383 }
2384 NEXT (vpc);
2385
2386 CASE (sem, INSN_MVTACHI_A) : /* mvtachi $src1,$accs */
2387 {
2388 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2389 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2390 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
2391 int UNUSED written = 0;
2392 IADDR UNUSED pc = abuf->addr;
2393 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2394
2395 {
2396 DI opval = ORDI (ANDDI (GET_H_ACCUMS (FLD (f_accs)), MAKEDI (0, 0xffffffff)), SLLDI (EXTSIDI (* FLD (i_src1)), 32));
2397 SET_H_ACCUMS (FLD (f_accs), opval);
2398 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2399 }
2400
2401 #undef FLD
2402 }
2403 NEXT (vpc);
2404
2405 CASE (sem, INSN_MVTACLO_A) : /* mvtaclo $src1,$accs */
2406 {
2407 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2408 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2409 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
2410 int UNUSED written = 0;
2411 IADDR UNUSED pc = abuf->addr;
2412 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2413
2414 {
2415 DI opval = ORDI (ANDDI (GET_H_ACCUMS (FLD (f_accs)), MAKEDI (0xffffffff, 0)), ZEXTSIDI (* FLD (i_src1)));
2416 SET_H_ACCUMS (FLD (f_accs), opval);
2417 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2418 }
2419
2420 #undef FLD
2421 }
2422 NEXT (vpc);
2423
2424 CASE (sem, INSN_MVTC) : /* mvtc $sr,$dcr */
2425 {
2426 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2427 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2428 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2429 int UNUSED written = 0;
2430 IADDR UNUSED pc = abuf->addr;
2431 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2432
2433 {
2434 USI opval = * FLD (i_sr);
2435 SET_H_CR (FLD (f_r1), opval);
2436 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
2437 }
2438
2439 #undef FLD
2440 }
2441 NEXT (vpc);
2442
2443 CASE (sem, INSN_NEG) : /* neg $dr,$sr */
2444 {
2445 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2446 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2447 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2448 int UNUSED written = 0;
2449 IADDR UNUSED pc = abuf->addr;
2450 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2451
2452 {
2453 SI opval = NEGSI (* FLD (i_sr));
2454 * FLD (i_dr) = opval;
2455 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2456 }
2457
2458 #undef FLD
2459 }
2460 NEXT (vpc);
2461
2462 CASE (sem, INSN_NOP) : /* nop */
2463 {
2464 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2465 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2466 #define FLD(f) abuf->fields.fmt_empty.f
2467 int UNUSED written = 0;
2468 IADDR UNUSED pc = abuf->addr;
2469 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2470
2471 PROFILE_COUNT_FILLNOPS (current_cpu, abuf->addr);
2472
2473 #undef FLD
2474 }
2475 NEXT (vpc);
2476
2477 CASE (sem, INSN_NOT) : /* not $dr,$sr */
2478 {
2479 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2480 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2481 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2482 int UNUSED written = 0;
2483 IADDR UNUSED pc = abuf->addr;
2484 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2485
2486 {
2487 SI opval = INVSI (* FLD (i_sr));
2488 * FLD (i_dr) = opval;
2489 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2490 }
2491
2492 #undef FLD
2493 }
2494 NEXT (vpc);
2495
2496 CASE (sem, INSN_RAC_DSI) : /* rac $accd,$accs,$imm1 */
2497 {
2498 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2499 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2500 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
2501 int UNUSED written = 0;
2502 IADDR UNUSED pc = abuf->addr;
2503 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2504
2505 {
2506 DI tmp_tmp1;
2507 tmp_tmp1 = SLLDI (GET_H_ACCUMS (FLD (f_accs)), FLD (f_imm1));
2508 tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
2509 {
2510 DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0xffff0000))) ? (MAKEDI (32767, 0xffff0000)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0xffff0000)));
2511 SET_H_ACCUMS (FLD (f_accd), opval);
2512 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2513 }
2514 }
2515
2516 #undef FLD
2517 }
2518 NEXT (vpc);
2519
2520 CASE (sem, INSN_RACH_DSI) : /* rach $accd,$accs,$imm1 */
2521 {
2522 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2523 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2524 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
2525 int UNUSED written = 0;
2526 IADDR UNUSED pc = abuf->addr;
2527 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2528
2529 {
2530 DI tmp_tmp1;
2531 tmp_tmp1 = SLLDI (GET_H_ACCUMS (FLD (f_accs)), FLD (f_imm1));
2532 tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 0x80000000));
2533 {
2534 DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0))) ? (MAKEDI (32767, 0)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0)));
2535 SET_H_ACCUMS (FLD (f_accd), opval);
2536 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2537 }
2538 }
2539
2540 #undef FLD
2541 }
2542 NEXT (vpc);
2543
2544 CASE (sem, INSN_RTE) : /* rte */
2545 {
2546 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2547 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2548 #define FLD(f) abuf->fields.fmt_empty.f
2549 int UNUSED written = 0;
2550 IADDR UNUSED pc = abuf->addr;
2551 SEM_BRANCH_INIT
2552 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2553
2554 {
2555 {
2556 USI opval = ANDSI (GET_H_CR (((UINT) 6)), -4);
2557 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
2558 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
2559 }
2560 {
2561 USI opval = GET_H_CR (((UINT) 14));
2562 SET_H_CR (((UINT) 6), opval);
2563 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
2564 }
2565 {
2566 UQI opval = CPU (h_bpsw);
2567 SET_H_PSW (opval);
2568 TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
2569 }
2570 {
2571 UQI opval = CPU (h_bbpsw);
2572 CPU (h_bpsw) = opval;
2573 TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
2574 }
2575 }
2576
2577 SEM_BRANCH_FINI (vpc);
2578 #undef FLD
2579 }
2580 NEXT (vpc);
2581
2582 CASE (sem, INSN_SETH) : /* seth $dr,$hash$hi16 */
2583 {
2584 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2585 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2586 #define FLD(f) abuf->fields.sfmt_seth.f
2587 int UNUSED written = 0;
2588 IADDR UNUSED pc = abuf->addr;
2589 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2590
2591 {
2592 SI opval = SLLSI (FLD (f_hi16), 16);
2593 * FLD (i_dr) = opval;
2594 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2595 }
2596
2597 #undef FLD
2598 }
2599 NEXT (vpc);
2600
2601 CASE (sem, INSN_SLL) : /* sll $dr,$sr */
2602 {
2603 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2604 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2605 #define FLD(f) abuf->fields.sfmt_add.f
2606 int UNUSED written = 0;
2607 IADDR UNUSED pc = abuf->addr;
2608 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2609
2610 {
2611 SI opval = SLLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2612 * FLD (i_dr) = opval;
2613 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2614 }
2615
2616 #undef FLD
2617 }
2618 NEXT (vpc);
2619
2620 CASE (sem, INSN_SLL3) : /* sll3 $dr,$sr,$simm16 */
2621 {
2622 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2623 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2624 #define FLD(f) abuf->fields.sfmt_add3.f
2625 int UNUSED written = 0;
2626 IADDR UNUSED pc = abuf->addr;
2627 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2628
2629 {
2630 SI opval = SLLSI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2631 * FLD (i_dr) = opval;
2632 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2633 }
2634
2635 #undef FLD
2636 }
2637 NEXT (vpc);
2638
2639 CASE (sem, INSN_SLLI) : /* slli $dr,$uimm5 */
2640 {
2641 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2642 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2643 #define FLD(f) abuf->fields.sfmt_slli.f
2644 int UNUSED written = 0;
2645 IADDR UNUSED pc = abuf->addr;
2646 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2647
2648 {
2649 SI opval = SLLSI (* FLD (i_dr), FLD (f_uimm5));
2650 * FLD (i_dr) = opval;
2651 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2652 }
2653
2654 #undef FLD
2655 }
2656 NEXT (vpc);
2657
2658 CASE (sem, INSN_SRA) : /* sra $dr,$sr */
2659 {
2660 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2661 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2662 #define FLD(f) abuf->fields.sfmt_add.f
2663 int UNUSED written = 0;
2664 IADDR UNUSED pc = abuf->addr;
2665 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2666
2667 {
2668 SI opval = SRASI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2669 * FLD (i_dr) = opval;
2670 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2671 }
2672
2673 #undef FLD
2674 }
2675 NEXT (vpc);
2676
2677 CASE (sem, INSN_SRA3) : /* sra3 $dr,$sr,$simm16 */
2678 {
2679 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2680 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2681 #define FLD(f) abuf->fields.sfmt_add3.f
2682 int UNUSED written = 0;
2683 IADDR UNUSED pc = abuf->addr;
2684 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2685
2686 {
2687 SI opval = SRASI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2688 * FLD (i_dr) = opval;
2689 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2690 }
2691
2692 #undef FLD
2693 }
2694 NEXT (vpc);
2695
2696 CASE (sem, INSN_SRAI) : /* srai $dr,$uimm5 */
2697 {
2698 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2699 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2700 #define FLD(f) abuf->fields.sfmt_slli.f
2701 int UNUSED written = 0;
2702 IADDR UNUSED pc = abuf->addr;
2703 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2704
2705 {
2706 SI opval = SRASI (* FLD (i_dr), FLD (f_uimm5));
2707 * FLD (i_dr) = opval;
2708 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2709 }
2710
2711 #undef FLD
2712 }
2713 NEXT (vpc);
2714
2715 CASE (sem, INSN_SRL) : /* srl $dr,$sr */
2716 {
2717 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2718 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2719 #define FLD(f) abuf->fields.sfmt_add.f
2720 int UNUSED written = 0;
2721 IADDR UNUSED pc = abuf->addr;
2722 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2723
2724 {
2725 SI opval = SRLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2726 * FLD (i_dr) = opval;
2727 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2728 }
2729
2730 #undef FLD
2731 }
2732 NEXT (vpc);
2733
2734 CASE (sem, INSN_SRL3) : /* srl3 $dr,$sr,$simm16 */
2735 {
2736 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2737 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2738 #define FLD(f) abuf->fields.sfmt_add3.f
2739 int UNUSED written = 0;
2740 IADDR UNUSED pc = abuf->addr;
2741 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2742
2743 {
2744 SI opval = SRLSI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2745 * FLD (i_dr) = opval;
2746 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2747 }
2748
2749 #undef FLD
2750 }
2751 NEXT (vpc);
2752
2753 CASE (sem, INSN_SRLI) : /* srli $dr,$uimm5 */
2754 {
2755 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2756 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2757 #define FLD(f) abuf->fields.sfmt_slli.f
2758 int UNUSED written = 0;
2759 IADDR UNUSED pc = abuf->addr;
2760 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2761
2762 {
2763 SI opval = SRLSI (* FLD (i_dr), FLD (f_uimm5));
2764 * FLD (i_dr) = opval;
2765 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2766 }
2767
2768 #undef FLD
2769 }
2770 NEXT (vpc);
2771
2772 CASE (sem, INSN_ST) : /* st $src1,@$src2 */
2773 {
2774 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2775 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2776 #define FLD(f) abuf->fields.sfmt_st_plus.f
2777 int UNUSED written = 0;
2778 IADDR UNUSED pc = abuf->addr;
2779 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2780
2781 {
2782 SI opval = * FLD (i_src1);
2783 SETMEMSI (current_cpu, pc, * FLD (i_src2), opval);
2784 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2785 }
2786
2787 #undef FLD
2788 }
2789 NEXT (vpc);
2790
2791 CASE (sem, INSN_ST_D) : /* st $src1,@($slo16,$src2) */
2792 {
2793 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2794 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2795 #define FLD(f) abuf->fields.sfmt_st_d.f
2796 int UNUSED written = 0;
2797 IADDR UNUSED pc = abuf->addr;
2798 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2799
2800 {
2801 SI opval = * FLD (i_src1);
2802 SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2803 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2804 }
2805
2806 #undef FLD
2807 }
2808 NEXT (vpc);
2809
2810 CASE (sem, INSN_STB) : /* stb $src1,@$src2 */
2811 {
2812 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2813 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2814 #define FLD(f) abuf->fields.sfmt_st_plus.f
2815 int UNUSED written = 0;
2816 IADDR UNUSED pc = abuf->addr;
2817 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2818
2819 {
2820 QI opval = * FLD (i_src1);
2821 SETMEMQI (current_cpu, pc, * FLD (i_src2), opval);
2822 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2823 }
2824
2825 #undef FLD
2826 }
2827 NEXT (vpc);
2828
2829 CASE (sem, INSN_STB_D) : /* stb $src1,@($slo16,$src2) */
2830 {
2831 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2832 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2833 #define FLD(f) abuf->fields.sfmt_st_d.f
2834 int UNUSED written = 0;
2835 IADDR UNUSED pc = abuf->addr;
2836 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2837
2838 {
2839 QI opval = * FLD (i_src1);
2840 SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2841 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2842 }
2843
2844 #undef FLD
2845 }
2846 NEXT (vpc);
2847
2848 CASE (sem, INSN_STH) : /* sth $src1,@$src2 */
2849 {
2850 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2851 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2852 #define FLD(f) abuf->fields.sfmt_st_plus.f
2853 int UNUSED written = 0;
2854 IADDR UNUSED pc = abuf->addr;
2855 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2856
2857 {
2858 HI opval = * FLD (i_src1);
2859 SETMEMHI (current_cpu, pc, * FLD (i_src2), opval);
2860 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2861 }
2862
2863 #undef FLD
2864 }
2865 NEXT (vpc);
2866
2867 CASE (sem, INSN_STH_D) : /* sth $src1,@($slo16,$src2) */
2868 {
2869 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2870 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2871 #define FLD(f) abuf->fields.sfmt_st_d.f
2872 int UNUSED written = 0;
2873 IADDR UNUSED pc = abuf->addr;
2874 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2875
2876 {
2877 HI opval = * FLD (i_src1);
2878 SETMEMHI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2879 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2880 }
2881
2882 #undef FLD
2883 }
2884 NEXT (vpc);
2885
2886 CASE (sem, INSN_ST_PLUS) : /* st $src1,@+$src2 */
2887 {
2888 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2889 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2890 #define FLD(f) abuf->fields.sfmt_st_plus.f
2891 int UNUSED written = 0;
2892 IADDR UNUSED pc = abuf->addr;
2893 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2894
2895 {
2896 SI tmp_new_src2;
2897 tmp_new_src2 = ADDSI (* FLD (i_src2), 4);
2898 {
2899 SI opval = * FLD (i_src1);
2900 SETMEMSI (current_cpu, pc, tmp_new_src2, opval);
2901 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2902 }
2903 {
2904 SI opval = tmp_new_src2;
2905 * FLD (i_src2) = opval;
2906 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2907 }
2908 }
2909
2910 #undef FLD
2911 }
2912 NEXT (vpc);
2913
2914 CASE (sem, INSN_STH_PLUS) : /* sth $src1,@$src2+ */
2915 {
2916 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2917 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2918 #define FLD(f) abuf->fields.sfmt_st_plus.f
2919 int UNUSED written = 0;
2920 IADDR UNUSED pc = abuf->addr;
2921 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2922
2923 {
2924 HI tmp_new_src2;
2925 {
2926 HI opval = * FLD (i_src1);
2927 SETMEMHI (current_cpu, pc, tmp_new_src2, opval);
2928 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2929 }
2930 tmp_new_src2 = ADDSI (* FLD (i_src2), 2);
2931 {
2932 SI opval = tmp_new_src2;
2933 * FLD (i_src2) = opval;
2934 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2935 }
2936 }
2937
2938 #undef FLD
2939 }
2940 NEXT (vpc);
2941
2942 CASE (sem, INSN_STB_PLUS) : /* stb $src1,@$src2+ */
2943 {
2944 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2945 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2946 #define FLD(f) abuf->fields.sfmt_st_plus.f
2947 int UNUSED written = 0;
2948 IADDR UNUSED pc = abuf->addr;
2949 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2950
2951 {
2952 QI tmp_new_src2;
2953 {
2954 QI opval = * FLD (i_src1);
2955 SETMEMQI (current_cpu, pc, tmp_new_src2, opval);
2956 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2957 }
2958 tmp_new_src2 = ADDSI (* FLD (i_src2), 1);
2959 {
2960 SI opval = tmp_new_src2;
2961 * FLD (i_src2) = opval;
2962 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2963 }
2964 }
2965
2966 #undef FLD
2967 }
2968 NEXT (vpc);
2969
2970 CASE (sem, INSN_ST_MINUS) : /* st $src1,@-$src2 */
2971 {
2972 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2973 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2974 #define FLD(f) abuf->fields.sfmt_st_plus.f
2975 int UNUSED written = 0;
2976 IADDR UNUSED pc = abuf->addr;
2977 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2978
2979 {
2980 SI tmp_new_src2;
2981 tmp_new_src2 = SUBSI (* FLD (i_src2), 4);
2982 {
2983 SI opval = * FLD (i_src1);
2984 SETMEMSI (current_cpu, pc, tmp_new_src2, opval);
2985 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2986 }
2987 {
2988 SI opval = tmp_new_src2;
2989 * FLD (i_src2) = opval;
2990 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2991 }
2992 }
2993
2994 #undef FLD
2995 }
2996 NEXT (vpc);
2997
2998 CASE (sem, INSN_SUB) : /* sub $dr,$sr */
2999 {
3000 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3001 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3002 #define FLD(f) abuf->fields.sfmt_add.f
3003 int UNUSED written = 0;
3004 IADDR UNUSED pc = abuf->addr;
3005 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3006
3007 {
3008 SI opval = SUBSI (* FLD (i_dr), * FLD (i_sr));
3009 * FLD (i_dr) = opval;
3010 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3011 }
3012
3013 #undef FLD
3014 }
3015 NEXT (vpc);
3016
3017 CASE (sem, INSN_SUBV) : /* subv $dr,$sr */
3018 {
3019 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3020 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3021 #define FLD(f) abuf->fields.sfmt_add.f
3022 int UNUSED written = 0;
3023 IADDR UNUSED pc = abuf->addr;
3024 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3025
3026 {
3027 SI temp0;BI temp1;
3028 temp0 = SUBSI (* FLD (i_dr), * FLD (i_sr));
3029 temp1 = SUBOFSI (* FLD (i_dr), * FLD (i_sr), 0);
3030 {
3031 SI opval = temp0;
3032 * FLD (i_dr) = opval;
3033 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3034 }
3035 {
3036 BI opval = temp1;
3037 CPU (h_cond) = opval;
3038 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3039 }
3040 }
3041
3042 #undef FLD
3043 }
3044 NEXT (vpc);
3045
3046 CASE (sem, INSN_SUBX) : /* subx $dr,$sr */
3047 {
3048 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3049 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3050 #define FLD(f) abuf->fields.sfmt_add.f
3051 int UNUSED written = 0;
3052 IADDR UNUSED pc = abuf->addr;
3053 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3054
3055 {
3056 SI temp0;BI temp1;
3057 temp0 = SUBCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
3058 temp1 = SUBCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
3059 {
3060 SI opval = temp0;
3061 * FLD (i_dr) = opval;
3062 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3063 }
3064 {
3065 BI opval = temp1;
3066 CPU (h_cond) = opval;
3067 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3068 }
3069 }
3070
3071 #undef FLD
3072 }
3073 NEXT (vpc);
3074
3075 CASE (sem, INSN_TRAP) : /* trap $uimm4 */
3076 {
3077 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3078 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3079 #define FLD(f) abuf->fields.sfmt_trap.f
3080 int UNUSED written = 0;
3081 IADDR UNUSED pc = abuf->addr;
3082 SEM_BRANCH_INIT
3083 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3084
3085 {
3086 {
3087 USI opval = GET_H_CR (((UINT) 6));
3088 SET_H_CR (((UINT) 14), opval);
3089 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
3090 }
3091 {
3092 USI opval = ADDSI (pc, 4);
3093 SET_H_CR (((UINT) 6), opval);
3094 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
3095 }
3096 {
3097 UQI opval = CPU (h_bpsw);
3098 CPU (h_bbpsw) = opval;
3099 TRACE_RESULT (current_cpu, abuf, "bbpsw", 'x', opval);
3100 }
3101 {
3102 UQI opval = GET_H_PSW ();
3103 CPU (h_bpsw) = opval;
3104 TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
3105 }
3106 {
3107 UQI opval = ANDQI (GET_H_PSW (), 128);
3108 SET_H_PSW (opval);
3109 TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
3110 }
3111 {
3112 SI opval = m32r_trap (current_cpu, pc, FLD (f_uimm4));
3113 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3114 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3115 }
3116 }
3117
3118 SEM_BRANCH_FINI (vpc);
3119 #undef FLD
3120 }
3121 NEXT (vpc);
3122
3123 CASE (sem, INSN_UNLOCK) : /* unlock $src1,@$src2 */
3124 {
3125 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3126 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3127 #define FLD(f) abuf->fields.sfmt_st_plus.f
3128 int UNUSED written = 0;
3129 IADDR UNUSED pc = abuf->addr;
3130 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3131
3132 {
3133 if (CPU (h_lock)) {
3134 {
3135 SI opval = * FLD (i_src1);
3136 SETMEMSI (current_cpu, pc, * FLD (i_src2), opval);
3137 written |= (1 << 4);
3138 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3139 }
3140 }
3141 {
3142 BI opval = 0;
3143 CPU (h_lock) = opval;
3144 TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
3145 }
3146 }
3147
3148 abuf->written = written;
3149 #undef FLD
3150 }
3151 NEXT (vpc);
3152
3153 CASE (sem, INSN_SATB) : /* satb $dr,$sr */
3154 {
3155 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3156 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3157 #define FLD(f) abuf->fields.sfmt_ld_plus.f
3158 int UNUSED written = 0;
3159 IADDR UNUSED pc = abuf->addr;
3160 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3161
3162 {
3163 SI opval = (GESI (* FLD (i_sr), 127)) ? (127) : (LESI (* FLD (i_sr), -128)) ? (-128) : (* FLD (i_sr));
3164 * FLD (i_dr) = opval;
3165 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3166 }
3167
3168 #undef FLD
3169 }
3170 NEXT (vpc);
3171
3172 CASE (sem, INSN_SATH) : /* sath $dr,$sr */
3173 {
3174 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3175 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3176 #define FLD(f) abuf->fields.sfmt_ld_plus.f
3177 int UNUSED written = 0;
3178 IADDR UNUSED pc = abuf->addr;
3179 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3180
3181 {
3182 SI opval = (GESI (* FLD (i_sr), 32767)) ? (32767) : (LESI (* FLD (i_sr), -32768)) ? (-32768) : (* FLD (i_sr));
3183 * FLD (i_dr) = opval;
3184 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3185 }
3186
3187 #undef FLD
3188 }
3189 NEXT (vpc);
3190
3191 CASE (sem, INSN_SAT) : /* sat $dr,$sr */
3192 {
3193 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3194 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3195 #define FLD(f) abuf->fields.sfmt_ld_plus.f
3196 int UNUSED written = 0;
3197 IADDR UNUSED pc = abuf->addr;
3198 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3199
3200 {
3201 SI opval = ((CPU (h_cond)) ? (((LTSI (* FLD (i_sr), 0)) ? (2147483647) : (0x80000000))) : (* FLD (i_sr)));
3202 * FLD (i_dr) = opval;
3203 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3204 }
3205
3206 #undef FLD
3207 }
3208 NEXT (vpc);
3209
3210 CASE (sem, INSN_PCMPBZ) : /* pcmpbz $src2 */
3211 {
3212 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3213 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3214 #define FLD(f) abuf->fields.sfmt_st_plus.f
3215 int UNUSED written = 0;
3216 IADDR UNUSED pc = abuf->addr;
3217 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3218
3219 {
3220 BI opval = (EQSI (ANDSI (* FLD (i_src2), 255), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 65280), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 16711680), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 0xff000000), 0)) ? (1) : (0);
3221 CPU (h_cond) = opval;
3222 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3223 }
3224
3225 #undef FLD
3226 }
3227 NEXT (vpc);
3228
3229 CASE (sem, INSN_SADD) : /* sadd */
3230 {
3231 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3232 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3233 #define FLD(f) abuf->fields.fmt_empty.f
3234 int UNUSED written = 0;
3235 IADDR UNUSED pc = abuf->addr;
3236 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3237
3238 {
3239 DI opval = ADDDI (SRADI (GET_H_ACCUMS (((UINT) 1)), 16), GET_H_ACCUMS (((UINT) 0)));
3240 SET_H_ACCUMS (((UINT) 0), opval);
3241 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
3242 }
3243
3244 #undef FLD
3245 }
3246 NEXT (vpc);
3247
3248 CASE (sem, INSN_MACWU1) : /* macwu1 $src1,$src2 */
3249 {
3250 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3251 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3252 #define FLD(f) abuf->fields.sfmt_st_plus.f
3253 int UNUSED written = 0;
3254 IADDR UNUSED pc = abuf->addr;
3255 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3256
3257 {
3258 DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (((UINT) 1)), MULDI (EXTSIDI (* FLD (i_src1)), EXTSIDI (ANDSI (* FLD (i_src2), 65535)))), 8), 8);
3259 SET_H_ACCUMS (((UINT) 1), opval);
3260 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
3261 }
3262
3263 #undef FLD
3264 }
3265 NEXT (vpc);
3266
3267 CASE (sem, INSN_MSBLO) : /* msblo $src1,$src2 */
3268 {
3269 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3270 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3271 #define FLD(f) abuf->fields.sfmt_st_plus.f
3272 int UNUSED written = 0;
3273 IADDR UNUSED pc = abuf->addr;
3274 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3275
3276 {
3277 DI opval = SRADI (SLLDI (SUBDI (GET_H_ACCUM (), SRADI (SLLDI (MULDI (EXTHIDI (TRUNCSIHI (* FLD (i_src1))), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 32), 16)), 8), 8);
3278 SET_H_ACCUM (opval);
3279 TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
3280 }
3281
3282 #undef FLD
3283 }
3284 NEXT (vpc);
3285
3286 CASE (sem, INSN_MULWU1) : /* mulwu1 $src1,$src2 */
3287 {
3288 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3289 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3290 #define FLD(f) abuf->fields.sfmt_st_plus.f
3291 int UNUSED written = 0;
3292 IADDR UNUSED pc = abuf->addr;
3293 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3294
3295 {
3296 DI opval = SRADI (SLLDI (MULDI (EXTSIDI (* FLD (i_src1)), EXTSIDI (ANDSI (* FLD (i_src2), 65535))), 16), 16);
3297 SET_H_ACCUMS (((UINT) 1), opval);
3298 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
3299 }
3300
3301 #undef FLD
3302 }
3303 NEXT (vpc);
3304
3305 CASE (sem, INSN_MACLH1) : /* maclh1 $src1,$src2 */
3306 {
3307 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3308 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3309 #define FLD(f) abuf->fields.sfmt_st_plus.f
3310 int UNUSED written = 0;
3311 IADDR UNUSED pc = abuf->addr;
3312 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3313
3314 {
3315 DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (((UINT) 1)), SLLDI (EXTSIDI (MULSI (EXTHISI (TRUNCSIHI (* FLD (i_src1))), SRASI (* FLD (i_src2), 16))), 16)), 8), 8);
3316 SET_H_ACCUMS (((UINT) 1), opval);
3317 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
3318 }
3319
3320 #undef FLD
3321 }
3322 NEXT (vpc);
3323
3324 CASE (sem, INSN_SC) : /* sc */
3325 {
3326 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3327 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3328 #define FLD(f) abuf->fields.fmt_empty.f
3329 int UNUSED written = 0;
3330 IADDR UNUSED pc = abuf->addr;
3331 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3332
3333 if (ZEXTBISI (CPU (h_cond)))
3334 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
3335
3336 #undef FLD
3337 }
3338 NEXT (vpc);
3339
3340 CASE (sem, INSN_SNC) : /* snc */
3341 {
3342 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3343 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3344 #define FLD(f) abuf->fields.fmt_empty.f
3345 int UNUSED written = 0;
3346 IADDR UNUSED pc = abuf->addr;
3347 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3348
3349 if (ZEXTBISI (NOTBI (CPU (h_cond))))
3350 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
3351
3352 #undef FLD
3353 }
3354 NEXT (vpc);
3355
3356 CASE (sem, INSN_CLRPSW) : /* clrpsw $uimm8 */
3357 {
3358 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3359 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3360 #define FLD(f) abuf->fields.sfmt_clrpsw.f
3361 int UNUSED written = 0;
3362 IADDR UNUSED pc = abuf->addr;
3363 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3364
3365 {
3366 SI opval = ANDSI (GET_H_CR (((UINT) 0)), ORSI (INVBI (FLD (f_uimm8)), 65280));
3367 SET_H_CR (((UINT) 0), opval);
3368 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
3369 }
3370
3371 #undef FLD
3372 }
3373 NEXT (vpc);
3374
3375 CASE (sem, INSN_SETPSW) : /* setpsw $uimm8 */
3376 {
3377 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3378 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3379 #define FLD(f) abuf->fields.sfmt_clrpsw.f
3380 int UNUSED written = 0;
3381 IADDR UNUSED pc = abuf->addr;
3382 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3383
3384 {
3385 SI opval = FLD (f_uimm8);
3386 SET_H_CR (((UINT) 0), opval);
3387 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
3388 }
3389
3390 #undef FLD
3391 }
3392 NEXT (vpc);
3393
3394 CASE (sem, INSN_BSET) : /* bset $uimm3,@($slo16,$sr) */
3395 {
3396 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3397 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3398 #define FLD(f) abuf->fields.sfmt_bset.f
3399 int UNUSED written = 0;
3400 IADDR UNUSED pc = abuf->addr;
3401 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3402
3403 {
3404 QI opval = ORQI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))), SLLSI (1, SUBSI (7, FLD (f_uimm3))));
3405 SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)), opval);
3406 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3407 }
3408
3409 #undef FLD
3410 }
3411 NEXT (vpc);
3412
3413 CASE (sem, INSN_BCLR) : /* bclr $uimm3,@($slo16,$sr) */
3414 {
3415 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3416 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3417 #define FLD(f) abuf->fields.sfmt_bset.f
3418 int UNUSED written = 0;
3419 IADDR UNUSED pc = abuf->addr;
3420 vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3421
3422 {
3423 QI opval = ANDQI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))), INVQI (SLLSI (1, SUBSI (7, FLD (f_uimm3)))));
3424 SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)), opval);
3425 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3426 }
3427
3428 #undef FLD
3429 }
3430 NEXT (vpc);
3431
3432 CASE (sem, INSN_BTST) : /* btst $uimm3,$sr */
3433 {
3434 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3435 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3436 #define FLD(f) abuf->fields.sfmt_bset.f
3437 int UNUSED written = 0;
3438 IADDR UNUSED pc = abuf->addr;
3439 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3440
3441 {
3442 BI opval = ANDQI (SRLSI (* FLD (i_sr), SUBSI (7, FLD (f_uimm3))), 1);
3443 CPU (h_cond) = opval;
3444 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3445 }
3446
3447 #undef FLD
3448 }
3449 NEXT (vpc);
3450
3451 CASE (sem, INSN_PAR_ADD) : /* add $dr,$sr */
3452 {
3453 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3454 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3455 #define FLD(f) abuf->fields.sfmt_add.f
3456 #define OPRND(f) par_exec->operands.sfmt_add.f
3457 int UNUSED written = 0;
3458 IADDR UNUSED pc = abuf->addr;
3459 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3460
3461 {
3462 SI opval = ADDSI (* FLD (i_dr), * FLD (i_sr));
3463 OPRND (dr) = opval;
3464 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3465 }
3466
3467 #undef OPRND
3468 #undef FLD
3469 }
3470 NEXT (vpc);
3471
3472 CASE (sem, INSN_WRITE_ADD) : /* add $dr,$sr */
3473 {
3474 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3475 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3476 #define FLD(f) abuf->fields.sfmt_add.f
3477 #define OPRND(f) par_exec->operands.sfmt_add.f
3478 int UNUSED written = abuf->written;
3479 IADDR UNUSED pc = abuf->addr;
3480 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3481
3482 * FLD (i_dr) = OPRND (dr);
3483
3484 #undef OPRND
3485 #undef FLD
3486 }
3487 NEXT (vpc);
3488
3489 CASE (sem, INSN_PAR_AND) : /* and $dr,$sr */
3490 {
3491 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3492 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3493 #define FLD(f) abuf->fields.sfmt_add.f
3494 #define OPRND(f) par_exec->operands.sfmt_add.f
3495 int UNUSED written = 0;
3496 IADDR UNUSED pc = abuf->addr;
3497 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3498
3499 {
3500 SI opval = ANDSI (* FLD (i_dr), * FLD (i_sr));
3501 OPRND (dr) = opval;
3502 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3503 }
3504
3505 #undef OPRND
3506 #undef FLD
3507 }
3508 NEXT (vpc);
3509
3510 CASE (sem, INSN_WRITE_AND) : /* and $dr,$sr */
3511 {
3512 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3513 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3514 #define FLD(f) abuf->fields.sfmt_add.f
3515 #define OPRND(f) par_exec->operands.sfmt_add.f
3516 int UNUSED written = abuf->written;
3517 IADDR UNUSED pc = abuf->addr;
3518 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3519
3520 * FLD (i_dr) = OPRND (dr);
3521
3522 #undef OPRND
3523 #undef FLD
3524 }
3525 NEXT (vpc);
3526
3527 CASE (sem, INSN_PAR_OR) : /* or $dr,$sr */
3528 {
3529 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3530 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3531 #define FLD(f) abuf->fields.sfmt_add.f
3532 #define OPRND(f) par_exec->operands.sfmt_add.f
3533 int UNUSED written = 0;
3534 IADDR UNUSED pc = abuf->addr;
3535 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3536
3537 {
3538 SI opval = ORSI (* FLD (i_dr), * FLD (i_sr));
3539 OPRND (dr) = opval;
3540 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3541 }
3542
3543 #undef OPRND
3544 #undef FLD
3545 }
3546 NEXT (vpc);
3547
3548 CASE (sem, INSN_WRITE_OR) : /* or $dr,$sr */
3549 {
3550 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3551 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3552 #define FLD(f) abuf->fields.sfmt_add.f
3553 #define OPRND(f) par_exec->operands.sfmt_add.f
3554 int UNUSED written = abuf->written;
3555 IADDR UNUSED pc = abuf->addr;
3556 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3557
3558 * FLD (i_dr) = OPRND (dr);
3559
3560 #undef OPRND
3561 #undef FLD
3562 }
3563 NEXT (vpc);
3564
3565 CASE (sem, INSN_PAR_XOR) : /* xor $dr,$sr */
3566 {
3567 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3568 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3569 #define FLD(f) abuf->fields.sfmt_add.f
3570 #define OPRND(f) par_exec->operands.sfmt_add.f
3571 int UNUSED written = 0;
3572 IADDR UNUSED pc = abuf->addr;
3573 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3574
3575 {
3576 SI opval = XORSI (* FLD (i_dr), * FLD (i_sr));
3577 OPRND (dr) = opval;
3578 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3579 }
3580
3581 #undef OPRND
3582 #undef FLD
3583 }
3584 NEXT (vpc);
3585
3586 CASE (sem, INSN_WRITE_XOR) : /* xor $dr,$sr */
3587 {
3588 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3589 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3590 #define FLD(f) abuf->fields.sfmt_add.f
3591 #define OPRND(f) par_exec->operands.sfmt_add.f
3592 int UNUSED written = abuf->written;
3593 IADDR UNUSED pc = abuf->addr;
3594 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3595
3596 * FLD (i_dr) = OPRND (dr);
3597
3598 #undef OPRND
3599 #undef FLD
3600 }
3601 NEXT (vpc);
3602
3603 CASE (sem, INSN_PAR_ADDI) : /* addi $dr,$simm8 */
3604 {
3605 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3606 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3607 #define FLD(f) abuf->fields.sfmt_addi.f
3608 #define OPRND(f) par_exec->operands.sfmt_addi.f
3609 int UNUSED written = 0;
3610 IADDR UNUSED pc = abuf->addr;
3611 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3612
3613 {
3614 SI opval = ADDSI (* FLD (i_dr), FLD (f_simm8));
3615 OPRND (dr) = opval;
3616 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3617 }
3618
3619 #undef OPRND
3620 #undef FLD
3621 }
3622 NEXT (vpc);
3623
3624 CASE (sem, INSN_WRITE_ADDI) : /* addi $dr,$simm8 */
3625 {
3626 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3627 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3628 #define FLD(f) abuf->fields.sfmt_addi.f
3629 #define OPRND(f) par_exec->operands.sfmt_addi.f
3630 int UNUSED written = abuf->written;
3631 IADDR UNUSED pc = abuf->addr;
3632 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3633
3634 * FLD (i_dr) = OPRND (dr);
3635
3636 #undef OPRND
3637 #undef FLD
3638 }
3639 NEXT (vpc);
3640
3641 CASE (sem, INSN_PAR_ADDV) : /* addv $dr,$sr */
3642 {
3643 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3644 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3645 #define FLD(f) abuf->fields.sfmt_add.f
3646 #define OPRND(f) par_exec->operands.sfmt_addv.f
3647 int UNUSED written = 0;
3648 IADDR UNUSED pc = abuf->addr;
3649 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3650
3651 {
3652 SI temp0;BI temp1;
3653 temp0 = ADDSI (* FLD (i_dr), * FLD (i_sr));
3654 temp1 = ADDOFSI (* FLD (i_dr), * FLD (i_sr), 0);
3655 {
3656 SI opval = temp0;
3657 OPRND (dr) = opval;
3658 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3659 }
3660 {
3661 BI opval = temp1;
3662 OPRND (condbit) = opval;
3663 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3664 }
3665 }
3666
3667 #undef OPRND
3668 #undef FLD
3669 }
3670 NEXT (vpc);
3671
3672 CASE (sem, INSN_WRITE_ADDV) : /* addv $dr,$sr */
3673 {
3674 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3675 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3676 #define FLD(f) abuf->fields.sfmt_add.f
3677 #define OPRND(f) par_exec->operands.sfmt_addv.f
3678 int UNUSED written = abuf->written;
3679 IADDR UNUSED pc = abuf->addr;
3680 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3681
3682 CPU (h_cond) = OPRND (condbit);
3683 * FLD (i_dr) = OPRND (dr);
3684
3685 #undef OPRND
3686 #undef FLD
3687 }
3688 NEXT (vpc);
3689
3690 CASE (sem, INSN_PAR_ADDX) : /* addx $dr,$sr */
3691 {
3692 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3693 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3694 #define FLD(f) abuf->fields.sfmt_add.f
3695 #define OPRND(f) par_exec->operands.sfmt_addx.f
3696 int UNUSED written = 0;
3697 IADDR UNUSED pc = abuf->addr;
3698 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3699
3700 {
3701 SI temp0;BI temp1;
3702 temp0 = ADDCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
3703 temp1 = ADDCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
3704 {
3705 SI opval = temp0;
3706 OPRND (dr) = opval;
3707 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3708 }
3709 {
3710 BI opval = temp1;
3711 OPRND (condbit) = opval;
3712 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3713 }
3714 }
3715
3716 #undef OPRND
3717 #undef FLD
3718 }
3719 NEXT (vpc);
3720
3721 CASE (sem, INSN_WRITE_ADDX) : /* addx $dr,$sr */
3722 {
3723 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3724 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3725 #define FLD(f) abuf->fields.sfmt_add.f
3726 #define OPRND(f) par_exec->operands.sfmt_addx.f
3727 int UNUSED written = abuf->written;
3728 IADDR UNUSED pc = abuf->addr;
3729 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3730
3731 CPU (h_cond) = OPRND (condbit);
3732 * FLD (i_dr) = OPRND (dr);
3733
3734 #undef OPRND
3735 #undef FLD
3736 }
3737 NEXT (vpc);
3738
3739 CASE (sem, INSN_PAR_BC8) : /* bc.s $disp8 */
3740 {
3741 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3742 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3743 #define FLD(f) abuf->fields.sfmt_bl8.f
3744 #define OPRND(f) par_exec->operands.sfmt_bc8.f
3745 int UNUSED written = 0;
3746 IADDR UNUSED pc = abuf->addr;
3747 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3748
3749 if (CPU (h_cond)) {
3750 {
3751 USI opval = FLD (i_disp8);
3752 OPRND (pc) = opval;
3753 written |= (1 << 2);
3754 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3755 }
3756 }
3757
3758 abuf->written = written;
3759 #undef OPRND
3760 #undef FLD
3761 }
3762 NEXT (vpc);
3763
3764 CASE (sem, INSN_WRITE_BC8) : /* bc.s $disp8 */
3765 {
3766 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3767 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3768 #define FLD(f) abuf->fields.sfmt_bl8.f
3769 #define OPRND(f) par_exec->operands.sfmt_bc8.f
3770 int UNUSED written = abuf->written;
3771 IADDR UNUSED pc = abuf->addr;
3772 SEM_BRANCH_INIT
3773 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3774
3775 if (written & (1 << 2))
3776 {
3777 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3778 }
3779
3780 SEM_BRANCH_FINI (vpc);
3781 #undef OPRND
3782 #undef FLD
3783 }
3784 NEXT (vpc);
3785
3786 CASE (sem, INSN_PAR_BL8) : /* bl.s $disp8 */
3787 {
3788 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3789 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3790 #define FLD(f) abuf->fields.sfmt_bl8.f
3791 #define OPRND(f) par_exec->operands.sfmt_bl8.f
3792 int UNUSED written = 0;
3793 IADDR UNUSED pc = abuf->addr;
3794 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3795
3796 {
3797 {
3798 SI opval = ADDSI (ANDSI (pc, -4), 4);
3799 OPRND (h_gr_SI_14) = opval;
3800 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3801 }
3802 {
3803 USI opval = FLD (i_disp8);
3804 OPRND (pc) = opval;
3805 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3806 }
3807 }
3808
3809 #undef OPRND
3810 #undef FLD
3811 }
3812 NEXT (vpc);
3813
3814 CASE (sem, INSN_WRITE_BL8) : /* bl.s $disp8 */
3815 {
3816 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3817 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3818 #define FLD(f) abuf->fields.sfmt_bl8.f
3819 #define OPRND(f) par_exec->operands.sfmt_bl8.f
3820 int UNUSED written = abuf->written;
3821 IADDR UNUSED pc = abuf->addr;
3822 SEM_BRANCH_INIT
3823 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3824
3825 CPU (h_gr[((UINT) 14)]) = OPRND (h_gr_SI_14);
3826 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3827
3828 SEM_BRANCH_FINI (vpc);
3829 #undef OPRND
3830 #undef FLD
3831 }
3832 NEXT (vpc);
3833
3834 CASE (sem, INSN_PAR_BCL8) : /* bcl.s $disp8 */
3835 {
3836 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3837 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3838 #define FLD(f) abuf->fields.sfmt_bl8.f
3839 #define OPRND(f) par_exec->operands.sfmt_bcl8.f
3840 int UNUSED written = 0;
3841 IADDR UNUSED pc = abuf->addr;
3842 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3843
3844 if (CPU (h_cond)) {
3845 {
3846 {
3847 SI opval = ADDSI (ANDSI (pc, -4), 4);
3848 OPRND (h_gr_SI_14) = opval;
3849 written |= (1 << 3);
3850 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3851 }
3852 {
3853 USI opval = FLD (i_disp8);
3854 OPRND (pc) = opval;
3855 written |= (1 << 4);
3856 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3857 }
3858 }
3859 }
3860
3861 abuf->written = written;
3862 #undef OPRND
3863 #undef FLD
3864 }
3865 NEXT (vpc);
3866
3867 CASE (sem, INSN_WRITE_BCL8) : /* bcl.s $disp8 */
3868 {
3869 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3870 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3871 #define FLD(f) abuf->fields.sfmt_bl8.f
3872 #define OPRND(f) par_exec->operands.sfmt_bcl8.f
3873 int UNUSED written = abuf->written;
3874 IADDR UNUSED pc = abuf->addr;
3875 SEM_BRANCH_INIT
3876 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3877
3878 if (written & (1 << 3))
3879 {
3880 CPU (h_gr[((UINT) 14)]) = OPRND (h_gr_SI_14);
3881 }
3882 if (written & (1 << 4))
3883 {
3884 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3885 }
3886
3887 SEM_BRANCH_FINI (vpc);
3888 #undef OPRND
3889 #undef FLD
3890 }
3891 NEXT (vpc);
3892
3893 CASE (sem, INSN_PAR_BNC8) : /* bnc.s $disp8 */
3894 {
3895 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3896 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3897 #define FLD(f) abuf->fields.sfmt_bl8.f
3898 #define OPRND(f) par_exec->operands.sfmt_bc8.f
3899 int UNUSED written = 0;
3900 IADDR UNUSED pc = abuf->addr;
3901 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3902
3903 if (NOTBI (CPU (h_cond))) {
3904 {
3905 USI opval = FLD (i_disp8);
3906 OPRND (pc) = opval;
3907 written |= (1 << 2);
3908 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3909 }
3910 }
3911
3912 abuf->written = written;
3913 #undef OPRND
3914 #undef FLD
3915 }
3916 NEXT (vpc);
3917
3918 CASE (sem, INSN_WRITE_BNC8) : /* bnc.s $disp8 */
3919 {
3920 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3921 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3922 #define FLD(f) abuf->fields.sfmt_bl8.f
3923 #define OPRND(f) par_exec->operands.sfmt_bc8.f
3924 int UNUSED written = abuf->written;
3925 IADDR UNUSED pc = abuf->addr;
3926 SEM_BRANCH_INIT
3927 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3928
3929 if (written & (1 << 2))
3930 {
3931 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3932 }
3933
3934 SEM_BRANCH_FINI (vpc);
3935 #undef OPRND
3936 #undef FLD
3937 }
3938 NEXT (vpc);
3939
3940 CASE (sem, INSN_PAR_BRA8) : /* bra.s $disp8 */
3941 {
3942 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3943 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3944 #define FLD(f) abuf->fields.sfmt_bl8.f
3945 #define OPRND(f) par_exec->operands.sfmt_bra8.f
3946 int UNUSED written = 0;
3947 IADDR UNUSED pc = abuf->addr;
3948 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3949
3950 {
3951 USI opval = FLD (i_disp8);
3952 OPRND (pc) = opval;
3953 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3954 }
3955
3956 #undef OPRND
3957 #undef FLD
3958 }
3959 NEXT (vpc);
3960
3961 CASE (sem, INSN_WRITE_BRA8) : /* bra.s $disp8 */
3962 {
3963 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3964 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3965 #define FLD(f) abuf->fields.sfmt_bl8.f
3966 #define OPRND(f) par_exec->operands.sfmt_bra8.f
3967 int UNUSED written = abuf->written;
3968 IADDR UNUSED pc = abuf->addr;
3969 SEM_BRANCH_INIT
3970 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3971
3972 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3973
3974 SEM_BRANCH_FINI (vpc);
3975 #undef OPRND
3976 #undef FLD
3977 }
3978 NEXT (vpc);
3979
3980 CASE (sem, INSN_PAR_BNCL8) : /* bncl.s $disp8 */
3981 {
3982 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3983 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3984 #define FLD(f) abuf->fields.sfmt_bl8.f
3985 #define OPRND(f) par_exec->operands.sfmt_bcl8.f
3986 int UNUSED written = 0;
3987 IADDR UNUSED pc = abuf->addr;
3988 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3989
3990 if (NOTBI (CPU (h_cond))) {
3991 {
3992 {
3993 SI opval = ADDSI (ANDSI (pc, -4), 4);
3994 OPRND (h_gr_SI_14) = opval;
3995 written |= (1 << 3);
3996 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3997 }
3998 {
3999 USI opval = FLD (i_disp8);
4000 OPRND (pc) = opval;
4001 written |= (1 << 4);
4002 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4003 }
4004 }
4005 }
4006
4007 abuf->written = written;
4008 #undef OPRND
4009 #undef FLD
4010 }
4011 NEXT (vpc);
4012
4013 CASE (sem, INSN_WRITE_BNCL8) : /* bncl.s $disp8 */
4014 {
4015 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4016 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4017 #define FLD(f) abuf->fields.sfmt_bl8.f
4018 #define OPRND(f) par_exec->operands.sfmt_bcl8.f
4019 int UNUSED written = abuf->written;
4020 IADDR UNUSED pc = abuf->addr;
4021 SEM_BRANCH_INIT
4022 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4023
4024 if (written & (1 << 3))
4025 {
4026 CPU (h_gr[((UINT) 14)]) = OPRND (h_gr_SI_14);
4027 }
4028 if (written & (1 << 4))
4029 {
4030 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4031 }
4032
4033 SEM_BRANCH_FINI (vpc);
4034 #undef OPRND
4035 #undef FLD
4036 }
4037 NEXT (vpc);
4038
4039 CASE (sem, INSN_PAR_CMP) : /* cmp $src1,$src2 */
4040 {
4041 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4042 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4043 #define FLD(f) abuf->fields.sfmt_st_plus.f
4044 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4045 int UNUSED written = 0;
4046 IADDR UNUSED pc = abuf->addr;
4047 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4048
4049 {
4050 BI opval = LTSI (* FLD (i_src1), * FLD (i_src2));
4051 OPRND (condbit) = opval;
4052 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
4053 }
4054
4055 #undef OPRND
4056 #undef FLD
4057 }
4058 NEXT (vpc);
4059
4060 CASE (sem, INSN_WRITE_CMP) : /* cmp $src1,$src2 */
4061 {
4062 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4063 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4064 #define FLD(f) abuf->fields.sfmt_st_plus.f
4065 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4066 int UNUSED written = abuf->written;
4067 IADDR UNUSED pc = abuf->addr;
4068 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4069
4070 CPU (h_cond) = OPRND (condbit);
4071
4072 #undef OPRND
4073 #undef FLD
4074 }
4075 NEXT (vpc);
4076
4077 CASE (sem, INSN_PAR_CMPU) : /* cmpu $src1,$src2 */
4078 {
4079 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4080 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4081 #define FLD(f) abuf->fields.sfmt_st_plus.f
4082 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4083 int UNUSED written = 0;
4084 IADDR UNUSED pc = abuf->addr;
4085 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4086
4087 {
4088 BI opval = LTUSI (* FLD (i_src1), * FLD (i_src2));
4089 OPRND (condbit) = opval;
4090 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
4091 }
4092
4093 #undef OPRND
4094 #undef FLD
4095 }
4096 NEXT (vpc);
4097
4098 CASE (sem, INSN_WRITE_CMPU) : /* cmpu $src1,$src2 */
4099 {
4100 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4101 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4102 #define FLD(f) abuf->fields.sfmt_st_plus.f
4103 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4104 int UNUSED written = abuf->written;
4105 IADDR UNUSED pc = abuf->addr;
4106 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4107
4108 CPU (h_cond) = OPRND (condbit);
4109
4110 #undef OPRND
4111 #undef FLD
4112 }
4113 NEXT (vpc);
4114
4115 CASE (sem, INSN_PAR_CMPEQ) : /* cmpeq $src1,$src2 */
4116 {
4117 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4118 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4119 #define FLD(f) abuf->fields.sfmt_st_plus.f
4120 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4121 int UNUSED written = 0;
4122 IADDR UNUSED pc = abuf->addr;
4123 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4124
4125 {
4126 BI opval = EQSI (* FLD (i_src1), * FLD (i_src2));
4127 OPRND (condbit) = opval;
4128 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
4129 }
4130
4131 #undef OPRND
4132 #undef FLD
4133 }
4134 NEXT (vpc);
4135
4136 CASE (sem, INSN_WRITE_CMPEQ) : /* cmpeq $src1,$src2 */
4137 {
4138 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4139 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4140 #define FLD(f) abuf->fields.sfmt_st_plus.f
4141 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4142 int UNUSED written = abuf->written;
4143 IADDR UNUSED pc = abuf->addr;
4144 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4145
4146 CPU (h_cond) = OPRND (condbit);
4147
4148 #undef OPRND
4149 #undef FLD
4150 }
4151 NEXT (vpc);
4152
4153 CASE (sem, INSN_PAR_CMPZ) : /* cmpz $src2 */
4154 {
4155 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4156 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4157 #define FLD(f) abuf->fields.sfmt_st_plus.f
4158 #define OPRND(f) par_exec->operands.sfmt_cmpz.f
4159 int UNUSED written = 0;
4160 IADDR UNUSED pc = abuf->addr;
4161 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4162
4163 {
4164 BI opval = EQSI (* FLD (i_src2), 0);
4165 OPRND (condbit) = opval;
4166 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
4167 }
4168
4169 #undef OPRND
4170 #undef FLD
4171 }
4172 NEXT (vpc);
4173
4174 CASE (sem, INSN_WRITE_CMPZ) : /* cmpz $src2 */
4175 {
4176 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4177 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4178 #define FLD(f) abuf->fields.sfmt_st_plus.f
4179 #define OPRND(f) par_exec->operands.sfmt_cmpz.f
4180 int UNUSED written = abuf->written;
4181 IADDR UNUSED pc = abuf->addr;
4182 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4183
4184 CPU (h_cond) = OPRND (condbit);
4185
4186 #undef OPRND
4187 #undef FLD
4188 }
4189 NEXT (vpc);
4190
4191 CASE (sem, INSN_PAR_JC) : /* jc $sr */
4192 {
4193 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4194 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4195 #define FLD(f) abuf->fields.sfmt_jl.f
4196 #define OPRND(f) par_exec->operands.sfmt_jc.f
4197 int UNUSED written = 0;
4198 IADDR UNUSED pc = abuf->addr;
4199 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4200
4201 if (CPU (h_cond)) {
4202 {
4203 USI opval = ANDSI (* FLD (i_sr), -4);
4204 OPRND (pc) = opval;
4205 written |= (1 << 2);
4206 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4207 }
4208 }
4209
4210 abuf->written = written;
4211 #undef OPRND
4212 #undef FLD
4213 }
4214 NEXT (vpc);
4215
4216 CASE (sem, INSN_WRITE_JC) : /* jc $sr */
4217 {
4218 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4219 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4220 #define FLD(f) abuf->fields.sfmt_jl.f
4221 #define OPRND(f) par_exec->operands.sfmt_jc.f
4222 int UNUSED written = abuf->written;
4223 IADDR UNUSED pc = abuf->addr;
4224 SEM_BRANCH_INIT
4225 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4226
4227 if (written & (1 << 2))
4228 {
4229 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4230 }
4231
4232 SEM_BRANCH_FINI (vpc);
4233 #undef OPRND
4234 #undef FLD
4235 }
4236 NEXT (vpc);
4237
4238 CASE (sem, INSN_PAR_JNC) : /* jnc $sr */
4239 {
4240 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4241 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4242 #define FLD(f) abuf->fields.sfmt_jl.f
4243 #define OPRND(f) par_exec->operands.sfmt_jc.f
4244 int UNUSED written = 0;
4245 IADDR UNUSED pc = abuf->addr;
4246 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4247
4248 if (NOTBI (CPU (h_cond))) {
4249 {
4250 USI opval = ANDSI (* FLD (i_sr), -4);
4251 OPRND (pc) = opval;
4252 written |= (1 << 2);
4253 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4254 }
4255 }
4256
4257 abuf->written = written;
4258 #undef OPRND
4259 #undef FLD
4260 }
4261 NEXT (vpc);
4262
4263 CASE (sem, INSN_WRITE_JNC) : /* jnc $sr */
4264 {
4265 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4266 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4267 #define FLD(f) abuf->fields.sfmt_jl.f
4268 #define OPRND(f) par_exec->operands.sfmt_jc.f
4269 int UNUSED written = abuf->written;
4270 IADDR UNUSED pc = abuf->addr;
4271 SEM_BRANCH_INIT
4272 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4273
4274 if (written & (1 << 2))
4275 {
4276 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4277 }
4278
4279 SEM_BRANCH_FINI (vpc);
4280 #undef OPRND
4281 #undef FLD
4282 }
4283 NEXT (vpc);
4284
4285 CASE (sem, INSN_PAR_JL) : /* jl $sr */
4286 {
4287 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4288 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4289 #define FLD(f) abuf->fields.sfmt_jl.f
4290 #define OPRND(f) par_exec->operands.sfmt_jl.f
4291 int UNUSED written = 0;
4292 IADDR UNUSED pc = abuf->addr;
4293 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4294
4295 {
4296 SI temp0;USI temp1;
4297 temp0 = ADDSI (ANDSI (pc, -4), 4);
4298 temp1 = ANDSI (* FLD (i_sr), -4);
4299 {
4300 SI opval = temp0;
4301 OPRND (h_gr_SI_14) = opval;
4302 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4303 }
4304 {
4305 USI opval = temp1;
4306 OPRND (pc) = opval;
4307 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4308 }
4309 }
4310
4311 #undef OPRND
4312 #undef FLD
4313 }
4314 NEXT (vpc);
4315
4316 CASE (sem, INSN_WRITE_JL) : /* jl $sr */
4317 {
4318 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4319 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4320 #define FLD(f) abuf->fields.sfmt_jl.f
4321 #define OPRND(f) par_exec->operands.sfmt_jl.f
4322 int UNUSED written = abuf->written;
4323 IADDR UNUSED pc = abuf->addr;
4324 SEM_BRANCH_INIT
4325 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4326
4327 CPU (h_gr[((UINT) 14)]) = OPRND (h_gr_SI_14);
4328 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4329
4330 SEM_BRANCH_FINI (vpc);
4331 #undef OPRND
4332 #undef FLD
4333 }
4334 NEXT (vpc);
4335
4336 CASE (sem, INSN_PAR_JMP) : /* jmp $sr */
4337 {
4338 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4339 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4340 #define FLD(f) abuf->fields.sfmt_jl.f
4341 #define OPRND(f) par_exec->operands.sfmt_jmp.f
4342 int UNUSED written = 0;
4343 IADDR UNUSED pc = abuf->addr;
4344 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4345
4346 {
4347 USI opval = ANDSI (* FLD (i_sr), -4);
4348 OPRND (pc) = opval;
4349 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4350 }
4351
4352 #undef OPRND
4353 #undef FLD
4354 }
4355 NEXT (vpc);
4356
4357 CASE (sem, INSN_WRITE_JMP) : /* jmp $sr */
4358 {
4359 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4360 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4361 #define FLD(f) abuf->fields.sfmt_jl.f
4362 #define OPRND(f) par_exec->operands.sfmt_jmp.f
4363 int UNUSED written = abuf->written;
4364 IADDR UNUSED pc = abuf->addr;
4365 SEM_BRANCH_INIT
4366 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4367
4368 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4369
4370 SEM_BRANCH_FINI (vpc);
4371 #undef OPRND
4372 #undef FLD
4373 }
4374 NEXT (vpc);
4375
4376 CASE (sem, INSN_PAR_LD) : /* ld $dr,@$sr */
4377 {
4378 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4379 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4380 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4381 #define OPRND(f) par_exec->operands.sfmt_ld.f
4382 int UNUSED written = 0;
4383 IADDR UNUSED pc = abuf->addr;
4384 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4385
4386 {
4387 SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
4388 OPRND (dr) = opval;
4389 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4390 }
4391
4392 #undef OPRND
4393 #undef FLD
4394 }
4395 NEXT (vpc);
4396
4397 CASE (sem, INSN_WRITE_LD) : /* ld $dr,@$sr */
4398 {
4399 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4400 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4401 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4402 #define OPRND(f) par_exec->operands.sfmt_ld.f
4403 int UNUSED written = abuf->written;
4404 IADDR UNUSED pc = abuf->addr;
4405 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4406
4407 * FLD (i_dr) = OPRND (dr);
4408
4409 #undef OPRND
4410 #undef FLD
4411 }
4412 NEXT (vpc);
4413
4414 CASE (sem, INSN_PAR_LDB) : /* ldb $dr,@$sr */
4415 {
4416 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4417 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4418 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4419 #define OPRND(f) par_exec->operands.sfmt_ldb.f
4420 int UNUSED written = 0;
4421 IADDR UNUSED pc = abuf->addr;
4422 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4423
4424 {
4425 SI opval = EXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
4426 OPRND (dr) = opval;
4427 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4428 }
4429
4430 #undef OPRND
4431 #undef FLD
4432 }
4433 NEXT (vpc);
4434
4435 CASE (sem, INSN_WRITE_LDB) : /* ldb $dr,@$sr */
4436 {
4437 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4438 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4439 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4440 #define OPRND(f) par_exec->operands.sfmt_ldb.f
4441 int UNUSED written = abuf->written;
4442 IADDR UNUSED pc = abuf->addr;
4443 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4444
4445 * FLD (i_dr) = OPRND (dr);
4446
4447 #undef OPRND
4448 #undef FLD
4449 }
4450 NEXT (vpc);
4451
4452 CASE (sem, INSN_PAR_LDH) : /* ldh $dr,@$sr */
4453 {
4454 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4455 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4456 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4457 #define OPRND(f) par_exec->operands.sfmt_ldh.f
4458 int UNUSED written = 0;
4459 IADDR UNUSED pc = abuf->addr;
4460 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4461
4462 {
4463 SI opval = EXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
4464 OPRND (dr) = opval;
4465 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4466 }
4467
4468 #undef OPRND
4469 #undef FLD
4470 }
4471 NEXT (vpc);
4472
4473 CASE (sem, INSN_WRITE_LDH) : /* ldh $dr,@$sr */
4474 {
4475 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4476 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4477 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4478 #define OPRND(f) par_exec->operands.sfmt_ldh.f
4479 int UNUSED written = abuf->written;
4480 IADDR UNUSED pc = abuf->addr;
4481 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4482
4483 * FLD (i_dr) = OPRND (dr);
4484
4485 #undef OPRND
4486 #undef FLD
4487 }
4488 NEXT (vpc);
4489
4490 CASE (sem, INSN_PAR_LDUB) : /* ldub $dr,@$sr */
4491 {
4492 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4493 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4494 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4495 #define OPRND(f) par_exec->operands.sfmt_ldb.f
4496 int UNUSED written = 0;
4497 IADDR UNUSED pc = abuf->addr;
4498 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4499
4500 {
4501 SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
4502 OPRND (dr) = opval;
4503 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4504 }
4505
4506 #undef OPRND
4507 #undef FLD
4508 }
4509 NEXT (vpc);
4510
4511 CASE (sem, INSN_WRITE_LDUB) : /* ldub $dr,@$sr */
4512 {
4513 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4514 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4515 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4516 #define OPRND(f) par_exec->operands.sfmt_ldb.f
4517 int UNUSED written = abuf->written;
4518 IADDR UNUSED pc = abuf->addr;
4519 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4520
4521 * FLD (i_dr) = OPRND (dr);
4522
4523 #undef OPRND
4524 #undef FLD
4525 }
4526 NEXT (vpc);
4527
4528 CASE (sem, INSN_PAR_LDUH) : /* lduh $dr,@$sr */
4529 {
4530 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4531 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4532 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4533 #define OPRND(f) par_exec->operands.sfmt_ldh.f
4534 int UNUSED written = 0;
4535 IADDR UNUSED pc = abuf->addr;
4536 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4537
4538 {
4539 SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
4540 OPRND (dr) = opval;
4541 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4542 }
4543
4544 #undef OPRND
4545 #undef FLD
4546 }
4547 NEXT (vpc);
4548
4549 CASE (sem, INSN_WRITE_LDUH) : /* lduh $dr,@$sr */
4550 {
4551 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4552 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4553 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4554 #define OPRND(f) par_exec->operands.sfmt_ldh.f
4555 int UNUSED written = abuf->written;
4556 IADDR UNUSED pc = abuf->addr;
4557 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4558
4559 * FLD (i_dr) = OPRND (dr);
4560
4561 #undef OPRND
4562 #undef FLD
4563 }
4564 NEXT (vpc);
4565
4566 CASE (sem, INSN_PAR_LD_PLUS) : /* ld $dr,@$sr+ */
4567 {
4568 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4569 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4570 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4571 #define OPRND(f) par_exec->operands.sfmt_ld_plus.f
4572 int UNUSED written = 0;
4573 IADDR UNUSED pc = abuf->addr;
4574 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4575
4576 {
4577 SI temp0;SI temp1;
4578 temp0 = GETMEMSI (current_cpu, pc, * FLD (i_sr));
4579 temp1 = ADDSI (* FLD (i_sr), 4);
4580 {
4581 SI opval = temp0;
4582 OPRND (dr) = opval;
4583 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4584 }
4585 {
4586 SI opval = temp1;
4587 OPRND (sr) = opval;
4588 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4589 }
4590 }
4591
4592 #undef OPRND
4593 #undef FLD
4594 }
4595 NEXT (vpc);
4596
4597 CASE (sem, INSN_WRITE_LD_PLUS) : /* ld $dr,@$sr+ */
4598 {
4599 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4600 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4601 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4602 #define OPRND(f) par_exec->operands.sfmt_ld_plus.f
4603 int UNUSED written = abuf->written;
4604 IADDR UNUSED pc = abuf->addr;
4605 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4606
4607 * FLD (i_dr) = OPRND (dr);
4608 * FLD (i_sr) = OPRND (sr);
4609
4610 #undef OPRND
4611 #undef FLD
4612 }
4613 NEXT (vpc);
4614
4615 CASE (sem, INSN_PAR_LDI8) : /* ldi8 $dr,$simm8 */
4616 {
4617 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4618 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4619 #define FLD(f) abuf->fields.sfmt_addi.f
4620 #define OPRND(f) par_exec->operands.sfmt_ldi8.f
4621 int UNUSED written = 0;
4622 IADDR UNUSED pc = abuf->addr;
4623 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4624
4625 {
4626 SI opval = FLD (f_simm8);
4627 OPRND (dr) = opval;
4628 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4629 }
4630
4631 #undef OPRND
4632 #undef FLD
4633 }
4634 NEXT (vpc);
4635
4636 CASE (sem, INSN_WRITE_LDI8) : /* ldi8 $dr,$simm8 */
4637 {
4638 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4639 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4640 #define FLD(f) abuf->fields.sfmt_addi.f
4641 #define OPRND(f) par_exec->operands.sfmt_ldi8.f
4642 int UNUSED written = abuf->written;
4643 IADDR UNUSED pc = abuf->addr;
4644 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4645
4646 * FLD (i_dr) = OPRND (dr);
4647
4648 #undef OPRND
4649 #undef FLD
4650 }
4651 NEXT (vpc);
4652
4653 CASE (sem, INSN_PAR_LOCK) : /* lock $dr,@$sr */
4654 {
4655 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4656 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4657 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4658 #define OPRND(f) par_exec->operands.sfmt_lock.f
4659 int UNUSED written = 0;
4660 IADDR UNUSED pc = abuf->addr;
4661 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4662
4663 {
4664 {
4665 BI opval = 1;
4666 OPRND (h_lock_BI) = opval;
4667 TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
4668 }
4669 {
4670 SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
4671 OPRND (dr) = opval;
4672 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4673 }
4674 }
4675
4676 #undef OPRND
4677 #undef FLD
4678 }
4679 NEXT (vpc);
4680
4681 CASE (sem, INSN_WRITE_LOCK) : /* lock $dr,@$sr */
4682 {
4683 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4684 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4685 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4686 #define OPRND(f) par_exec->operands.sfmt_lock.f
4687 int UNUSED written = abuf->written;
4688 IADDR UNUSED pc = abuf->addr;
4689 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4690
4691 * FLD (i_dr) = OPRND (dr);
4692 CPU (h_lock) = OPRND (h_lock_BI);
4693
4694 #undef OPRND
4695 #undef FLD
4696 }
4697 NEXT (vpc);
4698
4699 CASE (sem, INSN_PAR_MACHI_A) : /* machi $src1,$src2,$acc */
4700 {
4701 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4702 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4703 #define FLD(f) abuf->fields.sfmt_machi_a.f
4704 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4705 int UNUSED written = 0;
4706 IADDR UNUSED pc = abuf->addr;
4707 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4708
4709 {
4710 DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))))), 8), 8);
4711 OPRND (acc) = opval;
4712 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4713 }
4714
4715 #undef OPRND
4716 #undef FLD
4717 }
4718 NEXT (vpc);
4719
4720 CASE (sem, INSN_WRITE_MACHI_A) : /* machi $src1,$src2,$acc */
4721 {
4722 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4723 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4724 #define FLD(f) abuf->fields.sfmt_machi_a.f
4725 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4726 int UNUSED written = abuf->written;
4727 IADDR UNUSED pc = abuf->addr;
4728 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4729
4730 SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4731
4732 #undef OPRND
4733 #undef FLD
4734 }
4735 NEXT (vpc);
4736
4737 CASE (sem, INSN_PAR_MACLO_A) : /* maclo $src1,$src2,$acc */
4738 {
4739 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4740 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4741 #define FLD(f) abuf->fields.sfmt_machi_a.f
4742 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4743 int UNUSED written = 0;
4744 IADDR UNUSED pc = abuf->addr;
4745 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4746
4747 {
4748 DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))))), 8), 8);
4749 OPRND (acc) = opval;
4750 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4751 }
4752
4753 #undef OPRND
4754 #undef FLD
4755 }
4756 NEXT (vpc);
4757
4758 CASE (sem, INSN_WRITE_MACLO_A) : /* maclo $src1,$src2,$acc */
4759 {
4760 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4761 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4762 #define FLD(f) abuf->fields.sfmt_machi_a.f
4763 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4764 int UNUSED written = abuf->written;
4765 IADDR UNUSED pc = abuf->addr;
4766 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4767
4768 SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4769
4770 #undef OPRND
4771 #undef FLD
4772 }
4773 NEXT (vpc);
4774
4775 CASE (sem, INSN_PAR_MACWHI_A) : /* macwhi $src1,$src2,$acc */
4776 {
4777 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4778 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4779 #define FLD(f) abuf->fields.sfmt_machi_a.f
4780 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4781 int UNUSED written = 0;
4782 IADDR UNUSED pc = abuf->addr;
4783 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4784
4785 {
4786 DI opval = ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))));
4787 OPRND (acc) = opval;
4788 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4789 }
4790
4791 #undef OPRND
4792 #undef FLD
4793 }
4794 NEXT (vpc);
4795
4796 CASE (sem, INSN_WRITE_MACWHI_A) : /* macwhi $src1,$src2,$acc */
4797 {
4798 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4799 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4800 #define FLD(f) abuf->fields.sfmt_machi_a.f
4801 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4802 int UNUSED written = abuf->written;
4803 IADDR UNUSED pc = abuf->addr;
4804 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4805
4806 SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4807
4808 #undef OPRND
4809 #undef FLD
4810 }
4811 NEXT (vpc);
4812
4813 CASE (sem, INSN_PAR_MACWLO_A) : /* macwlo $src1,$src2,$acc */
4814 {
4815 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4816 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4817 #define FLD(f) abuf->fields.sfmt_machi_a.f
4818 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4819 int UNUSED written = 0;
4820 IADDR UNUSED pc = abuf->addr;
4821 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4822
4823 {
4824 DI opval = ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))));
4825 OPRND (acc) = opval;
4826 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4827 }
4828
4829 #undef OPRND
4830 #undef FLD
4831 }
4832 NEXT (vpc);
4833
4834 CASE (sem, INSN_WRITE_MACWLO_A) : /* macwlo $src1,$src2,$acc */
4835 {
4836 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4837 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4838 #define FLD(f) abuf->fields.sfmt_machi_a.f
4839 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4840 int UNUSED written = abuf->written;
4841 IADDR UNUSED pc = abuf->addr;
4842 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4843
4844 SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4845
4846 #undef OPRND
4847 #undef FLD
4848 }
4849 NEXT (vpc);
4850
4851 CASE (sem, INSN_PAR_MUL) : /* mul $dr,$sr */
4852 {
4853 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4854 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4855 #define FLD(f) abuf->fields.sfmt_add.f
4856 #define OPRND(f) par_exec->operands.sfmt_add.f
4857 int UNUSED written = 0;
4858 IADDR UNUSED pc = abuf->addr;
4859 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4860
4861 {
4862 SI opval = MULSI (* FLD (i_dr), * FLD (i_sr));
4863 OPRND (dr) = opval;
4864 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4865 }
4866
4867 #undef OPRND
4868 #undef FLD
4869 }
4870 NEXT (vpc);
4871
4872 CASE (sem, INSN_WRITE_MUL) : /* mul $dr,$sr */
4873 {
4874 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4875 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4876 #define FLD(f) abuf->fields.sfmt_add.f
4877 #define OPRND(f) par_exec->operands.sfmt_add.f
4878 int UNUSED written = abuf->written;
4879 IADDR UNUSED pc = abuf->addr;
4880 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4881
4882 * FLD (i_dr) = OPRND (dr);
4883
4884 #undef OPRND
4885 #undef FLD
4886 }
4887 NEXT (vpc);
4888
4889 CASE (sem, INSN_PAR_MULHI_A) : /* mulhi $src1,$src2,$acc */
4890 {
4891 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4892 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4893 #define FLD(f) abuf->fields.sfmt_machi_a.f
4894 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4895 int UNUSED written = 0;
4896 IADDR UNUSED pc = abuf->addr;
4897 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4898
4899 {
4900 DI opval = SRADI (SLLDI (MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))), 16), 16);
4901 OPRND (acc) = opval;
4902 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4903 }
4904
4905 #undef OPRND
4906 #undef FLD
4907 }
4908 NEXT (vpc);
4909
4910 CASE (sem, INSN_WRITE_MULHI_A) : /* mulhi $src1,$src2,$acc */
4911 {
4912 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4913 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4914 #define FLD(f) abuf->fields.sfmt_machi_a.f
4915 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4916 int UNUSED written = abuf->written;
4917 IADDR UNUSED pc = abuf->addr;
4918 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4919
4920 SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4921
4922 #undef OPRND
4923 #undef FLD
4924 }
4925 NEXT (vpc);
4926
4927 CASE (sem, INSN_PAR_MULLO_A) : /* mullo $src1,$src2,$acc */
4928 {
4929 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4930 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4931 #define FLD(f) abuf->fields.sfmt_machi_a.f
4932 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4933 int UNUSED written = 0;
4934 IADDR UNUSED pc = abuf->addr;
4935 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4936
4937 {
4938 DI opval = SRADI (SLLDI (MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 16), 16);
4939 OPRND (acc) = opval;
4940 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4941 }
4942
4943 #undef OPRND
4944 #undef FLD
4945 }
4946 NEXT (vpc);
4947
4948 CASE (sem, INSN_WRITE_MULLO_A) : /* mullo $src1,$src2,$acc */
4949 {
4950 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4951 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4952 #define FLD(f) abuf->fields.sfmt_machi_a.f
4953 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4954 int UNUSED written = abuf->written;
4955 IADDR UNUSED pc = abuf->addr;
4956 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4957
4958 SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4959
4960 #undef OPRND
4961 #undef FLD
4962 }
4963 NEXT (vpc);
4964
4965 CASE (sem, INSN_PAR_MULWHI_A) : /* mulwhi $src1,$src2,$acc */
4966 {
4967 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4968 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4969 #define FLD(f) abuf->fields.sfmt_machi_a.f
4970 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4971 int UNUSED written = 0;
4972 IADDR UNUSED pc = abuf->addr;
4973 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4974
4975 {
4976 DI opval = MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))));
4977 OPRND (acc) = opval;
4978 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4979 }
4980
4981 #undef OPRND
4982 #undef FLD
4983 }
4984 NEXT (vpc);
4985
4986 CASE (sem, INSN_WRITE_MULWHI_A) : /* mulwhi $src1,$src2,$acc */
4987 {
4988 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4989 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4990 #define FLD(f) abuf->fields.sfmt_machi_a.f
4991 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4992 int UNUSED written = abuf->written;
4993 IADDR UNUSED pc = abuf->addr;
4994 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4995
4996 SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4997
4998 #undef OPRND
4999 #undef FLD
5000 }
5001 NEXT (vpc);
5002
5003 CASE (sem, INSN_PAR_MULWLO_A) : /* mulwlo $src1,$src2,$acc */
5004 {
5005 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5006 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5007 #define FLD(f) abuf->fields.sfmt_machi_a.f
5008 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
5009 int UNUSED written = 0;
5010 IADDR UNUSED pc = abuf->addr;
5011 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5012
5013 {
5014 DI opval = MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))));
5015 OPRND (acc) = opval;
5016 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5017 }
5018
5019 #undef OPRND
5020 #undef FLD
5021 }
5022 NEXT (vpc);
5023
5024 CASE (sem, INSN_WRITE_MULWLO_A) : /* mulwlo $src1,$src2,$acc */
5025 {
5026 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5027 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5028 #define FLD(f) abuf->fields.sfmt_machi_a.f
5029 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
5030 int UNUSED written = abuf->written;
5031 IADDR UNUSED pc = abuf->addr;
5032 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5033
5034 SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
5035
5036 #undef OPRND
5037 #undef FLD
5038 }
5039 NEXT (vpc);
5040
5041 CASE (sem, INSN_PAR_MV) : /* mv $dr,$sr */
5042 {
5043 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5044 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5045 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5046 #define OPRND(f) par_exec->operands.sfmt_mv.f
5047 int UNUSED written = 0;
5048 IADDR UNUSED pc = abuf->addr;
5049 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5050
5051 {
5052 SI opval = * FLD (i_sr);
5053 OPRND (dr) = opval;
5054 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5055 }
5056
5057 #undef OPRND
5058 #undef FLD
5059 }
5060 NEXT (vpc);
5061
5062 CASE (sem, INSN_WRITE_MV) : /* mv $dr,$sr */
5063 {
5064 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5065 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5066 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5067 #define OPRND(f) par_exec->operands.sfmt_mv.f
5068 int UNUSED written = abuf->written;
5069 IADDR UNUSED pc = abuf->addr;
5070 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5071
5072 * FLD (i_dr) = OPRND (dr);
5073
5074 #undef OPRND
5075 #undef FLD
5076 }
5077 NEXT (vpc);
5078
5079 CASE (sem, INSN_PAR_MVFACHI_A) : /* mvfachi $dr,$accs */
5080 {
5081 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5082 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5083 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5084 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5085 int UNUSED written = 0;
5086 IADDR UNUSED pc = abuf->addr;
5087 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5088
5089 {
5090 SI opval = TRUNCDISI (SRADI (GET_H_ACCUMS (FLD (f_accs)), 32));
5091 OPRND (dr) = opval;
5092 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5093 }
5094
5095 #undef OPRND
5096 #undef FLD
5097 }
5098 NEXT (vpc);
5099
5100 CASE (sem, INSN_WRITE_MVFACHI_A) : /* mvfachi $dr,$accs */
5101 {
5102 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5103 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5104 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5105 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5106 int UNUSED written = abuf->written;
5107 IADDR UNUSED pc = abuf->addr;
5108 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5109
5110 * FLD (i_dr) = OPRND (dr);
5111
5112 #undef OPRND
5113 #undef FLD
5114 }
5115 NEXT (vpc);
5116
5117 CASE (sem, INSN_PAR_MVFACLO_A) : /* mvfaclo $dr,$accs */
5118 {
5119 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5120 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5121 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5122 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5123 int UNUSED written = 0;
5124 IADDR UNUSED pc = abuf->addr;
5125 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5126
5127 {
5128 SI opval = TRUNCDISI (GET_H_ACCUMS (FLD (f_accs)));
5129 OPRND (dr) = opval;
5130 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5131 }
5132
5133 #undef OPRND
5134 #undef FLD
5135 }
5136 NEXT (vpc);
5137
5138 CASE (sem, INSN_WRITE_MVFACLO_A) : /* mvfaclo $dr,$accs */
5139 {
5140 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5141 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5142 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5143 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5144 int UNUSED written = abuf->written;
5145 IADDR UNUSED pc = abuf->addr;
5146 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5147
5148 * FLD (i_dr) = OPRND (dr);
5149
5150 #undef OPRND
5151 #undef FLD
5152 }
5153 NEXT (vpc);
5154
5155 CASE (sem, INSN_PAR_MVFACMI_A) : /* mvfacmi $dr,$accs */
5156 {
5157 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5158 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5159 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5160 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5161 int UNUSED written = 0;
5162 IADDR UNUSED pc = abuf->addr;
5163 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5164
5165 {
5166 SI opval = TRUNCDISI (SRADI (GET_H_ACCUMS (FLD (f_accs)), 16));
5167 OPRND (dr) = opval;
5168 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5169 }
5170
5171 #undef OPRND
5172 #undef FLD
5173 }
5174 NEXT (vpc);
5175
5176 CASE (sem, INSN_WRITE_MVFACMI_A) : /* mvfacmi $dr,$accs */
5177 {
5178 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5179 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5180 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5181 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5182 int UNUSED written = abuf->written;
5183 IADDR UNUSED pc = abuf->addr;
5184 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5185
5186 * FLD (i_dr) = OPRND (dr);
5187
5188 #undef OPRND
5189 #undef FLD
5190 }
5191 NEXT (vpc);
5192
5193 CASE (sem, INSN_PAR_MVFC) : /* mvfc $dr,$scr */
5194 {
5195 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5196 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5197 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5198 #define OPRND(f) par_exec->operands.sfmt_mvfc.f
5199 int UNUSED written = 0;
5200 IADDR UNUSED pc = abuf->addr;
5201 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5202
5203 {
5204 SI opval = GET_H_CR (FLD (f_r2));
5205 OPRND (dr) = opval;
5206 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5207 }
5208
5209 #undef OPRND
5210 #undef FLD
5211 }
5212 NEXT (vpc);
5213
5214 CASE (sem, INSN_WRITE_MVFC) : /* mvfc $dr,$scr */
5215 {
5216 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5217 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5218 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5219 #define OPRND(f) par_exec->operands.sfmt_mvfc.f
5220 int UNUSED written = abuf->written;
5221 IADDR UNUSED pc = abuf->addr;
5222 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5223
5224 * FLD (i_dr) = OPRND (dr);
5225
5226 #undef OPRND
5227 #undef FLD
5228 }
5229 NEXT (vpc);
5230
5231 CASE (sem, INSN_PAR_MVTACHI_A) : /* mvtachi $src1,$accs */
5232 {
5233 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5234 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5235 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
5236 #define OPRND(f) par_exec->operands.sfmt_mvtachi_a.f
5237 int UNUSED written = 0;
5238 IADDR UNUSED pc = abuf->addr;
5239 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5240
5241 {
5242 DI opval = ORDI (ANDDI (GET_H_ACCUMS (FLD (f_accs)), MAKEDI (0, 0xffffffff)), SLLDI (EXTSIDI (* FLD (i_src1)), 32));
5243 OPRND (accs) = opval;
5244 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5245 }
5246
5247 #undef OPRND
5248 #undef FLD
5249 }
5250 NEXT (vpc);
5251
5252 CASE (sem, INSN_WRITE_MVTACHI_A) : /* mvtachi $src1,$accs */
5253 {
5254 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5255 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5256 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
5257 #define OPRND(f) par_exec->operands.sfmt_mvtachi_a.f
5258 int UNUSED written = abuf->written;
5259 IADDR UNUSED pc = abuf->addr;
5260 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5261
5262 SET_H_ACCUMS (FLD (f_accs), OPRND (accs));
5263
5264 #undef OPRND
5265 #undef FLD
5266 }
5267 NEXT (vpc);
5268
5269 CASE (sem, INSN_PAR_MVTACLO_A) : /* mvtaclo $src1,$accs */
5270 {
5271 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5272 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5273 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
5274 #define OPRND(f) par_exec->operands.sfmt_mvtachi_a.f
5275 int UNUSED written = 0;
5276 IADDR UNUSED pc = abuf->addr;
5277 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5278
5279 {
5280 DI opval = ORDI (ANDDI (GET_H_ACCUMS (FLD (f_accs)), MAKEDI (0xffffffff, 0)), ZEXTSIDI (* FLD (i_src1)));
5281 OPRND (accs) = opval;
5282 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5283 }
5284
5285 #undef OPRND
5286 #undef FLD
5287 }
5288 NEXT (vpc);
5289
5290 CASE (sem, INSN_WRITE_MVTACLO_A) : /* mvtaclo $src1,$accs */
5291 {
5292 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5293 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5294 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
5295 #define OPRND(f) par_exec->operands.sfmt_mvtachi_a.f
5296 int UNUSED written = abuf->written;
5297 IADDR UNUSED pc = abuf->addr;
5298 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5299
5300 SET_H_ACCUMS (FLD (f_accs), OPRND (accs));
5301
5302 #undef OPRND
5303 #undef FLD
5304 }
5305 NEXT (vpc);
5306
5307 CASE (sem, INSN_PAR_MVTC) : /* mvtc $sr,$dcr */
5308 {
5309 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5310 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5311 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5312 #define OPRND(f) par_exec->operands.sfmt_mvtc.f
5313 int UNUSED written = 0;
5314 IADDR UNUSED pc = abuf->addr;
5315 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5316
5317 {
5318 USI opval = * FLD (i_sr);
5319 OPRND (dcr) = opval;
5320 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
5321 }
5322
5323 #undef OPRND
5324 #undef FLD
5325 }
5326 NEXT (vpc);
5327
5328 CASE (sem, INSN_WRITE_MVTC) : /* mvtc $sr,$dcr */
5329 {
5330 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5331 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5332 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5333 #define OPRND(f) par_exec->operands.sfmt_mvtc.f
5334 int UNUSED written = abuf->written;
5335 IADDR UNUSED pc = abuf->addr;
5336 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5337
5338 SET_H_CR (FLD (f_r1), OPRND (dcr));
5339
5340 #undef OPRND
5341 #undef FLD
5342 }
5343 NEXT (vpc);
5344
5345 CASE (sem, INSN_PAR_NEG) : /* neg $dr,$sr */
5346 {
5347 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5348 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5349 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5350 #define OPRND(f) par_exec->operands.sfmt_mv.f
5351 int UNUSED written = 0;
5352 IADDR UNUSED pc = abuf->addr;
5353 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5354
5355 {
5356 SI opval = NEGSI (* FLD (i_sr));
5357 OPRND (dr) = opval;
5358 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5359 }
5360
5361 #undef OPRND
5362 #undef FLD
5363 }
5364 NEXT (vpc);
5365
5366 CASE (sem, INSN_WRITE_NEG) : /* neg $dr,$sr */
5367 {
5368 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5369 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5370 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5371 #define OPRND(f) par_exec->operands.sfmt_mv.f
5372 int UNUSED written = abuf->written;
5373 IADDR UNUSED pc = abuf->addr;
5374 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5375
5376 * FLD (i_dr) = OPRND (dr);
5377
5378 #undef OPRND
5379 #undef FLD
5380 }
5381 NEXT (vpc);
5382
5383 CASE (sem, INSN_PAR_NOP) : /* nop */
5384 {
5385 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5386 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5387 #define FLD(f) abuf->fields.fmt_empty.f
5388 #define OPRND(f) par_exec->operands.sfmt_nop.f
5389 int UNUSED written = 0;
5390 IADDR UNUSED pc = abuf->addr;
5391 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5392
5393 PROFILE_COUNT_FILLNOPS (current_cpu, abuf->addr);
5394
5395 #undef OPRND
5396 #undef FLD
5397 }
5398 NEXT (vpc);
5399
5400 CASE (sem, INSN_WRITE_NOP) : /* nop */
5401 {
5402 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5403 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5404 #define FLD(f) abuf->fields.fmt_empty.f
5405 #define OPRND(f) par_exec->operands.sfmt_nop.f
5406 int UNUSED written = abuf->written;
5407 IADDR UNUSED pc = abuf->addr;
5408 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5409
5410
5411 #undef OPRND
5412 #undef FLD
5413 }
5414 NEXT (vpc);
5415
5416 CASE (sem, INSN_PAR_NOT) : /* not $dr,$sr */
5417 {
5418 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5419 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5420 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5421 #define OPRND(f) par_exec->operands.sfmt_mv.f
5422 int UNUSED written = 0;
5423 IADDR UNUSED pc = abuf->addr;
5424 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5425
5426 {
5427 SI opval = INVSI (* FLD (i_sr));
5428 OPRND (dr) = opval;
5429 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5430 }
5431
5432 #undef OPRND
5433 #undef FLD
5434 }
5435 NEXT (vpc);
5436
5437 CASE (sem, INSN_WRITE_NOT) : /* not $dr,$sr */
5438 {
5439 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5440 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5441 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5442 #define OPRND(f) par_exec->operands.sfmt_mv.f
5443 int UNUSED written = abuf->written;
5444 IADDR UNUSED pc = abuf->addr;
5445 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5446
5447 * FLD (i_dr) = OPRND (dr);
5448
5449 #undef OPRND
5450 #undef FLD
5451 }
5452 NEXT (vpc);
5453
5454 CASE (sem, INSN_PAR_RAC_DSI) : /* rac $accd,$accs,$imm1 */
5455 {
5456 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5457 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5458 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
5459 #define OPRND(f) par_exec->operands.sfmt_rac_dsi.f
5460 int UNUSED written = 0;
5461 IADDR UNUSED pc = abuf->addr;
5462 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5463
5464 {
5465 DI tmp_tmp1;
5466 tmp_tmp1 = SLLDI (GET_H_ACCUMS (FLD (f_accs)), FLD (f_imm1));
5467 tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
5468 {
5469 DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0xffff0000))) ? (MAKEDI (32767, 0xffff0000)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0xffff0000)));
5470 OPRND (accd) = opval;
5471 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5472 }
5473 }
5474
5475 #undef OPRND
5476 #undef FLD
5477 }
5478 NEXT (vpc);
5479
5480 CASE (sem, INSN_WRITE_RAC_DSI) : /* rac $accd,$accs,$imm1 */
5481 {
5482 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5483 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5484 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
5485 #define OPRND(f) par_exec->operands.sfmt_rac_dsi.f
5486 int UNUSED written = abuf->written;
5487 IADDR UNUSED pc = abuf->addr;
5488 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5489
5490 SET_H_ACCUMS (FLD (f_accd), OPRND (accd));
5491
5492 #undef OPRND
5493 #undef FLD
5494 }
5495 NEXT (vpc);
5496
5497 CASE (sem, INSN_PAR_RACH_DSI) : /* rach $accd,$accs,$imm1 */
5498 {
5499 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5500 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5501 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
5502 #define OPRND(f) par_exec->operands.sfmt_rac_dsi.f
5503 int UNUSED written = 0;
5504 IADDR UNUSED pc = abuf->addr;
5505 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5506
5507 {
5508 DI tmp_tmp1;
5509 tmp_tmp1 = SLLDI (GET_H_ACCUMS (FLD (f_accs)), FLD (f_imm1));
5510 tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 0x80000000));
5511 {
5512 DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0))) ? (MAKEDI (32767, 0)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0)));
5513 OPRND (accd) = opval;
5514 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5515 }
5516 }
5517
5518 #undef OPRND
5519 #undef FLD
5520 }
5521 NEXT (vpc);
5522
5523 CASE (sem, INSN_WRITE_RACH_DSI) : /* rach $accd,$accs,$imm1 */
5524 {
5525 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5526 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5527 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
5528 #define OPRND(f) par_exec->operands.sfmt_rac_dsi.f
5529 int UNUSED written = abuf->written;
5530 IADDR UNUSED pc = abuf->addr;
5531 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5532
5533 SET_H_ACCUMS (FLD (f_accd), OPRND (accd));
5534
5535 #undef OPRND
5536 #undef FLD
5537 }
5538 NEXT (vpc);
5539
5540 CASE (sem, INSN_PAR_RTE) : /* rte */
5541 {
5542 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5543 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5544 #define FLD(f) abuf->fields.fmt_empty.f
5545 #define OPRND(f) par_exec->operands.sfmt_rte.f
5546 int UNUSED written = 0;
5547 IADDR UNUSED pc = abuf->addr;
5548 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5549
5550 {
5551 {
5552 USI opval = ANDSI (GET_H_CR (((UINT) 6)), -4);
5553 OPRND (pc) = opval;
5554 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5555 }
5556 {
5557 USI opval = GET_H_CR (((UINT) 14));
5558 OPRND (h_cr_USI_6) = opval;
5559 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
5560 }
5561 {
5562 UQI opval = CPU (h_bpsw);
5563 OPRND (h_psw_UQI) = opval;
5564 TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
5565 }
5566 {
5567 UQI opval = CPU (h_bbpsw);
5568 OPRND (h_bpsw_UQI) = opval;
5569 TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
5570 }
5571 }
5572
5573 #undef OPRND
5574 #undef FLD
5575 }
5576 NEXT (vpc);
5577
5578 CASE (sem, INSN_WRITE_RTE) : /* rte */
5579 {
5580 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5581 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5582 #define FLD(f) abuf->fields.fmt_empty.f
5583 #define OPRND(f) par_exec->operands.sfmt_rte.f
5584 int UNUSED written = abuf->written;
5585 IADDR UNUSED pc = abuf->addr;
5586 SEM_BRANCH_INIT
5587 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5588
5589 CPU (h_bpsw) = OPRND (h_bpsw_UQI);
5590 SET_H_CR (((UINT) 6), OPRND (h_cr_USI_6));
5591 SET_H_PSW (OPRND (h_psw_UQI));
5592 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
5593
5594 SEM_BRANCH_FINI (vpc);
5595 #undef OPRND
5596 #undef FLD
5597 }
5598 NEXT (vpc);
5599
5600 CASE (sem, INSN_PAR_SLL) : /* sll $dr,$sr */
5601 {
5602 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5603 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5604 #define FLD(f) abuf->fields.sfmt_add.f
5605 #define OPRND(f) par_exec->operands.sfmt_add.f
5606 int UNUSED written = 0;
5607 IADDR UNUSED pc = abuf->addr;
5608 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5609
5610 {
5611 SI opval = SLLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
5612 OPRND (dr) = opval;
5613 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5614 }
5615
5616 #undef OPRND
5617 #undef FLD
5618 }
5619 NEXT (vpc);
5620
5621 CASE (sem, INSN_WRITE_SLL) : /* sll $dr,$sr */
5622 {
5623 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5624 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5625 #define FLD(f) abuf->fields.sfmt_add.f
5626 #define OPRND(f) par_exec->operands.sfmt_add.f
5627 int UNUSED written = abuf->written;
5628 IADDR UNUSED pc = abuf->addr;
5629 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5630
5631 * FLD (i_dr) = OPRND (dr);
5632
5633 #undef OPRND
5634 #undef FLD
5635 }
5636 NEXT (vpc);
5637
5638 CASE (sem, INSN_PAR_SLLI) : /* slli $dr,$uimm5 */
5639 {
5640 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5641 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5642 #define FLD(f) abuf->fields.sfmt_slli.f
5643 #define OPRND(f) par_exec->operands.sfmt_slli.f
5644 int UNUSED written = 0;
5645 IADDR UNUSED pc = abuf->addr;
5646 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5647
5648 {
5649 SI opval = SLLSI (* FLD (i_dr), FLD (f_uimm5));
5650 OPRND (dr) = opval;
5651 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5652 }
5653
5654 #undef OPRND
5655 #undef FLD
5656 }
5657 NEXT (vpc);
5658
5659 CASE (sem, INSN_WRITE_SLLI) : /* slli $dr,$uimm5 */
5660 {
5661 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5662 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5663 #define FLD(f) abuf->fields.sfmt_slli.f
5664 #define OPRND(f) par_exec->operands.sfmt_slli.f
5665 int UNUSED written = abuf->written;
5666 IADDR UNUSED pc = abuf->addr;
5667 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5668
5669 * FLD (i_dr) = OPRND (dr);
5670
5671 #undef OPRND
5672 #undef FLD
5673 }
5674 NEXT (vpc);
5675
5676 CASE (sem, INSN_PAR_SRA) : /* sra $dr,$sr */
5677 {
5678 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5679 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5680 #define FLD(f) abuf->fields.sfmt_add.f
5681 #define OPRND(f) par_exec->operands.sfmt_add.f
5682 int UNUSED written = 0;
5683 IADDR UNUSED pc = abuf->addr;
5684 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5685
5686 {
5687 SI opval = SRASI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
5688 OPRND (dr) = opval;
5689 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5690 }
5691
5692 #undef OPRND
5693 #undef FLD
5694 }
5695 NEXT (vpc);
5696
5697 CASE (sem, INSN_WRITE_SRA) : /* sra $dr,$sr */
5698 {
5699 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5700 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5701 #define FLD(f) abuf->fields.sfmt_add.f
5702 #define OPRND(f) par_exec->operands.sfmt_add.f
5703 int UNUSED written = abuf->written;
5704 IADDR UNUSED pc = abuf->addr;
5705 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5706
5707 * FLD (i_dr) = OPRND (dr);
5708
5709 #undef OPRND
5710 #undef FLD
5711 }
5712 NEXT (vpc);
5713
5714 CASE (sem, INSN_PAR_SRAI) : /* srai $dr,$uimm5 */
5715 {
5716 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5717 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5718 #define FLD(f) abuf->fields.sfmt_slli.f
5719 #define OPRND(f) par_exec->operands.sfmt_slli.f
5720 int UNUSED written = 0;
5721 IADDR UNUSED pc = abuf->addr;
5722 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5723
5724 {
5725 SI opval = SRASI (* FLD (i_dr), FLD (f_uimm5));
5726 OPRND (dr) = opval;
5727 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5728 }
5729
5730 #undef OPRND
5731 #undef FLD
5732 }
5733 NEXT (vpc);
5734
5735 CASE (sem, INSN_WRITE_SRAI) : /* srai $dr,$uimm5 */
5736 {
5737 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5738 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5739 #define FLD(f) abuf->fields.sfmt_slli.f
5740 #define OPRND(f) par_exec->operands.sfmt_slli.f
5741 int UNUSED written = abuf->written;
5742 IADDR UNUSED pc = abuf->addr;
5743 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5744
5745 * FLD (i_dr) = OPRND (dr);
5746
5747 #undef OPRND
5748 #undef FLD
5749 }
5750 NEXT (vpc);
5751
5752 CASE (sem, INSN_PAR_SRL) : /* srl $dr,$sr */
5753 {
5754 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5755 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5756 #define FLD(f) abuf->fields.sfmt_add.f
5757 #define OPRND(f) par_exec->operands.sfmt_add.f
5758 int UNUSED written = 0;
5759 IADDR UNUSED pc = abuf->addr;
5760 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5761
5762 {
5763 SI opval = SRLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
5764 OPRND (dr) = opval;
5765 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5766 }
5767
5768 #undef OPRND
5769 #undef FLD
5770 }
5771 NEXT (vpc);
5772
5773 CASE (sem, INSN_WRITE_SRL) : /* srl $dr,$sr */
5774 {
5775 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5776 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5777 #define FLD(f) abuf->fields.sfmt_add.f
5778 #define OPRND(f) par_exec->operands.sfmt_add.f
5779 int UNUSED written = abuf->written;
5780 IADDR UNUSED pc = abuf->addr;
5781 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5782
5783 * FLD (i_dr) = OPRND (dr);
5784
5785 #undef OPRND
5786 #undef FLD
5787 }
5788 NEXT (vpc);
5789
5790 CASE (sem, INSN_PAR_SRLI) : /* srli $dr,$uimm5 */
5791 {
5792 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5793 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5794 #define FLD(f) abuf->fields.sfmt_slli.f
5795 #define OPRND(f) par_exec->operands.sfmt_slli.f
5796 int UNUSED written = 0;
5797 IADDR UNUSED pc = abuf->addr;
5798 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5799
5800 {
5801 SI opval = SRLSI (* FLD (i_dr), FLD (f_uimm5));
5802 OPRND (dr) = opval;
5803 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5804 }
5805
5806 #undef OPRND
5807 #undef FLD
5808 }
5809 NEXT (vpc);
5810
5811 CASE (sem, INSN_WRITE_SRLI) : /* srli $dr,$uimm5 */
5812 {
5813 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5814 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5815 #define FLD(f) abuf->fields.sfmt_slli.f
5816 #define OPRND(f) par_exec->operands.sfmt_slli.f
5817 int UNUSED written = abuf->written;
5818 IADDR UNUSED pc = abuf->addr;
5819 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5820
5821 * FLD (i_dr) = OPRND (dr);
5822
5823 #undef OPRND
5824 #undef FLD
5825 }
5826 NEXT (vpc);
5827
5828 CASE (sem, INSN_PAR_ST) : /* st $src1,@$src2 */
5829 {
5830 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5831 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5832 #define FLD(f) abuf->fields.sfmt_st_plus.f
5833 #define OPRND(f) par_exec->operands.sfmt_st.f
5834 int UNUSED written = 0;
5835 IADDR UNUSED pc = abuf->addr;
5836 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5837
5838 {
5839 SI opval = * FLD (i_src1);
5840 OPRND (h_memory_SI_src2_idx) = * FLD (i_src2);
5841 OPRND (h_memory_SI_src2) = opval;
5842 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5843 }
5844
5845 #undef OPRND
5846 #undef FLD
5847 }
5848 NEXT (vpc);
5849
5850 CASE (sem, INSN_WRITE_ST) : /* st $src1,@$src2 */
5851 {
5852 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5853 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5854 #define FLD(f) abuf->fields.sfmt_st_plus.f
5855 #define OPRND(f) par_exec->operands.sfmt_st.f
5856 int UNUSED written = abuf->written;
5857 IADDR UNUSED pc = abuf->addr;
5858 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5859
5860 SETMEMSI (current_cpu, pc, OPRND (h_memory_SI_src2_idx), OPRND (h_memory_SI_src2));
5861
5862 #undef OPRND
5863 #undef FLD
5864 }
5865 NEXT (vpc);
5866
5867 CASE (sem, INSN_PAR_STB) : /* stb $src1,@$src2 */
5868 {
5869 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5870 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5871 #define FLD(f) abuf->fields.sfmt_st_plus.f
5872 #define OPRND(f) par_exec->operands.sfmt_stb.f
5873 int UNUSED written = 0;
5874 IADDR UNUSED pc = abuf->addr;
5875 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5876
5877 {
5878 QI opval = * FLD (i_src1);
5879 OPRND (h_memory_QI_src2_idx) = * FLD (i_src2);
5880 OPRND (h_memory_QI_src2) = opval;
5881 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5882 }
5883
5884 #undef OPRND
5885 #undef FLD
5886 }
5887 NEXT (vpc);
5888
5889 CASE (sem, INSN_WRITE_STB) : /* stb $src1,@$src2 */
5890 {
5891 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5892 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5893 #define FLD(f) abuf->fields.sfmt_st_plus.f
5894 #define OPRND(f) par_exec->operands.sfmt_stb.f
5895 int UNUSED written = abuf->written;
5896 IADDR UNUSED pc = abuf->addr;
5897 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5898
5899 SETMEMQI (current_cpu, pc, OPRND (h_memory_QI_src2_idx), OPRND (h_memory_QI_src2));
5900
5901 #undef OPRND
5902 #undef FLD
5903 }
5904 NEXT (vpc);
5905
5906 CASE (sem, INSN_PAR_STH) : /* sth $src1,@$src2 */
5907 {
5908 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5909 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5910 #define FLD(f) abuf->fields.sfmt_st_plus.f
5911 #define OPRND(f) par_exec->operands.sfmt_sth.f
5912 int UNUSED written = 0;
5913 IADDR UNUSED pc = abuf->addr;
5914 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5915
5916 {
5917 HI opval = * FLD (i_src1);
5918 OPRND (h_memory_HI_src2_idx) = * FLD (i_src2);
5919 OPRND (h_memory_HI_src2) = opval;
5920 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5921 }
5922
5923 #undef OPRND
5924 #undef FLD
5925 }
5926 NEXT (vpc);
5927
5928 CASE (sem, INSN_WRITE_STH) : /* sth $src1,@$src2 */
5929 {
5930 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5931 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5932 #define FLD(f) abuf->fields.sfmt_st_plus.f
5933 #define OPRND(f) par_exec->operands.sfmt_sth.f
5934 int UNUSED written = abuf->written;
5935 IADDR UNUSED pc = abuf->addr;
5936 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5937
5938 SETMEMHI (current_cpu, pc, OPRND (h_memory_HI_src2_idx), OPRND (h_memory_HI_src2));
5939
5940 #undef OPRND
5941 #undef FLD
5942 }
5943 NEXT (vpc);
5944
5945 CASE (sem, INSN_PAR_ST_PLUS) : /* st $src1,@+$src2 */
5946 {
5947 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5948 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5949 #define FLD(f) abuf->fields.sfmt_st_plus.f
5950 #define OPRND(f) par_exec->operands.sfmt_st_plus.f
5951 int UNUSED written = 0;
5952 IADDR UNUSED pc = abuf->addr;
5953 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5954
5955 {
5956 SI tmp_new_src2;
5957 tmp_new_src2 = ADDSI (* FLD (i_src2), 4);
5958 {
5959 SI opval = * FLD (i_src1);
5960 OPRND (h_memory_SI_new_src2_idx) = tmp_new_src2;
5961 OPRND (h_memory_SI_new_src2) = opval;
5962 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5963 }
5964 {
5965 SI opval = tmp_new_src2;
5966 OPRND (src2) = opval;
5967 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5968 }
5969 }
5970
5971 #undef OPRND
5972 #undef FLD
5973 }
5974 NEXT (vpc);
5975
5976 CASE (sem, INSN_WRITE_ST_PLUS) : /* st $src1,@+$src2 */
5977 {
5978 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5979 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5980 #define FLD(f) abuf->fields.sfmt_st_plus.f
5981 #define OPRND(f) par_exec->operands.sfmt_st_plus.f
5982 int UNUSED written = abuf->written;
5983 IADDR UNUSED pc = abuf->addr;
5984 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5985
5986 SETMEMSI (current_cpu, pc, OPRND (h_memory_SI_new_src2_idx), OPRND (h_memory_SI_new_src2));
5987 * FLD (i_src2) = OPRND (src2);
5988
5989 #undef OPRND
5990 #undef FLD
5991 }
5992 NEXT (vpc);
5993
5994 CASE (sem, INSN_PAR_STH_PLUS) : /* sth $src1,@$src2+ */
5995 {
5996 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5997 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5998 #define FLD(f) abuf->fields.sfmt_st_plus.f
5999 #define OPRND(f) par_exec->operands.sfmt_sth_plus.f
6000 int UNUSED written = 0;
6001 IADDR UNUSED pc = abuf->addr;
6002 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6003
6004 {
6005 HI tmp_new_src2;
6006 {
6007 HI opval = * FLD (i_src1);
6008 OPRND (h_memory_HI_new_src2_idx) = tmp_new_src2;
6009 OPRND (h_memory_HI_new_src2) = opval;
6010 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
6011 }
6012 tmp_new_src2 = ADDSI (* FLD (i_src2), 2);
6013 {
6014 SI opval = tmp_new_src2;
6015 OPRND (src2) = opval;
6016 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6017 }
6018 }
6019
6020 #undef OPRND
6021 #undef FLD
6022 }
6023 NEXT (vpc);
6024
6025 CASE (sem, INSN_WRITE_STH_PLUS) : /* sth $src1,@$src2+ */
6026 {
6027 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6028 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6029 #define FLD(f) abuf->fields.sfmt_st_plus.f
6030 #define OPRND(f) par_exec->operands.sfmt_sth_plus.f
6031 int UNUSED written = abuf->written;
6032 IADDR UNUSED pc = abuf->addr;
6033 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6034
6035 SETMEMHI (current_cpu, pc, OPRND (h_memory_HI_new_src2_idx), OPRND (h_memory_HI_new_src2));
6036 * FLD (i_src2) = OPRND (src2);
6037
6038 #undef OPRND
6039 #undef FLD
6040 }
6041 NEXT (vpc);
6042
6043 CASE (sem, INSN_PAR_STB_PLUS) : /* stb $src1,@$src2+ */
6044 {
6045 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6046 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6047 #define FLD(f) abuf->fields.sfmt_st_plus.f
6048 #define OPRND(f) par_exec->operands.sfmt_stb_plus.f
6049 int UNUSED written = 0;
6050 IADDR UNUSED pc = abuf->addr;
6051 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6052
6053 {
6054 QI tmp_new_src2;
6055 {
6056 QI opval = * FLD (i_src1);
6057 OPRND (h_memory_QI_new_src2_idx) = tmp_new_src2;
6058 OPRND (h_memory_QI_new_src2) = opval;
6059 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
6060 }
6061 tmp_new_src2 = ADDSI (* FLD (i_src2), 1);
6062 {
6063 SI opval = tmp_new_src2;
6064 OPRND (src2) = opval;
6065 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6066 }
6067 }
6068
6069 #undef OPRND
6070 #undef FLD
6071 }
6072 NEXT (vpc);
6073
6074 CASE (sem, INSN_WRITE_STB_PLUS) : /* stb $src1,@$src2+ */
6075 {
6076 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6077 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6078 #define FLD(f) abuf->fields.sfmt_st_plus.f
6079 #define OPRND(f) par_exec->operands.sfmt_stb_plus.f
6080 int UNUSED written = abuf->written;
6081 IADDR UNUSED pc = abuf->addr;
6082 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6083
6084 SETMEMQI (current_cpu, pc, OPRND (h_memory_QI_new_src2_idx), OPRND (h_memory_QI_new_src2));
6085 * FLD (i_src2) = OPRND (src2);
6086
6087 #undef OPRND
6088 #undef FLD
6089 }
6090 NEXT (vpc);
6091
6092 CASE (sem, INSN_PAR_ST_MINUS) : /* st $src1,@-$src2 */
6093 {
6094 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6095 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6096 #define FLD(f) abuf->fields.sfmt_st_plus.f
6097 #define OPRND(f) par_exec->operands.sfmt_st_plus.f
6098 int UNUSED written = 0;
6099 IADDR UNUSED pc = abuf->addr;
6100 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6101
6102 {
6103 SI tmp_new_src2;
6104 tmp_new_src2 = SUBSI (* FLD (i_src2), 4);
6105 {
6106 SI opval = * FLD (i_src1);
6107 OPRND (h_memory_SI_new_src2_idx) = tmp_new_src2;
6108 OPRND (h_memory_SI_new_src2) = opval;
6109 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
6110 }
6111 {
6112 SI opval = tmp_new_src2;
6113 OPRND (src2) = opval;
6114 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6115 }
6116 }
6117
6118 #undef OPRND
6119 #undef FLD
6120 }
6121 NEXT (vpc);
6122
6123 CASE (sem, INSN_WRITE_ST_MINUS) : /* st $src1,@-$src2 */
6124 {
6125 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6126 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6127 #define FLD(f) abuf->fields.sfmt_st_plus.f
6128 #define OPRND(f) par_exec->operands.sfmt_st_plus.f
6129 int UNUSED written = abuf->written;
6130 IADDR UNUSED pc = abuf->addr;
6131 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6132
6133 SETMEMSI (current_cpu, pc, OPRND (h_memory_SI_new_src2_idx), OPRND (h_memory_SI_new_src2));
6134 * FLD (i_src2) = OPRND (src2);
6135
6136 #undef OPRND
6137 #undef FLD
6138 }
6139 NEXT (vpc);
6140
6141 CASE (sem, INSN_PAR_SUB) : /* sub $dr,$sr */
6142 {
6143 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6144 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6145 #define FLD(f) abuf->fields.sfmt_add.f
6146 #define OPRND(f) par_exec->operands.sfmt_add.f
6147 int UNUSED written = 0;
6148 IADDR UNUSED pc = abuf->addr;
6149 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6150
6151 {
6152 SI opval = SUBSI (* FLD (i_dr), * FLD (i_sr));
6153 OPRND (dr) = opval;
6154 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6155 }
6156
6157 #undef OPRND
6158 #undef FLD
6159 }
6160 NEXT (vpc);
6161
6162 CASE (sem, INSN_WRITE_SUB) : /* sub $dr,$sr */
6163 {
6164 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6165 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6166 #define FLD(f) abuf->fields.sfmt_add.f
6167 #define OPRND(f) par_exec->operands.sfmt_add.f
6168 int UNUSED written = abuf->written;
6169 IADDR UNUSED pc = abuf->addr;
6170 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6171
6172 * FLD (i_dr) = OPRND (dr);
6173
6174 #undef OPRND
6175 #undef FLD
6176 }
6177 NEXT (vpc);
6178
6179 CASE (sem, INSN_PAR_SUBV) : /* subv $dr,$sr */
6180 {
6181 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6182 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6183 #define FLD(f) abuf->fields.sfmt_add.f
6184 #define OPRND(f) par_exec->operands.sfmt_addv.f
6185 int UNUSED written = 0;
6186 IADDR UNUSED pc = abuf->addr;
6187 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6188
6189 {
6190 SI temp0;BI temp1;
6191 temp0 = SUBSI (* FLD (i_dr), * FLD (i_sr));
6192 temp1 = SUBOFSI (* FLD (i_dr), * FLD (i_sr), 0);
6193 {
6194 SI opval = temp0;
6195 OPRND (dr) = opval;
6196 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6197 }
6198 {
6199 BI opval = temp1;
6200 OPRND (condbit) = opval;
6201 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
6202 }
6203 }
6204
6205 #undef OPRND
6206 #undef FLD
6207 }
6208 NEXT (vpc);
6209
6210 CASE (sem, INSN_WRITE_SUBV) : /* subv $dr,$sr */
6211 {
6212 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6213 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6214 #define FLD(f) abuf->fields.sfmt_add.f
6215 #define OPRND(f) par_exec->operands.sfmt_addv.f
6216 int UNUSED written = abuf->written;
6217 IADDR UNUSED pc = abuf->addr;
6218 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6219
6220 CPU (h_cond) = OPRND (condbit);
6221 * FLD (i_dr) = OPRND (dr);
6222
6223 #undef OPRND
6224 #undef FLD
6225 }
6226 NEXT (vpc);
6227
6228 CASE (sem, INSN_PAR_SUBX) : /* subx $dr,$sr */
6229 {
6230 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6231 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6232 #define FLD(f) abuf->fields.sfmt_add.f
6233 #define OPRND(f) par_exec->operands.sfmt_addx.f
6234 int UNUSED written = 0;
6235 IADDR UNUSED pc = abuf->addr;
6236 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6237
6238 {
6239 SI temp0;BI temp1;
6240 temp0 = SUBCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
6241 temp1 = SUBCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
6242 {
6243 SI opval = temp0;
6244 OPRND (dr) = opval;
6245 TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6246 }
6247 {
6248 BI opval = temp1;
6249 OPRND (condbit) = opval;
6250 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
6251 }
6252 }
6253
6254 #undef OPRND
6255 #undef FLD
6256 }
6257 NEXT (vpc);
6258
6259 CASE (sem, INSN_WRITE_SUBX) : /* subx $dr,$sr */
6260 {
6261 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6262 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6263 #define FLD(f) abuf->fields.sfmt_add.f
6264 #define OPRND(f) par_exec->operands.sfmt_addx.f
6265 int UNUSED written = abuf->written;
6266 IADDR UNUSED pc = abuf->addr;
6267 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6268
6269 CPU (h_cond) = OPRND (condbit);
6270 * FLD (i_dr) = OPRND (dr);
6271
6272 #undef OPRND
6273 #undef FLD
6274 }
6275 NEXT (vpc);
6276
6277 CASE (sem, INSN_PAR_TRAP) : /* trap $uimm4 */
6278 {
6279 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6280 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6281 #define FLD(f) abuf->fields.sfmt_trap.f
6282 #define OPRND(f) par_exec->operands.sfmt_trap.f
6283 int UNUSED written = 0;
6284 IADDR UNUSED pc = abuf->addr;
6285 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6286
6287 {
6288 {
6289 USI opval = GET_H_CR (((UINT) 6));
6290 OPRND (h_cr_USI_14) = opval;
6291 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
6292 }
6293 {
6294 USI opval = ADDSI (pc, 4);
6295 OPRND (h_cr_USI_6) = opval;
6296 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
6297 }
6298 {
6299 UQI opval = CPU (h_bpsw);
6300 OPRND (h_bbpsw_UQI) = opval;
6301 TRACE_RESULT (current_cpu, abuf, "bbpsw", 'x', opval);
6302 }
6303 {
6304 UQI opval = GET_H_PSW ();
6305 OPRND (h_bpsw_UQI) = opval;
6306 TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
6307 }
6308 {
6309 UQI opval = ANDQI (GET_H_PSW (), 128);
6310 OPRND (h_psw_UQI) = opval;
6311 TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
6312 }
6313 {
6314 SI opval = m32r_trap (current_cpu, pc, FLD (f_uimm4));
6315 OPRND (pc) = opval;
6316 TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6317 }
6318 }
6319
6320 #undef OPRND
6321 #undef FLD
6322 }
6323 NEXT (vpc);
6324
6325 CASE (sem, INSN_WRITE_TRAP) : /* trap $uimm4 */
6326 {
6327 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6328 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6329 #define FLD(f) abuf->fields.sfmt_trap.f
6330 #define OPRND(f) par_exec->operands.sfmt_trap.f
6331 int UNUSED written = abuf->written;
6332 IADDR UNUSED pc = abuf->addr;
6333 SEM_BRANCH_INIT
6334 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6335
6336 CPU (h_bbpsw) = OPRND (h_bbpsw_UQI);
6337 CPU (h_bpsw) = OPRND (h_bpsw_UQI);
6338 SET_H_CR (((UINT) 14), OPRND (h_cr_USI_14));
6339 SET_H_CR (((UINT) 6), OPRND (h_cr_USI_6));
6340 SET_H_PSW (OPRND (h_psw_UQI));
6341 SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
6342
6343 SEM_BRANCH_FINI (vpc);
6344 #undef OPRND
6345 #undef FLD
6346 }
6347 NEXT (vpc);
6348
6349 CASE (sem, INSN_PAR_UNLOCK) : /* unlock $src1,@$src2 */
6350 {
6351 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6352 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6353 #define FLD(f) abuf->fields.sfmt_st_plus.f
6354 #define OPRND(f) par_exec->operands.sfmt_unlock.f
6355 int UNUSED written = 0;
6356 IADDR UNUSED pc = abuf->addr;
6357 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6358
6359 {
6360 if (CPU (h_lock)) {
6361 {
6362 SI opval = * FLD (i_src1);
6363 OPRND (h_memory_SI_src2_idx) = * FLD (i_src2);
6364 OPRND (h_memory_SI_src2) = opval;
6365 written |= (1 << 4);
6366 TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
6367 }
6368 }
6369 {
6370 BI opval = 0;
6371 OPRND (h_lock_BI) = opval;
6372 TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
6373 }
6374 }
6375
6376 abuf->written = written;
6377 #undef OPRND
6378 #undef FLD
6379 }
6380 NEXT (vpc);
6381
6382 CASE (sem, INSN_WRITE_UNLOCK) : /* unlock $src1,@$src2 */
6383 {
6384 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6385 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6386 #define FLD(f) abuf->fields.sfmt_st_plus.f
6387 #define OPRND(f) par_exec->operands.sfmt_unlock.f
6388 int UNUSED written = abuf->written;
6389 IADDR UNUSED pc = abuf->addr;
6390 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6391
6392 CPU (h_lock) = OPRND (h_lock_BI);
6393 if (written & (1 << 4))
6394 {
6395 SETMEMSI (current_cpu, pc, OPRND (h_memory_SI_src2_idx), OPRND (h_memory_SI_src2));
6396 }
6397
6398 #undef OPRND
6399 #undef FLD
6400 }
6401 NEXT (vpc);
6402
6403 CASE (sem, INSN_PAR_PCMPBZ) : /* pcmpbz $src2 */
6404 {
6405 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6406 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6407 #define FLD(f) abuf->fields.sfmt_st_plus.f
6408 #define OPRND(f) par_exec->operands.sfmt_cmpz.f
6409 int UNUSED written = 0;
6410 IADDR UNUSED pc = abuf->addr;
6411 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6412
6413 {
6414 BI opval = (EQSI (ANDSI (* FLD (i_src2), 255), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 65280), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 16711680), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 0xff000000), 0)) ? (1) : (0);
6415 OPRND (condbit) = opval;
6416 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
6417 }
6418
6419 #undef OPRND
6420 #undef FLD
6421 }
6422 NEXT (vpc);
6423
6424 CASE (sem, INSN_WRITE_PCMPBZ) : /* pcmpbz $src2 */
6425 {
6426 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6427 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6428 #define FLD(f) abuf->fields.sfmt_st_plus.f
6429 #define OPRND(f) par_exec->operands.sfmt_cmpz.f
6430 int UNUSED written = abuf->written;
6431 IADDR UNUSED pc = abuf->addr;
6432 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6433
6434 CPU (h_cond) = OPRND (condbit);
6435
6436 #undef OPRND
6437 #undef FLD
6438 }
6439 NEXT (vpc);
6440
6441 CASE (sem, INSN_PAR_SADD) : /* sadd */
6442 {
6443 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6444 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6445 #define FLD(f) abuf->fields.fmt_empty.f
6446 #define OPRND(f) par_exec->operands.sfmt_sadd.f
6447 int UNUSED written = 0;
6448 IADDR UNUSED pc = abuf->addr;
6449 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6450
6451 {
6452 DI opval = ADDDI (SRADI (GET_H_ACCUMS (((UINT) 1)), 16), GET_H_ACCUMS (((UINT) 0)));
6453 OPRND (h_accums_DI_0) = opval;
6454 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
6455 }
6456
6457 #undef OPRND
6458 #undef FLD
6459 }
6460 NEXT (vpc);
6461
6462 CASE (sem, INSN_WRITE_SADD) : /* sadd */
6463 {
6464 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6465 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6466 #define FLD(f) abuf->fields.fmt_empty.f
6467 #define OPRND(f) par_exec->operands.sfmt_sadd.f
6468 int UNUSED written = abuf->written;
6469 IADDR UNUSED pc = abuf->addr;
6470 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6471
6472 SET_H_ACCUMS (((UINT) 0), OPRND (h_accums_DI_0));
6473
6474 #undef OPRND
6475 #undef FLD
6476 }
6477 NEXT (vpc);
6478
6479 CASE (sem, INSN_PAR_MACWU1) : /* macwu1 $src1,$src2 */
6480 {
6481 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6482 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6483 #define FLD(f) abuf->fields.sfmt_st_plus.f
6484 #define OPRND(f) par_exec->operands.sfmt_macwu1.f
6485 int UNUSED written = 0;
6486 IADDR UNUSED pc = abuf->addr;
6487 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6488
6489 {
6490 DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (((UINT) 1)), MULDI (EXTSIDI (* FLD (i_src1)), EXTSIDI (ANDSI (* FLD (i_src2), 65535)))), 8), 8);
6491 OPRND (h_accums_DI_1) = opval;
6492 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
6493 }
6494
6495 #undef OPRND
6496 #undef FLD
6497 }
6498 NEXT (vpc);
6499
6500 CASE (sem, INSN_WRITE_MACWU1) : /* macwu1 $src1,$src2 */
6501 {
6502 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6503 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6504 #define FLD(f) abuf->fields.sfmt_st_plus.f
6505 #define OPRND(f) par_exec->operands.sfmt_macwu1.f
6506 int UNUSED written = abuf->written;
6507 IADDR UNUSED pc = abuf->addr;
6508 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6509
6510 SET_H_ACCUMS (((UINT) 1), OPRND (h_accums_DI_1));
6511
6512 #undef OPRND
6513 #undef FLD
6514 }
6515 NEXT (vpc);
6516
6517 CASE (sem, INSN_PAR_MSBLO) : /* msblo $src1,$src2 */
6518 {
6519 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6520 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6521 #define FLD(f) abuf->fields.sfmt_st_plus.f
6522 #define OPRND(f) par_exec->operands.sfmt_msblo.f
6523 int UNUSED written = 0;
6524 IADDR UNUSED pc = abuf->addr;
6525 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6526
6527 {
6528 DI opval = SRADI (SLLDI (SUBDI (GET_H_ACCUM (), SRADI (SLLDI (MULDI (EXTHIDI (TRUNCSIHI (* FLD (i_src1))), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 32), 16)), 8), 8);
6529 OPRND (accum) = opval;
6530 TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
6531 }
6532
6533 #undef OPRND
6534 #undef FLD
6535 }
6536 NEXT (vpc);
6537
6538 CASE (sem, INSN_WRITE_MSBLO) : /* msblo $src1,$src2 */
6539 {
6540 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6541 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6542 #define FLD(f) abuf->fields.sfmt_st_plus.f
6543 #define OPRND(f) par_exec->operands.sfmt_msblo.f
6544 int UNUSED written = abuf->written;
6545 IADDR UNUSED pc = abuf->addr;
6546 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6547
6548 SET_H_ACCUM (OPRND (accum));
6549
6550 #undef OPRND
6551 #undef FLD
6552 }
6553 NEXT (vpc);
6554
6555 CASE (sem, INSN_PAR_MULWU1) : /* mulwu1 $src1,$src2 */
6556 {
6557 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6558 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6559 #define FLD(f) abuf->fields.sfmt_st_plus.f
6560 #define OPRND(f) par_exec->operands.sfmt_mulwu1.f
6561 int UNUSED written = 0;
6562 IADDR UNUSED pc = abuf->addr;
6563 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6564
6565 {
6566 DI opval = SRADI (SLLDI (MULDI (EXTSIDI (* FLD (i_src1)), EXTSIDI (ANDSI (* FLD (i_src2), 65535))), 16), 16);
6567 OPRND (h_accums_DI_1) = opval;
6568 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
6569 }
6570
6571 #undef OPRND
6572 #undef FLD
6573 }
6574 NEXT (vpc);
6575
6576 CASE (sem, INSN_WRITE_MULWU1) : /* mulwu1 $src1,$src2 */
6577 {
6578 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6579 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6580 #define FLD(f) abuf->fields.sfmt_st_plus.f
6581 #define OPRND(f) par_exec->operands.sfmt_mulwu1.f
6582 int UNUSED written = abuf->written;
6583 IADDR UNUSED pc = abuf->addr;
6584 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6585
6586 SET_H_ACCUMS (((UINT) 1), OPRND (h_accums_DI_1));
6587
6588 #undef OPRND
6589 #undef FLD
6590 }
6591 NEXT (vpc);
6592
6593 CASE (sem, INSN_PAR_MACLH1) : /* maclh1 $src1,$src2 */
6594 {
6595 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6596 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6597 #define FLD(f) abuf->fields.sfmt_st_plus.f
6598 #define OPRND(f) par_exec->operands.sfmt_macwu1.f
6599 int UNUSED written = 0;
6600 IADDR UNUSED pc = abuf->addr;
6601 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6602
6603 {
6604 DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (((UINT) 1)), SLLDI (EXTSIDI (MULSI (EXTHISI (TRUNCSIHI (* FLD (i_src1))), SRASI (* FLD (i_src2), 16))), 16)), 8), 8);
6605 OPRND (h_accums_DI_1) = opval;
6606 TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
6607 }
6608
6609 #undef OPRND
6610 #undef FLD
6611 }
6612 NEXT (vpc);
6613
6614 CASE (sem, INSN_WRITE_MACLH1) : /* maclh1 $src1,$src2 */
6615 {
6616 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6617 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6618 #define FLD(f) abuf->fields.sfmt_st_plus.f
6619 #define OPRND(f) par_exec->operands.sfmt_macwu1.f
6620 int UNUSED written = abuf->written;
6621 IADDR UNUSED pc = abuf->addr;
6622 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6623
6624 SET_H_ACCUMS (((UINT) 1), OPRND (h_accums_DI_1));
6625
6626 #undef OPRND
6627 #undef FLD
6628 }
6629 NEXT (vpc);
6630
6631 CASE (sem, INSN_PAR_SC) : /* sc */
6632 {
6633 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6634 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6635 #define FLD(f) abuf->fields.fmt_empty.f
6636 #define OPRND(f) par_exec->operands.sfmt_sc.f
6637 int UNUSED written = 0;
6638 IADDR UNUSED pc = abuf->addr;
6639 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6640
6641 if (ZEXTBISI (CPU (h_cond)))
6642 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
6643
6644 #undef OPRND
6645 #undef FLD
6646 }
6647 NEXT (vpc);
6648
6649 CASE (sem, INSN_WRITE_SC) : /* sc */
6650 {
6651 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6652 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6653 #define FLD(f) abuf->fields.fmt_empty.f
6654 #define OPRND(f) par_exec->operands.sfmt_sc.f
6655 int UNUSED written = abuf->written;
6656 IADDR UNUSED pc = abuf->addr;
6657 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6658
6659
6660 #undef OPRND
6661 #undef FLD
6662 }
6663 NEXT (vpc);
6664
6665 CASE (sem, INSN_PAR_SNC) : /* snc */
6666 {
6667 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6668 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6669 #define FLD(f) abuf->fields.fmt_empty.f
6670 #define OPRND(f) par_exec->operands.sfmt_sc.f
6671 int UNUSED written = 0;
6672 IADDR UNUSED pc = abuf->addr;
6673 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6674
6675 if (ZEXTBISI (NOTBI (CPU (h_cond))))
6676 SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
6677
6678 #undef OPRND
6679 #undef FLD
6680 }
6681 NEXT (vpc);
6682
6683 CASE (sem, INSN_WRITE_SNC) : /* snc */
6684 {
6685 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6686 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6687 #define FLD(f) abuf->fields.fmt_empty.f
6688 #define OPRND(f) par_exec->operands.sfmt_sc.f
6689 int UNUSED written = abuf->written;
6690 IADDR UNUSED pc = abuf->addr;
6691 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6692
6693
6694 #undef OPRND
6695 #undef FLD
6696 }
6697 NEXT (vpc);
6698
6699 CASE (sem, INSN_PAR_CLRPSW) : /* clrpsw $uimm8 */
6700 {
6701 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6702 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6703 #define FLD(f) abuf->fields.sfmt_clrpsw.f
6704 #define OPRND(f) par_exec->operands.sfmt_clrpsw.f
6705 int UNUSED written = 0;
6706 IADDR UNUSED pc = abuf->addr;
6707 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6708
6709 {
6710 SI opval = ANDSI (GET_H_CR (((UINT) 0)), ORSI (INVBI (FLD (f_uimm8)), 65280));
6711 OPRND (h_cr_USI_0) = opval;
6712 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
6713 }
6714
6715 #undef OPRND
6716 #undef FLD
6717 }
6718 NEXT (vpc);
6719
6720 CASE (sem, INSN_WRITE_CLRPSW) : /* clrpsw $uimm8 */
6721 {
6722 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6723 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6724 #define FLD(f) abuf->fields.sfmt_clrpsw.f
6725 #define OPRND(f) par_exec->operands.sfmt_clrpsw.f
6726 int UNUSED written = abuf->written;
6727 IADDR UNUSED pc = abuf->addr;
6728 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6729
6730 SET_H_CR (((UINT) 0), OPRND (h_cr_USI_0));
6731
6732 #undef OPRND
6733 #undef FLD
6734 }
6735 NEXT (vpc);
6736
6737 CASE (sem, INSN_PAR_SETPSW) : /* setpsw $uimm8 */
6738 {
6739 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6740 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6741 #define FLD(f) abuf->fields.sfmt_clrpsw.f
6742 #define OPRND(f) par_exec->operands.sfmt_setpsw.f
6743 int UNUSED written = 0;
6744 IADDR UNUSED pc = abuf->addr;
6745 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6746
6747 {
6748 SI opval = FLD (f_uimm8);
6749 OPRND (h_cr_USI_0) = opval;
6750 TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
6751 }
6752
6753 #undef OPRND
6754 #undef FLD
6755 }
6756 NEXT (vpc);
6757
6758 CASE (sem, INSN_WRITE_SETPSW) : /* setpsw $uimm8 */
6759 {
6760 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6761 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6762 #define FLD(f) abuf->fields.sfmt_clrpsw.f
6763 #define OPRND(f) par_exec->operands.sfmt_setpsw.f
6764 int UNUSED written = abuf->written;
6765 IADDR UNUSED pc = abuf->addr;
6766 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6767
6768 SET_H_CR (((UINT) 0), OPRND (h_cr_USI_0));
6769
6770 #undef OPRND
6771 #undef FLD
6772 }
6773 NEXT (vpc);
6774
6775 CASE (sem, INSN_PAR_BTST) : /* btst $uimm3,$sr */
6776 {
6777 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6778 ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6779 #define FLD(f) abuf->fields.sfmt_bset.f
6780 #define OPRND(f) par_exec->operands.sfmt_btst.f
6781 int UNUSED written = 0;
6782 IADDR UNUSED pc = abuf->addr;
6783 vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6784
6785 {
6786 BI opval = ANDQI (SRLSI (* FLD (i_sr), SUBSI (7, FLD (f_uimm3))), 1);
6787 OPRND (condbit) = opval;
6788 TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
6789 }
6790
6791 #undef OPRND
6792 #undef FLD
6793 }
6794 NEXT (vpc);
6795
6796 CASE (sem, INSN_WRITE_BTST) : /* btst $uimm3,$sr */
6797 {
6798 SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6799 const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6800 #define FLD(f) abuf->fields.sfmt_bset.f
6801 #define OPRND(f) par_exec->operands.sfmt_btst.f
6802 int UNUSED written = abuf->written;
6803 IADDR UNUSED pc = abuf->addr;
6804 vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6805
6806 CPU (h_cond) = OPRND (condbit);
6807
6808 #undef OPRND
6809 #undef FLD
6810 }
6811 NEXT (vpc);
6812
6813
6814 }
6815 ENDSWITCH (sem) /* End of semantic switch. */
6816
6817 /* At this point `vpc' contains the next insn to execute. */
6818 }
6819
6820 #undef DEFINE_SWITCH
6821 #endif /* DEFINE_SWITCH */
SamB's changes