projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* sim-main.h: Delete inclusion of config.h, include sim-basics.h
[deliverable/binutils-gdb.git] / sim / m32r / extractx.c
CommitLineData
bb51b65d
DE		 1/* Simulator instruction extractor for m32r.
2
3THIS FILE IS MACHINE GENERATED WITH CGEN.
4
5Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
6
7This file is part of the GNU Simulators.
8
9This program is free software; you can redistribute it and/or modify
10it under the terms of the GNU General Public License as published by
11the Free Software Foundation; either version 2, or (at your option)
12any later version.
13
14This program is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License along
20with this program; if not, write to the Free Software Foundation, Inc.,
2159 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22
23*/
24
25#define WANT_CPU
26#define WANT_CPU_M32RXF
27
28#include "sim-main.h"
29#include "cgen-ops.h"
bb51b65d
DE		 30
31void
32EX_FN_NAME (m32rxf,fmt_add) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
33{
34#define FLD(f) abuf->fields.fmt_add.f
35 EXTRACT_FMT_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
36
37 EXTRACT_FMT_ADD_CODE
38
39 /* Record the fields for the semantic handler. */
40 FLD (f_r1) = & CPU (h_gr)[f_r1];
41 FLD (f_r2) = & CPU (h_gr)[f_r2];
42 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_add", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
43
44#if WITH_PROFILE_MODEL_P
45 /* Record the fields for profiling. */
46 if (PROFILE_MODEL_P (current_cpu))
47 {
48 FLD (in_dr) = f_r1;
49 FLD (in_sr) = f_r2;
50 FLD (out_dr) = f_r1;
51 }
52#endif
53#undef FLD
54}
55
56void
57EX_FN_NAME (m32rxf,fmt_add3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
58{
59#define FLD(f) abuf->fields.fmt_add3.f
60 EXTRACT_FMT_ADD3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
61
62 EXTRACT_FMT_ADD3_CODE
63
64 /* Record the fields for the semantic handler. */
65 FLD (f_r1) = & CPU (h_gr)[f_r1];
66 FLD (f_r2) = & CPU (h_gr)[f_r2];
67 FLD (f_simm16) = f_simm16;
68 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_add3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
69
70#if WITH_PROFILE_MODEL_P
71 /* Record the fields for profiling. */
72 if (PROFILE_MODEL_P (current_cpu))
73 {
74 FLD (in_sr) = f_r2;
75 FLD (out_dr) = f_r1;
76 }
77#endif
78#undef FLD
79}
80
81void
82EX_FN_NAME (m32rxf,fmt_and3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
83{
84#define FLD(f) abuf->fields.fmt_and3.f
85 EXTRACT_FMT_AND3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
86
87 EXTRACT_FMT_AND3_CODE
88
89 /* Record the fields for the semantic handler. */
90 FLD (f_r1) = & CPU (h_gr)[f_r1];
91 FLD (f_r2) = & CPU (h_gr)[f_r2];
92 FLD (f_uimm16) = f_uimm16;
93 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_and3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "uimm16 0x%x", 'x', f_uimm16, (char *) 0));
94
95#if WITH_PROFILE_MODEL_P
96 /* Record the fields for profiling. */
97 if (PROFILE_MODEL_P (current_cpu))
98 {
99 FLD (in_sr) = f_r2;
100 FLD (out_dr) = f_r1;
101 }
102#endif
103#undef FLD
104}
105
106void
107EX_FN_NAME (m32rxf,fmt_or3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
108{
109#define FLD(f) abuf->fields.fmt_or3.f
110 EXTRACT_FMT_OR3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
111
112 EXTRACT_FMT_OR3_CODE
113
114 /* Record the fields for the semantic handler. */
115 FLD (f_r1) = & CPU (h_gr)[f_r1];
116 FLD (f_r2) = & CPU (h_gr)[f_r2];
117 FLD (f_uimm16) = f_uimm16;
118 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_or3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "ulo16 0x%x", 'x', f_uimm16, (char *) 0));
119
120#if WITH_PROFILE_MODEL_P
121 /* Record the fields for profiling. */
122 if (PROFILE_MODEL_P (current_cpu))
123 {
124 FLD (in_sr) = f_r2;
125 FLD (out_dr) = f_r1;
126 }
127#endif
128#undef FLD
129}
130
131void
132EX_FN_NAME (m32rxf,fmt_addi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
133{
134#define FLD(f) abuf->fields.fmt_addi.f
135 EXTRACT_FMT_ADDI_VARS /* f-op1 f-r1 f-simm8 */
136
137 EXTRACT_FMT_ADDI_CODE
138
139 /* Record the fields for the semantic handler. */
140 FLD (f_r1) = & CPU (h_gr)[f_r1];
141 FLD (f_simm8) = f_simm8;
142 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_addi", "dr 0x%x", 'x', f_r1, "simm8 0x%x", 'x', f_simm8, (char *) 0));
143
144#if WITH_PROFILE_MODEL_P
145 /* Record the fields for profiling. */
146 if (PROFILE_MODEL_P (current_cpu))
147 {
148 FLD (in_dr) = f_r1;
149 FLD (out_dr) = f_r1;
150 }
151#endif
152#undef FLD
153}
154
155void
156EX_FN_NAME (m32rxf,fmt_addv) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
157{
158#define FLD(f) abuf->fields.fmt_addv.f
159 EXTRACT_FMT_ADDV_VARS /* f-op1 f-r1 f-op2 f-r2 */
160
161 EXTRACT_FMT_ADDV_CODE
162
163 /* Record the fields for the semantic handler. */
164 FLD (f_r1) = & CPU (h_gr)[f_r1];
165 FLD (f_r2) = & CPU (h_gr)[f_r2];
166 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_addv", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
167
168#if WITH_PROFILE_MODEL_P
169 /* Record the fields for profiling. */
170 if (PROFILE_MODEL_P (current_cpu))
171 {
172 FLD (in_dr) = f_r1;
173 FLD (in_sr) = f_r2;
174 FLD (out_dr) = f_r1;
175 }
176#endif
177#undef FLD
178}
179
180void
181EX_FN_NAME (m32rxf,fmt_addv3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
182{
183#define FLD(f) abuf->fields.fmt_addv3.f
184 EXTRACT_FMT_ADDV3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
185
186 EXTRACT_FMT_ADDV3_CODE
187
188 /* Record the fields for the semantic handler. */
189 FLD (f_r1) = & CPU (h_gr)[f_r1];
190 FLD (f_r2) = & CPU (h_gr)[f_r2];
191 FLD (f_simm16) = f_simm16;
192 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_addv3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
193
194#if WITH_PROFILE_MODEL_P
195 /* Record the fields for profiling. */
196 if (PROFILE_MODEL_P (current_cpu))
197 {
198 FLD (in_sr) = f_r2;
199 FLD (out_dr) = f_r1;
200 }
201#endif
202#undef FLD
203}
204
205void
206EX_FN_NAME (m32rxf,fmt_addx) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
207{
208#define FLD(f) abuf->fields.fmt_addx.f
209 EXTRACT_FMT_ADDX_VARS /* f-op1 f-r1 f-op2 f-r2 */
210
211 EXTRACT_FMT_ADDX_CODE
212
213 /* Record the fields for the semantic handler. */
214 FLD (f_r1) = & CPU (h_gr)[f_r1];
215 FLD (f_r2) = & CPU (h_gr)[f_r2];
216 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_addx", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
217
218#if WITH_PROFILE_MODEL_P
219 /* Record the fields for profiling. */
220 if (PROFILE_MODEL_P (current_cpu))
221 {
222 FLD (in_dr) = f_r1;
223 FLD (in_sr) = f_r2;
224 FLD (out_dr) = f_r1;
225 }
226#endif
227#undef FLD
228}
229
230void
231EX_FN_NAME (m32rxf,fmt_bc8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
232{
233#define FLD(f) abuf->fields.cti.fields.fmt_bc8.f
234 EXTRACT_FMT_BC8_VARS /* f-op1 f-r1 f-disp8 */
235
236 EXTRACT_FMT_BC8_CODE
237
238 /* Record the fields for the semantic handler. */
239 FLD (f_disp8) = f_disp8;
240 SEM_BRANCH_INIT_EXTRACT (abuf);
241 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bc8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
242
243#if WITH_PROFILE_MODEL_P
244 /* Record the fields for profiling. */
245 if (PROFILE_MODEL_P (current_cpu))
246 {
247 }
248#endif
249#undef FLD
250}
251
252void
253EX_FN_NAME (m32rxf,fmt_bc24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
254{
255#define FLD(f) abuf->fields.cti.fields.fmt_bc24.f
256 EXTRACT_FMT_BC24_VARS /* f-op1 f-r1 f-disp24 */
257
258 EXTRACT_FMT_BC24_CODE
259
260 /* Record the fields for the semantic handler. */
261 FLD (f_disp24) = f_disp24;
262 SEM_BRANCH_INIT_EXTRACT (abuf);
263 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bc24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
264
265#if WITH_PROFILE_MODEL_P
266 /* Record the fields for profiling. */
267 if (PROFILE_MODEL_P (current_cpu))
268 {
269 }
270#endif
271#undef FLD
272}
273
274void
275EX_FN_NAME (m32rxf,fmt_beq) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
276{
277#define FLD(f) abuf->fields.cti.fields.fmt_beq.f
278 EXTRACT_FMT_BEQ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
279
280 EXTRACT_FMT_BEQ_CODE
281
282 /* Record the fields for the semantic handler. */
283 FLD (f_r1) = & CPU (h_gr)[f_r1];
284 FLD (f_r2) = & CPU (h_gr)[f_r2];
285 FLD (f_disp16) = f_disp16;
286 SEM_BRANCH_INIT_EXTRACT (abuf);
287 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_beq", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "disp16 0x%x", 'x', f_disp16, (char *) 0));
288
289#if WITH_PROFILE_MODEL_P
290 /* Record the fields for profiling. */
291 if (PROFILE_MODEL_P (current_cpu))
292 {
293 FLD (in_src1) = f_r1;
294 FLD (in_src2) = f_r2;
295 }
296#endif
297#undef FLD
298}
299
300void
301EX_FN_NAME (m32rxf,fmt_beqz) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
302{
303#define FLD(f) abuf->fields.cti.fields.fmt_beqz.f
304 EXTRACT_FMT_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
305
306 EXTRACT_FMT_BEQZ_CODE
307
308 /* Record the fields for the semantic handler. */
309 FLD (f_r2) = & CPU (h_gr)[f_r2];
310 FLD (f_disp16) = f_disp16;
311 SEM_BRANCH_INIT_EXTRACT (abuf);
312 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_beqz", "src2 0x%x", 'x', f_r2, "disp16 0x%x", 'x', f_disp16, (char *) 0));
313
314#if WITH_PROFILE_MODEL_P
315 /* Record the fields for profiling. */
316 if (PROFILE_MODEL_P (current_cpu))
317 {
318 FLD (in_src2) = f_r2;
319 }
320#endif
321#undef FLD
322}
323
324void
325EX_FN_NAME (m32rxf,fmt_bl8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
326{
327#define FLD(f) abuf->fields.cti.fields.fmt_bl8.f
328 EXTRACT_FMT_BL8_VARS /* f-op1 f-r1 f-disp8 */
329
330 EXTRACT_FMT_BL8_CODE
331
332 /* Record the fields for the semantic handler. */
333 FLD (f_disp8) = f_disp8;
334 SEM_BRANCH_INIT_EXTRACT (abuf);
335 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bl8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
336
337#if WITH_PROFILE_MODEL_P
338 /* Record the fields for profiling. */
339 if (PROFILE_MODEL_P (current_cpu))
340 {
341 FLD (out_h_gr_14) = 14;
342 }
343#endif
344#undef FLD
345}
346
347void
348EX_FN_NAME (m32rxf,fmt_bl24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
349{
350#define FLD(f) abuf->fields.cti.fields.fmt_bl24.f
351 EXTRACT_FMT_BL24_VARS /* f-op1 f-r1 f-disp24 */
352
353 EXTRACT_FMT_BL24_CODE
354
355 /* Record the fields for the semantic handler. */
356 FLD (f_disp24) = f_disp24;
357 SEM_BRANCH_INIT_EXTRACT (abuf);
358 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bl24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
359
360#if WITH_PROFILE_MODEL_P
361 /* Record the fields for profiling. */
362 if (PROFILE_MODEL_P (current_cpu))
363 {
364 FLD (out_h_gr_14) = 14;
365 }
366#endif
367#undef FLD
368}
369
370void
371EX_FN_NAME (m32rxf,fmt_bcl8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
372{
373#define FLD(f) abuf->fields.cti.fields.fmt_bcl8.f
374 EXTRACT_FMT_BCL8_VARS /* f-op1 f-r1 f-disp8 */
375
376 EXTRACT_FMT_BCL8_CODE
377
378 /* Record the fields for the semantic handler. */
379 FLD (f_disp8) = f_disp8;
380 SEM_BRANCH_INIT_EXTRACT (abuf);
381 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bcl8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
382
383#if WITH_PROFILE_MODEL_P
384 /* Record the fields for profiling. */
385 if (PROFILE_MODEL_P (current_cpu))
386 {
387 FLD (out_h_gr_14) = 14;
388 }
389#endif
390#undef FLD
391}
392
393void
394EX_FN_NAME (m32rxf,fmt_bcl24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
395{
396#define FLD(f) abuf->fields.cti.fields.fmt_bcl24.f
397 EXTRACT_FMT_BCL24_VARS /* f-op1 f-r1 f-disp24 */
398
399 EXTRACT_FMT_BCL24_CODE
400
401 /* Record the fields for the semantic handler. */
402 FLD (f_disp24) = f_disp24;
403 SEM_BRANCH_INIT_EXTRACT (abuf);
404 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bcl24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
405
406#if WITH_PROFILE_MODEL_P
407 /* Record the fields for profiling. */
408 if (PROFILE_MODEL_P (current_cpu))
409 {
410 FLD (out_h_gr_14) = 14;
411 }
412#endif
413#undef FLD
414}
415
416void
417EX_FN_NAME (m32rxf,fmt_bra8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
418{
419#define FLD(f) abuf->fields.cti.fields.fmt_bra8.f
420 EXTRACT_FMT_BRA8_VARS /* f-op1 f-r1 f-disp8 */
421
422 EXTRACT_FMT_BRA8_CODE
423
424 /* Record the fields for the semantic handler. */
425 FLD (f_disp8) = f_disp8;
426 SEM_BRANCH_INIT_EXTRACT (abuf);
427 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bra8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
428
429#if WITH_PROFILE_MODEL_P
430 /* Record the fields for profiling. */
431 if (PROFILE_MODEL_P (current_cpu))
432 {
433 }
434#endif
435#undef FLD
436}
437
438void
439EX_FN_NAME (m32rxf,fmt_bra24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
440{
441#define FLD(f) abuf->fields.cti.fields.fmt_bra24.f
442 EXTRACT_FMT_BRA24_VARS /* f-op1 f-r1 f-disp24 */
443
444 EXTRACT_FMT_BRA24_CODE
445
446 /* Record the fields for the semantic handler. */
447 FLD (f_disp24) = f_disp24;
448 SEM_BRANCH_INIT_EXTRACT (abuf);
449 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bra24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
450
451#if WITH_PROFILE_MODEL_P
452 /* Record the fields for profiling. */
453 if (PROFILE_MODEL_P (current_cpu))
454 {
455 }
456#endif
457#undef FLD
458}
459
460void
461EX_FN_NAME (m32rxf,fmt_cmp) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
462{
463#define FLD(f) abuf->fields.fmt_cmp.f
464 EXTRACT_FMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
465
466 EXTRACT_FMT_CMP_CODE
467
468 /* Record the fields for the semantic handler. */
469 FLD (f_r1) = & CPU (h_gr)[f_r1];
470 FLD (f_r2) = & CPU (h_gr)[f_r2];
471 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_cmp", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
472
473#if WITH_PROFILE_MODEL_P
474 /* Record the fields for profiling. */
475 if (PROFILE_MODEL_P (current_cpu))
476 {
477 FLD (in_src1) = f_r1;
478 FLD (in_src2) = f_r2;
479 }
480#endif
481#undef FLD
482}
483
484void
485EX_FN_NAME (m32rxf,fmt_cmpi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
486{
487#define FLD(f) abuf->fields.fmt_cmpi.f
488 EXTRACT_FMT_CMPI_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
489
490 EXTRACT_FMT_CMPI_CODE
491
492 /* Record the fields for the semantic handler. */
493 FLD (f_r2) = & CPU (h_gr)[f_r2];
494 FLD (f_simm16) = f_simm16;
495 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_cmpi", "src2 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
496
497#if WITH_PROFILE_MODEL_P
498 /* Record the fields for profiling. */
499 if (PROFILE_MODEL_P (current_cpu))
500 {
501 FLD (in_src2) = f_r2;
502 }
503#endif
504#undef FLD
505}
506
507void
508EX_FN_NAME (m32rxf,fmt_cmpz) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
509{
510#define FLD(f) abuf->fields.fmt_cmpz.f
511 EXTRACT_FMT_CMPZ_VARS /* f-op1 f-r1 f-op2 f-r2 */
512
513 EXTRACT_FMT_CMPZ_CODE
514
515 /* Record the fields for the semantic handler. */
516 FLD (f_r2) = & CPU (h_gr)[f_r2];
517 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_cmpz", "src2 0x%x", 'x', f_r2, (char *) 0));
518
519#if WITH_PROFILE_MODEL_P
520 /* Record the fields for profiling. */
521 if (PROFILE_MODEL_P (current_cpu))
522 {
523 FLD (in_src2) = f_r2;
524 }
525#endif
526#undef FLD
527}
528
529void
530EX_FN_NAME (m32rxf,fmt_div) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
531{
532#define FLD(f) abuf->fields.fmt_div.f
533 EXTRACT_FMT_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
534
535 EXTRACT_FMT_DIV_CODE
536
537 /* Record the fields for the semantic handler. */
538 FLD (f_r1) = & CPU (h_gr)[f_r1];
539 FLD (f_r2) = & CPU (h_gr)[f_r2];
540 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_div", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
541
542#if WITH_PROFILE_MODEL_P
543 /* Record the fields for profiling. */
544 if (PROFILE_MODEL_P (current_cpu))
545 {
546 FLD (in_sr) = f_r2;
547 FLD (in_dr) = f_r1;
548 FLD (out_dr) = f_r1;
549 }
550#endif
551#undef FLD
552}
553
554void
555EX_FN_NAME (m32rxf,fmt_jc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
556{
557#define FLD(f) abuf->fields.cti.fields.fmt_jc.f
558 EXTRACT_FMT_JC_VARS /* f-op1 f-r1 f-op2 f-r2 */
559
560 EXTRACT_FMT_JC_CODE
561
562 /* Record the fields for the semantic handler. */
563 FLD (f_r2) = & CPU (h_gr)[f_r2];
564 SEM_BRANCH_INIT_EXTRACT (abuf);
565 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_jc", "sr 0x%x", 'x', f_r2, (char *) 0));
566
567#if WITH_PROFILE_MODEL_P
568 /* Record the fields for profiling. */
569 if (PROFILE_MODEL_P (current_cpu))
570 {
571 FLD (in_sr) = f_r2;
572 }
573#endif
574#undef FLD
575}
576
577void
578EX_FN_NAME (m32rxf,fmt_jl) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
579{
580#define FLD(f) abuf->fields.cti.fields.fmt_jl.f
581 EXTRACT_FMT_JL_VARS /* f-op1 f-r1 f-op2 f-r2 */
582
583 EXTRACT_FMT_JL_CODE
584
585 /* Record the fields for the semantic handler. */
586 FLD (f_r2) = & CPU (h_gr)[f_r2];
587 SEM_BRANCH_INIT_EXTRACT (abuf);
588 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_jl", "sr 0x%x", 'x', f_r2, (char *) 0));
589
590#if WITH_PROFILE_MODEL_P
591 /* Record the fields for profiling. */
592 if (PROFILE_MODEL_P (current_cpu))
593 {
594 FLD (in_sr) = f_r2;
595 FLD (out_h_gr_14) = 14;
596 }
597#endif
598#undef FLD
599}
600
601void
602EX_FN_NAME (m32rxf,fmt_jmp) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
603{
604#define FLD(f) abuf->fields.cti.fields.fmt_jmp.f
605 EXTRACT_FMT_JMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
606
607 EXTRACT_FMT_JMP_CODE
608
609 /* Record the fields for the semantic handler. */
610 FLD (f_r2) = & CPU (h_gr)[f_r2];
611 SEM_BRANCH_INIT_EXTRACT (abuf);
612 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_jmp", "sr 0x%x", 'x', f_r2, (char *) 0));
613
614#if WITH_PROFILE_MODEL_P
615 /* Record the fields for profiling. */
616 if (PROFILE_MODEL_P (current_cpu))
617 {
618 FLD (in_sr) = f_r2;
619 }
620#endif
621#undef FLD
622}
623
624void
625EX_FN_NAME (m32rxf,fmt_ld) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
626{
627#define FLD(f) abuf->fields.fmt_ld.f
628 EXTRACT_FMT_LD_VARS /* f-op1 f-r1 f-op2 f-r2 */
629
630 EXTRACT_FMT_LD_CODE
631
632 /* Record the fields for the semantic handler. */
633 FLD (f_r1) = & CPU (h_gr)[f_r1];
634 FLD (f_r2) = & CPU (h_gr)[f_r2];
635 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ld", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
636
637#if WITH_PROFILE_MODEL_P
638 /* Record the fields for profiling. */
639 if (PROFILE_MODEL_P (current_cpu))
640 {
641 FLD (in_sr) = f_r2;
642 FLD (out_dr) = f_r1;
643 }
644#endif
645#undef FLD
646}
647
648void
649EX_FN_NAME (m32rxf,fmt_ld_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
650{
651#define FLD(f) abuf->fields.fmt_ld_d.f
652 EXTRACT_FMT_LD_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
653
654 EXTRACT_FMT_LD_D_CODE
655
656 /* Record the fields for the semantic handler. */
657 FLD (f_r1) = & CPU (h_gr)[f_r1];
658 FLD (f_r2) = & CPU (h_gr)[f_r2];
659 FLD (f_simm16) = f_simm16;
660 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ld_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
661
662#if WITH_PROFILE_MODEL_P
663 /* Record the fields for profiling. */
664 if (PROFILE_MODEL_P (current_cpu))
665 {
666 FLD (in_sr) = f_r2;
667 FLD (out_dr) = f_r1;
668 }
669#endif
670#undef FLD
671}
672
673void
674EX_FN_NAME (m32rxf,fmt_ldb) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
675{
676#define FLD(f) abuf->fields.fmt_ldb.f
677 EXTRACT_FMT_LDB_VARS /* f-op1 f-r1 f-op2 f-r2 */
678
679 EXTRACT_FMT_LDB_CODE
680
681 /* Record the fields for the semantic handler. */
682 FLD (f_r1) = & CPU (h_gr)[f_r1];
683 FLD (f_r2) = & CPU (h_gr)[f_r2];
684 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldb", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
685
686#if WITH_PROFILE_MODEL_P
687 /* Record the fields for profiling. */
688 if (PROFILE_MODEL_P (current_cpu))
689 {
690 FLD (in_sr) = f_r2;
691 FLD (out_dr) = f_r1;
692 }
693#endif
694#undef FLD
695}
696
697void
698EX_FN_NAME (m32rxf,fmt_ldb_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
699{
700#define FLD(f) abuf->fields.fmt_ldb_d.f
701 EXTRACT_FMT_LDB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
702
703 EXTRACT_FMT_LDB_D_CODE
704
705 /* Record the fields for the semantic handler. */
706 FLD (f_r1) = & CPU (h_gr)[f_r1];
707 FLD (f_r2) = & CPU (h_gr)[f_r2];
708 FLD (f_simm16) = f_simm16;
709 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldb_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
710
711#if WITH_PROFILE_MODEL_P
712 /* Record the fields for profiling. */
713 if (PROFILE_MODEL_P (current_cpu))
714 {
715 FLD (in_sr) = f_r2;
716 FLD (out_dr) = f_r1;
717 }
718#endif
719#undef FLD
720}
721
722void
723EX_FN_NAME (m32rxf,fmt_ldh) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
724{
725#define FLD(f) abuf->fields.fmt_ldh.f
726 EXTRACT_FMT_LDH_VARS /* f-op1 f-r1 f-op2 f-r2 */
727
728 EXTRACT_FMT_LDH_CODE
729
730 /* Record the fields for the semantic handler. */
731 FLD (f_r1) = & CPU (h_gr)[f_r1];
732 FLD (f_r2) = & CPU (h_gr)[f_r2];
733 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldh", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
734
735#if WITH_PROFILE_MODEL_P
736 /* Record the fields for profiling. */
737 if (PROFILE_MODEL_P (current_cpu))
738 {
739 FLD (in_sr) = f_r2;
740 FLD (out_dr) = f_r1;
741 }
742#endif
743#undef FLD
744}
745
746void
747EX_FN_NAME (m32rxf,fmt_ldh_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
748{
749#define FLD(f) abuf->fields.fmt_ldh_d.f
750 EXTRACT_FMT_LDH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
751
752 EXTRACT_FMT_LDH_D_CODE
753
754 /* Record the fields for the semantic handler. */
755 FLD (f_r1) = & CPU (h_gr)[f_r1];
756 FLD (f_r2) = & CPU (h_gr)[f_r2];
757 FLD (f_simm16) = f_simm16;
758 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldh_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
759
760#if WITH_PROFILE_MODEL_P
761 /* Record the fields for profiling. */
762 if (PROFILE_MODEL_P (current_cpu))
763 {
764 FLD (in_sr) = f_r2;
765 FLD (out_dr) = f_r1;
766 }
767#endif
768#undef FLD
769}
770
771void
772EX_FN_NAME (m32rxf,fmt_ld_plus) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
773{
774#define FLD(f) abuf->fields.fmt_ld_plus.f
775 EXTRACT_FMT_LD_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
776
777 EXTRACT_FMT_LD_PLUS_CODE
778
779 /* Record the fields for the semantic handler. */
780 FLD (f_r1) = & CPU (h_gr)[f_r1];
781 FLD (f_r2) = & CPU (h_gr)[f_r2];
782 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ld_plus", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
783
784#if WITH_PROFILE_MODEL_P
785 /* Record the fields for profiling. */
786 if (PROFILE_MODEL_P (current_cpu))
787 {
788 FLD (in_sr) = f_r2;
789 FLD (out_dr) = f_r1;
790 FLD (out_sr) = f_r2;
791 }
792#endif
793#undef FLD
794}
795
796void
797EX_FN_NAME (m32rxf,fmt_ld24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
798{
799#define FLD(f) abuf->fields.fmt_ld24.f
800 EXTRACT_FMT_LD24_VARS /* f-op1 f-r1 f-uimm24 */
801
802 EXTRACT_FMT_LD24_CODE
803
804 /* Record the fields for the semantic handler. */
805 FLD (f_r1) = & CPU (h_gr)[f_r1];
806 FLD (f_uimm24) = f_uimm24;
807 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ld24", "dr 0x%x", 'x', f_r1, "uimm24 0x%x", 'x', f_uimm24, (char *) 0));
808
809#if WITH_PROFILE_MODEL_P
810 /* Record the fields for profiling. */
811 if (PROFILE_MODEL_P (current_cpu))
812 {
813 FLD (out_dr) = f_r1;
814 }
815#endif
816#undef FLD
817}
818
819void
820EX_FN_NAME (m32rxf,fmt_ldi8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
821{
822#define FLD(f) abuf->fields.fmt_ldi8.f
823 EXTRACT_FMT_LDI8_VARS /* f-op1 f-r1 f-simm8 */
824
825 EXTRACT_FMT_LDI8_CODE
826
827 /* Record the fields for the semantic handler. */
828 FLD (f_r1) = & CPU (h_gr)[f_r1];
829 FLD (f_simm8) = f_simm8;
830 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldi8", "dr 0x%x", 'x', f_r1, "simm8 0x%x", 'x', f_simm8, (char *) 0));
831
832#if WITH_PROFILE_MODEL_P
833 /* Record the fields for profiling. */
834 if (PROFILE_MODEL_P (current_cpu))
835 {
836 FLD (out_dr) = f_r1;
837 }
838#endif
839#undef FLD
840}
841
842void
843EX_FN_NAME (m32rxf,fmt_ldi16) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
844{
845#define FLD(f) abuf->fields.fmt_ldi16.f
846 EXTRACT_FMT_LDI16_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
847
848 EXTRACT_FMT_LDI16_CODE
849
850 /* Record the fields for the semantic handler. */
851 FLD (f_r1) = & CPU (h_gr)[f_r1];
852 FLD (f_simm16) = f_simm16;
853 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldi16", "dr 0x%x", 'x', f_r1, "slo16 0x%x", 'x', f_simm16, (char *) 0));
854
855#if WITH_PROFILE_MODEL_P
856 /* Record the fields for profiling. */
857 if (PROFILE_MODEL_P (current_cpu))
858 {
859 FLD (out_dr) = f_r1;
860 }
861#endif
862#undef FLD
863}
864
865void
866EX_FN_NAME (m32rxf,fmt_lock) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
867{
868#define FLD(f) abuf->fields.fmt_lock.f
869 EXTRACT_FMT_LOCK_VARS /* f-op1 f-r1 f-op2 f-r2 */
870
871 EXTRACT_FMT_LOCK_CODE
872
873 /* Record the fields for the semantic handler. */
874 FLD (f_r1) = & CPU (h_gr)[f_r1];
875 FLD (f_r2) = & CPU (h_gr)[f_r2];
876 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_lock", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
877
878#if WITH_PROFILE_MODEL_P
879 /* Record the fields for profiling. */
880 if (PROFILE_MODEL_P (current_cpu))
881 {
882 FLD (in_sr) = f_r2;
883 FLD (out_dr) = f_r1;
884 }
885#endif
886#undef FLD
887}
888
889void
890EX_FN_NAME (m32rxf,fmt_machi_a) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
891{
892#define FLD(f) abuf->fields.fmt_machi_a.f
893 EXTRACT_FMT_MACHI_A_VARS /* f-op1 f-r1 f-acc f-op23 f-r2 */
894
895 EXTRACT_FMT_MACHI_A_CODE
896
897 /* Record the fields for the semantic handler. */
898 FLD (f_r1) = & CPU (h_gr)[f_r1];
899 FLD (f_acc) = f_acc;
900 FLD (f_r2) = & CPU (h_gr)[f_r2];
901 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_machi_a", "src1 0x%x", 'x', f_r1, "acc 0x%x", 'x', f_acc, "src2 0x%x", 'x', f_r2, (char *) 0));
902
903#if WITH_PROFILE_MODEL_P
904 /* Record the fields for profiling. */
905 if (PROFILE_MODEL_P (current_cpu))
906 {
907 FLD (in_src1) = f_r1;
908 FLD (in_src2) = f_r2;
909 }
910#endif
911#undef FLD
912}
913
914void
915EX_FN_NAME (m32rxf,fmt_mulhi_a) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
916{
917#define FLD(f) abuf->fields.fmt_mulhi_a.f
918 EXTRACT_FMT_MULHI_A_VARS /* f-op1 f-r1 f-acc f-op23 f-r2 */
919
920 EXTRACT_FMT_MULHI_A_CODE
921
922 /* Record the fields for the semantic handler. */
923 FLD (f_r1) = & CPU (h_gr)[f_r1];
924 FLD (f_acc) = f_acc;
925 FLD (f_r2) = & CPU (h_gr)[f_r2];
926 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mulhi_a", "src1 0x%x", 'x', f_r1, "acc 0x%x", 'x', f_acc, "src2 0x%x", 'x', f_r2, (char *) 0));
927
928#if WITH_PROFILE_MODEL_P
929 /* Record the fields for profiling. */
930 if (PROFILE_MODEL_P (current_cpu))
931 {
932 FLD (in_src1) = f_r1;
933 FLD (in_src2) = f_r2;
934 }
935#endif
936#undef FLD
937}
938
939void
940EX_FN_NAME (m32rxf,fmt_mv) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
941{
942#define FLD(f) abuf->fields.fmt_mv.f
943 EXTRACT_FMT_MV_VARS /* f-op1 f-r1 f-op2 f-r2 */
944
945 EXTRACT_FMT_MV_CODE
946
947 /* Record the fields for the semantic handler. */
948 FLD (f_r1) = & CPU (h_gr)[f_r1];
949 FLD (f_r2) = & CPU (h_gr)[f_r2];
950 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mv", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
951
952#if WITH_PROFILE_MODEL_P
953 /* Record the fields for profiling. */
954 if (PROFILE_MODEL_P (current_cpu))
955 {
956 FLD (in_sr) = f_r2;
957 FLD (out_dr) = f_r1;
958 }
959#endif
960#undef FLD
961}
962
963void
964EX_FN_NAME (m32rxf,fmt_mvfachi_a) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
965{
966#define FLD(f) abuf->fields.fmt_mvfachi_a.f
967 EXTRACT_FMT_MVFACHI_A_VARS /* f-op1 f-r1 f-op2 f-accs f-op3 */
968
969 EXTRACT_FMT_MVFACHI_A_CODE
970
971 /* Record the fields for the semantic handler. */
972 FLD (f_r1) = & CPU (h_gr)[f_r1];
973 FLD (f_accs) = f_accs;
974 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mvfachi_a", "dr 0x%x", 'x', f_r1, "accs 0x%x", 'x', f_accs, (char *) 0));
975
976#if WITH_PROFILE_MODEL_P
977 /* Record the fields for profiling. */
978 if (PROFILE_MODEL_P (current_cpu))
979 {
980 FLD (out_dr) = f_r1;
981 }
982#endif
983#undef FLD
984}
985
986void
987EX_FN_NAME (m32rxf,fmt_mvfc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
988{
989#define FLD(f) abuf->fields.fmt_mvfc.f
990 EXTRACT_FMT_MVFC_VARS /* f-op1 f-r1 f-op2 f-r2 */
991
992 EXTRACT_FMT_MVFC_CODE
993
994 /* Record the fields for the semantic handler. */
995 FLD (f_r1) = & CPU (h_gr)[f_r1];
996 FLD (f_r2) = f_r2;
997 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mvfc", "dr 0x%x", 'x', f_r1, "scr 0x%x", 'x', f_r2, (char *) 0));
998
999#if WITH_PROFILE_MODEL_P
1000 /* Record the fields for profiling. */
1001 if (PROFILE_MODEL_P (current_cpu))
1002 {
1003 FLD (out_dr) = f_r1;
1004 }
1005#endif
1006#undef FLD
1007}
1008
1009void
1010EX_FN_NAME (m32rxf,fmt_mvtachi_a) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1011{
1012#define FLD(f) abuf->fields.fmt_mvtachi_a.f
1013 EXTRACT_FMT_MVTACHI_A_VARS /* f-op1 f-r1 f-op2 f-accs f-op3 */
1014
1015 EXTRACT_FMT_MVTACHI_A_CODE
1016
1017 /* Record the fields for the semantic handler. */
1018 FLD (f_r1) = & CPU (h_gr)[f_r1];
1019 FLD (f_accs) = f_accs;
1020 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mvtachi_a", "src1 0x%x", 'x', f_r1, "accs 0x%x", 'x', f_accs, (char *) 0));
1021
1022#if WITH_PROFILE_MODEL_P
1023 /* Record the fields for profiling. */
1024 if (PROFILE_MODEL_P (current_cpu))
1025 {
1026 FLD (in_src1) = f_r1;
1027 }
1028#endif
1029#undef FLD
1030}
1031
1032void
1033EX_FN_NAME (m32rxf,fmt_mvtc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1034{
1035#define FLD(f) abuf->fields.fmt_mvtc.f
1036 EXTRACT_FMT_MVTC_VARS /* f-op1 f-r1 f-op2 f-r2 */
1037
1038 EXTRACT_FMT_MVTC_CODE
1039
1040 /* Record the fields for the semantic handler. */
1041 FLD (f_r1) = f_r1;
1042 FLD (f_r2) = & CPU (h_gr)[f_r2];
1043 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mvtc", "dcr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
1044
1045#if WITH_PROFILE_MODEL_P
1046 /* Record the fields for profiling. */
1047 if (PROFILE_MODEL_P (current_cpu))
1048 {
1049 FLD (in_sr) = f_r2;
1050 }
1051#endif
1052#undef FLD
1053}
1054
1055void
1056EX_FN_NAME (m32rxf,fmt_nop) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1057{
1058#define FLD(f) abuf->fields.fmt_nop.f
1059 EXTRACT_FMT_NOP_VARS /* f-op1 f-r1 f-op2 f-r2 */
1060
1061 EXTRACT_FMT_NOP_CODE
1062
1063 /* Record the fields for the semantic handler. */
1064 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_nop", (char *) 0));
1065
1066#undef FLD
1067}
1068
1069void
1070EX_FN_NAME (m32rxf,fmt_rac_dsi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1071{
1072#define FLD(f) abuf->fields.fmt_rac_dsi.f
1073 EXTRACT_FMT_RAC_DSI_VARS /* f-op1 f-accd f-bits67 f-op2 f-accs f-bit14 f-imm1 */
1074
1075 EXTRACT_FMT_RAC_DSI_CODE
1076
1077 /* Record the fields for the semantic handler. */
1078 FLD (f_accd) = f_accd;
1079 FLD (f_accs) = f_accs;
1080 FLD (f_imm1) = f_imm1;
1081 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_rac_dsi", "accd 0x%x", 'x', f_accd, "accs 0x%x", 'x', f_accs, "imm1 0x%x", 'x', f_imm1, (char *) 0));
1082
1083#undef FLD
1084}
1085
1086void
1087EX_FN_NAME (m32rxf,fmt_rte) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1088{
1089#define FLD(f) abuf->fields.cti.fields.fmt_rte.f
1090 EXTRACT_FMT_RTE_VARS /* f-op1 f-r1 f-op2 f-r2 */
1091
1092 EXTRACT_FMT_RTE_CODE
1093
1094 /* Record the fields for the semantic handler. */
1095 SEM_BRANCH_INIT_EXTRACT (abuf);
1096 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_rte", (char *) 0));
1097
1098#if WITH_PROFILE_MODEL_P
1099 /* Record the fields for profiling. */
1100 if (PROFILE_MODEL_P (current_cpu))
1101 {
1102 }
1103#endif
1104#undef FLD
1105}
1106
1107void
1108EX_FN_NAME (m32rxf,fmt_seth) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1109{
1110#define FLD(f) abuf->fields.fmt_seth.f
1111 EXTRACT_FMT_SETH_VARS /* f-op1 f-r1 f-op2 f-r2 f-hi16 */
1112
1113 EXTRACT_FMT_SETH_CODE
1114
1115 /* Record the fields for the semantic handler. */
1116 FLD (f_r1) = & CPU (h_gr)[f_r1];
1117 FLD (f_hi16) = f_hi16;
1118 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_seth", "dr 0x%x", 'x', f_r1, "hi16 0x%x", 'x', f_hi16, (char *) 0));
1119
1120#if WITH_PROFILE_MODEL_P
1121 /* Record the fields for profiling. */
1122 if (PROFILE_MODEL_P (current_cpu))
1123 {
1124 FLD (out_dr) = f_r1;
1125 }
1126#endif
1127#undef FLD
1128}
1129
1130void
1131EX_FN_NAME (m32rxf,fmt_sll3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1132{
1133#define FLD(f) abuf->fields.fmt_sll3.f
1134 EXTRACT_FMT_SLL3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1135
1136 EXTRACT_FMT_SLL3_CODE
1137
1138 /* Record the fields for the semantic handler. */
1139 FLD (f_r1) = & CPU (h_gr)[f_r1];
1140 FLD (f_r2) = & CPU (h_gr)[f_r2];
1141 FLD (f_simm16) = f_simm16;
1142 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_sll3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
1143
1144#if WITH_PROFILE_MODEL_P
1145 /* Record the fields for profiling. */
1146 if (PROFILE_MODEL_P (current_cpu))
1147 {
1148 FLD (in_sr) = f_r2;
1149 FLD (out_dr) = f_r1;
1150 }
1151#endif
1152#undef FLD
1153}
1154
1155void
1156EX_FN_NAME (m32rxf,fmt_slli) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1157{
1158#define FLD(f) abuf->fields.fmt_slli.f
1159 EXTRACT_FMT_SLLI_VARS /* f-op1 f-r1 f-shift-op2 f-uimm5 */
1160
1161 EXTRACT_FMT_SLLI_CODE
1162
1163 /* Record the fields for the semantic handler. */
1164 FLD (f_r1) = & CPU (h_gr)[f_r1];
1165 FLD (f_uimm5) = f_uimm5;
1166 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_slli", "dr 0x%x", 'x', f_r1, "uimm5 0x%x", 'x', f_uimm5, (char *) 0));
1167
1168#if WITH_PROFILE_MODEL_P
1169 /* Record the fields for profiling. */
1170 if (PROFILE_MODEL_P (current_cpu))
1171 {
1172 FLD (in_dr) = f_r1;
1173 FLD (out_dr) = f_r1;
1174 }
1175#endif
1176#undef FLD
1177}
1178
1179void
1180EX_FN_NAME (m32rxf,fmt_st) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1181{
1182#define FLD(f) abuf->fields.fmt_st.f
1183 EXTRACT_FMT_ST_VARS /* f-op1 f-r1 f-op2 f-r2 */
1184
1185 EXTRACT_FMT_ST_CODE
1186
1187 /* Record the fields for the semantic handler. */
1188 FLD (f_r1) = & CPU (h_gr)[f_r1];
1189 FLD (f_r2) = & CPU (h_gr)[f_r2];
1190 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_st", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1191
1192#if WITH_PROFILE_MODEL_P
1193 /* Record the fields for profiling. */
1194 if (PROFILE_MODEL_P (current_cpu))
1195 {
1196 FLD (in_src2) = f_r2;
1197 FLD (in_src1) = f_r1;
1198 }
1199#endif
1200#undef FLD
1201}
1202
1203void
1204EX_FN_NAME (m32rxf,fmt_st_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1205{
1206#define FLD(f) abuf->fields.fmt_st_d.f
1207 EXTRACT_FMT_ST_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1208
1209 EXTRACT_FMT_ST_D_CODE
1210
1211 /* Record the fields for the semantic handler. */
1212 FLD (f_r1) = & CPU (h_gr)[f_r1];
1213 FLD (f_r2) = & CPU (h_gr)[f_r2];
1214 FLD (f_simm16) = f_simm16;
1215 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_st_d", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
1216
1217#if WITH_PROFILE_MODEL_P
1218 /* Record the fields for profiling. */
1219 if (PROFILE_MODEL_P (current_cpu))
1220 {
1221 FLD (in_src2) = f_r2;
1222 FLD (in_src1) = f_r1;
1223 }
1224#endif
1225#undef FLD
1226}
1227
1228void
1229EX_FN_NAME (m32rxf,fmt_stb) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1230{
1231#define FLD(f) abuf->fields.fmt_stb.f
1232 EXTRACT_FMT_STB_VARS /* f-op1 f-r1 f-op2 f-r2 */
1233
1234 EXTRACT_FMT_STB_CODE
1235
1236 /* Record the fields for the semantic handler. */
1237 FLD (f_r1) = & CPU (h_gr)[f_r1];
1238 FLD (f_r2) = & CPU (h_gr)[f_r2];
1239 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_stb", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1240
1241#if WITH_PROFILE_MODEL_P
1242 /* Record the fields for profiling. */
1243 if (PROFILE_MODEL_P (current_cpu))
1244 {
1245 FLD (in_src2) = f_r2;
1246 FLD (in_src1) = f_r1;
1247 }
1248#endif
1249#undef FLD
1250}
1251
1252void
1253EX_FN_NAME (m32rxf,fmt_stb_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1254{
1255#define FLD(f) abuf->fields.fmt_stb_d.f
1256 EXTRACT_FMT_STB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1257
1258 EXTRACT_FMT_STB_D_CODE
1259
1260 /* Record the fields for the semantic handler. */
1261 FLD (f_r1) = & CPU (h_gr)[f_r1];
1262 FLD (f_r2) = & CPU (h_gr)[f_r2];
1263 FLD (f_simm16) = f_simm16;
1264 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_stb_d", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
1265
1266#if WITH_PROFILE_MODEL_P
1267 /* Record the fields for profiling. */
1268 if (PROFILE_MODEL_P (current_cpu))
1269 {
1270 FLD (in_src2) = f_r2;
1271 FLD (in_src1) = f_r1;
1272 }
1273#endif
1274#undef FLD
1275}
1276
1277void
1278EX_FN_NAME (m32rxf,fmt_sth) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1279{
1280#define FLD(f) abuf->fields.fmt_sth.f
1281 EXTRACT_FMT_STH_VARS /* f-op1 f-r1 f-op2 f-r2 */
1282
1283 EXTRACT_FMT_STH_CODE
1284
1285 /* Record the fields for the semantic handler. */
1286 FLD (f_r1) = & CPU (h_gr)[f_r1];
1287 FLD (f_r2) = & CPU (h_gr)[f_r2];
1288 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_sth", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1289
1290#if WITH_PROFILE_MODEL_P
1291 /* Record the fields for profiling. */
1292 if (PROFILE_MODEL_P (current_cpu))
1293 {
1294 FLD (in_src2) = f_r2;
1295 FLD (in_src1) = f_r1;
1296 }
1297#endif
1298#undef FLD
1299}
1300
1301void
1302EX_FN_NAME (m32rxf,fmt_sth_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1303{
1304#define FLD(f) abuf->fields.fmt_sth_d.f
1305 EXTRACT_FMT_STH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1306
1307 EXTRACT_FMT_STH_D_CODE
1308
1309 /* Record the fields for the semantic handler. */
1310 FLD (f_r1) = & CPU (h_gr)[f_r1];
1311 FLD (f_r2) = & CPU (h_gr)[f_r2];
1312 FLD (f_simm16) = f_simm16;
1313 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_sth_d", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
1314
1315#if WITH_PROFILE_MODEL_P
1316 /* Record the fields for profiling. */
1317 if (PROFILE_MODEL_P (current_cpu))
1318 {
1319 FLD (in_src2) = f_r2;
1320 FLD (in_src1) = f_r1;
1321 }
1322#endif
1323#undef FLD
1324}
1325
1326void
1327EX_FN_NAME (m32rxf,fmt_st_plus) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1328{
1329#define FLD(f) abuf->fields.fmt_st_plus.f
1330 EXTRACT_FMT_ST_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
1331
1332 EXTRACT_FMT_ST_PLUS_CODE
1333
1334 /* Record the fields for the semantic handler. */
1335 FLD (f_r1) = & CPU (h_gr)[f_r1];
1336 FLD (f_r2) = & CPU (h_gr)[f_r2];
1337 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_st_plus", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1338
1339#if WITH_PROFILE_MODEL_P
1340 /* Record the fields for profiling. */
1341 if (PROFILE_MODEL_P (current_cpu))
1342 {
1343 FLD (in_src2) = f_r2;
1344 FLD (in_src1) = f_r1;
1345 FLD (out_src2) = f_r2;
1346 }
1347#endif
1348#undef FLD
1349}
1350
1351void
1352EX_FN_NAME (m32rxf,fmt_trap) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1353{
1354#define FLD(f) abuf->fields.cti.fields.fmt_trap.f
1355 EXTRACT_FMT_TRAP_VARS /* f-op1 f-r1 f-op2 f-uimm4 */
1356
1357 EXTRACT_FMT_TRAP_CODE
1358
1359 /* Record the fields for the semantic handler. */
1360 FLD (f_uimm4) = f_uimm4;
1361 SEM_BRANCH_INIT_EXTRACT (abuf);
1362 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_trap", "uimm4 0x%x", 'x', f_uimm4, (char *) 0));
1363
1364#if WITH_PROFILE_MODEL_P
1365 /* Record the fields for profiling. */
1366 if (PROFILE_MODEL_P (current_cpu))
1367 {
1368 }
1369#endif
1370#undef FLD
1371}
1372
1373void
1374EX_FN_NAME (m32rxf,fmt_unlock) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1375{
1376#define FLD(f) abuf->fields.fmt_unlock.f
1377 EXTRACT_FMT_UNLOCK_VARS /* f-op1 f-r1 f-op2 f-r2 */
1378
1379 EXTRACT_FMT_UNLOCK_CODE
1380
1381 /* Record the fields for the semantic handler. */
1382 FLD (f_r1) = & CPU (h_gr)[f_r1];
1383 FLD (f_r2) = & CPU (h_gr)[f_r2];
1384 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_unlock", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1385
1386#if WITH_PROFILE_MODEL_P
1387 /* Record the fields for profiling. */
1388 if (PROFILE_MODEL_P (current_cpu))
1389 {
1390 FLD (in_src2) = f_r2;
1391 FLD (in_src1) = f_r1;
1392 }
1393#endif
1394#undef FLD
1395}
1396
1397void
1398EX_FN_NAME (m32rxf,fmt_satb) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1399{
1400#define FLD(f) abuf->fields.fmt_satb.f
1401 EXTRACT_FMT_SATB_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
1402
1403 EXTRACT_FMT_SATB_CODE
1404
1405 /* Record the fields for the semantic handler. */
1406 FLD (f_r1) = & CPU (h_gr)[f_r1];
1407 FLD (f_r2) = & CPU (h_gr)[f_r2];
1408 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_satb", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
1409
1410#if WITH_PROFILE_MODEL_P
1411 /* Record the fields for profiling. */
1412 if (PROFILE_MODEL_P (current_cpu))
1413 {
1414 FLD (in_sr) = f_r2;
1415 FLD (out_dr) = f_r1;
1416 }
1417#endif
1418#undef FLD
1419}
1420
1421void
1422EX_FN_NAME (m32rxf,fmt_sat) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1423{
1424#define FLD(f) abuf->fields.fmt_sat.f
1425 EXTRACT_FMT_SAT_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
1426
1427 EXTRACT_FMT_SAT_CODE
1428
1429 /* Record the fields for the semantic handler. */
1430 FLD (f_r1) = & CPU (h_gr)[f_r1];
1431 FLD (f_r2) = & CPU (h_gr)[f_r2];
1432 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_sat", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
1433
1434#if WITH_PROFILE_MODEL_P
1435 /* Record the fields for profiling. */
1436 if (PROFILE_MODEL_P (current_cpu))
1437 {
1438 FLD (in_sr) = f_r2;
1439 FLD (out_dr) = f_r1;
1440 }
1441#endif
1442#undef FLD
1443}
1444
1445void
1446EX_FN_NAME (m32rxf,fmt_sadd) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1447{
1448#define FLD(f) abuf->fields.fmt_sadd.f
1449 EXTRACT_FMT_SADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
1450
1451 EXTRACT_FMT_SADD_CODE
1452
1453 /* Record the fields for the semantic handler. */
1454 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_sadd", (char *) 0));
1455
1456#undef FLD
1457}
1458
1459void
1460EX_FN_NAME (m32rxf,fmt_macwu1) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1461{
1462#define FLD(f) abuf->fields.fmt_macwu1.f
1463 EXTRACT_FMT_MACWU1_VARS /* f-op1 f-r1 f-op2 f-r2 */
1464
1465 EXTRACT_FMT_MACWU1_CODE
1466
1467 /* Record the fields for the semantic handler. */
1468 FLD (f_r1) = & CPU (h_gr)[f_r1];
1469 FLD (f_r2) = & CPU (h_gr)[f_r2];
1470 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_macwu1", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1471
1472#if WITH_PROFILE_MODEL_P
1473 /* Record the fields for profiling. */
1474 if (PROFILE_MODEL_P (current_cpu))
1475 {
1476 FLD (in_src1) = f_r1;
1477 FLD (in_src2) = f_r2;
1478 }
1479#endif
1480#undef FLD
1481}
1482
1483void
1484EX_FN_NAME (m32rxf,fmt_msblo) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1485{
1486#define FLD(f) abuf->fields.fmt_msblo.f
1487 EXTRACT_FMT_MSBLO_VARS /* f-op1 f-r1 f-op2 f-r2 */
1488
1489 EXTRACT_FMT_MSBLO_CODE
1490
1491 /* Record the fields for the semantic handler. */
1492 FLD (f_r1) = & CPU (h_gr)[f_r1];
1493 FLD (f_r2) = & CPU (h_gr)[f_r2];
1494 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_msblo", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1495
1496#if WITH_PROFILE_MODEL_P
1497 /* Record the fields for profiling. */
1498 if (PROFILE_MODEL_P (current_cpu))
1499 {
1500 FLD (in_src1) = f_r1;
1501 FLD (in_src2) = f_r2;
1502 }
1503#endif
1504#undef FLD
1505}
1506
1507void
1508EX_FN_NAME (m32rxf,fmt_mulwu1) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1509{
1510#define FLD(f) abuf->fields.fmt_mulwu1.f
1511 EXTRACT_FMT_MULWU1_VARS /* f-op1 f-r1 f-op2 f-r2 */
1512
1513 EXTRACT_FMT_MULWU1_CODE
1514
1515 /* Record the fields for the semantic handler. */
1516 FLD (f_r1) = & CPU (h_gr)[f_r1];
1517 FLD (f_r2) = & CPU (h_gr)[f_r2];
1518 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mulwu1", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1519
1520#if WITH_PROFILE_MODEL_P
1521 /* Record the fields for profiling. */
1522 if (PROFILE_MODEL_P (current_cpu))
1523 {
1524 FLD (in_src1) = f_r1;
1525 FLD (in_src2) = f_r2;
1526 }
1527#endif
1528#undef FLD
1529}
1530
1531void
1532EX_FN_NAME (m32rxf,fmt_sc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1533{
1534#define FLD(f) abuf->fields.fmt_sc.f
1535 EXTRACT_FMT_SC_VARS /* f-op1 f-r1 f-op2 f-r2 */
1536
1537 EXTRACT_FMT_SC_CODE
1538
1539 /* Record the fields for the semantic handler. */
1540 TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_sc", (char *) 0));
1541
1542#undef FLD
1543}
1544
1545void
1546EX_FN_NAME (m32rxf,fmt_empty) (SIM_CPU *cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1547{
1548 /* Empty format handler for virtual insns. */
1549}
GDB Binutils - Deliverables
This page took 0.088266 seconds and 4 git commands to generate.