OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [sim/] [sh64/] [sem-media-switch.c] - Blame information for rev 842

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Simulator instruction semantics for sh64.
2
 
3
THIS FILE IS MACHINE GENERATED WITH CGEN.
4
 
5
Copyright 1996-2010 Free Software Foundation, Inc.
6
 
7
This file is part of the GNU simulators.
8
 
9
   This file is free software; you can redistribute it and/or modify
10
   it under the terms of the GNU General Public License as published by
11
   the Free Software Foundation; either version 3, or (at your option)
12
   any later version.
13
 
14
   It is distributed in the hope that it will be useful, but WITHOUT
15
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
16
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
17
   License for more details.
18
 
19
   You should have received a copy of the GNU General Public License along
20
   with this program; if not, write to the Free Software Foundation, Inc.,
21
   51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
22
 
23
*/
24
 
25
#ifdef DEFINE_LABELS
26
 
27
  /* The labels have the case they have because the enum of insn types
28
     is all uppercase and in the non-stdc case the insn symbol is built
29
     into the enum name.  */
30
 
31
  static struct {
32
    int index;
33
    void *label;
34
  } labels[] = {
35
    { SH64_MEDIA_INSN_X_INVALID, && case_sem_INSN_X_INVALID },
36
    { SH64_MEDIA_INSN_X_AFTER, && case_sem_INSN_X_AFTER },
37
    { SH64_MEDIA_INSN_X_BEFORE, && case_sem_INSN_X_BEFORE },
38
    { SH64_MEDIA_INSN_X_CTI_CHAIN, && case_sem_INSN_X_CTI_CHAIN },
39
    { SH64_MEDIA_INSN_X_CHAIN, && case_sem_INSN_X_CHAIN },
40
    { SH64_MEDIA_INSN_X_BEGIN, && case_sem_INSN_X_BEGIN },
41
    { SH64_MEDIA_INSN_ADD, && case_sem_INSN_ADD },
42
    { SH64_MEDIA_INSN_ADDL, && case_sem_INSN_ADDL },
43
    { SH64_MEDIA_INSN_ADDI, && case_sem_INSN_ADDI },
44
    { SH64_MEDIA_INSN_ADDIL, && case_sem_INSN_ADDIL },
45
    { SH64_MEDIA_INSN_ADDZL, && case_sem_INSN_ADDZL },
46
    { SH64_MEDIA_INSN_ALLOCO, && case_sem_INSN_ALLOCO },
47
    { SH64_MEDIA_INSN_AND, && case_sem_INSN_AND },
48
    { SH64_MEDIA_INSN_ANDC, && case_sem_INSN_ANDC },
49
    { SH64_MEDIA_INSN_ANDI, && case_sem_INSN_ANDI },
50
    { SH64_MEDIA_INSN_BEQ, && case_sem_INSN_BEQ },
51
    { SH64_MEDIA_INSN_BEQI, && case_sem_INSN_BEQI },
52
    { SH64_MEDIA_INSN_BGE, && case_sem_INSN_BGE },
53
    { SH64_MEDIA_INSN_BGEU, && case_sem_INSN_BGEU },
54
    { SH64_MEDIA_INSN_BGT, && case_sem_INSN_BGT },
55
    { SH64_MEDIA_INSN_BGTU, && case_sem_INSN_BGTU },
56
    { SH64_MEDIA_INSN_BLINK, && case_sem_INSN_BLINK },
57
    { SH64_MEDIA_INSN_BNE, && case_sem_INSN_BNE },
58
    { SH64_MEDIA_INSN_BNEI, && case_sem_INSN_BNEI },
59
    { SH64_MEDIA_INSN_BRK, && case_sem_INSN_BRK },
60
    { SH64_MEDIA_INSN_BYTEREV, && case_sem_INSN_BYTEREV },
61
    { SH64_MEDIA_INSN_CMPEQ, && case_sem_INSN_CMPEQ },
62
    { SH64_MEDIA_INSN_CMPGT, && case_sem_INSN_CMPGT },
63
    { SH64_MEDIA_INSN_CMPGTU, && case_sem_INSN_CMPGTU },
64
    { SH64_MEDIA_INSN_CMVEQ, && case_sem_INSN_CMVEQ },
65
    { SH64_MEDIA_INSN_CMVNE, && case_sem_INSN_CMVNE },
66
    { SH64_MEDIA_INSN_FABSD, && case_sem_INSN_FABSD },
67
    { SH64_MEDIA_INSN_FABSS, && case_sem_INSN_FABSS },
68
    { SH64_MEDIA_INSN_FADDD, && case_sem_INSN_FADDD },
69
    { SH64_MEDIA_INSN_FADDS, && case_sem_INSN_FADDS },
70
    { SH64_MEDIA_INSN_FCMPEQD, && case_sem_INSN_FCMPEQD },
71
    { SH64_MEDIA_INSN_FCMPEQS, && case_sem_INSN_FCMPEQS },
72
    { SH64_MEDIA_INSN_FCMPGED, && case_sem_INSN_FCMPGED },
73
    { SH64_MEDIA_INSN_FCMPGES, && case_sem_INSN_FCMPGES },
74
    { SH64_MEDIA_INSN_FCMPGTD, && case_sem_INSN_FCMPGTD },
75
    { SH64_MEDIA_INSN_FCMPGTS, && case_sem_INSN_FCMPGTS },
76
    { SH64_MEDIA_INSN_FCMPUND, && case_sem_INSN_FCMPUND },
77
    { SH64_MEDIA_INSN_FCMPUNS, && case_sem_INSN_FCMPUNS },
78
    { SH64_MEDIA_INSN_FCNVDS, && case_sem_INSN_FCNVDS },
79
    { SH64_MEDIA_INSN_FCNVSD, && case_sem_INSN_FCNVSD },
80
    { SH64_MEDIA_INSN_FDIVD, && case_sem_INSN_FDIVD },
81
    { SH64_MEDIA_INSN_FDIVS, && case_sem_INSN_FDIVS },
82
    { SH64_MEDIA_INSN_FGETSCR, && case_sem_INSN_FGETSCR },
83
    { SH64_MEDIA_INSN_FIPRS, && case_sem_INSN_FIPRS },
84
    { SH64_MEDIA_INSN_FLDD, && case_sem_INSN_FLDD },
85
    { SH64_MEDIA_INSN_FLDP, && case_sem_INSN_FLDP },
86
    { SH64_MEDIA_INSN_FLDS, && case_sem_INSN_FLDS },
87
    { SH64_MEDIA_INSN_FLDXD, && case_sem_INSN_FLDXD },
88
    { SH64_MEDIA_INSN_FLDXP, && case_sem_INSN_FLDXP },
89
    { SH64_MEDIA_INSN_FLDXS, && case_sem_INSN_FLDXS },
90
    { SH64_MEDIA_INSN_FLOATLD, && case_sem_INSN_FLOATLD },
91
    { SH64_MEDIA_INSN_FLOATLS, && case_sem_INSN_FLOATLS },
92
    { SH64_MEDIA_INSN_FLOATQD, && case_sem_INSN_FLOATQD },
93
    { SH64_MEDIA_INSN_FLOATQS, && case_sem_INSN_FLOATQS },
94
    { SH64_MEDIA_INSN_FMACS, && case_sem_INSN_FMACS },
95
    { SH64_MEDIA_INSN_FMOVD, && case_sem_INSN_FMOVD },
96
    { SH64_MEDIA_INSN_FMOVDQ, && case_sem_INSN_FMOVDQ },
97
    { SH64_MEDIA_INSN_FMOVLS, && case_sem_INSN_FMOVLS },
98
    { SH64_MEDIA_INSN_FMOVQD, && case_sem_INSN_FMOVQD },
99
    { SH64_MEDIA_INSN_FMOVS, && case_sem_INSN_FMOVS },
100
    { SH64_MEDIA_INSN_FMOVSL, && case_sem_INSN_FMOVSL },
101
    { SH64_MEDIA_INSN_FMULD, && case_sem_INSN_FMULD },
102
    { SH64_MEDIA_INSN_FMULS, && case_sem_INSN_FMULS },
103
    { SH64_MEDIA_INSN_FNEGD, && case_sem_INSN_FNEGD },
104
    { SH64_MEDIA_INSN_FNEGS, && case_sem_INSN_FNEGS },
105
    { SH64_MEDIA_INSN_FPUTSCR, && case_sem_INSN_FPUTSCR },
106
    { SH64_MEDIA_INSN_FSQRTD, && case_sem_INSN_FSQRTD },
107
    { SH64_MEDIA_INSN_FSQRTS, && case_sem_INSN_FSQRTS },
108
    { SH64_MEDIA_INSN_FSTD, && case_sem_INSN_FSTD },
109
    { SH64_MEDIA_INSN_FSTP, && case_sem_INSN_FSTP },
110
    { SH64_MEDIA_INSN_FSTS, && case_sem_INSN_FSTS },
111
    { SH64_MEDIA_INSN_FSTXD, && case_sem_INSN_FSTXD },
112
    { SH64_MEDIA_INSN_FSTXP, && case_sem_INSN_FSTXP },
113
    { SH64_MEDIA_INSN_FSTXS, && case_sem_INSN_FSTXS },
114
    { SH64_MEDIA_INSN_FSUBD, && case_sem_INSN_FSUBD },
115
    { SH64_MEDIA_INSN_FSUBS, && case_sem_INSN_FSUBS },
116
    { SH64_MEDIA_INSN_FTRCDL, && case_sem_INSN_FTRCDL },
117
    { SH64_MEDIA_INSN_FTRCSL, && case_sem_INSN_FTRCSL },
118
    { SH64_MEDIA_INSN_FTRCDQ, && case_sem_INSN_FTRCDQ },
119
    { SH64_MEDIA_INSN_FTRCSQ, && case_sem_INSN_FTRCSQ },
120
    { SH64_MEDIA_INSN_FTRVS, && case_sem_INSN_FTRVS },
121
    { SH64_MEDIA_INSN_GETCFG, && case_sem_INSN_GETCFG },
122
    { SH64_MEDIA_INSN_GETCON, && case_sem_INSN_GETCON },
123
    { SH64_MEDIA_INSN_GETTR, && case_sem_INSN_GETTR },
124
    { SH64_MEDIA_INSN_ICBI, && case_sem_INSN_ICBI },
125
    { SH64_MEDIA_INSN_LDB, && case_sem_INSN_LDB },
126
    { SH64_MEDIA_INSN_LDL, && case_sem_INSN_LDL },
127
    { SH64_MEDIA_INSN_LDQ, && case_sem_INSN_LDQ },
128
    { SH64_MEDIA_INSN_LDUB, && case_sem_INSN_LDUB },
129
    { SH64_MEDIA_INSN_LDUW, && case_sem_INSN_LDUW },
130
    { SH64_MEDIA_INSN_LDW, && case_sem_INSN_LDW },
131
    { SH64_MEDIA_INSN_LDHIL, && case_sem_INSN_LDHIL },
132
    { SH64_MEDIA_INSN_LDHIQ, && case_sem_INSN_LDHIQ },
133
    { SH64_MEDIA_INSN_LDLOL, && case_sem_INSN_LDLOL },
134
    { SH64_MEDIA_INSN_LDLOQ, && case_sem_INSN_LDLOQ },
135
    { SH64_MEDIA_INSN_LDXB, && case_sem_INSN_LDXB },
136
    { SH64_MEDIA_INSN_LDXL, && case_sem_INSN_LDXL },
137
    { SH64_MEDIA_INSN_LDXQ, && case_sem_INSN_LDXQ },
138
    { SH64_MEDIA_INSN_LDXUB, && case_sem_INSN_LDXUB },
139
    { SH64_MEDIA_INSN_LDXUW, && case_sem_INSN_LDXUW },
140
    { SH64_MEDIA_INSN_LDXW, && case_sem_INSN_LDXW },
141
    { SH64_MEDIA_INSN_MABSL, && case_sem_INSN_MABSL },
142
    { SH64_MEDIA_INSN_MABSW, && case_sem_INSN_MABSW },
143
    { SH64_MEDIA_INSN_MADDL, && case_sem_INSN_MADDL },
144
    { SH64_MEDIA_INSN_MADDW, && case_sem_INSN_MADDW },
145
    { SH64_MEDIA_INSN_MADDSL, && case_sem_INSN_MADDSL },
146
    { SH64_MEDIA_INSN_MADDSUB, && case_sem_INSN_MADDSUB },
147
    { SH64_MEDIA_INSN_MADDSW, && case_sem_INSN_MADDSW },
148
    { SH64_MEDIA_INSN_MCMPEQB, && case_sem_INSN_MCMPEQB },
149
    { SH64_MEDIA_INSN_MCMPEQL, && case_sem_INSN_MCMPEQL },
150
    { SH64_MEDIA_INSN_MCMPEQW, && case_sem_INSN_MCMPEQW },
151
    { SH64_MEDIA_INSN_MCMPGTL, && case_sem_INSN_MCMPGTL },
152
    { SH64_MEDIA_INSN_MCMPGTUB, && case_sem_INSN_MCMPGTUB },
153
    { SH64_MEDIA_INSN_MCMPGTW, && case_sem_INSN_MCMPGTW },
154
    { SH64_MEDIA_INSN_MCMV, && case_sem_INSN_MCMV },
155
    { SH64_MEDIA_INSN_MCNVSLW, && case_sem_INSN_MCNVSLW },
156
    { SH64_MEDIA_INSN_MCNVSWB, && case_sem_INSN_MCNVSWB },
157
    { SH64_MEDIA_INSN_MCNVSWUB, && case_sem_INSN_MCNVSWUB },
158
    { SH64_MEDIA_INSN_MEXTR1, && case_sem_INSN_MEXTR1 },
159
    { SH64_MEDIA_INSN_MEXTR2, && case_sem_INSN_MEXTR2 },
160
    { SH64_MEDIA_INSN_MEXTR3, && case_sem_INSN_MEXTR3 },
161
    { SH64_MEDIA_INSN_MEXTR4, && case_sem_INSN_MEXTR4 },
162
    { SH64_MEDIA_INSN_MEXTR5, && case_sem_INSN_MEXTR5 },
163
    { SH64_MEDIA_INSN_MEXTR6, && case_sem_INSN_MEXTR6 },
164
    { SH64_MEDIA_INSN_MEXTR7, && case_sem_INSN_MEXTR7 },
165
    { SH64_MEDIA_INSN_MMACFXWL, && case_sem_INSN_MMACFXWL },
166
    { SH64_MEDIA_INSN_MMACNFX_WL, && case_sem_INSN_MMACNFX_WL },
167
    { SH64_MEDIA_INSN_MMULL, && case_sem_INSN_MMULL },
168
    { SH64_MEDIA_INSN_MMULW, && case_sem_INSN_MMULW },
169
    { SH64_MEDIA_INSN_MMULFXL, && case_sem_INSN_MMULFXL },
170
    { SH64_MEDIA_INSN_MMULFXW, && case_sem_INSN_MMULFXW },
171
    { SH64_MEDIA_INSN_MMULFXRPW, && case_sem_INSN_MMULFXRPW },
172
    { SH64_MEDIA_INSN_MMULHIWL, && case_sem_INSN_MMULHIWL },
173
    { SH64_MEDIA_INSN_MMULLOWL, && case_sem_INSN_MMULLOWL },
174
    { SH64_MEDIA_INSN_MMULSUMWQ, && case_sem_INSN_MMULSUMWQ },
175
    { SH64_MEDIA_INSN_MOVI, && case_sem_INSN_MOVI },
176
    { SH64_MEDIA_INSN_MPERMW, && case_sem_INSN_MPERMW },
177
    { SH64_MEDIA_INSN_MSADUBQ, && case_sem_INSN_MSADUBQ },
178
    { SH64_MEDIA_INSN_MSHALDSL, && case_sem_INSN_MSHALDSL },
179
    { SH64_MEDIA_INSN_MSHALDSW, && case_sem_INSN_MSHALDSW },
180
    { SH64_MEDIA_INSN_MSHARDL, && case_sem_INSN_MSHARDL },
181
    { SH64_MEDIA_INSN_MSHARDW, && case_sem_INSN_MSHARDW },
182
    { SH64_MEDIA_INSN_MSHARDSQ, && case_sem_INSN_MSHARDSQ },
183
    { SH64_MEDIA_INSN_MSHFHIB, && case_sem_INSN_MSHFHIB },
184
    { SH64_MEDIA_INSN_MSHFHIL, && case_sem_INSN_MSHFHIL },
185
    { SH64_MEDIA_INSN_MSHFHIW, && case_sem_INSN_MSHFHIW },
186
    { SH64_MEDIA_INSN_MSHFLOB, && case_sem_INSN_MSHFLOB },
187
    { SH64_MEDIA_INSN_MSHFLOL, && case_sem_INSN_MSHFLOL },
188
    { SH64_MEDIA_INSN_MSHFLOW, && case_sem_INSN_MSHFLOW },
189
    { SH64_MEDIA_INSN_MSHLLDL, && case_sem_INSN_MSHLLDL },
190
    { SH64_MEDIA_INSN_MSHLLDW, && case_sem_INSN_MSHLLDW },
191
    { SH64_MEDIA_INSN_MSHLRDL, && case_sem_INSN_MSHLRDL },
192
    { SH64_MEDIA_INSN_MSHLRDW, && case_sem_INSN_MSHLRDW },
193
    { SH64_MEDIA_INSN_MSUBL, && case_sem_INSN_MSUBL },
194
    { SH64_MEDIA_INSN_MSUBW, && case_sem_INSN_MSUBW },
195
    { SH64_MEDIA_INSN_MSUBSL, && case_sem_INSN_MSUBSL },
196
    { SH64_MEDIA_INSN_MSUBSUB, && case_sem_INSN_MSUBSUB },
197
    { SH64_MEDIA_INSN_MSUBSW, && case_sem_INSN_MSUBSW },
198
    { SH64_MEDIA_INSN_MULSL, && case_sem_INSN_MULSL },
199
    { SH64_MEDIA_INSN_MULUL, && case_sem_INSN_MULUL },
200
    { SH64_MEDIA_INSN_NOP, && case_sem_INSN_NOP },
201
    { SH64_MEDIA_INSN_NSB, && case_sem_INSN_NSB },
202
    { SH64_MEDIA_INSN_OCBI, && case_sem_INSN_OCBI },
203
    { SH64_MEDIA_INSN_OCBP, && case_sem_INSN_OCBP },
204
    { SH64_MEDIA_INSN_OCBWB, && case_sem_INSN_OCBWB },
205
    { SH64_MEDIA_INSN_OR, && case_sem_INSN_OR },
206
    { SH64_MEDIA_INSN_ORI, && case_sem_INSN_ORI },
207
    { SH64_MEDIA_INSN_PREFI, && case_sem_INSN_PREFI },
208
    { SH64_MEDIA_INSN_PTA, && case_sem_INSN_PTA },
209
    { SH64_MEDIA_INSN_PTABS, && case_sem_INSN_PTABS },
210
    { SH64_MEDIA_INSN_PTB, && case_sem_INSN_PTB },
211
    { SH64_MEDIA_INSN_PTREL, && case_sem_INSN_PTREL },
212
    { SH64_MEDIA_INSN_PUTCFG, && case_sem_INSN_PUTCFG },
213
    { SH64_MEDIA_INSN_PUTCON, && case_sem_INSN_PUTCON },
214
    { SH64_MEDIA_INSN_RTE, && case_sem_INSN_RTE },
215
    { SH64_MEDIA_INSN_SHARD, && case_sem_INSN_SHARD },
216
    { SH64_MEDIA_INSN_SHARDL, && case_sem_INSN_SHARDL },
217
    { SH64_MEDIA_INSN_SHARI, && case_sem_INSN_SHARI },
218
    { SH64_MEDIA_INSN_SHARIL, && case_sem_INSN_SHARIL },
219
    { SH64_MEDIA_INSN_SHLLD, && case_sem_INSN_SHLLD },
220
    { SH64_MEDIA_INSN_SHLLDL, && case_sem_INSN_SHLLDL },
221
    { SH64_MEDIA_INSN_SHLLI, && case_sem_INSN_SHLLI },
222
    { SH64_MEDIA_INSN_SHLLIL, && case_sem_INSN_SHLLIL },
223
    { SH64_MEDIA_INSN_SHLRD, && case_sem_INSN_SHLRD },
224
    { SH64_MEDIA_INSN_SHLRDL, && case_sem_INSN_SHLRDL },
225
    { SH64_MEDIA_INSN_SHLRI, && case_sem_INSN_SHLRI },
226
    { SH64_MEDIA_INSN_SHLRIL, && case_sem_INSN_SHLRIL },
227
    { SH64_MEDIA_INSN_SHORI, && case_sem_INSN_SHORI },
228
    { SH64_MEDIA_INSN_SLEEP, && case_sem_INSN_SLEEP },
229
    { SH64_MEDIA_INSN_STB, && case_sem_INSN_STB },
230
    { SH64_MEDIA_INSN_STL, && case_sem_INSN_STL },
231
    { SH64_MEDIA_INSN_STQ, && case_sem_INSN_STQ },
232
    { SH64_MEDIA_INSN_STW, && case_sem_INSN_STW },
233
    { SH64_MEDIA_INSN_STHIL, && case_sem_INSN_STHIL },
234
    { SH64_MEDIA_INSN_STHIQ, && case_sem_INSN_STHIQ },
235
    { SH64_MEDIA_INSN_STLOL, && case_sem_INSN_STLOL },
236
    { SH64_MEDIA_INSN_STLOQ, && case_sem_INSN_STLOQ },
237
    { SH64_MEDIA_INSN_STXB, && case_sem_INSN_STXB },
238
    { SH64_MEDIA_INSN_STXL, && case_sem_INSN_STXL },
239
    { SH64_MEDIA_INSN_STXQ, && case_sem_INSN_STXQ },
240
    { SH64_MEDIA_INSN_STXW, && case_sem_INSN_STXW },
241
    { SH64_MEDIA_INSN_SUB, && case_sem_INSN_SUB },
242
    { SH64_MEDIA_INSN_SUBL, && case_sem_INSN_SUBL },
243
    { SH64_MEDIA_INSN_SWAPQ, && case_sem_INSN_SWAPQ },
244
    { SH64_MEDIA_INSN_SYNCI, && case_sem_INSN_SYNCI },
245
    { SH64_MEDIA_INSN_SYNCO, && case_sem_INSN_SYNCO },
246
    { SH64_MEDIA_INSN_TRAPA, && case_sem_INSN_TRAPA },
247
    { SH64_MEDIA_INSN_XOR, && case_sem_INSN_XOR },
248
    { SH64_MEDIA_INSN_XORI, && case_sem_INSN_XORI },
249
    { 0, 0 }
250
  };
251
  int i;
252
 
253
  for (i = 0; labels[i].label != 0; ++i)
254
    {
255
#if FAST_P
256
      CPU_IDESC (current_cpu) [labels[i].index].sem_fast_lab = labels[i].label;
257
#else
258
      CPU_IDESC (current_cpu) [labels[i].index].sem_full_lab = labels[i].label;
259
#endif
260
    }
261
 
262
#undef DEFINE_LABELS
263
#endif /* DEFINE_LABELS */
264
 
265
#ifdef DEFINE_SWITCH
266
 
267
/* If hyper-fast [well not unnecessarily slow] execution is selected, turn
268
   off frills like tracing and profiling.  */
269
/* FIXME: A better way would be to have TRACE_RESULT check for something
270
   that can cause it to be optimized out.  Another way would be to emit
271
   special handlers into the instruction "stream".  */
272
 
273
#if FAST_P
274
#undef TRACE_RESULT
275
#define TRACE_RESULT(cpu, abuf, name, type, val)
276
#endif
277
 
278
#undef GET_ATTR
279
#define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
280
 
281
{
282
 
283
#if WITH_SCACHE_PBB
284
 
285
/* Branch to next handler without going around main loop.  */
286
#define NEXT(vpc) goto * SEM_ARGBUF (vpc) -> semantic.sem_case
287
SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
288
 
289
#else /* ! WITH_SCACHE_PBB */
290
 
291
#define NEXT(vpc) BREAK (sem)
292
#ifdef __GNUC__
293
#if FAST_P
294
  SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_fast_lab)
295
#else
296
  SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_full_lab)
297
#endif
298
#else
299
  SWITCH (sem, SEM_ARGBUF (sc) -> idesc->num)
300
#endif
301
 
302
#endif /* ! WITH_SCACHE_PBB */
303
 
304
    {
305
 
306
  CASE (sem, INSN_X_INVALID) : /* --invalid-- */
307
{
308
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
309
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
310
#define FLD(f) abuf->fields.sfmt_empty.f
311
  int UNUSED written = 0;
312
  IADDR UNUSED pc = abuf->addr;
313
  vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
314
 
315
  {
316
    /* Update the recorded pc in the cpu state struct.
317
       Only necessary for WITH_SCACHE case, but to avoid the
318
       conditional compilation ....  */
319
    SET_H_PC (pc);
320
    /* Virtual insns have zero size.  Overwrite vpc with address of next insn
321
       using the default-insn-bitsize spec.  When executing insns in parallel
322
       we may want to queue the fault and continue execution.  */
323
    vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
324
    vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
325
  }
326
 
327
#undef FLD
328
}
329
  NEXT (vpc);
330
 
331
  CASE (sem, INSN_X_AFTER) : /* --after-- */
332
{
333
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
334
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
335
#define FLD(f) abuf->fields.sfmt_empty.f
336
  int UNUSED written = 0;
337
  IADDR UNUSED pc = abuf->addr;
338
  vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
339
 
340
  {
341
#if WITH_SCACHE_PBB_SH64_MEDIA
342
    sh64_media_pbb_after (current_cpu, sem_arg);
343
#endif
344
  }
345
 
346
#undef FLD
347
}
348
  NEXT (vpc);
349
 
350
  CASE (sem, INSN_X_BEFORE) : /* --before-- */
351
{
352
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
353
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
354
#define FLD(f) abuf->fields.sfmt_empty.f
355
  int UNUSED written = 0;
356
  IADDR UNUSED pc = abuf->addr;
357
  vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
358
 
359
  {
360
#if WITH_SCACHE_PBB_SH64_MEDIA
361
    sh64_media_pbb_before (current_cpu, sem_arg);
362
#endif
363
  }
364
 
365
#undef FLD
366
}
367
  NEXT (vpc);
368
 
369
  CASE (sem, INSN_X_CTI_CHAIN) : /* --cti-chain-- */
370
{
371
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
372
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
373
#define FLD(f) abuf->fields.sfmt_empty.f
374
  int UNUSED written = 0;
375
  IADDR UNUSED pc = abuf->addr;
376
  vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
377
 
378
  {
379
#if WITH_SCACHE_PBB_SH64_MEDIA
380
#ifdef DEFINE_SWITCH
381
    vpc = sh64_media_pbb_cti_chain (current_cpu, sem_arg,
382
                               pbb_br_type, pbb_br_npc);
383
    BREAK (sem);
384
#else
385
    /* FIXME: Allow provision of explicit ifmt spec in insn spec.  */
386
    vpc = sh64_media_pbb_cti_chain (current_cpu, sem_arg,
387
                               CPU_PBB_BR_TYPE (current_cpu),
388
                               CPU_PBB_BR_NPC (current_cpu));
389
#endif
390
#endif
391
  }
392
 
393
#undef FLD
394
}
395
  NEXT (vpc);
396
 
397
  CASE (sem, INSN_X_CHAIN) : /* --chain-- */
398
{
399
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
400
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
401
#define FLD(f) abuf->fields.sfmt_empty.f
402
  int UNUSED written = 0;
403
  IADDR UNUSED pc = abuf->addr;
404
  vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
405
 
406
  {
407
#if WITH_SCACHE_PBB_SH64_MEDIA
408
    vpc = sh64_media_pbb_chain (current_cpu, sem_arg);
409
#ifdef DEFINE_SWITCH
410
    BREAK (sem);
411
#endif
412
#endif
413
  }
414
 
415
#undef FLD
416
}
417
  NEXT (vpc);
418
 
419
  CASE (sem, INSN_X_BEGIN) : /* --begin-- */
420
{
421
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
422
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
423
#define FLD(f) abuf->fields.sfmt_empty.f
424
  int UNUSED written = 0;
425
  IADDR UNUSED pc = abuf->addr;
426
  vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
427
 
428
  {
429
#if WITH_SCACHE_PBB_SH64_MEDIA
430
#if defined DEFINE_SWITCH || defined FAST_P
431
    /* In the switch case FAST_P is a constant, allowing several optimizations
432
       in any called inline functions.  */
433
    vpc = sh64_media_pbb_begin (current_cpu, FAST_P);
434
#else
435
#if 0 /* cgen engine can't handle dynamic fast/full switching yet.  */
436
    vpc = sh64_media_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
437
#else
438
    vpc = sh64_media_pbb_begin (current_cpu, 0);
439
#endif
440
#endif
441
#endif
442
  }
443
 
444
#undef FLD
445
}
446
  NEXT (vpc);
447
 
448
  CASE (sem, INSN_ADD) : /* add $rm, $rn, $rd */
449
{
450
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
451
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
452
#define FLD(f) abuf->fields.sfmt_add.f
453
  int UNUSED written = 0;
454
  IADDR UNUSED pc = abuf->addr;
455
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
456
 
457
  {
458
    DI opval = ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
459
    SET_H_GR (FLD (f_dest), opval);
460
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
461
  }
462
 
463
#undef FLD
464
}
465
  NEXT (vpc);
466
 
467
  CASE (sem, INSN_ADDL) : /* add.l $rm, $rn, $rd */
468
{
469
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
470
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
471
#define FLD(f) abuf->fields.sfmt_add.f
472
  int UNUSED written = 0;
473
  IADDR UNUSED pc = abuf->addr;
474
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
475
 
476
  {
477
    DI opval = ADDSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1));
478
    SET_H_GR (FLD (f_dest), opval);
479
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
480
  }
481
 
482
#undef FLD
483
}
484
  NEXT (vpc);
485
 
486
  CASE (sem, INSN_ADDI) : /* addi $rm, $disp10, $rd */
487
{
488
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
489
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
490
#define FLD(f) abuf->fields.sfmt_addi.f
491
  int UNUSED written = 0;
492
  IADDR UNUSED pc = abuf->addr;
493
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
494
 
495
  {
496
    DI opval = ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10)));
497
    SET_H_GR (FLD (f_dest), opval);
498
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
499
  }
500
 
501
#undef FLD
502
}
503
  NEXT (vpc);
504
 
505
  CASE (sem, INSN_ADDIL) : /* addi.l $rm, $disp10, $rd */
506
{
507
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
508
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
509
#define FLD(f) abuf->fields.sfmt_addi.f
510
  int UNUSED written = 0;
511
  IADDR UNUSED pc = abuf->addr;
512
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
513
 
514
  {
515
    DI opval = EXTSIDI (ADDSI (EXTSISI (FLD (f_disp10)), SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)));
516
    SET_H_GR (FLD (f_dest), opval);
517
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
518
  }
519
 
520
#undef FLD
521
}
522
  NEXT (vpc);
523
 
524
  CASE (sem, INSN_ADDZL) : /* addz.l $rm, $rn, $rd */
525
{
526
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
527
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
528
#define FLD(f) abuf->fields.sfmt_add.f
529
  int UNUSED written = 0;
530
  IADDR UNUSED pc = abuf->addr;
531
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
532
 
533
  {
534
    DI opval = ZEXTSIDI (ADDSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
535
    SET_H_GR (FLD (f_dest), opval);
536
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
537
  }
538
 
539
#undef FLD
540
}
541
  NEXT (vpc);
542
 
543
  CASE (sem, INSN_ALLOCO) : /* alloco $rm, $disp6x32 */
544
{
545
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
546
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
547
#define FLD(f) abuf->fields.sfmt_xori.f
548
  int UNUSED written = 0;
549
  IADDR UNUSED pc = abuf->addr;
550
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
551
 
552
{
553
  {
554
    DI opval = GET_H_GR (FLD (f_left));
555
    SET_H_GR (FLD (f_left), opval);
556
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
557
  }
558
((void) 0); /*nop*/
559
}
560
 
561
#undef FLD
562
}
563
  NEXT (vpc);
564
 
565
  CASE (sem, INSN_AND) : /* and $rm, $rn, $rd */
566
{
567
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
568
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
569
#define FLD(f) abuf->fields.sfmt_add.f
570
  int UNUSED written = 0;
571
  IADDR UNUSED pc = abuf->addr;
572
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
573
 
574
  {
575
    DI opval = ANDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
576
    SET_H_GR (FLD (f_dest), opval);
577
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
578
  }
579
 
580
#undef FLD
581
}
582
  NEXT (vpc);
583
 
584
  CASE (sem, INSN_ANDC) : /* andc $rm, $rn, $rd */
585
{
586
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
587
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
588
#define FLD(f) abuf->fields.sfmt_add.f
589
  int UNUSED written = 0;
590
  IADDR UNUSED pc = abuf->addr;
591
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
592
 
593
  {
594
    DI opval = ANDDI (GET_H_GR (FLD (f_left)), INVDI (GET_H_GR (FLD (f_right))));
595
    SET_H_GR (FLD (f_dest), opval);
596
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
597
  }
598
 
599
#undef FLD
600
}
601
  NEXT (vpc);
602
 
603
  CASE (sem, INSN_ANDI) : /* andi $rm, $disp10, $rd */
604
{
605
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
606
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
607
#define FLD(f) abuf->fields.sfmt_addi.f
608
  int UNUSED written = 0;
609
  IADDR UNUSED pc = abuf->addr;
610
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
611
 
612
  {
613
    DI opval = ANDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10)));
614
    SET_H_GR (FLD (f_dest), opval);
615
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
616
  }
617
 
618
#undef FLD
619
}
620
  NEXT (vpc);
621
 
622
  CASE (sem, INSN_BEQ) : /* beq$likely $rm, $rn, $tra */
623
{
624
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
625
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
626
#define FLD(f) abuf->fields.sfmt_beq.f
627
  int UNUSED written = 0;
628
  IADDR UNUSED pc = abuf->addr;
629
  SEM_BRANCH_INIT
630
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
631
 
632
{
633
((void) 0); /*nop*/
634
if (EQDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
635
  {
636
    UDI opval = CPU (h_tr[FLD (f_tra)]);
637
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
638
    written |= (1 << 3);
639
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
640
  }
641
}
642
}
643
 
644
  abuf->written = written;
645
  SEM_BRANCH_FINI (vpc);
646
#undef FLD
647
}
648
  NEXT (vpc);
649
 
650
  CASE (sem, INSN_BEQI) : /* beqi$likely $rm, $imm6, $tra */
651
{
652
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
653
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
654
#define FLD(f) abuf->fields.sfmt_beqi.f
655
  int UNUSED written = 0;
656
  IADDR UNUSED pc = abuf->addr;
657
  SEM_BRANCH_INIT
658
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
659
 
660
{
661
((void) 0); /*nop*/
662
if (EQDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_imm6)))) {
663
  {
664
    UDI opval = CPU (h_tr[FLD (f_tra)]);
665
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
666
    written |= (1 << 3);
667
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
668
  }
669
}
670
}
671
 
672
  abuf->written = written;
673
  SEM_BRANCH_FINI (vpc);
674
#undef FLD
675
}
676
  NEXT (vpc);
677
 
678
  CASE (sem, INSN_BGE) : /* bge$likely $rm, $rn, $tra */
679
{
680
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
681
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
682
#define FLD(f) abuf->fields.sfmt_beq.f
683
  int UNUSED written = 0;
684
  IADDR UNUSED pc = abuf->addr;
685
  SEM_BRANCH_INIT
686
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
687
 
688
{
689
((void) 0); /*nop*/
690
if (GEDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
691
  {
692
    UDI opval = CPU (h_tr[FLD (f_tra)]);
693
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
694
    written |= (1 << 3);
695
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
696
  }
697
}
698
}
699
 
700
  abuf->written = written;
701
  SEM_BRANCH_FINI (vpc);
702
#undef FLD
703
}
704
  NEXT (vpc);
705
 
706
  CASE (sem, INSN_BGEU) : /* bgeu$likely $rm, $rn, $tra */
707
{
708
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
709
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
710
#define FLD(f) abuf->fields.sfmt_beq.f
711
  int UNUSED written = 0;
712
  IADDR UNUSED pc = abuf->addr;
713
  SEM_BRANCH_INIT
714
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
715
 
716
{
717
((void) 0); /*nop*/
718
if (GEUDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
719
  {
720
    UDI opval = CPU (h_tr[FLD (f_tra)]);
721
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
722
    written |= (1 << 3);
723
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
724
  }
725
}
726
}
727
 
728
  abuf->written = written;
729
  SEM_BRANCH_FINI (vpc);
730
#undef FLD
731
}
732
  NEXT (vpc);
733
 
734
  CASE (sem, INSN_BGT) : /* bgt$likely $rm, $rn, $tra */
735
{
736
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
737
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
738
#define FLD(f) abuf->fields.sfmt_beq.f
739
  int UNUSED written = 0;
740
  IADDR UNUSED pc = abuf->addr;
741
  SEM_BRANCH_INIT
742
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
743
 
744
{
745
((void) 0); /*nop*/
746
if (GTDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
747
  {
748
    UDI opval = CPU (h_tr[FLD (f_tra)]);
749
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
750
    written |= (1 << 3);
751
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
752
  }
753
}
754
}
755
 
756
  abuf->written = written;
757
  SEM_BRANCH_FINI (vpc);
758
#undef FLD
759
}
760
  NEXT (vpc);
761
 
762
  CASE (sem, INSN_BGTU) : /* bgtu$likely $rm, $rn, $tra */
763
{
764
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
765
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
766
#define FLD(f) abuf->fields.sfmt_beq.f
767
  int UNUSED written = 0;
768
  IADDR UNUSED pc = abuf->addr;
769
  SEM_BRANCH_INIT
770
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
771
 
772
{
773
((void) 0); /*nop*/
774
if (GTUDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
775
  {
776
    UDI opval = CPU (h_tr[FLD (f_tra)]);
777
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
778
    written |= (1 << 3);
779
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
780
  }
781
}
782
}
783
 
784
  abuf->written = written;
785
  SEM_BRANCH_FINI (vpc);
786
#undef FLD
787
}
788
  NEXT (vpc);
789
 
790
  CASE (sem, INSN_BLINK) : /* blink $trb, $rd */
791
{
792
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
793
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
794
#define FLD(f) abuf->fields.sfmt_blink.f
795
  int UNUSED written = 0;
796
  IADDR UNUSED pc = abuf->addr;
797
  SEM_BRANCH_INIT
798
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
799
 
800
{
801
  {
802
    DI opval = ORDI (ADDDI (pc, 4), 1);
803
    SET_H_GR (FLD (f_dest), opval);
804
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
805
  }
806
  {
807
    UDI opval = CPU (h_tr[FLD (f_trb)]);
808
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
809
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
810
  }
811
if (EQSI (FLD (f_dest), 63)) {
812
((void) 0); /*nop*/
813
} else {
814
((void) 0); /*nop*/
815
}
816
}
817
 
818
  SEM_BRANCH_FINI (vpc);
819
#undef FLD
820
}
821
  NEXT (vpc);
822
 
823
  CASE (sem, INSN_BNE) : /* bne$likely $rm, $rn, $tra */
824
{
825
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
826
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
827
#define FLD(f) abuf->fields.sfmt_beq.f
828
  int UNUSED written = 0;
829
  IADDR UNUSED pc = abuf->addr;
830
  SEM_BRANCH_INIT
831
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
832
 
833
{
834
((void) 0); /*nop*/
835
if (NEDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) {
836
  {
837
    UDI opval = CPU (h_tr[FLD (f_tra)]);
838
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
839
    written |= (1 << 3);
840
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
841
  }
842
}
843
}
844
 
845
  abuf->written = written;
846
  SEM_BRANCH_FINI (vpc);
847
#undef FLD
848
}
849
  NEXT (vpc);
850
 
851
  CASE (sem, INSN_BNEI) : /* bnei$likely $rm, $imm6, $tra */
852
{
853
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
854
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
855
#define FLD(f) abuf->fields.sfmt_beqi.f
856
  int UNUSED written = 0;
857
  IADDR UNUSED pc = abuf->addr;
858
  SEM_BRANCH_INIT
859
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
860
 
861
{
862
((void) 0); /*nop*/
863
if (NEDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_imm6)))) {
864
  {
865
    UDI opval = CPU (h_tr[FLD (f_tra)]);
866
    SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
867
    written |= (1 << 3);
868
    TRACE_RESULT (current_cpu, abuf, "pc", 'D', opval);
869
  }
870
}
871
}
872
 
873
  abuf->written = written;
874
  SEM_BRANCH_FINI (vpc);
875
#undef FLD
876
}
877
  NEXT (vpc);
878
 
879
  CASE (sem, INSN_BRK) : /* brk */
880
{
881
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
882
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
883
#define FLD(f) abuf->fields.sfmt_empty.f
884
  int UNUSED written = 0;
885
  IADDR UNUSED pc = abuf->addr;
886
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
887
 
888
sh64_break (current_cpu, pc);
889
 
890
#undef FLD
891
}
892
  NEXT (vpc);
893
 
894
  CASE (sem, INSN_BYTEREV) : /* byterev $rm, $rd */
895
{
896
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
897
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
898
#define FLD(f) abuf->fields.sfmt_xori.f
899
  int UNUSED written = 0;
900
  IADDR UNUSED pc = abuf->addr;
901
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
902
 
903
{
904
  DI tmp_source;
905
  DI tmp_result;
906
  tmp_source = GET_H_GR (FLD (f_left));
907
  tmp_result = 0;
908
{
909
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
910
  tmp_source = SRLDI (tmp_source, 8);
911
}
912
{
913
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
914
  tmp_source = SRLDI (tmp_source, 8);
915
}
916
{
917
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
918
  tmp_source = SRLDI (tmp_source, 8);
919
}
920
{
921
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
922
  tmp_source = SRLDI (tmp_source, 8);
923
}
924
{
925
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
926
  tmp_source = SRLDI (tmp_source, 8);
927
}
928
{
929
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
930
  tmp_source = SRLDI (tmp_source, 8);
931
}
932
{
933
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
934
  tmp_source = SRLDI (tmp_source, 8);
935
}
936
{
937
  tmp_result = ORDI (SLLDI (tmp_result, 8), ANDDI (tmp_source, 255));
938
  tmp_source = SRLDI (tmp_source, 8);
939
}
940
  {
941
    DI opval = tmp_result;
942
    SET_H_GR (FLD (f_dest), opval);
943
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
944
  }
945
}
946
 
947
#undef FLD
948
}
949
  NEXT (vpc);
950
 
951
  CASE (sem, INSN_CMPEQ) : /* cmpeq $rm, $rn, $rd */
952
{
953
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
954
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
955
#define FLD(f) abuf->fields.sfmt_add.f
956
  int UNUSED written = 0;
957
  IADDR UNUSED pc = abuf->addr;
958
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
959
 
960
  {
961
    DI opval = ((EQDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) ? (1) : (0));
962
    SET_H_GR (FLD (f_dest), opval);
963
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
964
  }
965
 
966
#undef FLD
967
}
968
  NEXT (vpc);
969
 
970
  CASE (sem, INSN_CMPGT) : /* cmpgt $rm, $rn, $rd */
971
{
972
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
973
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
974
#define FLD(f) abuf->fields.sfmt_add.f
975
  int UNUSED written = 0;
976
  IADDR UNUSED pc = abuf->addr;
977
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
978
 
979
  {
980
    DI opval = ((GTDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) ? (1) : (0));
981
    SET_H_GR (FLD (f_dest), opval);
982
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
983
  }
984
 
985
#undef FLD
986
}
987
  NEXT (vpc);
988
 
989
  CASE (sem, INSN_CMPGTU) : /* cmpgtu $rm,$rn, $rd */
990
{
991
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
992
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
993
#define FLD(f) abuf->fields.sfmt_add.f
994
  int UNUSED written = 0;
995
  IADDR UNUSED pc = abuf->addr;
996
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
997
 
998
  {
999
    DI opval = ((GTUDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))) ? (1) : (0));
1000
    SET_H_GR (FLD (f_dest), opval);
1001
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1002
  }
1003
 
1004
#undef FLD
1005
}
1006
  NEXT (vpc);
1007
 
1008
  CASE (sem, INSN_CMVEQ) : /* cmveq $rm, $rn, $rd */
1009
{
1010
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1011
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1012
#define FLD(f) abuf->fields.sfmt_add.f
1013
  int UNUSED written = 0;
1014
  IADDR UNUSED pc = abuf->addr;
1015
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1016
 
1017
if (EQDI (GET_H_GR (FLD (f_left)), 0)) {
1018
  {
1019
    DI opval = GET_H_GR (FLD (f_right));
1020
    SET_H_GR (FLD (f_dest), opval);
1021
    written |= (1 << 2);
1022
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1023
  }
1024
}
1025
 
1026
  abuf->written = written;
1027
#undef FLD
1028
}
1029
  NEXT (vpc);
1030
 
1031
  CASE (sem, INSN_CMVNE) : /* cmvne $rm, $rn, $rd */
1032
{
1033
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1034
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1035
#define FLD(f) abuf->fields.sfmt_add.f
1036
  int UNUSED written = 0;
1037
  IADDR UNUSED pc = abuf->addr;
1038
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1039
 
1040
if (NEDI (GET_H_GR (FLD (f_left)), 0)) {
1041
  {
1042
    DI opval = GET_H_GR (FLD (f_right));
1043
    SET_H_GR (FLD (f_dest), opval);
1044
    written |= (1 << 2);
1045
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1046
  }
1047
}
1048
 
1049
  abuf->written = written;
1050
#undef FLD
1051
}
1052
  NEXT (vpc);
1053
 
1054
  CASE (sem, INSN_FABSD) : /* fabs.d $drgh, $drf */
1055
{
1056
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1057
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1058
#define FLD(f) abuf->fields.sfmt_fabsd.f
1059
  int UNUSED written = 0;
1060
  IADDR UNUSED pc = abuf->addr;
1061
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1062
 
1063
  {
1064
    DF opval = sh64_fabsd (current_cpu, GET_H_DR (FLD (f_left_right)));
1065
    SET_H_DR (FLD (f_dest), opval);
1066
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1067
  }
1068
 
1069
#undef FLD
1070
}
1071
  NEXT (vpc);
1072
 
1073
  CASE (sem, INSN_FABSS) : /* fabs.s $frgh, $frf */
1074
{
1075
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1076
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1077
#define FLD(f) abuf->fields.sfmt_fabsd.f
1078
  int UNUSED written = 0;
1079
  IADDR UNUSED pc = abuf->addr;
1080
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1081
 
1082
  {
1083
    SF opval = sh64_fabss (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1084
    CPU (h_fr[FLD (f_dest)]) = opval;
1085
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1086
  }
1087
 
1088
#undef FLD
1089
}
1090
  NEXT (vpc);
1091
 
1092
  CASE (sem, INSN_FADDD) : /* fadd.d $drg, $drh, $drf */
1093
{
1094
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1095
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1096
#define FLD(f) abuf->fields.sfmt_add.f
1097
  int UNUSED written = 0;
1098
  IADDR UNUSED pc = abuf->addr;
1099
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1100
 
1101
  {
1102
    DF opval = sh64_faddd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right)));
1103
    SET_H_DR (FLD (f_dest), opval);
1104
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1105
  }
1106
 
1107
#undef FLD
1108
}
1109
  NEXT (vpc);
1110
 
1111
  CASE (sem, INSN_FADDS) : /* fadd.s $frg, $frh, $frf */
1112
{
1113
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1114
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1115
#define FLD(f) abuf->fields.sfmt_add.f
1116
  int UNUSED written = 0;
1117
  IADDR UNUSED pc = abuf->addr;
1118
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1119
 
1120
  {
1121
    SF opval = sh64_fadds (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)]));
1122
    CPU (h_fr[FLD (f_dest)]) = opval;
1123
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1124
  }
1125
 
1126
#undef FLD
1127
}
1128
  NEXT (vpc);
1129
 
1130
  CASE (sem, INSN_FCMPEQD) : /* fcmpeq.d $drg, $drh, $rd */
1131
{
1132
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1133
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1134
#define FLD(f) abuf->fields.sfmt_add.f
1135
  int UNUSED written = 0;
1136
  IADDR UNUSED pc = abuf->addr;
1137
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1138
 
1139
  {
1140
    DI opval = ZEXTBIDI (sh64_fcmpeqd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right))));
1141
    SET_H_GR (FLD (f_dest), opval);
1142
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1143
  }
1144
 
1145
#undef FLD
1146
}
1147
  NEXT (vpc);
1148
 
1149
  CASE (sem, INSN_FCMPEQS) : /* fcmpeq.s $frg, $frh, $rd */
1150
{
1151
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1152
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1153
#define FLD(f) abuf->fields.sfmt_add.f
1154
  int UNUSED written = 0;
1155
  IADDR UNUSED pc = abuf->addr;
1156
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1157
 
1158
  {
1159
    DI opval = ZEXTBIDI (sh64_fcmpeqs (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1160
    SET_H_GR (FLD (f_dest), opval);
1161
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1162
  }
1163
 
1164
#undef FLD
1165
}
1166
  NEXT (vpc);
1167
 
1168
  CASE (sem, INSN_FCMPGED) : /* fcmpge.d $drg, $drh, $rd */
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_add.f
1173
  int UNUSED written = 0;
1174
  IADDR UNUSED pc = abuf->addr;
1175
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1176
 
1177
  {
1178
    DI opval = ZEXTBIDI (sh64_fcmpged (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right))));
1179
    SET_H_GR (FLD (f_dest), opval);
1180
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1181
  }
1182
 
1183
#undef FLD
1184
}
1185
  NEXT (vpc);
1186
 
1187
  CASE (sem, INSN_FCMPGES) : /* fcmpge.s $frg, $frh, $rd */
1188
{
1189
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1190
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1191
#define FLD(f) abuf->fields.sfmt_add.f
1192
  int UNUSED written = 0;
1193
  IADDR UNUSED pc = abuf->addr;
1194
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1195
 
1196
  {
1197
    DI opval = ZEXTBIDI (sh64_fcmpges (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1198
    SET_H_GR (FLD (f_dest), opval);
1199
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1200
  }
1201
 
1202
#undef FLD
1203
}
1204
  NEXT (vpc);
1205
 
1206
  CASE (sem, INSN_FCMPGTD) : /* fcmpgt.d $drg, $drh, $rd */
1207
{
1208
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1209
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1210
#define FLD(f) abuf->fields.sfmt_add.f
1211
  int UNUSED written = 0;
1212
  IADDR UNUSED pc = abuf->addr;
1213
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1214
 
1215
  {
1216
    DI opval = ZEXTBIDI (sh64_fcmpgtd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right))));
1217
    SET_H_GR (FLD (f_dest), opval);
1218
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1219
  }
1220
 
1221
#undef FLD
1222
}
1223
  NEXT (vpc);
1224
 
1225
  CASE (sem, INSN_FCMPGTS) : /* fcmpgt.s $frg, $frh, $rd */
1226
{
1227
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1228
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1229
#define FLD(f) abuf->fields.sfmt_add.f
1230
  int UNUSED written = 0;
1231
  IADDR UNUSED pc = abuf->addr;
1232
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1233
 
1234
  {
1235
    DI opval = ZEXTBIDI (sh64_fcmpgts (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1236
    SET_H_GR (FLD (f_dest), opval);
1237
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1238
  }
1239
 
1240
#undef FLD
1241
}
1242
  NEXT (vpc);
1243
 
1244
  CASE (sem, INSN_FCMPUND) : /* fcmpun.d $drg, $drh, $rd */
1245
{
1246
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1247
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1248
#define FLD(f) abuf->fields.sfmt_add.f
1249
  int UNUSED written = 0;
1250
  IADDR UNUSED pc = abuf->addr;
1251
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1252
 
1253
  {
1254
    DI opval = ZEXTBIDI (sh64_fcmpund (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right))));
1255
    SET_H_GR (FLD (f_dest), opval);
1256
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1257
  }
1258
 
1259
#undef FLD
1260
}
1261
  NEXT (vpc);
1262
 
1263
  CASE (sem, INSN_FCMPUNS) : /* fcmpun.s $frg, $frh, $rd */
1264
{
1265
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1266
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1267
#define FLD(f) abuf->fields.sfmt_add.f
1268
  int UNUSED written = 0;
1269
  IADDR UNUSED pc = abuf->addr;
1270
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1271
 
1272
  {
1273
    DI opval = ZEXTBIDI (sh64_fcmpuns (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1274
    SET_H_GR (FLD (f_dest), opval);
1275
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1276
  }
1277
 
1278
#undef FLD
1279
}
1280
  NEXT (vpc);
1281
 
1282
  CASE (sem, INSN_FCNVDS) : /* fcnv.ds $drgh, $frf */
1283
{
1284
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1285
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1286
#define FLD(f) abuf->fields.sfmt_fabsd.f
1287
  int UNUSED written = 0;
1288
  IADDR UNUSED pc = abuf->addr;
1289
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1290
 
1291
  {
1292
    SF opval = sh64_fcnvds (current_cpu, GET_H_DR (FLD (f_left_right)));
1293
    CPU (h_fr[FLD (f_dest)]) = opval;
1294
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1295
  }
1296
 
1297
#undef FLD
1298
}
1299
  NEXT (vpc);
1300
 
1301
  CASE (sem, INSN_FCNVSD) : /* fcnv.sd $frgh, $drf */
1302
{
1303
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1304
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1305
#define FLD(f) abuf->fields.sfmt_fabsd.f
1306
  int UNUSED written = 0;
1307
  IADDR UNUSED pc = abuf->addr;
1308
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1309
 
1310
  {
1311
    DF opval = sh64_fcnvsd (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1312
    SET_H_DR (FLD (f_dest), opval);
1313
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1314
  }
1315
 
1316
#undef FLD
1317
}
1318
  NEXT (vpc);
1319
 
1320
  CASE (sem, INSN_FDIVD) : /* fdiv.d $drg, $drh, $drf */
1321
{
1322
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1323
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1324
#define FLD(f) abuf->fields.sfmt_add.f
1325
  int UNUSED written = 0;
1326
  IADDR UNUSED pc = abuf->addr;
1327
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1328
 
1329
  {
1330
    DF opval = sh64_fdivd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right)));
1331
    SET_H_DR (FLD (f_dest), opval);
1332
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1333
  }
1334
 
1335
#undef FLD
1336
}
1337
  NEXT (vpc);
1338
 
1339
  CASE (sem, INSN_FDIVS) : /* fdiv.s $frg, $frh, $frf */
1340
{
1341
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1342
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1343
#define FLD(f) abuf->fields.sfmt_add.f
1344
  int UNUSED written = 0;
1345
  IADDR UNUSED pc = abuf->addr;
1346
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1347
 
1348
  {
1349
    SF opval = sh64_fdivs (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)]));
1350
    CPU (h_fr[FLD (f_dest)]) = opval;
1351
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1352
  }
1353
 
1354
#undef FLD
1355
}
1356
  NEXT (vpc);
1357
 
1358
  CASE (sem, INSN_FGETSCR) : /* fgetscr $frf */
1359
{
1360
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1361
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1362
#define FLD(f) abuf->fields.sfmt_shori.f
1363
  int UNUSED written = 0;
1364
  IADDR UNUSED pc = abuf->addr;
1365
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1366
 
1367
  {
1368
    SF opval = SUBWORDSISF (CPU (h_fpscr));
1369
    CPU (h_fr[FLD (f_dest)]) = opval;
1370
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1371
  }
1372
 
1373
#undef FLD
1374
}
1375
  NEXT (vpc);
1376
 
1377
  CASE (sem, INSN_FIPRS) : /* fipr.s $fvg, $fvh, $frf */
1378
{
1379
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1380
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1381
#define FLD(f) abuf->fields.sfmt_add.f
1382
  int UNUSED written = 0;
1383
  IADDR UNUSED pc = abuf->addr;
1384
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1385
 
1386
{
1387
  {
1388
    SF opval = GET_H_FV (FLD (f_left));
1389
    SET_H_FV (FLD (f_left), opval);
1390
    TRACE_RESULT (current_cpu, abuf, "fv", 'f', opval);
1391
  }
1392
  {
1393
    SF opval = GET_H_FV (FLD (f_right));
1394
    SET_H_FV (FLD (f_right), opval);
1395
    TRACE_RESULT (current_cpu, abuf, "fv", 'f', opval);
1396
  }
1397
  {
1398
    SF opval = sh64_fiprs (current_cpu, FLD (f_left), FLD (f_right));
1399
    CPU (h_fr[FLD (f_dest)]) = opval;
1400
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1401
  }
1402
}
1403
 
1404
#undef FLD
1405
}
1406
  NEXT (vpc);
1407
 
1408
  CASE (sem, INSN_FLDD) : /* fld.d $rm, $disp10x8, $drf */
1409
{
1410
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1411
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1412
#define FLD(f) abuf->fields.sfmt_fldd.f
1413
  int UNUSED written = 0;
1414
  IADDR UNUSED pc = abuf->addr;
1415
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1416
 
1417
  {
1418
    DF opval = GETMEMDF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp10x8)));
1419
    SET_H_DR (FLD (f_dest), opval);
1420
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1421
  }
1422
 
1423
#undef FLD
1424
}
1425
  NEXT (vpc);
1426
 
1427
  CASE (sem, INSN_FLDP) : /* fld.p $rm, $disp10x8, $fpf */
1428
{
1429
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1430
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1431
#define FLD(f) abuf->fields.sfmt_fldd.f
1432
  int UNUSED written = 0;
1433
  IADDR UNUSED pc = abuf->addr;
1434
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1435
 
1436
{
1437
  {
1438
    SF opval = GET_H_FP (FLD (f_dest));
1439
    SET_H_FP (FLD (f_dest), opval);
1440
    TRACE_RESULT (current_cpu, abuf, "fp", 'f', opval);
1441
  }
1442
sh64_fldp (current_cpu, pc, GET_H_GR (FLD (f_left)), FLD (f_disp10x8), FLD (f_dest));
1443
}
1444
 
1445
#undef FLD
1446
}
1447
  NEXT (vpc);
1448
 
1449
  CASE (sem, INSN_FLDS) : /* fld.s $rm, $disp10x4, $frf */
1450
{
1451
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1452
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1453
#define FLD(f) abuf->fields.sfmt_flds.f
1454
  int UNUSED written = 0;
1455
  IADDR UNUSED pc = abuf->addr;
1456
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1457
 
1458
  {
1459
    SF opval = GETMEMSF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp10x4)));
1460
    CPU (h_fr[FLD (f_dest)]) = opval;
1461
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1462
  }
1463
 
1464
#undef FLD
1465
}
1466
  NEXT (vpc);
1467
 
1468
  CASE (sem, INSN_FLDXD) : /* fldx.d $rm, $rn, $drf */
1469
{
1470
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1471
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1472
#define FLD(f) abuf->fields.sfmt_add.f
1473
  int UNUSED written = 0;
1474
  IADDR UNUSED pc = abuf->addr;
1475
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1476
 
1477
  {
1478
    DF opval = GETMEMDF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))));
1479
    SET_H_DR (FLD (f_dest), opval);
1480
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1481
  }
1482
 
1483
#undef FLD
1484
}
1485
  NEXT (vpc);
1486
 
1487
  CASE (sem, INSN_FLDXP) : /* fldx.p $rm, $rn, $fpf */
1488
{
1489
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1490
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1491
#define FLD(f) abuf->fields.sfmt_add.f
1492
  int UNUSED written = 0;
1493
  IADDR UNUSED pc = abuf->addr;
1494
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1495
 
1496
{
1497
  {
1498
    SF opval = GET_H_FP (FLD (f_dest));
1499
    SET_H_FP (FLD (f_dest), opval);
1500
    TRACE_RESULT (current_cpu, abuf, "fp", 'f', opval);
1501
  }
1502
sh64_fldp (current_cpu, pc, GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)), FLD (f_dest));
1503
}
1504
 
1505
#undef FLD
1506
}
1507
  NEXT (vpc);
1508
 
1509
  CASE (sem, INSN_FLDXS) : /* fldx.s $rm, $rn, $frf */
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
  {
1519
    SF opval = GETMEMSF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))));
1520
    CPU (h_fr[FLD (f_dest)]) = opval;
1521
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1522
  }
1523
 
1524
#undef FLD
1525
}
1526
  NEXT (vpc);
1527
 
1528
  CASE (sem, INSN_FLOATLD) : /* float.ld $frgh, $drf */
1529
{
1530
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1531
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1532
#define FLD(f) abuf->fields.sfmt_fabsd.f
1533
  int UNUSED written = 0;
1534
  IADDR UNUSED pc = abuf->addr;
1535
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1536
 
1537
  {
1538
    DF opval = sh64_floatld (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1539
    SET_H_DR (FLD (f_dest), opval);
1540
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1541
  }
1542
 
1543
#undef FLD
1544
}
1545
  NEXT (vpc);
1546
 
1547
  CASE (sem, INSN_FLOATLS) : /* float.ls $frgh, $frf */
1548
{
1549
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1550
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1551
#define FLD(f) abuf->fields.sfmt_fabsd.f
1552
  int UNUSED written = 0;
1553
  IADDR UNUSED pc = abuf->addr;
1554
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1555
 
1556
  {
1557
    SF opval = sh64_floatls (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1558
    CPU (h_fr[FLD (f_dest)]) = opval;
1559
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1560
  }
1561
 
1562
#undef FLD
1563
}
1564
  NEXT (vpc);
1565
 
1566
  CASE (sem, INSN_FLOATQD) : /* float.qd $drgh, $drf */
1567
{
1568
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1569
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1570
#define FLD(f) abuf->fields.sfmt_fabsd.f
1571
  int UNUSED written = 0;
1572
  IADDR UNUSED pc = abuf->addr;
1573
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1574
 
1575
  {
1576
    DF opval = sh64_floatqd (current_cpu, GET_H_DR (FLD (f_left_right)));
1577
    SET_H_DR (FLD (f_dest), opval);
1578
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1579
  }
1580
 
1581
#undef FLD
1582
}
1583
  NEXT (vpc);
1584
 
1585
  CASE (sem, INSN_FLOATQS) : /* float.qs $drgh, $frf */
1586
{
1587
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1588
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1589
#define FLD(f) abuf->fields.sfmt_fabsd.f
1590
  int UNUSED written = 0;
1591
  IADDR UNUSED pc = abuf->addr;
1592
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1593
 
1594
  {
1595
    SF opval = sh64_floatqs (current_cpu, GET_H_DR (FLD (f_left_right)));
1596
    CPU (h_fr[FLD (f_dest)]) = opval;
1597
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1598
  }
1599
 
1600
#undef FLD
1601
}
1602
  NEXT (vpc);
1603
 
1604
  CASE (sem, INSN_FMACS) : /* fmac.s $frg, $frh, $frf */
1605
{
1606
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1607
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1608
#define FLD(f) abuf->fields.sfmt_add.f
1609
  int UNUSED written = 0;
1610
  IADDR UNUSED pc = abuf->addr;
1611
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1612
 
1613
  {
1614
    SF opval = sh64_fadds (current_cpu, CPU (h_fr[FLD (f_dest)]), sh64_fmuls (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)])));
1615
    CPU (h_fr[FLD (f_dest)]) = opval;
1616
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1617
  }
1618
 
1619
#undef FLD
1620
}
1621
  NEXT (vpc);
1622
 
1623
  CASE (sem, INSN_FMOVD) : /* fmov.d $drgh, $drf */
1624
{
1625
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1626
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1627
#define FLD(f) abuf->fields.sfmt_fabsd.f
1628
  int UNUSED written = 0;
1629
  IADDR UNUSED pc = abuf->addr;
1630
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1631
 
1632
  {
1633
    DF opval = GET_H_DR (FLD (f_left_right));
1634
    SET_H_DR (FLD (f_dest), opval);
1635
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1636
  }
1637
 
1638
#undef FLD
1639
}
1640
  NEXT (vpc);
1641
 
1642
  CASE (sem, INSN_FMOVDQ) : /* fmov.dq $drgh, $rd */
1643
{
1644
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1645
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1646
#define FLD(f) abuf->fields.sfmt_fabsd.f
1647
  int UNUSED written = 0;
1648
  IADDR UNUSED pc = abuf->addr;
1649
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1650
 
1651
  {
1652
    DI opval = SUBWORDDFDI (GET_H_DR (FLD (f_left_right)));
1653
    SET_H_GR (FLD (f_dest), opval);
1654
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1655
  }
1656
 
1657
#undef FLD
1658
}
1659
  NEXT (vpc);
1660
 
1661
  CASE (sem, INSN_FMOVLS) : /* fmov.ls $rm, $frf */
1662
{
1663
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1664
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1665
#define FLD(f) abuf->fields.sfmt_xori.f
1666
  int UNUSED written = 0;
1667
  IADDR UNUSED pc = abuf->addr;
1668
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1669
 
1670
  {
1671
    SF opval = SUBWORDSISF (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1));
1672
    CPU (h_fr[FLD (f_dest)]) = opval;
1673
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1674
  }
1675
 
1676
#undef FLD
1677
}
1678
  NEXT (vpc);
1679
 
1680
  CASE (sem, INSN_FMOVQD) : /* fmov.qd $rm, $drf */
1681
{
1682
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1683
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1684
#define FLD(f) abuf->fields.sfmt_xori.f
1685
  int UNUSED written = 0;
1686
  IADDR UNUSED pc = abuf->addr;
1687
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1688
 
1689
  {
1690
    DF opval = SUBWORDDIDF (GET_H_GR (FLD (f_left)));
1691
    SET_H_DR (FLD (f_dest), opval);
1692
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1693
  }
1694
 
1695
#undef FLD
1696
}
1697
  NEXT (vpc);
1698
 
1699
  CASE (sem, INSN_FMOVS) : /* fmov.s $frgh, $frf */
1700
{
1701
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1702
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1703
#define FLD(f) abuf->fields.sfmt_fabsd.f
1704
  int UNUSED written = 0;
1705
  IADDR UNUSED pc = abuf->addr;
1706
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1707
 
1708
  {
1709
    SF opval = CPU (h_fr[FLD (f_left_right)]);
1710
    CPU (h_fr[FLD (f_dest)]) = opval;
1711
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1712
  }
1713
 
1714
#undef FLD
1715
}
1716
  NEXT (vpc);
1717
 
1718
  CASE (sem, INSN_FMOVSL) : /* fmov.sl $frgh, $rd */
1719
{
1720
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1721
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1722
#define FLD(f) abuf->fields.sfmt_fabsd.f
1723
  int UNUSED written = 0;
1724
  IADDR UNUSED pc = abuf->addr;
1725
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1726
 
1727
  {
1728
    DI opval = EXTSIDI (SUBWORDSFSI (CPU (h_fr[FLD (f_left_right)])));
1729
    SET_H_GR (FLD (f_dest), opval);
1730
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
1731
  }
1732
 
1733
#undef FLD
1734
}
1735
  NEXT (vpc);
1736
 
1737
  CASE (sem, INSN_FMULD) : /* fmul.d $drg, $drh, $drf */
1738
{
1739
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1740
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1741
#define FLD(f) abuf->fields.sfmt_add.f
1742
  int UNUSED written = 0;
1743
  IADDR UNUSED pc = abuf->addr;
1744
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1745
 
1746
  {
1747
    DF opval = sh64_fmuld (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right)));
1748
    SET_H_DR (FLD (f_dest), opval);
1749
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1750
  }
1751
 
1752
#undef FLD
1753
}
1754
  NEXT (vpc);
1755
 
1756
  CASE (sem, INSN_FMULS) : /* fmul.s $frg, $frh, $frf */
1757
{
1758
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1759
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1760
#define FLD(f) abuf->fields.sfmt_add.f
1761
  int UNUSED written = 0;
1762
  IADDR UNUSED pc = abuf->addr;
1763
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1764
 
1765
  {
1766
    SF opval = sh64_fmuls (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)]));
1767
    CPU (h_fr[FLD (f_dest)]) = opval;
1768
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1769
  }
1770
 
1771
#undef FLD
1772
}
1773
  NEXT (vpc);
1774
 
1775
  CASE (sem, INSN_FNEGD) : /* fneg.d $drgh, $drf */
1776
{
1777
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1778
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1779
#define FLD(f) abuf->fields.sfmt_fabsd.f
1780
  int UNUSED written = 0;
1781
  IADDR UNUSED pc = abuf->addr;
1782
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1783
 
1784
  {
1785
    DF opval = sh64_fnegd (current_cpu, GET_H_DR (FLD (f_left_right)));
1786
    SET_H_DR (FLD (f_dest), opval);
1787
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1788
  }
1789
 
1790
#undef FLD
1791
}
1792
  NEXT (vpc);
1793
 
1794
  CASE (sem, INSN_FNEGS) : /* fneg.s $frgh, $frf */
1795
{
1796
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1797
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1798
#define FLD(f) abuf->fields.sfmt_fabsd.f
1799
  int UNUSED written = 0;
1800
  IADDR UNUSED pc = abuf->addr;
1801
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1802
 
1803
  {
1804
    SF opval = sh64_fnegs (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1805
    CPU (h_fr[FLD (f_dest)]) = opval;
1806
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1807
  }
1808
 
1809
#undef FLD
1810
}
1811
  NEXT (vpc);
1812
 
1813
  CASE (sem, INSN_FPUTSCR) : /* fputscr $frgh */
1814
{
1815
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1816
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1817
#define FLD(f) abuf->fields.sfmt_fabsd.f
1818
  int UNUSED written = 0;
1819
  IADDR UNUSED pc = abuf->addr;
1820
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1821
 
1822
  {
1823
    SI opval = SUBWORDSFSI (CPU (h_fr[FLD (f_left_right)]));
1824
    CPU (h_fpscr) = opval;
1825
    TRACE_RESULT (current_cpu, abuf, "fpscr", 'x', opval);
1826
  }
1827
 
1828
#undef FLD
1829
}
1830
  NEXT (vpc);
1831
 
1832
  CASE (sem, INSN_FSQRTD) : /* fsqrt.d $drgh, $drf */
1833
{
1834
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1835
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1836
#define FLD(f) abuf->fields.sfmt_fabsd.f
1837
  int UNUSED written = 0;
1838
  IADDR UNUSED pc = abuf->addr;
1839
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1840
 
1841
  {
1842
    DF opval = sh64_fsqrtd (current_cpu, GET_H_DR (FLD (f_left_right)));
1843
    SET_H_DR (FLD (f_dest), opval);
1844
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
1845
  }
1846
 
1847
#undef FLD
1848
}
1849
  NEXT (vpc);
1850
 
1851
  CASE (sem, INSN_FSQRTS) : /* fsqrt.s $frgh, $frf */
1852
{
1853
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1854
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1855
#define FLD(f) abuf->fields.sfmt_fabsd.f
1856
  int UNUSED written = 0;
1857
  IADDR UNUSED pc = abuf->addr;
1858
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1859
 
1860
  {
1861
    SF opval = sh64_fsqrts (current_cpu, CPU (h_fr[FLD (f_left_right)]));
1862
    CPU (h_fr[FLD (f_dest)]) = opval;
1863
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
1864
  }
1865
 
1866
#undef FLD
1867
}
1868
  NEXT (vpc);
1869
 
1870
  CASE (sem, INSN_FSTD) : /* fst.d $rm, $disp10x8, $drf */
1871
{
1872
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1873
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1874
#define FLD(f) abuf->fields.sfmt_fldd.f
1875
  int UNUSED written = 0;
1876
  IADDR UNUSED pc = abuf->addr;
1877
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1878
 
1879
  {
1880
    DF opval = GET_H_DR (FLD (f_dest));
1881
    SETMEMDF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp10x8)), opval);
1882
    TRACE_RESULT (current_cpu, abuf, "memory", 'f', opval);
1883
  }
1884
 
1885
#undef FLD
1886
}
1887
  NEXT (vpc);
1888
 
1889
  CASE (sem, INSN_FSTP) : /* fst.p $rm, $disp10x8, $fpf */
1890
{
1891
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1892
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1893
#define FLD(f) abuf->fields.sfmt_fldd.f
1894
  int UNUSED written = 0;
1895
  IADDR UNUSED pc = abuf->addr;
1896
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1897
 
1898
{
1899
  {
1900
    SF opval = GET_H_FP (FLD (f_dest));
1901
    SET_H_FP (FLD (f_dest), opval);
1902
    TRACE_RESULT (current_cpu, abuf, "fp", 'f', opval);
1903
  }
1904
sh64_fstp (current_cpu, pc, GET_H_GR (FLD (f_left)), FLD (f_disp10x8), FLD (f_dest));
1905
}
1906
 
1907
#undef FLD
1908
}
1909
  NEXT (vpc);
1910
 
1911
  CASE (sem, INSN_FSTS) : /* fst.s $rm, $disp10x4, $frf */
1912
{
1913
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1914
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1915
#define FLD(f) abuf->fields.sfmt_flds.f
1916
  int UNUSED written = 0;
1917
  IADDR UNUSED pc = abuf->addr;
1918
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1919
 
1920
  {
1921
    SF opval = CPU (h_fr[FLD (f_dest)]);
1922
    SETMEMSF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp10x4)), opval);
1923
    TRACE_RESULT (current_cpu, abuf, "memory", 'f', opval);
1924
  }
1925
 
1926
#undef FLD
1927
}
1928
  NEXT (vpc);
1929
 
1930
  CASE (sem, INSN_FSTXD) : /* fstx.d $rm, $rn, $drf */
1931
{
1932
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1933
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1934
#define FLD(f) abuf->fields.sfmt_add.f
1935
  int UNUSED written = 0;
1936
  IADDR UNUSED pc = abuf->addr;
1937
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1938
 
1939
  {
1940
    DF opval = GET_H_DR (FLD (f_dest));
1941
    SETMEMDF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
1942
    TRACE_RESULT (current_cpu, abuf, "memory", 'f', opval);
1943
  }
1944
 
1945
#undef FLD
1946
}
1947
  NEXT (vpc);
1948
 
1949
  CASE (sem, INSN_FSTXP) : /* fstx.p $rm, $rn, $fpf */
1950
{
1951
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1952
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1953
#define FLD(f) abuf->fields.sfmt_add.f
1954
  int UNUSED written = 0;
1955
  IADDR UNUSED pc = abuf->addr;
1956
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1957
 
1958
{
1959
  {
1960
    SF opval = GET_H_FP (FLD (f_dest));
1961
    SET_H_FP (FLD (f_dest), opval);
1962
    TRACE_RESULT (current_cpu, abuf, "fp", 'f', opval);
1963
  }
1964
sh64_fstp (current_cpu, pc, GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)), FLD (f_dest));
1965
}
1966
 
1967
#undef FLD
1968
}
1969
  NEXT (vpc);
1970
 
1971
  CASE (sem, INSN_FSTXS) : /* fstx.s $rm, $rn, $frf */
1972
{
1973
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1974
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1975
#define FLD(f) abuf->fields.sfmt_add.f
1976
  int UNUSED written = 0;
1977
  IADDR UNUSED pc = abuf->addr;
1978
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1979
 
1980
  {
1981
    SF opval = CPU (h_fr[FLD (f_dest)]);
1982
    SETMEMSF (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
1983
    TRACE_RESULT (current_cpu, abuf, "memory", 'f', opval);
1984
  }
1985
 
1986
#undef FLD
1987
}
1988
  NEXT (vpc);
1989
 
1990
  CASE (sem, INSN_FSUBD) : /* fsub.d $drg, $drh, $drf */
1991
{
1992
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1993
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1994
#define FLD(f) abuf->fields.sfmt_add.f
1995
  int UNUSED written = 0;
1996
  IADDR UNUSED pc = abuf->addr;
1997
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1998
 
1999
  {
2000
    DF opval = sh64_fsubd (current_cpu, GET_H_DR (FLD (f_left)), GET_H_DR (FLD (f_right)));
2001
    SET_H_DR (FLD (f_dest), opval);
2002
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
2003
  }
2004
 
2005
#undef FLD
2006
}
2007
  NEXT (vpc);
2008
 
2009
  CASE (sem, INSN_FSUBS) : /* fsub.s $frg, $frh, $frf */
2010
{
2011
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2012
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2013
#define FLD(f) abuf->fields.sfmt_add.f
2014
  int UNUSED written = 0;
2015
  IADDR UNUSED pc = abuf->addr;
2016
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2017
 
2018
  {
2019
    SF opval = sh64_fsubs (current_cpu, CPU (h_fr[FLD (f_left)]), CPU (h_fr[FLD (f_right)]));
2020
    CPU (h_fr[FLD (f_dest)]) = opval;
2021
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
2022
  }
2023
 
2024
#undef FLD
2025
}
2026
  NEXT (vpc);
2027
 
2028
  CASE (sem, INSN_FTRCDL) : /* ftrc.dl $drgh, $frf */
2029
{
2030
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2031
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2032
#define FLD(f) abuf->fields.sfmt_fabsd.f
2033
  int UNUSED written = 0;
2034
  IADDR UNUSED pc = abuf->addr;
2035
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2036
 
2037
  {
2038
    SF opval = sh64_ftrcdl (current_cpu, GET_H_DR (FLD (f_left_right)));
2039
    CPU (h_fr[FLD (f_dest)]) = opval;
2040
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
2041
  }
2042
 
2043
#undef FLD
2044
}
2045
  NEXT (vpc);
2046
 
2047
  CASE (sem, INSN_FTRCSL) : /* ftrc.sl $frgh, $frf */
2048
{
2049
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2050
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2051
#define FLD(f) abuf->fields.sfmt_fabsd.f
2052
  int UNUSED written = 0;
2053
  IADDR UNUSED pc = abuf->addr;
2054
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2055
 
2056
  {
2057
    SF opval = sh64_ftrcsl (current_cpu, CPU (h_fr[FLD (f_left_right)]));
2058
    CPU (h_fr[FLD (f_dest)]) = opval;
2059
    TRACE_RESULT (current_cpu, abuf, "fr", 'f', opval);
2060
  }
2061
 
2062
#undef FLD
2063
}
2064
  NEXT (vpc);
2065
 
2066
  CASE (sem, INSN_FTRCDQ) : /* ftrc.dq $drgh, $drf */
2067
{
2068
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2069
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2070
#define FLD(f) abuf->fields.sfmt_fabsd.f
2071
  int UNUSED written = 0;
2072
  IADDR UNUSED pc = abuf->addr;
2073
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2074
 
2075
  {
2076
    DF opval = sh64_ftrcdq (current_cpu, GET_H_DR (FLD (f_left_right)));
2077
    SET_H_DR (FLD (f_dest), opval);
2078
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
2079
  }
2080
 
2081
#undef FLD
2082
}
2083
  NEXT (vpc);
2084
 
2085
  CASE (sem, INSN_FTRCSQ) : /* ftrc.sq $frgh, $drf */
2086
{
2087
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2088
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2089
#define FLD(f) abuf->fields.sfmt_fabsd.f
2090
  int UNUSED written = 0;
2091
  IADDR UNUSED pc = abuf->addr;
2092
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2093
 
2094
  {
2095
    DF opval = sh64_ftrcsq (current_cpu, CPU (h_fr[FLD (f_left_right)]));
2096
    SET_H_DR (FLD (f_dest), opval);
2097
    TRACE_RESULT (current_cpu, abuf, "dr", 'f', opval);
2098
  }
2099
 
2100
#undef FLD
2101
}
2102
  NEXT (vpc);
2103
 
2104
  CASE (sem, INSN_FTRVS) : /* ftrv.s $mtrxg, $fvh, $fvf */
2105
{
2106
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2107
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2108
#define FLD(f) abuf->fields.sfmt_add.f
2109
  int UNUSED written = 0;
2110
  IADDR UNUSED pc = abuf->addr;
2111
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2112
 
2113
{
2114
  {
2115
    SF opval = GET_H_FMTX (FLD (f_left));
2116
    SET_H_FMTX (FLD (f_left), opval);
2117
    TRACE_RESULT (current_cpu, abuf, "fmtx", 'f', opval);
2118
  }
2119
  {
2120
    SF opval = GET_H_FV (FLD (f_right));
2121
    SET_H_FV (FLD (f_right), opval);
2122
    TRACE_RESULT (current_cpu, abuf, "fv", 'f', opval);
2123
  }
2124
  {
2125
    SF opval = GET_H_FV (FLD (f_dest));
2126
    SET_H_FV (FLD (f_dest), opval);
2127
    TRACE_RESULT (current_cpu, abuf, "fv", 'f', opval);
2128
  }
2129
sh64_ftrvs (current_cpu, FLD (f_left), FLD (f_right), FLD (f_dest));
2130
}
2131
 
2132
#undef FLD
2133
}
2134
  NEXT (vpc);
2135
 
2136
  CASE (sem, INSN_GETCFG) : /* getcfg $rm, $disp6, $rd */
2137
{
2138
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2139
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2140
#define FLD(f) abuf->fields.sfmt_getcfg.f
2141
  int UNUSED written = 0;
2142
  IADDR UNUSED pc = abuf->addr;
2143
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2144
 
2145
{
2146
  SI tmp_address;
2147
  tmp_address = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2148
((void) 0); /*nop*/
2149
  {
2150
    DI opval = GETMEMSI (current_cpu, pc, tmp_address);
2151
    SET_H_GR (FLD (f_dest), opval);
2152
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2153
  }
2154
}
2155
 
2156
#undef FLD
2157
}
2158
  NEXT (vpc);
2159
 
2160
  CASE (sem, INSN_GETCON) : /* getcon $crk, $rd */
2161
{
2162
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2163
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2164
#define FLD(f) abuf->fields.sfmt_xori.f
2165
  int UNUSED written = 0;
2166
  IADDR UNUSED pc = abuf->addr;
2167
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2168
 
2169
  {
2170
    DI opval = GET_H_CR (FLD (f_left));
2171
    SET_H_GR (FLD (f_dest), opval);
2172
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2173
  }
2174
 
2175
#undef FLD
2176
}
2177
  NEXT (vpc);
2178
 
2179
  CASE (sem, INSN_GETTR) : /* gettr $trb, $rd */
2180
{
2181
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2182
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2183
#define FLD(f) abuf->fields.sfmt_blink.f
2184
  int UNUSED written = 0;
2185
  IADDR UNUSED pc = abuf->addr;
2186
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2187
 
2188
  {
2189
    DI opval = CPU (h_tr[FLD (f_trb)]);
2190
    SET_H_GR (FLD (f_dest), opval);
2191
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2192
  }
2193
 
2194
#undef FLD
2195
}
2196
  NEXT (vpc);
2197
 
2198
  CASE (sem, INSN_ICBI) : /* icbi $rm, $disp6x32 */
2199
{
2200
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2201
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2202
#define FLD(f) abuf->fields.sfmt_xori.f
2203
  int UNUSED written = 0;
2204
  IADDR UNUSED pc = abuf->addr;
2205
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2206
 
2207
{
2208
  {
2209
    DI opval = GET_H_GR (FLD (f_left));
2210
    SET_H_GR (FLD (f_left), opval);
2211
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2212
  }
2213
((void) 0); /*nop*/
2214
}
2215
 
2216
#undef FLD
2217
}
2218
  NEXT (vpc);
2219
 
2220
  CASE (sem, INSN_LDB) : /* ld.b $rm, $disp10, $rd */
2221
{
2222
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2223
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2224
#define FLD(f) abuf->fields.sfmt_addi.f
2225
  int UNUSED written = 0;
2226
  IADDR UNUSED pc = abuf->addr;
2227
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2228
 
2229
  {
2230
    DI opval = EXTQIDI (GETMEMQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10)))));
2231
    SET_H_GR (FLD (f_dest), opval);
2232
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2233
  }
2234
 
2235
#undef FLD
2236
}
2237
  NEXT (vpc);
2238
 
2239
  CASE (sem, INSN_LDL) : /* ld.l $rm, $disp10x4, $rd */
2240
{
2241
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2242
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2243
#define FLD(f) abuf->fields.sfmt_flds.f
2244
  int UNUSED written = 0;
2245
  IADDR UNUSED pc = abuf->addr;
2246
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2247
 
2248
  {
2249
    DI opval = EXTSIDI (GETMEMSI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x4)))));
2250
    SET_H_GR (FLD (f_dest), opval);
2251
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2252
  }
2253
 
2254
#undef FLD
2255
}
2256
  NEXT (vpc);
2257
 
2258
  CASE (sem, INSN_LDQ) : /* ld.q $rm, $disp10x8, $rd */
2259
{
2260
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2261
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2262
#define FLD(f) abuf->fields.sfmt_fldd.f
2263
  int UNUSED written = 0;
2264
  IADDR UNUSED pc = abuf->addr;
2265
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2266
 
2267
  {
2268
    DI opval = GETMEMDI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x8))));
2269
    SET_H_GR (FLD (f_dest), opval);
2270
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2271
  }
2272
 
2273
#undef FLD
2274
}
2275
  NEXT (vpc);
2276
 
2277
  CASE (sem, INSN_LDUB) : /* ld.ub $rm, $disp10, $rd */
2278
{
2279
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2280
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2281
#define FLD(f) abuf->fields.sfmt_addi.f
2282
  int UNUSED written = 0;
2283
  IADDR UNUSED pc = abuf->addr;
2284
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2285
 
2286
  {
2287
    DI opval = ZEXTQIDI (GETMEMQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10)))));
2288
    SET_H_GR (FLD (f_dest), opval);
2289
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2290
  }
2291
 
2292
#undef FLD
2293
}
2294
  NEXT (vpc);
2295
 
2296
  CASE (sem, INSN_LDUW) : /* ld.uw $rm, $disp10x2, $rd */
2297
{
2298
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2299
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2300
#define FLD(f) abuf->fields.sfmt_lduw.f
2301
  int UNUSED written = 0;
2302
  IADDR UNUSED pc = abuf->addr;
2303
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2304
 
2305
  {
2306
    DI opval = ZEXTHIDI (GETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x2)))));
2307
    SET_H_GR (FLD (f_dest), opval);
2308
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2309
  }
2310
 
2311
#undef FLD
2312
}
2313
  NEXT (vpc);
2314
 
2315
  CASE (sem, INSN_LDW) : /* ld.w $rm, $disp10x2, $rd */
2316
{
2317
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2318
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2319
#define FLD(f) abuf->fields.sfmt_lduw.f
2320
  int UNUSED written = 0;
2321
  IADDR UNUSED pc = abuf->addr;
2322
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2323
 
2324
  {
2325
    DI opval = EXTHIDI (GETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x2)))));
2326
    SET_H_GR (FLD (f_dest), opval);
2327
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2328
  }
2329
 
2330
#undef FLD
2331
}
2332
  NEXT (vpc);
2333
 
2334
  CASE (sem, INSN_LDHIL) : /* ldhi.l $rm, $disp6, $rd */
2335
{
2336
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2337
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2338
#define FLD(f) abuf->fields.sfmt_getcfg.f
2339
  int UNUSED written = 0;
2340
  IADDR UNUSED pc = abuf->addr;
2341
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2342
 
2343
{
2344
  DI tmp_addr;
2345
  QI tmp_bytecount;
2346
  SI tmp_val;
2347
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2348
  tmp_bytecount = ADDDI (ANDDI (tmp_addr, 3), 1);
2349
  tmp_val = 0;
2350
if (ANDQI (tmp_bytecount, 4)) {
2351
  {
2352
    DI opval = EXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -4)));
2353
    SET_H_GR (FLD (f_dest), opval);
2354
    written |= (1 << 6);
2355
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2356
  }
2357
} else {
2358
if (GET_H_ENDIAN ()) {
2359
{
2360
if (ANDQI (tmp_bytecount, 2)) {
2361
  tmp_val = ADDSI (SLLSI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4))));
2362
}
2363
if (ANDQI (tmp_bytecount, 1)) {
2364
  tmp_val = ADDSI (SLLSI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2365
}
2366
  {
2367
    DI opval = EXTSIDI (tmp_val);
2368
    SET_H_GR (FLD (f_dest), opval);
2369
    written |= (1 << 6);
2370
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2371
  }
2372
}
2373
} else {
2374
{
2375
if (ANDQI (tmp_bytecount, 1)) {
2376
  tmp_val = ADDSI (SLLSI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2377
}
2378
if (ANDQI (tmp_bytecount, 2)) {
2379
  tmp_val = ADDSI (SLLSI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4))));
2380
}
2381
  {
2382
    DI opval = EXTSIDI (SLLSI (tmp_val, SUBSI (32, MULSI (8, tmp_bytecount))));
2383
    SET_H_GR (FLD (f_dest), opval);
2384
    written |= (1 << 6);
2385
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2386
  }
2387
}
2388
}
2389
}
2390
}
2391
 
2392
  abuf->written = written;
2393
#undef FLD
2394
}
2395
  NEXT (vpc);
2396
 
2397
  CASE (sem, INSN_LDHIQ) : /* ldhi.q $rm, $disp6, $rd */
2398
{
2399
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2400
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2401
#define FLD(f) abuf->fields.sfmt_getcfg.f
2402
  int UNUSED written = 0;
2403
  IADDR UNUSED pc = abuf->addr;
2404
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2405
 
2406
{
2407
  DI tmp_addr;
2408
  QI tmp_bytecount;
2409
  DI tmp_val;
2410
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2411
  tmp_bytecount = ADDDI (ANDDI (tmp_addr, 7), 1);
2412
  tmp_val = 0;
2413
if (ANDQI (tmp_bytecount, 8)) {
2414
  {
2415
    DI opval = GETMEMDI (current_cpu, pc, ANDDI (tmp_addr, -8));
2416
    SET_H_GR (FLD (f_dest), opval);
2417
    written |= (1 << 7);
2418
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2419
  }
2420
} else {
2421
if (GET_H_ENDIAN ()) {
2422
{
2423
if (ANDQI (tmp_bytecount, 4)) {
2424
  tmp_val = ADDDI (SLLDI (tmp_val, 32), ZEXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -8))));
2425
}
2426
if (ANDQI (tmp_bytecount, 2)) {
2427
  tmp_val = ADDDI (SLLDI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4))));
2428
}
2429
if (ANDQI (tmp_bytecount, 1)) {
2430
  tmp_val = ADDDI (SLLDI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2431
}
2432
  {
2433
    DI opval = tmp_val;
2434
    SET_H_GR (FLD (f_dest), opval);
2435
    written |= (1 << 7);
2436
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2437
  }
2438
}
2439
} else {
2440
{
2441
if (ANDQI (tmp_bytecount, 1)) {
2442
  tmp_val = ADDDI (SLLDI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2443
}
2444
if (ANDQI (tmp_bytecount, 2)) {
2445
  tmp_val = ADDDI (SLLDI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4))));
2446
}
2447
if (ANDQI (tmp_bytecount, 4)) {
2448
  tmp_val = ADDDI (SLLDI (tmp_val, 32), ZEXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -8))));
2449
}
2450
  {
2451
    DI opval = SLLDI (tmp_val, SUBSI (64, MULSI (8, tmp_bytecount)));
2452
    SET_H_GR (FLD (f_dest), opval);
2453
    written |= (1 << 7);
2454
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2455
  }
2456
}
2457
}
2458
}
2459
}
2460
 
2461
  abuf->written = written;
2462
#undef FLD
2463
}
2464
  NEXT (vpc);
2465
 
2466
  CASE (sem, INSN_LDLOL) : /* ldlo.l $rm, $disp6, $rd */
2467
{
2468
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2469
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2470
#define FLD(f) abuf->fields.sfmt_getcfg.f
2471
  int UNUSED written = 0;
2472
  IADDR UNUSED pc = abuf->addr;
2473
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2474
 
2475
{
2476
  DI tmp_addr;
2477
  QI tmp_bytecount;
2478
  SI tmp_val;
2479
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2480
  tmp_bytecount = SUBSI (4, ANDDI (tmp_addr, 3));
2481
  tmp_val = 0;
2482
if (ANDQI (tmp_bytecount, 4)) {
2483
  {
2484
    DI opval = EXTSIDI (GETMEMSI (current_cpu, pc, tmp_addr));
2485
    SET_H_GR (FLD (f_dest), opval);
2486
    written |= (1 << 6);
2487
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2488
  }
2489
} else {
2490
if (GET_H_ENDIAN ()) {
2491
{
2492
if (ANDQI (tmp_bytecount, 1)) {
2493
  tmp_val = ADDSI (SLLSI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2494
}
2495
if (ANDQI (tmp_bytecount, 2)) {
2496
  tmp_val = ADDSI (SLLSI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2))));
2497
}
2498
  {
2499
    DI opval = EXTSIDI (SLLSI (tmp_val, SUBSI (32, MULSI (8, tmp_bytecount))));
2500
    SET_H_GR (FLD (f_dest), opval);
2501
    written |= (1 << 6);
2502
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2503
  }
2504
}
2505
} else {
2506
{
2507
if (ANDQI (tmp_bytecount, 2)) {
2508
  tmp_val = ADDSI (SLLSI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2))));
2509
}
2510
if (ANDQI (tmp_bytecount, 1)) {
2511
  tmp_val = ADDSI (SLLSI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2512
}
2513
  {
2514
    DI opval = EXTSIDI (tmp_val);
2515
    SET_H_GR (FLD (f_dest), opval);
2516
    written |= (1 << 6);
2517
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2518
  }
2519
}
2520
}
2521
}
2522
}
2523
 
2524
  abuf->written = written;
2525
#undef FLD
2526
}
2527
  NEXT (vpc);
2528
 
2529
  CASE (sem, INSN_LDLOQ) : /* ldlo.q $rm, $disp6, $rd */
2530
{
2531
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2532
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2533
#define FLD(f) abuf->fields.sfmt_getcfg.f
2534
  int UNUSED written = 0;
2535
  IADDR UNUSED pc = abuf->addr;
2536
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2537
 
2538
{
2539
  DI tmp_addr;
2540
  QI tmp_bytecount;
2541
  DI tmp_val;
2542
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
2543
  tmp_bytecount = SUBSI (8, ANDDI (tmp_addr, 7));
2544
  tmp_val = 0;
2545
if (ANDQI (tmp_bytecount, 8)) {
2546
  {
2547
    DI opval = GETMEMDI (current_cpu, pc, tmp_addr);
2548
    SET_H_GR (FLD (f_dest), opval);
2549
    written |= (1 << 7);
2550
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2551
  }
2552
} else {
2553
if (GET_H_ENDIAN ()) {
2554
{
2555
if (ANDQI (tmp_bytecount, 1)) {
2556
  tmp_val = ADDDI (SLLDI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2557
}
2558
if (ANDQI (tmp_bytecount, 2)) {
2559
  tmp_val = ADDDI (SLLDI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2))));
2560
}
2561
if (ANDQI (tmp_bytecount, 4)) {
2562
  tmp_val = ADDDI (SLLDI (tmp_val, 32), ZEXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 3), -4))));
2563
}
2564
  {
2565
    DI opval = SLLDI (tmp_val, SUBSI (64, MULSI (8, tmp_bytecount)));
2566
    SET_H_GR (FLD (f_dest), opval);
2567
    written |= (1 << 7);
2568
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2569
  }
2570
}
2571
} else {
2572
{
2573
if (ANDQI (tmp_bytecount, 4)) {
2574
  tmp_val = ADDDI (SLLDI (tmp_val, 32), ZEXTSIDI (GETMEMSI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 3), -4))));
2575
}
2576
if (ANDQI (tmp_bytecount, 2)) {
2577
  tmp_val = ADDDI (SLLDI (tmp_val, 16), ZEXTHIDI (GETMEMHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2))));
2578
}
2579
if (ANDQI (tmp_bytecount, 1)) {
2580
  tmp_val = ADDDI (SLLDI (tmp_val, 8), ZEXTQIDI (GETMEMQI (current_cpu, pc, tmp_addr)));
2581
}
2582
  {
2583
    DI opval = tmp_val;
2584
    SET_H_GR (FLD (f_dest), opval);
2585
    written |= (1 << 7);
2586
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2587
  }
2588
}
2589
}
2590
}
2591
}
2592
 
2593
  abuf->written = written;
2594
#undef FLD
2595
}
2596
  NEXT (vpc);
2597
 
2598
  CASE (sem, INSN_LDXB) : /* ldx.b $rm, $rn, $rd */
2599
{
2600
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2601
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2602
#define FLD(f) abuf->fields.sfmt_add.f
2603
  int UNUSED written = 0;
2604
  IADDR UNUSED pc = abuf->addr;
2605
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2606
 
2607
  {
2608
    DI opval = EXTQIDI (GETMEMQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2609
    SET_H_GR (FLD (f_dest), opval);
2610
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2611
  }
2612
 
2613
#undef FLD
2614
}
2615
  NEXT (vpc);
2616
 
2617
  CASE (sem, INSN_LDXL) : /* ldx.l $rm, $rn, $rd */
2618
{
2619
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2620
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2621
#define FLD(f) abuf->fields.sfmt_add.f
2622
  int UNUSED written = 0;
2623
  IADDR UNUSED pc = abuf->addr;
2624
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2625
 
2626
  {
2627
    DI opval = EXTSIDI (GETMEMSI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2628
    SET_H_GR (FLD (f_dest), opval);
2629
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2630
  }
2631
 
2632
#undef FLD
2633
}
2634
  NEXT (vpc);
2635
 
2636
  CASE (sem, INSN_LDXQ) : /* ldx.q $rm, $rn, $rd */
2637
{
2638
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2639
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2640
#define FLD(f) abuf->fields.sfmt_add.f
2641
  int UNUSED written = 0;
2642
  IADDR UNUSED pc = abuf->addr;
2643
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2644
 
2645
  {
2646
    DI opval = GETMEMDI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))));
2647
    SET_H_GR (FLD (f_dest), opval);
2648
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2649
  }
2650
 
2651
#undef FLD
2652
}
2653
  NEXT (vpc);
2654
 
2655
  CASE (sem, INSN_LDXUB) : /* ldx.ub $rm, $rn, $rd */
2656
{
2657
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2658
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2659
#define FLD(f) abuf->fields.sfmt_add.f
2660
  int UNUSED written = 0;
2661
  IADDR UNUSED pc = abuf->addr;
2662
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2663
 
2664
  {
2665
    DI opval = ZEXTQIDI (GETMEMUQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2666
    SET_H_GR (FLD (f_dest), opval);
2667
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2668
  }
2669
 
2670
#undef FLD
2671
}
2672
  NEXT (vpc);
2673
 
2674
  CASE (sem, INSN_LDXUW) : /* ldx.uw $rm, $rn, $rd */
2675
{
2676
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2677
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2678
#define FLD(f) abuf->fields.sfmt_add.f
2679
  int UNUSED written = 0;
2680
  IADDR UNUSED pc = abuf->addr;
2681
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2682
 
2683
  {
2684
    DI opval = ZEXTHIDI (GETMEMUHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2685
    SET_H_GR (FLD (f_dest), opval);
2686
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2687
  }
2688
 
2689
#undef FLD
2690
}
2691
  NEXT (vpc);
2692
 
2693
  CASE (sem, INSN_LDXW) : /* ldx.w $rm, $rn, $rd */
2694
{
2695
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2696
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2697
#define FLD(f) abuf->fields.sfmt_add.f
2698
  int UNUSED written = 0;
2699
  IADDR UNUSED pc = abuf->addr;
2700
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2701
 
2702
  {
2703
    DI opval = EXTHIDI (GETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)))));
2704
    SET_H_GR (FLD (f_dest), opval);
2705
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2706
  }
2707
 
2708
#undef FLD
2709
}
2710
  NEXT (vpc);
2711
 
2712
  CASE (sem, INSN_MABSL) : /* mabs.l $rm, $rd */
2713
{
2714
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2715
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2716
#define FLD(f) abuf->fields.sfmt_xori.f
2717
  int UNUSED written = 0;
2718
  IADDR UNUSED pc = abuf->addr;
2719
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2720
 
2721
{
2722
  SI tmp_result1;
2723
  SI tmp_result0;
2724
  tmp_result0 = ABSSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1));
2725
  tmp_result1 = ABSSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0));
2726
  {
2727
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2728
    SET_H_GR (FLD (f_dest), opval);
2729
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2730
  }
2731
}
2732
 
2733
#undef FLD
2734
}
2735
  NEXT (vpc);
2736
 
2737
  CASE (sem, INSN_MABSW) : /* mabs.w $rm, $rd */
2738
{
2739
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2740
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2741
#define FLD(f) abuf->fields.sfmt_xori.f
2742
  int UNUSED written = 0;
2743
  IADDR UNUSED pc = abuf->addr;
2744
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2745
 
2746
{
2747
  HI tmp_result3;
2748
  HI tmp_result2;
2749
  HI tmp_result1;
2750
  HI tmp_result0;
2751
  tmp_result0 = ABSHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3));
2752
  tmp_result1 = ABSHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2));
2753
  tmp_result2 = ABSHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1));
2754
  tmp_result3 = ABSHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0));
2755
  {
2756
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
2757
    SET_H_GR (FLD (f_dest), opval);
2758
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2759
  }
2760
}
2761
 
2762
#undef FLD
2763
}
2764
  NEXT (vpc);
2765
 
2766
  CASE (sem, INSN_MADDL) : /* madd.l $rm, $rn, $rd */
2767
{
2768
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2769
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2770
#define FLD(f) abuf->fields.sfmt_add.f
2771
  int UNUSED written = 0;
2772
  IADDR UNUSED pc = abuf->addr;
2773
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2774
 
2775
{
2776
  SI tmp_result1;
2777
  SI tmp_result0;
2778
  tmp_result0 = ADDSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1));
2779
  tmp_result1 = ADDSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0));
2780
  {
2781
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2782
    SET_H_GR (FLD (f_dest), opval);
2783
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2784
  }
2785
}
2786
 
2787
#undef FLD
2788
}
2789
  NEXT (vpc);
2790
 
2791
  CASE (sem, INSN_MADDW) : /* madd.w $rm, $rn, $rd */
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_add.f
2796
  int UNUSED written = 0;
2797
  IADDR UNUSED pc = abuf->addr;
2798
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2799
 
2800
{
2801
  HI tmp_result3;
2802
  HI tmp_result2;
2803
  HI tmp_result1;
2804
  HI tmp_result0;
2805
  tmp_result0 = ADDHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3));
2806
  tmp_result1 = ADDHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2));
2807
  tmp_result2 = ADDHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1));
2808
  tmp_result3 = ADDHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0));
2809
  {
2810
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
2811
    SET_H_GR (FLD (f_dest), opval);
2812
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2813
  }
2814
}
2815
 
2816
#undef FLD
2817
}
2818
  NEXT (vpc);
2819
 
2820
  CASE (sem, INSN_MADDSL) : /* madds.l $rm, $rn, $rd */
2821
{
2822
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2823
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2824
#define FLD(f) abuf->fields.sfmt_add.f
2825
  int UNUSED written = 0;
2826
  IADDR UNUSED pc = abuf->addr;
2827
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2828
 
2829
{
2830
  SI tmp_result1;
2831
  SI tmp_result0;
2832
  tmp_result0 = ((LTDI (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, SUBSI (32, 1)))) ? (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
2833
  tmp_result1 = ((LTDI (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, SUBSI (32, 1)))) ? (ADDDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0)))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
2834
  {
2835
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2836
    SET_H_GR (FLD (f_dest), opval);
2837
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2838
  }
2839
}
2840
 
2841
#undef FLD
2842
}
2843
  NEXT (vpc);
2844
 
2845
  CASE (sem, INSN_MADDSUB) : /* madds.ub $rm, $rn, $rd */
2846
{
2847
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2848
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2849
#define FLD(f) abuf->fields.sfmt_add.f
2850
  int UNUSED written = 0;
2851
  IADDR UNUSED pc = abuf->addr;
2852
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2853
 
2854
{
2855
  QI tmp_result7;
2856
  QI tmp_result6;
2857
  QI tmp_result5;
2858
  QI tmp_result4;
2859
  QI tmp_result3;
2860
  QI tmp_result2;
2861
  QI tmp_result1;
2862
  QI tmp_result0;
2863
  tmp_result0 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7)))) : (SUBQI (SLLQI (1, 8), 1)))));
2864
  tmp_result1 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6)))) : (SUBQI (SLLQI (1, 8), 1)))));
2865
  tmp_result2 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5)))) : (SUBQI (SLLQI (1, 8), 1)))));
2866
  tmp_result3 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4)))) : (SUBQI (SLLQI (1, 8), 1)))));
2867
  tmp_result4 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3)))) : (SUBQI (SLLQI (1, 8), 1)))));
2868
  tmp_result5 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2)))) : (SUBQI (SLLQI (1, 8), 1)))));
2869
  tmp_result6 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1)))) : (SUBQI (SLLQI (1, 8), 1)))));
2870
  tmp_result7 = ((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), MAKEDI (0, 0))) ? (0) : (((LTDI (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, 8))) ? (ADDDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0)))) : (SUBQI (SLLQI (1, 8), 1)))));
2871
  {
2872
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
2873
    SET_H_GR (FLD (f_dest), opval);
2874
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2875
  }
2876
}
2877
 
2878
#undef FLD
2879
}
2880
  NEXT (vpc);
2881
 
2882
  CASE (sem, INSN_MADDSW) : /* madds.w $rm, $rn, $rd */
2883
{
2884
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2885
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2886
#define FLD(f) abuf->fields.sfmt_add.f
2887
  int UNUSED written = 0;
2888
  IADDR UNUSED pc = abuf->addr;
2889
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2890
 
2891
{
2892
  HI tmp_result3;
2893
  HI tmp_result2;
2894
  HI tmp_result1;
2895
  HI tmp_result0;
2896
  tmp_result0 = ((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))), SLLDI (1, SUBSI (16, 1)))) ? (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
2897
  tmp_result1 = ((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))), SLLDI (1, SUBSI (16, 1)))) ? (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
2898
  tmp_result2 = ((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, SUBSI (16, 1)))) ? (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
2899
  tmp_result3 = ((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, SUBSI (16, 1)))) ? (ADDDI (EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), EXTHIDI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
2900
  {
2901
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
2902
    SET_H_GR (FLD (f_dest), opval);
2903
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2904
  }
2905
}
2906
 
2907
#undef FLD
2908
}
2909
  NEXT (vpc);
2910
 
2911
  CASE (sem, INSN_MCMPEQB) : /* mcmpeq.b $rm, $rn, $rd */
2912
{
2913
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2914
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2915
#define FLD(f) abuf->fields.sfmt_add.f
2916
  int UNUSED written = 0;
2917
  IADDR UNUSED pc = abuf->addr;
2918
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2919
 
2920
{
2921
  QI tmp_result7;
2922
  QI tmp_result6;
2923
  QI tmp_result5;
2924
  QI tmp_result4;
2925
  QI tmp_result3;
2926
  QI tmp_result2;
2927
  QI tmp_result1;
2928
  QI tmp_result0;
2929
  tmp_result0 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))) ? (INVQI (0)) : (0));
2930
  tmp_result1 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))) ? (INVQI (0)) : (0));
2931
  tmp_result2 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))) ? (INVQI (0)) : (0));
2932
  tmp_result3 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))) ? (INVQI (0)) : (0));
2933
  tmp_result4 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))) ? (INVQI (0)) : (0));
2934
  tmp_result5 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))) ? (INVQI (0)) : (0));
2935
  tmp_result6 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))) ? (INVQI (0)) : (0));
2936
  tmp_result7 = ((EQQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))) ? (INVQI (0)) : (0));
2937
  {
2938
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
2939
    SET_H_GR (FLD (f_dest), opval);
2940
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2941
  }
2942
}
2943
 
2944
#undef FLD
2945
}
2946
  NEXT (vpc);
2947
 
2948
  CASE (sem, INSN_MCMPEQL) : /* mcmpeq.l $rm, $rn, $rd */
2949
{
2950
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2951
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2952
#define FLD(f) abuf->fields.sfmt_add.f
2953
  int UNUSED written = 0;
2954
  IADDR UNUSED pc = abuf->addr;
2955
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2956
 
2957
{
2958
  SI tmp_result1;
2959
  SI tmp_result0;
2960
  tmp_result0 = ((EQSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))) ? (INVSI (0)) : (0));
2961
  tmp_result1 = ((EQSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))) ? (INVSI (0)) : (0));
2962
  {
2963
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
2964
    SET_H_GR (FLD (f_dest), opval);
2965
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2966
  }
2967
}
2968
 
2969
#undef FLD
2970
}
2971
  NEXT (vpc);
2972
 
2973
  CASE (sem, INSN_MCMPEQW) : /* mcmpeq.w $rm, $rn, $rd */
2974
{
2975
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2976
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2977
#define FLD(f) abuf->fields.sfmt_add.f
2978
  int UNUSED written = 0;
2979
  IADDR UNUSED pc = abuf->addr;
2980
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2981
 
2982
{
2983
  HI tmp_result3;
2984
  HI tmp_result2;
2985
  HI tmp_result1;
2986
  HI tmp_result0;
2987
  tmp_result0 = ((EQHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))) ? (INVHI (0)) : (0));
2988
  tmp_result1 = ((EQHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))) ? (INVHI (0)) : (0));
2989
  tmp_result2 = ((EQHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))) ? (INVHI (0)) : (0));
2990
  tmp_result3 = ((EQHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0))) ? (INVHI (0)) : (0));
2991
  {
2992
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
2993
    SET_H_GR (FLD (f_dest), opval);
2994
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
2995
  }
2996
}
2997
 
2998
#undef FLD
2999
}
3000
  NEXT (vpc);
3001
 
3002
  CASE (sem, INSN_MCMPGTL) : /* mcmpgt.l $rm, $rn, $rd */
3003
{
3004
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3005
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3006
#define FLD(f) abuf->fields.sfmt_add.f
3007
  int UNUSED written = 0;
3008
  IADDR UNUSED pc = abuf->addr;
3009
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3010
 
3011
{
3012
  SI tmp_result1;
3013
  SI tmp_result0;
3014
  tmp_result0 = ((GTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))) ? (INVSI (0)) : (0));
3015
  tmp_result1 = ((GTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))) ? (INVSI (0)) : (0));
3016
  {
3017
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3018
    SET_H_GR (FLD (f_dest), opval);
3019
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3020
  }
3021
}
3022
 
3023
#undef FLD
3024
}
3025
  NEXT (vpc);
3026
 
3027
  CASE (sem, INSN_MCMPGTUB) : /* mcmpgt.ub $rm, $rn, $rd */
3028
{
3029
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3030
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3031
#define FLD(f) abuf->fields.sfmt_add.f
3032
  int UNUSED written = 0;
3033
  IADDR UNUSED pc = abuf->addr;
3034
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3035
 
3036
{
3037
  QI tmp_result7;
3038
  QI tmp_result6;
3039
  QI tmp_result5;
3040
  QI tmp_result4;
3041
  QI tmp_result3;
3042
  QI tmp_result2;
3043
  QI tmp_result1;
3044
  QI tmp_result0;
3045
  tmp_result0 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))) ? (INVQI (0)) : (0));
3046
  tmp_result1 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))) ? (INVQI (0)) : (0));
3047
  tmp_result2 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))) ? (INVQI (0)) : (0));
3048
  tmp_result3 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))) ? (INVQI (0)) : (0));
3049
  tmp_result4 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))) ? (INVQI (0)) : (0));
3050
  tmp_result5 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))) ? (INVQI (0)) : (0));
3051
  tmp_result6 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))) ? (INVQI (0)) : (0));
3052
  tmp_result7 = ((GTUQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))) ? (INVQI (0)) : (0));
3053
  {
3054
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
3055
    SET_H_GR (FLD (f_dest), opval);
3056
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3057
  }
3058
}
3059
 
3060
#undef FLD
3061
}
3062
  NEXT (vpc);
3063
 
3064
  CASE (sem, INSN_MCMPGTW) : /* mcmpgt.w $rm, $rn, $rd */
3065
{
3066
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3067
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3068
#define FLD(f) abuf->fields.sfmt_add.f
3069
  int UNUSED written = 0;
3070
  IADDR UNUSED pc = abuf->addr;
3071
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3072
 
3073
{
3074
  HI tmp_result3;
3075
  HI tmp_result2;
3076
  HI tmp_result1;
3077
  HI tmp_result0;
3078
  tmp_result0 = ((GTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))) ? (INVHI (0)) : (0));
3079
  tmp_result1 = ((GTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))) ? (INVHI (0)) : (0));
3080
  tmp_result2 = ((GTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))) ? (INVHI (0)) : (0));
3081
  tmp_result3 = ((GTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0))) ? (INVHI (0)) : (0));
3082
  {
3083
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3084
    SET_H_GR (FLD (f_dest), opval);
3085
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3086
  }
3087
}
3088
 
3089
#undef FLD
3090
}
3091
  NEXT (vpc);
3092
 
3093
  CASE (sem, INSN_MCMV) : /* mcmv $rm, $rn, $rd */
3094
{
3095
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3096
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3097
#define FLD(f) abuf->fields.sfmt_add.f
3098
  int UNUSED written = 0;
3099
  IADDR UNUSED pc = abuf->addr;
3100
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3101
 
3102
  {
3103
    DI opval = ORDI (ANDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), ANDDI (GET_H_GR (FLD (f_dest)), INVDI (GET_H_GR (FLD (f_right)))));
3104
    SET_H_GR (FLD (f_dest), opval);
3105
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3106
  }
3107
 
3108
#undef FLD
3109
}
3110
  NEXT (vpc);
3111
 
3112
  CASE (sem, INSN_MCNVSLW) : /* mcnvs.lw $rm, $rn, $rd */
3113
{
3114
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3115
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3116
#define FLD(f) abuf->fields.sfmt_add.f
3117
  int UNUSED written = 0;
3118
  IADDR UNUSED pc = abuf->addr;
3119
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3120
 
3121
{
3122
  HI tmp_result3;
3123
  HI tmp_result2;
3124
  HI tmp_result1;
3125
  HI tmp_result0;
3126
  tmp_result0 = ((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SLLDI (1, SUBSI (16, 1)))) ? (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3127
  tmp_result1 = ((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SLLDI (1, SUBSI (16, 1)))) ? (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3128
  tmp_result2 = ((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1), SLLDI (1, SUBSI (16, 1)))) ? (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3129
  tmp_result3 = ((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0), SLLDI (1, SUBSI (16, 1)))) ? (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3130
  {
3131
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3132
    SET_H_GR (FLD (f_dest), opval);
3133
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3134
  }
3135
}
3136
 
3137
#undef FLD
3138
}
3139
  NEXT (vpc);
3140
 
3141
  CASE (sem, INSN_MCNVSWB) : /* mcnvs.wb $rm, $rn, $rd */
3142
{
3143
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3144
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3145
#define FLD(f) abuf->fields.sfmt_add.f
3146
  int UNUSED written = 0;
3147
  IADDR UNUSED pc = abuf->addr;
3148
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3149
 
3150
{
3151
  QI tmp_result7;
3152
  QI tmp_result6;
3153
  QI tmp_result5;
3154
  QI tmp_result4;
3155
  QI tmp_result3;
3156
  QI tmp_result2;
3157
  QI tmp_result1;
3158
  QI tmp_result0;
3159
  tmp_result0 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3160
  tmp_result1 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3161
  tmp_result2 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3162
  tmp_result3 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3163
  tmp_result4 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3164
  tmp_result5 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3165
  tmp_result6 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3166
  tmp_result7 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0), NEGDI (SLLDI (1, SUBSI (8, 1))))) ? (NEGQI (SLLQI (1, SUBSI (8, 1)))) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0), SLLDI (1, SUBSI (8, 1)))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)) : (SUBQI (SLLQI (1, SUBSI (8, 1)), 1)))));
3167
  {
3168
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
3169
    SET_H_GR (FLD (f_dest), opval);
3170
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3171
  }
3172
}
3173
 
3174
#undef FLD
3175
}
3176
  NEXT (vpc);
3177
 
3178
  CASE (sem, INSN_MCNVSWUB) : /* mcnvs.wub $rm, $rn, $rd */
3179
{
3180
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3181
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3182
#define FLD(f) abuf->fields.sfmt_add.f
3183
  int UNUSED written = 0;
3184
  IADDR UNUSED pc = abuf->addr;
3185
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3186
 
3187
{
3188
  QI tmp_result7;
3189
  QI tmp_result6;
3190
  QI tmp_result5;
3191
  QI tmp_result4;
3192
  QI tmp_result3;
3193
  QI tmp_result2;
3194
  QI tmp_result1;
3195
  QI tmp_result0;
3196
  tmp_result0 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)) : (SUBQI (SLLQI (1, 8), 1)))));
3197
  tmp_result1 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)) : (SUBQI (SLLQI (1, 8), 1)))));
3198
  tmp_result2 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)) : (SUBQI (SLLQI (1, 8), 1)))));
3199
  tmp_result3 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)) : (SUBQI (SLLQI (1, 8), 1)))));
3200
  tmp_result4 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)) : (SUBQI (SLLQI (1, 8), 1)))));
3201
  tmp_result5 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)) : (SUBQI (SLLQI (1, 8), 1)))));
3202
  tmp_result6 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)) : (SUBQI (SLLQI (1, 8), 1)))));
3203
  tmp_result7 = ((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0), MAKEDI (0, 0))) ? (0) : (((LTHI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0), SLLDI (1, 8))) ? (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)) : (SUBQI (SLLQI (1, 8), 1)))));
3204
  {
3205
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
3206
    SET_H_GR (FLD (f_dest), opval);
3207
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3208
  }
3209
}
3210
 
3211
#undef FLD
3212
}
3213
  NEXT (vpc);
3214
 
3215
  CASE (sem, INSN_MEXTR1) : /* mextr1 $rm, $rn, $rd */
3216
{
3217
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3218
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3219
#define FLD(f) abuf->fields.sfmt_add.f
3220
  int UNUSED written = 0;
3221
  IADDR UNUSED pc = abuf->addr;
3222
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3223
 
3224
{
3225
  QI tmp_count;
3226
  DI tmp_mask;
3227
  DI tmp_rhs;
3228
  tmp_count = MULQI (8, 1);
3229
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3230
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3231
  tmp_count = MULQI (8, SUBQI (8, 1));
3232
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3233
  {
3234
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3235
    SET_H_GR (FLD (f_dest), opval);
3236
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3237
  }
3238
}
3239
 
3240
#undef FLD
3241
}
3242
  NEXT (vpc);
3243
 
3244
  CASE (sem, INSN_MEXTR2) : /* mextr2 $rm, $rn, $rd */
3245
{
3246
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3247
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3248
#define FLD(f) abuf->fields.sfmt_add.f
3249
  int UNUSED written = 0;
3250
  IADDR UNUSED pc = abuf->addr;
3251
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3252
 
3253
{
3254
  QI tmp_count;
3255
  DI tmp_mask;
3256
  DI tmp_rhs;
3257
  tmp_count = MULQI (8, 2);
3258
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3259
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3260
  tmp_count = MULQI (8, SUBQI (8, 2));
3261
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3262
  {
3263
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3264
    SET_H_GR (FLD (f_dest), opval);
3265
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3266
  }
3267
}
3268
 
3269
#undef FLD
3270
}
3271
  NEXT (vpc);
3272
 
3273
  CASE (sem, INSN_MEXTR3) : /* mextr3 $rm, $rn, $rd */
3274
{
3275
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3276
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3277
#define FLD(f) abuf->fields.sfmt_add.f
3278
  int UNUSED written = 0;
3279
  IADDR UNUSED pc = abuf->addr;
3280
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3281
 
3282
{
3283
  QI tmp_count;
3284
  DI tmp_mask;
3285
  DI tmp_rhs;
3286
  tmp_count = MULQI (8, 3);
3287
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3288
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3289
  tmp_count = MULQI (8, SUBQI (8, 3));
3290
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3291
  {
3292
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3293
    SET_H_GR (FLD (f_dest), opval);
3294
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3295
  }
3296
}
3297
 
3298
#undef FLD
3299
}
3300
  NEXT (vpc);
3301
 
3302
  CASE (sem, INSN_MEXTR4) : /* mextr4 $rm, $rn, $rd */
3303
{
3304
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3305
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3306
#define FLD(f) abuf->fields.sfmt_add.f
3307
  int UNUSED written = 0;
3308
  IADDR UNUSED pc = abuf->addr;
3309
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3310
 
3311
{
3312
  QI tmp_count;
3313
  DI tmp_mask;
3314
  DI tmp_rhs;
3315
  tmp_count = MULQI (8, 4);
3316
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3317
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3318
  tmp_count = MULQI (8, SUBQI (8, 4));
3319
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3320
  {
3321
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3322
    SET_H_GR (FLD (f_dest), opval);
3323
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3324
  }
3325
}
3326
 
3327
#undef FLD
3328
}
3329
  NEXT (vpc);
3330
 
3331
  CASE (sem, INSN_MEXTR5) : /* mextr5 $rm, $rn, $rd */
3332
{
3333
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3334
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3335
#define FLD(f) abuf->fields.sfmt_add.f
3336
  int UNUSED written = 0;
3337
  IADDR UNUSED pc = abuf->addr;
3338
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3339
 
3340
{
3341
  QI tmp_count;
3342
  DI tmp_mask;
3343
  DI tmp_rhs;
3344
  tmp_count = MULQI (8, 5);
3345
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3346
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3347
  tmp_count = MULQI (8, SUBQI (8, 5));
3348
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3349
  {
3350
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3351
    SET_H_GR (FLD (f_dest), opval);
3352
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3353
  }
3354
}
3355
 
3356
#undef FLD
3357
}
3358
  NEXT (vpc);
3359
 
3360
  CASE (sem, INSN_MEXTR6) : /* mextr6 $rm, $rn, $rd */
3361
{
3362
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3363
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3364
#define FLD(f) abuf->fields.sfmt_add.f
3365
  int UNUSED written = 0;
3366
  IADDR UNUSED pc = abuf->addr;
3367
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3368
 
3369
{
3370
  QI tmp_count;
3371
  DI tmp_mask;
3372
  DI tmp_rhs;
3373
  tmp_count = MULQI (8, 6);
3374
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3375
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3376
  tmp_count = MULQI (8, SUBQI (8, 6));
3377
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3378
  {
3379
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3380
    SET_H_GR (FLD (f_dest), opval);
3381
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3382
  }
3383
}
3384
 
3385
#undef FLD
3386
}
3387
  NEXT (vpc);
3388
 
3389
  CASE (sem, INSN_MEXTR7) : /* mextr7 $rm, $rn, $rd */
3390
{
3391
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3392
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3393
#define FLD(f) abuf->fields.sfmt_add.f
3394
  int UNUSED written = 0;
3395
  IADDR UNUSED pc = abuf->addr;
3396
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3397
 
3398
{
3399
  QI tmp_count;
3400
  DI tmp_mask;
3401
  DI tmp_rhs;
3402
  tmp_count = MULQI (8, 7);
3403
  tmp_mask = SLLDI (INVSI (0), tmp_count);
3404
  tmp_rhs = SRLDI (ANDDI (GET_H_GR (FLD (f_left)), tmp_mask), tmp_count);
3405
  tmp_count = MULQI (8, SUBQI (8, 7));
3406
  tmp_mask = SRLDI (INVSI (0), tmp_count);
3407
  {
3408
    DI opval = ORDI (tmp_rhs, SLLDI (ANDDI (GET_H_GR (FLD (f_right)), tmp_mask), tmp_count));
3409
    SET_H_GR (FLD (f_dest), opval);
3410
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3411
  }
3412
}
3413
 
3414
#undef FLD
3415
}
3416
  NEXT (vpc);
3417
 
3418
  CASE (sem, INSN_MMACFXWL) : /* mmacfx.wl $rm, $rn, $rd */
3419
{
3420
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3421
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3422
#define FLD(f) abuf->fields.sfmt_add.f
3423
  int UNUSED written = 0;
3424
  IADDR UNUSED pc = abuf->addr;
3425
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3426
 
3427
{
3428
  SI tmp_temp;
3429
  SI tmp_result1;
3430
  SI tmp_result0;
3431
  tmp_result0 = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 1);
3432
  tmp_result1 = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 0);
3433
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3434
  tmp_temp = ((LTDI (SLLDI (tmp_temp, 1), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (tmp_temp, 1), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (tmp_temp, 1)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3435
  tmp_result0 = ((LTDI (ADDDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (ADDDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp)), SLLDI (1, SUBSI (32, 1)))) ? (ADDDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3436
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3437
  tmp_temp = ((LTDI (SLLDI (tmp_temp, 1), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (tmp_temp, 1), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (tmp_temp, 1)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3438
  tmp_result1 = ((LTDI (ADDDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (ADDDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp)), SLLDI (1, SUBSI (32, 1)))) ? (ADDDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3439
  {
3440
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3441
    SET_H_GR (FLD (f_dest), opval);
3442
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3443
  }
3444
}
3445
 
3446
#undef FLD
3447
}
3448
  NEXT (vpc);
3449
 
3450
  CASE (sem, INSN_MMACNFX_WL) : /* mmacnfx.wl $rm, $rn, $rd */
3451
{
3452
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3453
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3454
#define FLD(f) abuf->fields.sfmt_add.f
3455
  int UNUSED written = 0;
3456
  IADDR UNUSED pc = abuf->addr;
3457
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3458
 
3459
{
3460
  SI tmp_temp;
3461
  SI tmp_result1;
3462
  SI tmp_result0;
3463
  tmp_result0 = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 1);
3464
  tmp_result1 = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 0);
3465
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3466
  tmp_temp = ((LTDI (SLLDI (tmp_temp, 1), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (tmp_temp, 1), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (tmp_temp, 1)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3467
  tmp_result0 = ((LTDI (SUBDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SUBDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp)), SLLDI (1, SUBSI (32, 1)))) ? (SUBDI (EXTSIDI (tmp_result0), EXTSIDI (tmp_temp))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3468
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3469
  tmp_temp = ((LTDI (SLLDI (tmp_temp, 1), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (tmp_temp, 1), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (tmp_temp, 1)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3470
  tmp_result1 = ((LTDI (SUBDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SUBDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp)), SLLDI (1, SUBSI (32, 1)))) ? (SUBDI (EXTSIDI (tmp_result1), EXTSIDI (tmp_temp))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3471
  {
3472
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3473
    SET_H_GR (FLD (f_dest), opval);
3474
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3475
  }
3476
}
3477
 
3478
#undef FLD
3479
}
3480
  NEXT (vpc);
3481
 
3482
  CASE (sem, INSN_MMULL) : /* mmul.l $rm, $rn, $rd */
3483
{
3484
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3485
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3486
#define FLD(f) abuf->fields.sfmt_add.f
3487
  int UNUSED written = 0;
3488
  IADDR UNUSED pc = abuf->addr;
3489
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3490
 
3491
{
3492
  SI tmp_result1;
3493
  SI tmp_result0;
3494
  tmp_result0 = MULSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1));
3495
  tmp_result1 = MULSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0));
3496
  {
3497
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3498
    SET_H_GR (FLD (f_dest), opval);
3499
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3500
  }
3501
}
3502
 
3503
#undef FLD
3504
}
3505
  NEXT (vpc);
3506
 
3507
  CASE (sem, INSN_MMULW) : /* mmul.w $rm, $rn, $rd */
3508
{
3509
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3510
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3511
#define FLD(f) abuf->fields.sfmt_add.f
3512
  int UNUSED written = 0;
3513
  IADDR UNUSED pc = abuf->addr;
3514
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3515
 
3516
{
3517
  HI tmp_result3;
3518
  HI tmp_result2;
3519
  HI tmp_result1;
3520
  HI tmp_result0;
3521
  tmp_result0 = MULHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3));
3522
  tmp_result1 = MULHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2));
3523
  tmp_result2 = MULHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1));
3524
  tmp_result3 = MULHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0));
3525
  {
3526
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3527
    SET_H_GR (FLD (f_dest), opval);
3528
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3529
  }
3530
}
3531
 
3532
#undef FLD
3533
}
3534
  NEXT (vpc);
3535
 
3536
  CASE (sem, INSN_MMULFXL) : /* mmulfx.l $rm, $rn, $rd */
3537
{
3538
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3539
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3540
#define FLD(f) abuf->fields.sfmt_add.f
3541
  int UNUSED written = 0;
3542
  IADDR UNUSED pc = abuf->addr;
3543
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3544
 
3545
{
3546
  DI tmp_temp;
3547
  SI tmp_result0;
3548
  SI tmp_result1;
3549
  tmp_temp = MULDI (ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
3550
  tmp_result0 = ((LTDI (SRADI (tmp_temp, 31), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SRADI (tmp_temp, 31), SLLDI (1, SUBSI (32, 1)))) ? (SRADI (tmp_temp, 31)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3551
  tmp_temp = MULDI (ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0)));
3552
  tmp_result1 = ((LTDI (SRADI (tmp_temp, 31), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SRADI (tmp_temp, 31), SLLDI (1, SUBSI (32, 1)))) ? (SRADI (tmp_temp, 31)) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3553
  {
3554
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3555
    SET_H_GR (FLD (f_dest), opval);
3556
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3557
  }
3558
}
3559
 
3560
#undef FLD
3561
}
3562
  NEXT (vpc);
3563
 
3564
  CASE (sem, INSN_MMULFXW) : /* mmulfx.w $rm, $rn, $rd */
3565
{
3566
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3567
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3568
#define FLD(f) abuf->fields.sfmt_add.f
3569
  int UNUSED written = 0;
3570
  IADDR UNUSED pc = abuf->addr;
3571
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3572
 
3573
{
3574
  SI tmp_temp;
3575
  HI tmp_result0;
3576
  HI tmp_result1;
3577
  HI tmp_result2;
3578
  HI tmp_result3;
3579
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3580
  tmp_result0 = ((LTSI (SRASI (tmp_temp, 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (tmp_temp, 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (tmp_temp, 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3581
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3582
  tmp_result1 = ((LTSI (SRASI (tmp_temp, 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (tmp_temp, 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (tmp_temp, 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3583
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)));
3584
  tmp_result2 = ((LTSI (SRASI (tmp_temp, 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (tmp_temp, 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (tmp_temp, 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3585
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)));
3586
  tmp_result3 = ((LTSI (SRASI (tmp_temp, 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (tmp_temp, 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (tmp_temp, 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3587
  {
3588
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3589
    SET_H_GR (FLD (f_dest), opval);
3590
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3591
  }
3592
}
3593
 
3594
#undef FLD
3595
}
3596
  NEXT (vpc);
3597
 
3598
  CASE (sem, INSN_MMULFXRPW) : /* mmulfxrp.w $rm, $rn, $rd */
3599
{
3600
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3601
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3602
#define FLD(f) abuf->fields.sfmt_add.f
3603
  int UNUSED written = 0;
3604
  IADDR UNUSED pc = abuf->addr;
3605
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3606
 
3607
{
3608
  SI tmp_temp;
3609
  HI tmp_result0;
3610
  HI tmp_result1;
3611
  HI tmp_result2;
3612
  HI tmp_result3;
3613
  HI tmp_c;
3614
  tmp_c = SLLSI (1, 14);
3615
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3616
  tmp_result0 = ((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (ADDSI (tmp_temp, tmp_c), 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3617
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3618
  tmp_result1 = ((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (ADDSI (tmp_temp, tmp_c), 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3619
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)));
3620
  tmp_result2 = ((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (ADDSI (tmp_temp, tmp_c), 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3621
  tmp_temp = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)));
3622
  tmp_result3 = ((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTSI (SRASI (ADDSI (tmp_temp, tmp_c), 15), SLLDI (1, SUBSI (16, 1)))) ? (SRASI (ADDSI (tmp_temp, tmp_c), 15)) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3623
  {
3624
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3625
    SET_H_GR (FLD (f_dest), opval);
3626
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3627
  }
3628
}
3629
 
3630
#undef FLD
3631
}
3632
  NEXT (vpc);
3633
 
3634
  CASE (sem, INSN_MMULHIWL) : /* mmulhi.wl $rm, $rn, $rd */
3635
{
3636
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3637
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3638
#define FLD(f) abuf->fields.sfmt_add.f
3639
  int UNUSED written = 0;
3640
  IADDR UNUSED pc = abuf->addr;
3641
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3642
 
3643
{
3644
  SI tmp_result1;
3645
  SI tmp_result0;
3646
  tmp_result0 = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1)));
3647
  tmp_result1 = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)));
3648
  {
3649
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3650
    SET_H_GR (FLD (f_dest), opval);
3651
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3652
  }
3653
}
3654
 
3655
#undef FLD
3656
}
3657
  NEXT (vpc);
3658
 
3659
  CASE (sem, INSN_MMULLOWL) : /* mmullo.wl $rm, $rn, $rd */
3660
{
3661
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3662
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3663
#define FLD(f) abuf->fields.sfmt_add.f
3664
  int UNUSED written = 0;
3665
  IADDR UNUSED pc = abuf->addr;
3666
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3667
 
3668
{
3669
  SI tmp_result1;
3670
  SI tmp_result0;
3671
  tmp_result0 = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3)));
3672
  tmp_result1 = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2)));
3673
  {
3674
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3675
    SET_H_GR (FLD (f_dest), opval);
3676
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3677
  }
3678
}
3679
 
3680
#undef FLD
3681
}
3682
  NEXT (vpc);
3683
 
3684
  CASE (sem, INSN_MMULSUMWQ) : /* mmulsum.wq $rm, $rn, $rd */
3685
{
3686
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3687
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3688
#define FLD(f) abuf->fields.sfmt_add.f
3689
  int UNUSED written = 0;
3690
  IADDR UNUSED pc = abuf->addr;
3691
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3692
 
3693
{
3694
  DI tmp_acc;
3695
  tmp_acc = MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0)));
3696
  tmp_acc = ADDDI (tmp_acc, MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1))));
3697
  tmp_acc = ADDDI (tmp_acc, MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2))));
3698
  tmp_acc = ADDDI (tmp_acc, MULSI (ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3)), ZEXTHISI (SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3))));
3699
  {
3700
    DI opval = ADDDI (GET_H_GR (FLD (f_dest)), tmp_acc);
3701
    SET_H_GR (FLD (f_dest), opval);
3702
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3703
  }
3704
}
3705
 
3706
#undef FLD
3707
}
3708
  NEXT (vpc);
3709
 
3710
  CASE (sem, INSN_MOVI) : /* movi $imm16, $rd */
3711
{
3712
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3713
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3714
#define FLD(f) abuf->fields.sfmt_movi.f
3715
  int UNUSED written = 0;
3716
  IADDR UNUSED pc = abuf->addr;
3717
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3718
 
3719
  {
3720
    DI opval = EXTSIDI (FLD (f_imm16));
3721
    SET_H_GR (FLD (f_dest), opval);
3722
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3723
  }
3724
 
3725
#undef FLD
3726
}
3727
  NEXT (vpc);
3728
 
3729
  CASE (sem, INSN_MPERMW) : /* mperm.w $rm, $rn, $rd */
3730
{
3731
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3732
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3733
#define FLD(f) abuf->fields.sfmt_add.f
3734
  int UNUSED written = 0;
3735
  IADDR UNUSED pc = abuf->addr;
3736
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3737
 
3738
{
3739
  QI tmp_control;
3740
  HI tmp_result3;
3741
  HI tmp_result2;
3742
  HI tmp_result1;
3743
  HI tmp_result0;
3744
  tmp_control = ANDQI (GET_H_GR (FLD (f_right)), 255);
3745
  tmp_result0 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), SUBSI (3, ANDQI (tmp_control, 3)));
3746
  tmp_result1 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), SUBSI (3, ANDQI (SRLQI (tmp_control, 2), 3)));
3747
  tmp_result2 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), SUBSI (3, ANDQI (SRLQI (tmp_control, 4), 3)));
3748
  tmp_result3 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), SUBSI (3, ANDQI (SRLQI (tmp_control, 6), 3)));
3749
  {
3750
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3751
    SET_H_GR (FLD (f_dest), opval);
3752
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3753
  }
3754
}
3755
 
3756
#undef FLD
3757
}
3758
  NEXT (vpc);
3759
 
3760
  CASE (sem, INSN_MSADUBQ) : /* msad.ubq $rm, $rn, $rd */
3761
{
3762
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3763
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3764
#define FLD(f) abuf->fields.sfmt_add.f
3765
  int UNUSED written = 0;
3766
  IADDR UNUSED pc = abuf->addr;
3767
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3768
 
3769
{
3770
  DI tmp_acc;
3771
  tmp_acc = ABSDI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0)));
3772
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))));
3773
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))));
3774
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))));
3775
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))));
3776
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))));
3777
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))));
3778
  tmp_acc = ADDDI (tmp_acc, ABSQI (SUBQI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7), SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))));
3779
  {
3780
    DI opval = ADDDI (GET_H_GR (FLD (f_dest)), tmp_acc);
3781
    SET_H_GR (FLD (f_dest), opval);
3782
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3783
  }
3784
}
3785
 
3786
#undef FLD
3787
}
3788
  NEXT (vpc);
3789
 
3790
  CASE (sem, INSN_MSHALDSL) : /* mshalds.l $rm, $rn, $rd */
3791
{
3792
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3793
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3794
#define FLD(f) abuf->fields.sfmt_add.f
3795
  int UNUSED written = 0;
3796
  IADDR UNUSED pc = abuf->addr;
3797
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3798
 
3799
{
3800
  SI tmp_result1;
3801
  SI tmp_result0;
3802
  tmp_result0 = ((LTDI (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31)), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3803
  tmp_result1 = ((LTDI (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31)), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31)), SLLDI (1, SUBSI (32, 1)))) ? (SLLDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
3804
  {
3805
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3806
    SET_H_GR (FLD (f_dest), opval);
3807
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3808
  }
3809
}
3810
 
3811
#undef FLD
3812
}
3813
  NEXT (vpc);
3814
 
3815
  CASE (sem, INSN_MSHALDSW) : /* mshalds.w $rm, $rn, $rd */
3816
{
3817
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3818
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3819
#define FLD(f) abuf->fields.sfmt_add.f
3820
  int UNUSED written = 0;
3821
  IADDR UNUSED pc = abuf->addr;
3822
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3823
 
3824
{
3825
  HI tmp_result3;
3826
  HI tmp_result2;
3827
  HI tmp_result1;
3828
  HI tmp_result0;
3829
  tmp_result0 = ((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15)), SLLDI (1, SUBSI (16, 1)))) ? (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3830
  tmp_result1 = ((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15)), SLLDI (1, SUBSI (16, 1)))) ? (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3831
  tmp_result2 = ((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15)), SLLDI (1, SUBSI (16, 1)))) ? (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3832
  tmp_result3 = ((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15)), SLLDI (1, SUBSI (16, 1)))) ? (SLLDI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
3833
  {
3834
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3835
    SET_H_GR (FLD (f_dest), opval);
3836
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3837
  }
3838
}
3839
 
3840
#undef FLD
3841
}
3842
  NEXT (vpc);
3843
 
3844
  CASE (sem, INSN_MSHARDL) : /* mshard.l $rm, $rn, $rd */
3845
{
3846
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3847
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3848
#define FLD(f) abuf->fields.sfmt_add.f
3849
  int UNUSED written = 0;
3850
  IADDR UNUSED pc = abuf->addr;
3851
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3852
 
3853
{
3854
  SI tmp_result1;
3855
  SI tmp_result0;
3856
  tmp_result0 = SRASI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31));
3857
  tmp_result1 = SRASI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31));
3858
  {
3859
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3860
    SET_H_GR (FLD (f_dest), opval);
3861
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3862
  }
3863
}
3864
 
3865
#undef FLD
3866
}
3867
  NEXT (vpc);
3868
 
3869
  CASE (sem, INSN_MSHARDW) : /* mshard.w $rm, $rn, $rd */
3870
{
3871
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3872
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3873
#define FLD(f) abuf->fields.sfmt_add.f
3874
  int UNUSED written = 0;
3875
  IADDR UNUSED pc = abuf->addr;
3876
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3877
 
3878
{
3879
  HI tmp_result3;
3880
  HI tmp_result2;
3881
  HI tmp_result1;
3882
  HI tmp_result0;
3883
  tmp_result0 = SRAHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15));
3884
  tmp_result1 = SRAHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15));
3885
  tmp_result2 = SRAHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15));
3886
  tmp_result3 = SRAHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15));
3887
  {
3888
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3889
    SET_H_GR (FLD (f_dest), opval);
3890
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3891
  }
3892
}
3893
 
3894
#undef FLD
3895
}
3896
  NEXT (vpc);
3897
 
3898
  CASE (sem, INSN_MSHARDSQ) : /* mshards.q $rm, $rn, $rd */
3899
{
3900
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3901
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3902
#define FLD(f) abuf->fields.sfmt_add.f
3903
  int UNUSED written = 0;
3904
  IADDR UNUSED pc = abuf->addr;
3905
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3906
 
3907
  {
3908
    DI opval = ((LTDI (SRADI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63)), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGDI (SLLDI (1, SUBSI (16, 1)))) : (((LTDI (SRADI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63)), SLLDI (1, SUBSI (16, 1)))) ? (SRADI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63))) : (SUBDI (SLLDI (1, SUBSI (16, 1)), 1)))));
3909
    SET_H_GR (FLD (f_dest), opval);
3910
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3911
  }
3912
 
3913
#undef FLD
3914
}
3915
  NEXT (vpc);
3916
 
3917
  CASE (sem, INSN_MSHFHIB) : /* mshfhi.b $rm, $rn, $rd */
3918
{
3919
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3920
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3921
#define FLD(f) abuf->fields.sfmt_add.f
3922
  int UNUSED written = 0;
3923
  IADDR UNUSED pc = abuf->addr;
3924
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3925
 
3926
{
3927
  QI tmp_result7;
3928
  QI tmp_result6;
3929
  QI tmp_result5;
3930
  QI tmp_result4;
3931
  QI tmp_result3;
3932
  QI tmp_result2;
3933
  QI tmp_result1;
3934
  QI tmp_result0;
3935
  tmp_result0 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3);
3936
  tmp_result1 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3);
3937
  tmp_result2 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2);
3938
  tmp_result3 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2);
3939
  tmp_result4 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1);
3940
  tmp_result5 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1);
3941
  tmp_result6 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0);
3942
  tmp_result7 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0);
3943
  {
3944
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
3945
    SET_H_GR (FLD (f_dest), opval);
3946
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3947
  }
3948
}
3949
 
3950
#undef FLD
3951
}
3952
  NEXT (vpc);
3953
 
3954
  CASE (sem, INSN_MSHFHIL) : /* mshfhi.l $rm, $rn, $rd */
3955
{
3956
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3957
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3958
#define FLD(f) abuf->fields.sfmt_add.f
3959
  int UNUSED written = 0;
3960
  IADDR UNUSED pc = abuf->addr;
3961
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3962
 
3963
{
3964
  SI tmp_result1;
3965
  SI tmp_result0;
3966
  tmp_result0 = SUBWORDDISI (GET_H_GR (FLD (f_left)), 0);
3967
  tmp_result1 = SUBWORDDISI (GET_H_GR (FLD (f_right)), 0);
3968
  {
3969
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
3970
    SET_H_GR (FLD (f_dest), opval);
3971
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
3972
  }
3973
}
3974
 
3975
#undef FLD
3976
}
3977
  NEXT (vpc);
3978
 
3979
  CASE (sem, INSN_MSHFHIW) : /* mshfhi.w $rm, $rn, $rd */
3980
{
3981
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3982
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3983
#define FLD(f) abuf->fields.sfmt_add.f
3984
  int UNUSED written = 0;
3985
  IADDR UNUSED pc = abuf->addr;
3986
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3987
 
3988
{
3989
  HI tmp_result3;
3990
  HI tmp_result2;
3991
  HI tmp_result1;
3992
  HI tmp_result0;
3993
  tmp_result0 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1);
3994
  tmp_result1 = SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1);
3995
  tmp_result2 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0);
3996
  tmp_result3 = SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0);
3997
  {
3998
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
3999
    SET_H_GR (FLD (f_dest), opval);
4000
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4001
  }
4002
}
4003
 
4004
#undef FLD
4005
}
4006
  NEXT (vpc);
4007
 
4008
  CASE (sem, INSN_MSHFLOB) : /* mshflo.b $rm, $rn, $rd */
4009
{
4010
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4011
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4012
#define FLD(f) abuf->fields.sfmt_add.f
4013
  int UNUSED written = 0;
4014
  IADDR UNUSED pc = abuf->addr;
4015
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4016
 
4017
{
4018
  QI tmp_result7;
4019
  QI tmp_result6;
4020
  QI tmp_result5;
4021
  QI tmp_result4;
4022
  QI tmp_result3;
4023
  QI tmp_result2;
4024
  QI tmp_result1;
4025
  QI tmp_result0;
4026
  tmp_result0 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7);
4027
  tmp_result1 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7);
4028
  tmp_result2 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6);
4029
  tmp_result3 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6);
4030
  tmp_result4 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5);
4031
  tmp_result5 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5);
4032
  tmp_result6 = SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4);
4033
  tmp_result7 = SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4);
4034
  {
4035
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
4036
    SET_H_GR (FLD (f_dest), opval);
4037
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4038
  }
4039
}
4040
 
4041
#undef FLD
4042
}
4043
  NEXT (vpc);
4044
 
4045
  CASE (sem, INSN_MSHFLOL) : /* mshflo.l $rm, $rn, $rd */
4046
{
4047
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4048
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4049
#define FLD(f) abuf->fields.sfmt_add.f
4050
  int UNUSED written = 0;
4051
  IADDR UNUSED pc = abuf->addr;
4052
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4053
 
4054
{
4055
  SI tmp_result1;
4056
  SI tmp_result0;
4057
  tmp_result0 = SUBWORDDISI (GET_H_GR (FLD (f_left)), 1);
4058
  tmp_result1 = SUBWORDDISI (GET_H_GR (FLD (f_right)), 1);
4059
  {
4060
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4061
    SET_H_GR (FLD (f_dest), opval);
4062
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4063
  }
4064
}
4065
 
4066
#undef FLD
4067
}
4068
  NEXT (vpc);
4069
 
4070
  CASE (sem, INSN_MSHFLOW) : /* mshflo.w $rm, $rn, $rd */
4071
{
4072
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4073
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4074
#define FLD(f) abuf->fields.sfmt_add.f
4075
  int UNUSED written = 0;
4076
  IADDR UNUSED pc = abuf->addr;
4077
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4078
 
4079
{
4080
  HI tmp_result3;
4081
  HI tmp_result2;
4082
  HI tmp_result1;
4083
  HI tmp_result0;
4084
  tmp_result0 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3);
4085
  tmp_result1 = SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3);
4086
  tmp_result2 = SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2);
4087
  tmp_result3 = SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2);
4088
  {
4089
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4090
    SET_H_GR (FLD (f_dest), opval);
4091
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4092
  }
4093
}
4094
 
4095
#undef FLD
4096
}
4097
  NEXT (vpc);
4098
 
4099
  CASE (sem, INSN_MSHLLDL) : /* mshlld.l $rm, $rn, $rd */
4100
{
4101
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4102
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4103
#define FLD(f) abuf->fields.sfmt_add.f
4104
  int UNUSED written = 0;
4105
  IADDR UNUSED pc = abuf->addr;
4106
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4107
 
4108
{
4109
  SI tmp_result1;
4110
  SI tmp_result0;
4111
  tmp_result0 = SLLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31));
4112
  tmp_result1 = SLLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31));
4113
  {
4114
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4115
    SET_H_GR (FLD (f_dest), opval);
4116
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4117
  }
4118
}
4119
 
4120
#undef FLD
4121
}
4122
  NEXT (vpc);
4123
 
4124
  CASE (sem, INSN_MSHLLDW) : /* mshlld.w $rm, $rn, $rd */
4125
{
4126
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4127
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4128
#define FLD(f) abuf->fields.sfmt_add.f
4129
  int UNUSED written = 0;
4130
  IADDR UNUSED pc = abuf->addr;
4131
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4132
 
4133
{
4134
  HI tmp_result3;
4135
  HI tmp_result2;
4136
  HI tmp_result1;
4137
  HI tmp_result0;
4138
  tmp_result0 = SLLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15));
4139
  tmp_result1 = SLLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15));
4140
  tmp_result2 = SLLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15));
4141
  tmp_result3 = SLLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15));
4142
  {
4143
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4144
    SET_H_GR (FLD (f_dest), opval);
4145
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4146
  }
4147
}
4148
 
4149
#undef FLD
4150
}
4151
  NEXT (vpc);
4152
 
4153
  CASE (sem, INSN_MSHLRDL) : /* mshlrd.l $rm, $rn, $rd */
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_add.f
4158
  int UNUSED written = 0;
4159
  IADDR UNUSED pc = abuf->addr;
4160
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4161
 
4162
{
4163
  SI tmp_result1;
4164
  SI tmp_result0;
4165
  tmp_result0 = SRLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 31));
4166
  tmp_result1 = SRLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 31));
4167
  {
4168
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4169
    SET_H_GR (FLD (f_dest), opval);
4170
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4171
  }
4172
}
4173
 
4174
#undef FLD
4175
}
4176
  NEXT (vpc);
4177
 
4178
  CASE (sem, INSN_MSHLRDW) : /* mshlrd.w $rm, $rn, $rd */
4179
{
4180
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4181
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4182
#define FLD(f) abuf->fields.sfmt_add.f
4183
  int UNUSED written = 0;
4184
  IADDR UNUSED pc = abuf->addr;
4185
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4186
 
4187
{
4188
  HI tmp_result3;
4189
  HI tmp_result2;
4190
  HI tmp_result1;
4191
  HI tmp_result0;
4192
  tmp_result0 = SRLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), ANDDI (GET_H_GR (FLD (f_right)), 15));
4193
  tmp_result1 = SRLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), ANDDI (GET_H_GR (FLD (f_right)), 15));
4194
  tmp_result2 = SRLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 15));
4195
  tmp_result3 = SRLHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), ANDDI (GET_H_GR (FLD (f_right)), 15));
4196
  {
4197
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4198
    SET_H_GR (FLD (f_dest), opval);
4199
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4200
  }
4201
}
4202
 
4203
#undef FLD
4204
}
4205
  NEXT (vpc);
4206
 
4207
  CASE (sem, INSN_MSUBL) : /* msub.l $rm, $rn, $rd */
4208
{
4209
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4210
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4211
#define FLD(f) abuf->fields.sfmt_add.f
4212
  int UNUSED written = 0;
4213
  IADDR UNUSED pc = abuf->addr;
4214
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4215
 
4216
{
4217
  SI tmp_result1;
4218
  SI tmp_result0;
4219
  tmp_result0 = SUBSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1));
4220
  tmp_result1 = SUBSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0), SUBWORDDISI (GET_H_GR (FLD (f_right)), 0));
4221
  {
4222
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4223
    SET_H_GR (FLD (f_dest), opval);
4224
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4225
  }
4226
}
4227
 
4228
#undef FLD
4229
}
4230
  NEXT (vpc);
4231
 
4232
  CASE (sem, INSN_MSUBW) : /* msub.w $rm, $rn, $rd */
4233
{
4234
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4235
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4236
#define FLD(f) abuf->fields.sfmt_add.f
4237
  int UNUSED written = 0;
4238
  IADDR UNUSED pc = abuf->addr;
4239
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4240
 
4241
{
4242
  HI tmp_result3;
4243
  HI tmp_result2;
4244
  HI tmp_result1;
4245
  HI tmp_result0;
4246
  tmp_result0 = SUBHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 3), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 3));
4247
  tmp_result1 = SUBHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 2), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 2));
4248
  tmp_result2 = SUBHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 1), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 1));
4249
  tmp_result3 = SUBHI (SUBWORDDIHI (GET_H_GR (FLD (f_left)), 0), SUBWORDDIHI (GET_H_GR (FLD (f_right)), 0));
4250
  {
4251
    DI opval = ORDI (SLLDI (ZEXTHIDI (tmp_result3), 48), ORDI (SLLDI (ZEXTHIDI (tmp_result2), 32), ORDI (SLLDI (ZEXTHIDI (tmp_result1), 16), ZEXTHIDI (tmp_result0))));
4252
    SET_H_GR (FLD (f_dest), opval);
4253
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4254
  }
4255
}
4256
 
4257
#undef FLD
4258
}
4259
  NEXT (vpc);
4260
 
4261
  CASE (sem, INSN_MSUBSL) : /* msubs.l $rm, $rn, $rd */
4262
{
4263
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4264
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4265
#define FLD(f) abuf->fields.sfmt_add.f
4266
  int UNUSED written = 0;
4267
  IADDR UNUSED pc = abuf->addr;
4268
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4269
 
4270
{
4271
  SI tmp_result1;
4272
  SI tmp_result0;
4273
  tmp_result0 = ((LTDI (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, SUBSI (32, 1)))) ? (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
4274
  tmp_result1 = ((LTDI (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))), NEGDI (SLLDI (1, SUBSI (32, 1))))) ? (NEGSI (SLLSI (1, SUBSI (32, 1)))) : (((LTDI (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, SUBSI (32, 1)))) ? (SUBDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 0)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 0)))) : (SUBSI (SLLSI (1, SUBSI (32, 1)), 1)))));
4275
  {
4276
    DI opval = ORDI (SLLDI (ZEXTSIDI (tmp_result1), 32), ZEXTSIDI (tmp_result0));
4277
    SET_H_GR (FLD (f_dest), opval);
4278
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4279
  }
4280
}
4281
 
4282
#undef FLD
4283
}
4284
  NEXT (vpc);
4285
 
4286
  CASE (sem, INSN_MSUBSUB) : /* msubs.ub $rm, $rn, $rd */
4287
{
4288
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4289
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4290
#define FLD(f) abuf->fields.sfmt_add.f
4291
  int UNUSED written = 0;
4292
  IADDR UNUSED pc = abuf->addr;
4293
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4294
 
4295
{
4296
  QI tmp_result7;
4297
  QI tmp_result6;
4298
  QI tmp_result5;
4299
  QI tmp_result4;
4300
  QI tmp_result3;
4301
  QI tmp_result2;
4302
  QI tmp_result1;
4303
  QI tmp_result0;
4304
  tmp_result0 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7)))) : (SUBQI (SLLQI (1, 8), 1)))));
4305
  tmp_result1 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6)))) : (SUBQI (SLLQI (1, 8), 1)))));
4306
  tmp_result2 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5)))) : (SUBQI (SLLQI (1, 8), 1)))));
4307
  tmp_result3 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4)))) : (SUBQI (SLLQI (1, 8), 1)))));
4308
  tmp_result4 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3)))) : (SUBQI (SLLQI (1, 8), 1)))));
4309
  tmp_result5 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2)))) : (SUBQI (SLLQI (1, 8), 1)))));
4310
  tmp_result6 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1)))) : (SUBQI (SLLQI (1, 8), 1)))));
4311
  tmp_result7 = ((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), MAKEDI (0, 0))) ? (0) : (((LTDI (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, 8))) ? (SUBDI (ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), ZEXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0)))) : (SUBQI (SLLQI (1, 8), 1)))));
4312
  {
4313
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
4314
    SET_H_GR (FLD (f_dest), opval);
4315
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4316
  }
4317
}
4318
 
4319
#undef FLD
4320
}
4321
  NEXT (vpc);
4322
 
4323
  CASE (sem, INSN_MSUBSW) : /* msubs.w $rm, $rn, $rd */
4324
{
4325
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4326
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4327
#define FLD(f) abuf->fields.sfmt_add.f
4328
  int UNUSED written = 0;
4329
  IADDR UNUSED pc = abuf->addr;
4330
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4331
 
4332
{
4333
  QI tmp_result7;
4334
  QI tmp_result6;
4335
  QI tmp_result5;
4336
  QI tmp_result4;
4337
  QI tmp_result3;
4338
  QI tmp_result2;
4339
  QI tmp_result1;
4340
  QI tmp_result0;
4341
  tmp_result0 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 7)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 7)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4342
  tmp_result1 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 6)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 6)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4343
  tmp_result2 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 5)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 5)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4344
  tmp_result3 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 4)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 4)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4345
  tmp_result4 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 3)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 3)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4346
  tmp_result5 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 2)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 2)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4347
  tmp_result6 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 1)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 1)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4348
  tmp_result7 = ((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), NEGDI (SLLDI (1, SUBSI (16, 1))))) ? (NEGHI (SLLHI (1, SUBSI (16, 1)))) : (((LTDI (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0))), SLLDI (1, SUBSI (16, 1)))) ? (SUBDI (EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_left)), 0)), EXTQIDI (SUBWORDDIQI (GET_H_GR (FLD (f_right)), 0)))) : (SUBHI (SLLHI (1, SUBSI (16, 1)), 1)))));
4349
  {
4350
    DI opval = ORDI (SLLDI (ZEXTQIDI (tmp_result7), 56), ORDI (SLLDI (ZEXTQIDI (tmp_result6), 48), ORDI (SLLDI (ZEXTQIDI (tmp_result5), 40), ORDI (SLLDI (ZEXTQIDI (tmp_result4), 32), ORDI (SLLDI (ZEXTQIDI (tmp_result3), 24), ORDI (SLLDI (ZEXTQIDI (tmp_result2), 16), ORDI (SLLDI (ZEXTQIDI (tmp_result1), 8), ZEXTQIDI (tmp_result0))))))));
4351
    SET_H_GR (FLD (f_dest), opval);
4352
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4353
  }
4354
}
4355
 
4356
#undef FLD
4357
}
4358
  NEXT (vpc);
4359
 
4360
  CASE (sem, INSN_MULSL) : /* muls.l $rm, $rn, $rd */
4361
{
4362
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4363
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4364
#define FLD(f) abuf->fields.sfmt_add.f
4365
  int UNUSED written = 0;
4366
  IADDR UNUSED pc = abuf->addr;
4367
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4368
 
4369
  {
4370
    DI opval = MULDI (EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), EXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
4371
    SET_H_GR (FLD (f_dest), opval);
4372
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4373
  }
4374
 
4375
#undef FLD
4376
}
4377
  NEXT (vpc);
4378
 
4379
  CASE (sem, INSN_MULUL) : /* mulu.l $rm, $rn, $rd */
4380
{
4381
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4382
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4383
#define FLD(f) abuf->fields.sfmt_add.f
4384
  int UNUSED written = 0;
4385
  IADDR UNUSED pc = abuf->addr;
4386
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4387
 
4388
  {
4389
    DI opval = MULDI (ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1)), ZEXTSIDI (SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
4390
    SET_H_GR (FLD (f_dest), opval);
4391
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4392
  }
4393
 
4394
#undef FLD
4395
}
4396
  NEXT (vpc);
4397
 
4398
  CASE (sem, INSN_NOP) : /* nop */
4399
{
4400
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4401
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4402
#define FLD(f) abuf->fields.sfmt_empty.f
4403
  int UNUSED written = 0;
4404
  IADDR UNUSED pc = abuf->addr;
4405
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4406
 
4407
((void) 0); /*nop*/
4408
 
4409
#undef FLD
4410
}
4411
  NEXT (vpc);
4412
 
4413
  CASE (sem, INSN_NSB) : /* nsb $rm, $rd */
4414
{
4415
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4416
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4417
#define FLD(f) abuf->fields.sfmt_xori.f
4418
  int UNUSED written = 0;
4419
  IADDR UNUSED pc = abuf->addr;
4420
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4421
 
4422
  {
4423
    DI opval = sh64_nsb (current_cpu, GET_H_GR (FLD (f_left)));
4424
    SET_H_GR (FLD (f_dest), opval);
4425
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4426
  }
4427
 
4428
#undef FLD
4429
}
4430
  NEXT (vpc);
4431
 
4432
  CASE (sem, INSN_OCBI) : /* ocbi $rm, $disp6x32 */
4433
{
4434
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4435
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4436
#define FLD(f) abuf->fields.sfmt_xori.f
4437
  int UNUSED written = 0;
4438
  IADDR UNUSED pc = abuf->addr;
4439
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4440
 
4441
{
4442
  {
4443
    DI opval = GET_H_GR (FLD (f_left));
4444
    SET_H_GR (FLD (f_left), opval);
4445
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4446
  }
4447
((void) 0); /*nop*/
4448
}
4449
 
4450
#undef FLD
4451
}
4452
  NEXT (vpc);
4453
 
4454
  CASE (sem, INSN_OCBP) : /* ocbp $rm, $disp6x32 */
4455
{
4456
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4457
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4458
#define FLD(f) abuf->fields.sfmt_xori.f
4459
  int UNUSED written = 0;
4460
  IADDR UNUSED pc = abuf->addr;
4461
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4462
 
4463
{
4464
  {
4465
    DI opval = GET_H_GR (FLD (f_left));
4466
    SET_H_GR (FLD (f_left), opval);
4467
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4468
  }
4469
((void) 0); /*nop*/
4470
}
4471
 
4472
#undef FLD
4473
}
4474
  NEXT (vpc);
4475
 
4476
  CASE (sem, INSN_OCBWB) : /* ocbwb $rm, $disp6x32 */
4477
{
4478
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4479
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4480
#define FLD(f) abuf->fields.sfmt_xori.f
4481
  int UNUSED written = 0;
4482
  IADDR UNUSED pc = abuf->addr;
4483
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4484
 
4485
{
4486
  {
4487
    DI opval = GET_H_GR (FLD (f_left));
4488
    SET_H_GR (FLD (f_left), opval);
4489
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4490
  }
4491
((void) 0); /*nop*/
4492
}
4493
 
4494
#undef FLD
4495
}
4496
  NEXT (vpc);
4497
 
4498
  CASE (sem, INSN_OR) : /* or $rm, $rn, $rd */
4499
{
4500
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4501
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4502
#define FLD(f) abuf->fields.sfmt_add.f
4503
  int UNUSED written = 0;
4504
  IADDR UNUSED pc = abuf->addr;
4505
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4506
 
4507
  {
4508
    DI opval = ORDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
4509
    SET_H_GR (FLD (f_dest), opval);
4510
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4511
  }
4512
 
4513
#undef FLD
4514
}
4515
  NEXT (vpc);
4516
 
4517
  CASE (sem, INSN_ORI) : /* ori $rm, $imm10, $rd */
4518
{
4519
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4520
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4521
#define FLD(f) abuf->fields.sfmt_ori.f
4522
  int UNUSED written = 0;
4523
  IADDR UNUSED pc = abuf->addr;
4524
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4525
 
4526
  {
4527
    DI opval = ORDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_imm10)));
4528
    SET_H_GR (FLD (f_dest), opval);
4529
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4530
  }
4531
 
4532
#undef FLD
4533
}
4534
  NEXT (vpc);
4535
 
4536
  CASE (sem, INSN_PREFI) : /* prefi $rm, $disp6x32 */
4537
{
4538
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4539
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4540
#define FLD(f) abuf->fields.sfmt_xori.f
4541
  int UNUSED written = 0;
4542
  IADDR UNUSED pc = abuf->addr;
4543
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4544
 
4545
{
4546
  {
4547
    DI opval = GET_H_GR (FLD (f_left));
4548
    SET_H_GR (FLD (f_left), opval);
4549
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4550
  }
4551
((void) 0); /*nop*/
4552
}
4553
 
4554
#undef FLD
4555
}
4556
  NEXT (vpc);
4557
 
4558
  CASE (sem, INSN_PTA) : /* pta$likely $disp16, $tra */
4559
{
4560
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4561
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4562
#define FLD(f) abuf->fields.sfmt_pta.f
4563
  int UNUSED written = 0;
4564
  IADDR UNUSED pc = abuf->addr;
4565
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4566
 
4567
{
4568
((void) 0); /*nop*/
4569
  {
4570
    DI opval = ADDSI (FLD (f_disp16), 1);
4571
    CPU (h_tr[FLD (f_tra)]) = opval;
4572
    TRACE_RESULT (current_cpu, abuf, "tr", 'D', opval);
4573
  }
4574
}
4575
 
4576
#undef FLD
4577
}
4578
  NEXT (vpc);
4579
 
4580
  CASE (sem, INSN_PTABS) : /* ptabs$likely $rn, $tra */
4581
{
4582
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4583
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4584
#define FLD(f) abuf->fields.sfmt_beq.f
4585
  int UNUSED written = 0;
4586
  IADDR UNUSED pc = abuf->addr;
4587
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4588
 
4589
{
4590
((void) 0); /*nop*/
4591
  {
4592
    DI opval = GET_H_GR (FLD (f_right));
4593
    CPU (h_tr[FLD (f_tra)]) = opval;
4594
    TRACE_RESULT (current_cpu, abuf, "tr", 'D', opval);
4595
  }
4596
}
4597
 
4598
#undef FLD
4599
}
4600
  NEXT (vpc);
4601
 
4602
  CASE (sem, INSN_PTB) : /* ptb$likely $disp16, $tra */
4603
{
4604
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4605
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4606
#define FLD(f) abuf->fields.sfmt_pta.f
4607
  int UNUSED written = 0;
4608
  IADDR UNUSED pc = abuf->addr;
4609
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4610
 
4611
{
4612
((void) 0); /*nop*/
4613
  {
4614
    DI opval = FLD (f_disp16);
4615
    CPU (h_tr[FLD (f_tra)]) = opval;
4616
    TRACE_RESULT (current_cpu, abuf, "tr", 'D', opval);
4617
  }
4618
}
4619
 
4620
#undef FLD
4621
}
4622
  NEXT (vpc);
4623
 
4624
  CASE (sem, INSN_PTREL) : /* ptrel$likely $rn, $tra */
4625
{
4626
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4627
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4628
#define FLD(f) abuf->fields.sfmt_beq.f
4629
  int UNUSED written = 0;
4630
  IADDR UNUSED pc = abuf->addr;
4631
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4632
 
4633
{
4634
((void) 0); /*nop*/
4635
  {
4636
    DI opval = ADDDI (pc, GET_H_GR (FLD (f_right)));
4637
    CPU (h_tr[FLD (f_tra)]) = opval;
4638
    TRACE_RESULT (current_cpu, abuf, "tr", 'D', opval);
4639
  }
4640
}
4641
 
4642
#undef FLD
4643
}
4644
  NEXT (vpc);
4645
 
4646
  CASE (sem, INSN_PUTCFG) : /* putcfg $rm, $disp6, $rd */
4647
{
4648
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4649
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4650
#define FLD(f) abuf->fields.sfmt_getcfg.f
4651
  int UNUSED written = 0;
4652
  IADDR UNUSED pc = abuf->addr;
4653
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4654
 
4655
{
4656
  SI tmp_address;
4657
  tmp_address = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
4658
((void) 0); /*nop*/
4659
  {
4660
    SI opval = GET_H_GR (FLD (f_dest));
4661
    SETMEMSI (current_cpu, pc, tmp_address, opval);
4662
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4663
  }
4664
}
4665
 
4666
#undef FLD
4667
}
4668
  NEXT (vpc);
4669
 
4670
  CASE (sem, INSN_PUTCON) : /* putcon $rm, $crj */
4671
{
4672
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4673
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4674
#define FLD(f) abuf->fields.sfmt_xori.f
4675
  int UNUSED written = 0;
4676
  IADDR UNUSED pc = abuf->addr;
4677
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4678
 
4679
  {
4680
    DI opval = GET_H_GR (FLD (f_left));
4681
    SET_H_CR (FLD (f_dest), opval);
4682
    TRACE_RESULT (current_cpu, abuf, "cr", 'D', opval);
4683
  }
4684
 
4685
#undef FLD
4686
}
4687
  NEXT (vpc);
4688
 
4689
  CASE (sem, INSN_RTE) : /* rte */
4690
{
4691
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4692
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4693
#define FLD(f) abuf->fields.sfmt_empty.f
4694
  int UNUSED written = 0;
4695
  IADDR UNUSED pc = abuf->addr;
4696
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4697
 
4698
((void) 0); /*nop*/
4699
 
4700
#undef FLD
4701
}
4702
  NEXT (vpc);
4703
 
4704
  CASE (sem, INSN_SHARD) : /* shard $rm, $rn, $rd */
4705
{
4706
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4707
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4708
#define FLD(f) abuf->fields.sfmt_add.f
4709
  int UNUSED written = 0;
4710
  IADDR UNUSED pc = abuf->addr;
4711
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4712
 
4713
  {
4714
    DI opval = SRADI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63));
4715
    SET_H_GR (FLD (f_dest), opval);
4716
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4717
  }
4718
 
4719
#undef FLD
4720
}
4721
  NEXT (vpc);
4722
 
4723
  CASE (sem, INSN_SHARDL) : /* shard.l $rm, $rn, $rd */
4724
{
4725
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4726
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4727
#define FLD(f) abuf->fields.sfmt_add.f
4728
  int UNUSED written = 0;
4729
  IADDR UNUSED pc = abuf->addr;
4730
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4731
 
4732
  {
4733
    DI opval = EXTSIDI (SRASI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 63)));
4734
    SET_H_GR (FLD (f_dest), opval);
4735
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4736
  }
4737
 
4738
#undef FLD
4739
}
4740
  NEXT (vpc);
4741
 
4742
  CASE (sem, INSN_SHARI) : /* shari $rm, $uimm6, $rd */
4743
{
4744
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4745
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4746
#define FLD(f) abuf->fields.sfmt_shari.f
4747
  int UNUSED written = 0;
4748
  IADDR UNUSED pc = abuf->addr;
4749
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4750
 
4751
  {
4752
    DI opval = SRADI (GET_H_GR (FLD (f_left)), FLD (f_uimm6));
4753
    SET_H_GR (FLD (f_dest), opval);
4754
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4755
  }
4756
 
4757
#undef FLD
4758
}
4759
  NEXT (vpc);
4760
 
4761
  CASE (sem, INSN_SHARIL) : /* shari.l $rm, $uimm6, $rd */
4762
{
4763
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4764
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4765
#define FLD(f) abuf->fields.sfmt_shari.f
4766
  int UNUSED written = 0;
4767
  IADDR UNUSED pc = abuf->addr;
4768
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4769
 
4770
  {
4771
    DI opval = EXTSIDI (SRASI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDSI (FLD (f_uimm6), 63)));
4772
    SET_H_GR (FLD (f_dest), opval);
4773
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4774
  }
4775
 
4776
#undef FLD
4777
}
4778
  NEXT (vpc);
4779
 
4780
  CASE (sem, INSN_SHLLD) : /* shlld $rm, $rn, $rd */
4781
{
4782
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4783
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4784
#define FLD(f) abuf->fields.sfmt_add.f
4785
  int UNUSED written = 0;
4786
  IADDR UNUSED pc = abuf->addr;
4787
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4788
 
4789
  {
4790
    DI opval = SLLDI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63));
4791
    SET_H_GR (FLD (f_dest), opval);
4792
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4793
  }
4794
 
4795
#undef FLD
4796
}
4797
  NEXT (vpc);
4798
 
4799
  CASE (sem, INSN_SHLLDL) : /* shlld.l $rm, $rn, $rd */
4800
{
4801
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4802
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4803
#define FLD(f) abuf->fields.sfmt_add.f
4804
  int UNUSED written = 0;
4805
  IADDR UNUSED pc = abuf->addr;
4806
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4807
 
4808
  {
4809
    DI opval = EXTSIDI (SLLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 63)));
4810
    SET_H_GR (FLD (f_dest), opval);
4811
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4812
  }
4813
 
4814
#undef FLD
4815
}
4816
  NEXT (vpc);
4817
 
4818
  CASE (sem, INSN_SHLLI) : /* shlli $rm, $uimm6, $rd */
4819
{
4820
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4821
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4822
#define FLD(f) abuf->fields.sfmt_shari.f
4823
  int UNUSED written = 0;
4824
  IADDR UNUSED pc = abuf->addr;
4825
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4826
 
4827
  {
4828
    DI opval = SLLDI (GET_H_GR (FLD (f_left)), FLD (f_uimm6));
4829
    SET_H_GR (FLD (f_dest), opval);
4830
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4831
  }
4832
 
4833
#undef FLD
4834
}
4835
  NEXT (vpc);
4836
 
4837
  CASE (sem, INSN_SHLLIL) : /* shlli.l $rm, $uimm6, $rd */
4838
{
4839
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4840
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4841
#define FLD(f) abuf->fields.sfmt_shari.f
4842
  int UNUSED written = 0;
4843
  IADDR UNUSED pc = abuf->addr;
4844
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4845
 
4846
  {
4847
    DI opval = EXTSIDI (SLLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDSI (FLD (f_uimm6), 63)));
4848
    SET_H_GR (FLD (f_dest), opval);
4849
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4850
  }
4851
 
4852
#undef FLD
4853
}
4854
  NEXT (vpc);
4855
 
4856
  CASE (sem, INSN_SHLRD) : /* shlrd $rm, $rn, $rd */
4857
{
4858
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4859
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4860
#define FLD(f) abuf->fields.sfmt_add.f
4861
  int UNUSED written = 0;
4862
  IADDR UNUSED pc = abuf->addr;
4863
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4864
 
4865
  {
4866
    DI opval = SRLDI (GET_H_GR (FLD (f_left)), ANDDI (GET_H_GR (FLD (f_right)), 63));
4867
    SET_H_GR (FLD (f_dest), opval);
4868
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4869
  }
4870
 
4871
#undef FLD
4872
}
4873
  NEXT (vpc);
4874
 
4875
  CASE (sem, INSN_SHLRDL) : /* shlrd.l $rm, $rn, $rd */
4876
{
4877
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4878
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4879
#define FLD(f) abuf->fields.sfmt_add.f
4880
  int UNUSED written = 0;
4881
  IADDR UNUSED pc = abuf->addr;
4882
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4883
 
4884
  {
4885
    DI opval = EXTSIDI (SRLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDDI (GET_H_GR (FLD (f_right)), 63)));
4886
    SET_H_GR (FLD (f_dest), opval);
4887
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4888
  }
4889
 
4890
#undef FLD
4891
}
4892
  NEXT (vpc);
4893
 
4894
  CASE (sem, INSN_SHLRI) : /* shlri $rm, $uimm6, $rd */
4895
{
4896
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4897
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4898
#define FLD(f) abuf->fields.sfmt_shari.f
4899
  int UNUSED written = 0;
4900
  IADDR UNUSED pc = abuf->addr;
4901
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4902
 
4903
  {
4904
    DI opval = SRLDI (GET_H_GR (FLD (f_left)), FLD (f_uimm6));
4905
    SET_H_GR (FLD (f_dest), opval);
4906
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4907
  }
4908
 
4909
#undef FLD
4910
}
4911
  NEXT (vpc);
4912
 
4913
  CASE (sem, INSN_SHLRIL) : /* shlri.l $rm, $uimm6, $rd */
4914
{
4915
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4916
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4917
#define FLD(f) abuf->fields.sfmt_shari.f
4918
  int UNUSED written = 0;
4919
  IADDR UNUSED pc = abuf->addr;
4920
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4921
 
4922
  {
4923
    DI opval = EXTSIDI (SRLSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), ANDSI (FLD (f_uimm6), 63)));
4924
    SET_H_GR (FLD (f_dest), opval);
4925
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4926
  }
4927
 
4928
#undef FLD
4929
}
4930
  NEXT (vpc);
4931
 
4932
  CASE (sem, INSN_SHORI) : /* shori $uimm16, $rd */
4933
{
4934
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4935
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4936
#define FLD(f) abuf->fields.sfmt_shori.f
4937
  int UNUSED written = 0;
4938
  IADDR UNUSED pc = abuf->addr;
4939
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4940
 
4941
  {
4942
    DI opval = ORDI (SLLDI (GET_H_GR (FLD (f_dest)), 16), ZEXTSIDI (FLD (f_uimm16)));
4943
    SET_H_GR (FLD (f_dest), opval);
4944
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
4945
  }
4946
 
4947
#undef FLD
4948
}
4949
  NEXT (vpc);
4950
 
4951
  CASE (sem, INSN_SLEEP) : /* sleep */
4952
{
4953
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4954
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4955
#define FLD(f) abuf->fields.sfmt_empty.f
4956
  int UNUSED written = 0;
4957
  IADDR UNUSED pc = abuf->addr;
4958
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4959
 
4960
((void) 0); /*nop*/
4961
 
4962
#undef FLD
4963
}
4964
  NEXT (vpc);
4965
 
4966
  CASE (sem, INSN_STB) : /* st.b $rm, $disp10, $rd */
4967
{
4968
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4969
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4970
#define FLD(f) abuf->fields.sfmt_addi.f
4971
  int UNUSED written = 0;
4972
  IADDR UNUSED pc = abuf->addr;
4973
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4974
 
4975
  {
4976
    UQI opval = ANDQI (GET_H_GR (FLD (f_dest)), 255);
4977
    SETMEMUQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10))), opval);
4978
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4979
  }
4980
 
4981
#undef FLD
4982
}
4983
  NEXT (vpc);
4984
 
4985
  CASE (sem, INSN_STL) : /* st.l $rm, $disp10x4, $rd */
4986
{
4987
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4988
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4989
#define FLD(f) abuf->fields.sfmt_flds.f
4990
  int UNUSED written = 0;
4991
  IADDR UNUSED pc = abuf->addr;
4992
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4993
 
4994
  {
4995
    SI opval = ANDSI (GET_H_GR (FLD (f_dest)), 0xffffffff);
4996
    SETMEMSI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x4))), opval);
4997
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4998
  }
4999
 
5000
#undef FLD
5001
}
5002
  NEXT (vpc);
5003
 
5004
  CASE (sem, INSN_STQ) : /* st.q $rm, $disp10x8, $rd */
5005
{
5006
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5007
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5008
#define FLD(f) abuf->fields.sfmt_fldd.f
5009
  int UNUSED written = 0;
5010
  IADDR UNUSED pc = abuf->addr;
5011
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5012
 
5013
  {
5014
    DI opval = GET_H_GR (FLD (f_dest));
5015
    SETMEMDI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x8))), opval);
5016
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5017
  }
5018
 
5019
#undef FLD
5020
}
5021
  NEXT (vpc);
5022
 
5023
  CASE (sem, INSN_STW) : /* st.w $rm, $disp10x2, $rd */
5024
{
5025
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5026
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5027
#define FLD(f) abuf->fields.sfmt_lduw.f
5028
  int UNUSED written = 0;
5029
  IADDR UNUSED pc = abuf->addr;
5030
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5031
 
5032
  {
5033
    HI opval = ANDHI (GET_H_GR (FLD (f_dest)), 65535);
5034
    SETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_disp10x2))), opval);
5035
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5036
  }
5037
 
5038
#undef FLD
5039
}
5040
  NEXT (vpc);
5041
 
5042
  CASE (sem, INSN_STHIL) : /* sthi.l $rm, $disp6, $rd */
5043
{
5044
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5045
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5046
#define FLD(f) abuf->fields.sfmt_getcfg.f
5047
  int UNUSED written = 0;
5048
  IADDR UNUSED pc = abuf->addr;
5049
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5050
 
5051
{
5052
  DI tmp_addr;
5053
  QI tmp_bytecount;
5054
  DI tmp_val;
5055
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
5056
  tmp_bytecount = ADDDI (ANDDI (tmp_addr, 3), 1);
5057
if (ANDQI (tmp_bytecount, 4)) {
5058
  {
5059
    SI opval = GET_H_GR (FLD (f_dest));
5060
    SETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5061
    written |= (1 << 5);
5062
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5063
  }
5064
} else {
5065
if (GET_H_ENDIAN ()) {
5066
{
5067
  tmp_val = GET_H_GR (FLD (f_dest));
5068
if (ANDQI (tmp_bytecount, 1)) {
5069
{
5070
  {
5071
    UQI opval = ANDQI (tmp_val, 255);
5072
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5073
    written |= (1 << 6);
5074
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5075
  }
5076
  tmp_val = SRLDI (tmp_val, 8);
5077
}
5078
}
5079
if (ANDQI (tmp_bytecount, 2)) {
5080
{
5081
  {
5082
    HI opval = ANDHI (tmp_val, 65535);
5083
    SETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5084
    written |= (1 << 4);
5085
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5086
  }
5087
  tmp_val = SRLDI (tmp_val, 16);
5088
}
5089
}
5090
}
5091
} else {
5092
{
5093
  tmp_val = SRLDI (GET_H_GR (FLD (f_dest)), SUBSI (32, MULSI (8, tmp_bytecount)));
5094
if (ANDQI (tmp_bytecount, 2)) {
5095
{
5096
  {
5097
    HI opval = ANDHI (tmp_val, 65535);
5098
    SETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5099
    written |= (1 << 4);
5100
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5101
  }
5102
  tmp_val = SRLDI (tmp_val, 16);
5103
}
5104
}
5105
if (ANDQI (tmp_bytecount, 1)) {
5106
{
5107
  {
5108
    UQI opval = ANDQI (tmp_val, 255);
5109
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5110
    written |= (1 << 6);
5111
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5112
  }
5113
  tmp_val = SRLDI (tmp_val, 8);
5114
}
5115
}
5116
}
5117
}
5118
}
5119
}
5120
 
5121
  abuf->written = written;
5122
#undef FLD
5123
}
5124
  NEXT (vpc);
5125
 
5126
  CASE (sem, INSN_STHIQ) : /* sthi.q $rm, $disp6, $rd */
5127
{
5128
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5129
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5130
#define FLD(f) abuf->fields.sfmt_getcfg.f
5131
  int UNUSED written = 0;
5132
  IADDR UNUSED pc = abuf->addr;
5133
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5134
 
5135
{
5136
  DI tmp_addr;
5137
  QI tmp_bytecount;
5138
  DI tmp_val;
5139
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
5140
  tmp_bytecount = ADDDI (ANDDI (tmp_addr, 7), 1);
5141
if (ANDQI (tmp_bytecount, 8)) {
5142
  {
5143
    DI opval = GET_H_GR (FLD (f_dest));
5144
    SETMEMDI (current_cpu, pc, ANDDI (tmp_addr, -8), opval);
5145
    written |= (1 << 4);
5146
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5147
  }
5148
} else {
5149
if (GET_H_ENDIAN ()) {
5150
{
5151
  tmp_val = GET_H_GR (FLD (f_dest));
5152
if (ANDQI (tmp_bytecount, 1)) {
5153
{
5154
  {
5155
    UQI opval = ANDQI (tmp_val, 255);
5156
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5157
    written |= (1 << 7);
5158
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5159
  }
5160
  tmp_val = SRLDI (tmp_val, 8);
5161
}
5162
}
5163
if (ANDQI (tmp_bytecount, 2)) {
5164
{
5165
  {
5166
    HI opval = ANDHI (tmp_val, 65535);
5167
    SETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5168
    written |= (1 << 5);
5169
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5170
  }
5171
  tmp_val = SRLDI (tmp_val, 16);
5172
}
5173
}
5174
if (ANDQI (tmp_bytecount, 4)) {
5175
{
5176
  {
5177
    SI opval = ANDSI (tmp_val, 0xffffffff);
5178
    SETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -8), opval);
5179
    written |= (1 << 6);
5180
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5181
  }
5182
  tmp_val = SRLDI (tmp_val, 32);
5183
}
5184
}
5185
}
5186
} else {
5187
{
5188
  tmp_val = SRLDI (GET_H_GR (FLD (f_dest)), SUBSI (64, MULSI (8, tmp_bytecount)));
5189
if (ANDQI (tmp_bytecount, 4)) {
5190
{
5191
  {
5192
    SI opval = ANDSI (tmp_val, 0xffffffff);
5193
    SETMEMSI (current_cpu, pc, ANDDI (tmp_addr, -8), opval);
5194
    written |= (1 << 6);
5195
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5196
  }
5197
  tmp_val = SRLDI (tmp_val, 32);
5198
}
5199
}
5200
if (ANDQI (tmp_bytecount, 2)) {
5201
{
5202
  {
5203
    HI opval = ANDHI (tmp_val, 65535);
5204
    SETMEMHI (current_cpu, pc, ANDDI (tmp_addr, -4), opval);
5205
    written |= (1 << 5);
5206
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5207
  }
5208
  tmp_val = SRLDI (tmp_val, 16);
5209
}
5210
}
5211
if (ANDQI (tmp_bytecount, 1)) {
5212
{
5213
  {
5214
    UQI opval = ANDQI (tmp_val, 255);
5215
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5216
    written |= (1 << 7);
5217
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5218
  }
5219
  tmp_val = SRLDI (tmp_val, 8);
5220
}
5221
}
5222
}
5223
}
5224
}
5225
}
5226
 
5227
  abuf->written = written;
5228
#undef FLD
5229
}
5230
  NEXT (vpc);
5231
 
5232
  CASE (sem, INSN_STLOL) : /* stlo.l $rm, $disp6, $rd */
5233
{
5234
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5235
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5236
#define FLD(f) abuf->fields.sfmt_getcfg.f
5237
  int UNUSED written = 0;
5238
  IADDR UNUSED pc = abuf->addr;
5239
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5240
 
5241
{
5242
  DI tmp_addr;
5243
  QI tmp_bytecount;
5244
  DI tmp_val;
5245
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
5246
  tmp_bytecount = SUBSI (4, ANDDI (tmp_addr, 3));
5247
if (ANDQI (tmp_bytecount, 4)) {
5248
  {
5249
    USI opval = GET_H_GR (FLD (f_dest));
5250
    SETMEMUSI (current_cpu, pc, tmp_addr, opval);
5251
    written |= (1 << 6);
5252
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5253
  }
5254
} else {
5255
if (GET_H_ENDIAN ()) {
5256
{
5257
  tmp_val = SRLDI (GET_H_GR (FLD (f_dest)), SUBSI (32, MULSI (8, tmp_bytecount)));
5258
if (ANDQI (tmp_bytecount, 2)) {
5259
{
5260
  {
5261
    UHI opval = ANDHI (tmp_val, 65535);
5262
    SETMEMUHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2), opval);
5263
    written |= (1 << 4);
5264
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5265
  }
5266
  tmp_val = SRLDI (tmp_val, 16);
5267
}
5268
}
5269
if (ANDQI (tmp_bytecount, 1)) {
5270
{
5271
  {
5272
    UQI opval = ANDQI (tmp_val, 255);
5273
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5274
    written |= (1 << 5);
5275
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5276
  }
5277
  tmp_val = SRLDI (tmp_val, 8);
5278
}
5279
}
5280
}
5281
} else {
5282
{
5283
  tmp_val = GET_H_GR (FLD (f_dest));
5284
if (ANDQI (tmp_bytecount, 1)) {
5285
{
5286
  {
5287
    UQI opval = ANDQI (tmp_val, 255);
5288
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5289
    written |= (1 << 5);
5290
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5291
  }
5292
  tmp_val = SRLDI (tmp_val, 8);
5293
}
5294
}
5295
if (ANDQI (tmp_bytecount, 2)) {
5296
{
5297
  {
5298
    UHI opval = ANDHI (tmp_val, 65535);
5299
    SETMEMUHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2), opval);
5300
    written |= (1 << 4);
5301
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5302
  }
5303
  tmp_val = SRLDI (tmp_val, 16);
5304
}
5305
}
5306
}
5307
}
5308
}
5309
}
5310
 
5311
  abuf->written = written;
5312
#undef FLD
5313
}
5314
  NEXT (vpc);
5315
 
5316
  CASE (sem, INSN_STLOQ) : /* stlo.q $rm, $disp6, $rd */
5317
{
5318
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5319
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5320
#define FLD(f) abuf->fields.sfmt_getcfg.f
5321
  int UNUSED written = 0;
5322
  IADDR UNUSED pc = abuf->addr;
5323
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5324
 
5325
{
5326
  DI tmp_addr;
5327
  QI tmp_bytecount;
5328
  DI tmp_val;
5329
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), FLD (f_disp6));
5330
  tmp_bytecount = SUBSI (8, ANDDI (tmp_addr, 7));
5331
if (ANDQI (tmp_bytecount, 8)) {
5332
  {
5333
    UDI opval = GET_H_GR (FLD (f_dest));
5334
    SETMEMUDI (current_cpu, pc, tmp_addr, opval);
5335
    written |= (1 << 4);
5336
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5337
  }
5338
} else {
5339
if (GET_H_ENDIAN ()) {
5340
{
5341
  tmp_val = SRLDI (GET_H_GR (FLD (f_dest)), SUBSI (64, MULSI (8, tmp_bytecount)));
5342
if (ANDQI (tmp_bytecount, 4)) {
5343
{
5344
  {
5345
    USI opval = ANDSI (tmp_val, 0xffffffff);
5346
    SETMEMUSI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 3), -4), opval);
5347
    written |= (1 << 7);
5348
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5349
  }
5350
  tmp_val = SRLDI (tmp_val, 32);
5351
}
5352
}
5353
if (ANDQI (tmp_bytecount, 2)) {
5354
{
5355
  {
5356
    UHI opval = ANDHI (tmp_val, 65535);
5357
    SETMEMUHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2), opval);
5358
    written |= (1 << 5);
5359
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5360
  }
5361
  tmp_val = SRLDI (tmp_val, 16);
5362
}
5363
}
5364
if (ANDQI (tmp_bytecount, 1)) {
5365
{
5366
  {
5367
    UQI opval = ANDQI (tmp_val, 255);
5368
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5369
    written |= (1 << 6);
5370
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5371
  }
5372
  tmp_val = SRLDI (tmp_val, 8);
5373
}
5374
}
5375
}
5376
} else {
5377
{
5378
  tmp_val = GET_H_GR (FLD (f_dest));
5379
if (ANDQI (tmp_bytecount, 1)) {
5380
{
5381
  {
5382
    UQI opval = ANDQI (tmp_val, 255);
5383
    SETMEMUQI (current_cpu, pc, tmp_addr, opval);
5384
    written |= (1 << 6);
5385
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5386
  }
5387
  tmp_val = SRLDI (tmp_val, 8);
5388
}
5389
}
5390
if (ANDQI (tmp_bytecount, 2)) {
5391
{
5392
  {
5393
    UHI opval = ANDHI (tmp_val, 65535);
5394
    SETMEMUHI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 1), -2), opval);
5395
    written |= (1 << 5);
5396
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5397
  }
5398
  tmp_val = SRLDI (tmp_val, 16);
5399
}
5400
}
5401
if (ANDQI (tmp_bytecount, 4)) {
5402
{
5403
  {
5404
    USI opval = ANDSI (tmp_val, 0xffffffff);
5405
    SETMEMUSI (current_cpu, pc, ANDDI (ADDDI (tmp_addr, 3), -4), opval);
5406
    written |= (1 << 7);
5407
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5408
  }
5409
  tmp_val = SRLDI (tmp_val, 32);
5410
}
5411
}
5412
}
5413
}
5414
}
5415
}
5416
 
5417
  abuf->written = written;
5418
#undef FLD
5419
}
5420
  NEXT (vpc);
5421
 
5422
  CASE (sem, INSN_STXB) : /* stx.b $rm, $rn, $rd */
5423
{
5424
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5425
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5426
#define FLD(f) abuf->fields.sfmt_add.f
5427
  int UNUSED written = 0;
5428
  IADDR UNUSED pc = abuf->addr;
5429
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5430
 
5431
  {
5432
    UQI opval = SUBWORDDIQI (GET_H_GR (FLD (f_dest)), 7);
5433
    SETMEMUQI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
5434
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5435
  }
5436
 
5437
#undef FLD
5438
}
5439
  NEXT (vpc);
5440
 
5441
  CASE (sem, INSN_STXL) : /* stx.l $rm, $rn, $rd */
5442
{
5443
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5444
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5445
#define FLD(f) abuf->fields.sfmt_add.f
5446
  int UNUSED written = 0;
5447
  IADDR UNUSED pc = abuf->addr;
5448
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5449
 
5450
  {
5451
    SI opval = SUBWORDDISI (GET_H_GR (FLD (f_dest)), 1);
5452
    SETMEMSI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
5453
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5454
  }
5455
 
5456
#undef FLD
5457
}
5458
  NEXT (vpc);
5459
 
5460
  CASE (sem, INSN_STXQ) : /* stx.q $rm, $rn, $rd */
5461
{
5462
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5463
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5464
#define FLD(f) abuf->fields.sfmt_add.f
5465
  int UNUSED written = 0;
5466
  IADDR UNUSED pc = abuf->addr;
5467
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5468
 
5469
  {
5470
    DI opval = GET_H_GR (FLD (f_dest));
5471
    SETMEMDI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
5472
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5473
  }
5474
 
5475
#undef FLD
5476
}
5477
  NEXT (vpc);
5478
 
5479
  CASE (sem, INSN_STXW) : /* stx.w $rm, $rn, $rd */
5480
{
5481
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5482
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5483
#define FLD(f) abuf->fields.sfmt_add.f
5484
  int UNUSED written = 0;
5485
  IADDR UNUSED pc = abuf->addr;
5486
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5487
 
5488
  {
5489
    HI opval = SUBWORDDIHI (GET_H_GR (FLD (f_dest)), 3);
5490
    SETMEMHI (current_cpu, pc, ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right))), opval);
5491
    TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5492
  }
5493
 
5494
#undef FLD
5495
}
5496
  NEXT (vpc);
5497
 
5498
  CASE (sem, INSN_SUB) : /* sub $rm, $rn, $rd */
5499
{
5500
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5501
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5502
#define FLD(f) abuf->fields.sfmt_add.f
5503
  int UNUSED written = 0;
5504
  IADDR UNUSED pc = abuf->addr;
5505
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5506
 
5507
  {
5508
    DI opval = SUBDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
5509
    SET_H_GR (FLD (f_dest), opval);
5510
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5511
  }
5512
 
5513
#undef FLD
5514
}
5515
  NEXT (vpc);
5516
 
5517
  CASE (sem, INSN_SUBL) : /* sub.l $rm, $rn, $rd */
5518
{
5519
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5520
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5521
#define FLD(f) abuf->fields.sfmt_add.f
5522
  int UNUSED written = 0;
5523
  IADDR UNUSED pc = abuf->addr;
5524
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5525
 
5526
  {
5527
    DI opval = EXTSIDI (SUBSI (SUBWORDDISI (GET_H_GR (FLD (f_left)), 1), SUBWORDDISI (GET_H_GR (FLD (f_right)), 1)));
5528
    SET_H_GR (FLD (f_dest), opval);
5529
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5530
  }
5531
 
5532
#undef FLD
5533
}
5534
  NEXT (vpc);
5535
 
5536
  CASE (sem, INSN_SWAPQ) : /* swap.q $rm, $rn, $rd */
5537
{
5538
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5539
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5540
#define FLD(f) abuf->fields.sfmt_add.f
5541
  int UNUSED written = 0;
5542
  IADDR UNUSED pc = abuf->addr;
5543
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5544
 
5545
{
5546
  DI tmp_addr;
5547
  DI tmp_temp;
5548
  tmp_addr = ADDDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
5549
  tmp_temp = GETMEMDI (current_cpu, pc, tmp_addr);
5550
  {
5551
    DI opval = GET_H_GR (FLD (f_dest));
5552
    SETMEMDI (current_cpu, pc, tmp_addr, opval);
5553
    TRACE_RESULT (current_cpu, abuf, "memory", 'D', opval);
5554
  }
5555
  {
5556
    DI opval = tmp_temp;
5557
    SET_H_GR (FLD (f_dest), opval);
5558
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5559
  }
5560
}
5561
 
5562
#undef FLD
5563
}
5564
  NEXT (vpc);
5565
 
5566
  CASE (sem, INSN_SYNCI) : /* synci */
5567
{
5568
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5569
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5570
#define FLD(f) abuf->fields.sfmt_empty.f
5571
  int UNUSED written = 0;
5572
  IADDR UNUSED pc = abuf->addr;
5573
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5574
 
5575
((void) 0); /*nop*/
5576
 
5577
#undef FLD
5578
}
5579
  NEXT (vpc);
5580
 
5581
  CASE (sem, INSN_SYNCO) : /* synco */
5582
{
5583
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5584
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5585
#define FLD(f) abuf->fields.sfmt_empty.f
5586
  int UNUSED written = 0;
5587
  IADDR UNUSED pc = abuf->addr;
5588
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5589
 
5590
((void) 0); /*nop*/
5591
 
5592
#undef FLD
5593
}
5594
  NEXT (vpc);
5595
 
5596
  CASE (sem, INSN_TRAPA) : /* trapa $rm */
5597
{
5598
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5599
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5600
#define FLD(f) abuf->fields.sfmt_xori.f
5601
  int UNUSED written = 0;
5602
  IADDR UNUSED pc = abuf->addr;
5603
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5604
 
5605
sh64_trapa (current_cpu, GET_H_GR (FLD (f_left)), pc);
5606
 
5607
#undef FLD
5608
}
5609
  NEXT (vpc);
5610
 
5611
  CASE (sem, INSN_XOR) : /* xor $rm, $rn, $rd */
5612
{
5613
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5614
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5615
#define FLD(f) abuf->fields.sfmt_add.f
5616
  int UNUSED written = 0;
5617
  IADDR UNUSED pc = abuf->addr;
5618
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5619
 
5620
  {
5621
    DI opval = XORDI (GET_H_GR (FLD (f_left)), GET_H_GR (FLD (f_right)));
5622
    SET_H_GR (FLD (f_dest), opval);
5623
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5624
  }
5625
 
5626
#undef FLD
5627
}
5628
  NEXT (vpc);
5629
 
5630
  CASE (sem, INSN_XORI) : /* xori $rm, $imm6, $rd */
5631
{
5632
  SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5633
  ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5634
#define FLD(f) abuf->fields.sfmt_xori.f
5635
  int UNUSED written = 0;
5636
  IADDR UNUSED pc = abuf->addr;
5637
  vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5638
 
5639
  {
5640
    DI opval = XORDI (GET_H_GR (FLD (f_left)), EXTSIDI (FLD (f_imm6)));
5641
    SET_H_GR (FLD (f_dest), opval);
5642
    TRACE_RESULT (current_cpu, abuf, "gr", 'D', opval);
5643
  }
5644
 
5645
#undef FLD
5646
}
5647
  NEXT (vpc);
5648
 
5649
 
5650
    }
5651
  ENDSWITCH (sem) /* End of semantic switch.  */
5652
 
5653
  /* At this point `vpc' contains the next insn to execute.  */
5654
}
5655
 
5656
#undef DEFINE_SWITCH
5657
#endif /* DEFINE_SWITCH */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.