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