sim/m32r/extractx.c

   1 /* Simulator instruction extractor for m32r.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
   6
   7 This file is part of the GNU Simulators.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License along
  20 with this program; if not, write to the Free Software Foundation, Inc.,
  21 59 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"
  30
  31 void
  32 EX_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
  56 void
  57 EX_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
  81 void
  82 EX_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
 106 void
 107 EX_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
 131 void
 132 EX_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
 155 void
 156 EX_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
 180 void
 181 EX_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
 205 void
 206 EX_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
 230 void
 231 EX_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
 252 void
 253 EX_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
 274 void
 275 EX_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
 300 void
 301 EX_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
 324 void
 325 EX_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
 347 void
 348 EX_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
 370 void
 371 EX_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
 393 void
 394 EX_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
 416 void
 417 EX_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
 438 void
 439 EX_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
 460 void
 461 EX_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
 484 void
 485 EX_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
 507 void
 508 EX_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
 529 void
 530 EX_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
 554 void
 555 EX_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
 577 void
 578 EX_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
 601 void
 602 EX_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
 624 void
 625 EX_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
 648 void
 649 EX_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
 673 void
 674 EX_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
 697 void
 698 EX_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
 722 void
 723 EX_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
 746 void
 747 EX_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
 771 void
 772 EX_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
 796 void
 797 EX_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
 819 void
 820 EX_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
 842 void
 843 EX_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
 865 void
 866 EX_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
 889 void
 890 EX_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
 914 void
 915 EX_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
 939 void
 940 EX_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
 963 void
 964 EX_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
 986 void
 987 EX_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
1009 void
1010 EX_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
1032 void
1033 EX_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
1055 void
1056 EX_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
1069 void
1070 EX_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
1086 void
1087 EX_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
1107 void
1108 EX_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
1130 void
1131 EX_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
1155 void
1156 EX_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
1179 void
1180 EX_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
1203 void
1204 EX_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
1228 void
1229 EX_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
1252 void
1253 EX_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
1277 void
1278 EX_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
1301 void
1302 EX_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
1326 void
1327 EX_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
1351 void
1352 EX_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
1373 void
1374 EX_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
1397 void
1398 EX_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
1421 void
1422 EX_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
1445 void
1446 EX_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
1459 void
1460 EX_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
1483 void
1484 EX_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
1507 void
1508 EX_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
1531 void
1532 EX_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
1545 void
1546 EX_FN_NAME (m32rxf,fmt_empty) (SIM_CPU *cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1547 {
1548   /* Empty format handler for virtual insns.  */
1549 }