sim/m32r/extract.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_M32RBF
  27
  28 #include "sim-main.h"
  29 #include "cgen-ops.h"
  30
  31 void
  32 EX_FN_NAME (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,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 (m32rbf,fmt_bra8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 372 {
 373 #define FLD(f) abuf->fields.cti.fields.fmt_bra8.f
 374   EXTRACT_FMT_BRA8_VARS /* f-op1 f-r1 f-disp8 */
 375
 376   EXTRACT_FMT_BRA8_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_bra8", "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     }
 388 #endif
 389 #undef FLD
 390 }
 391
 392 void
 393 EX_FN_NAME (m32rbf,fmt_bra24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 394 {
 395 #define FLD(f) abuf->fields.cti.fields.fmt_bra24.f
 396   EXTRACT_FMT_BRA24_VARS /* f-op1 f-r1 f-disp24 */
 397
 398   EXTRACT_FMT_BRA24_CODE
 399
 400   /* Record the fields for the semantic handler.  */
 401   FLD (f_disp24) = f_disp24;
 402   SEM_BRANCH_INIT_EXTRACT (abuf);
 403   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_bra24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
 404
 405 #if WITH_PROFILE_MODEL_P
 406   /* Record the fields for profiling.  */
 407   if (PROFILE_MODEL_P (current_cpu))
 408     {
 409     }
 410 #endif
 411 #undef FLD
 412 }
 413
 414 void
 415 EX_FN_NAME (m32rbf,fmt_cmp) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 416 {
 417 #define FLD(f) abuf->fields.fmt_cmp.f
 418   EXTRACT_FMT_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
 419
 420   EXTRACT_FMT_CMP_CODE
 421
 422   /* Record the fields for the semantic handler.  */
 423   FLD (f_r1) = & CPU (h_gr)[f_r1];
 424   FLD (f_r2) = & CPU (h_gr)[f_r2];
 425   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_cmp", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
 426
 427 #if WITH_PROFILE_MODEL_P
 428   /* Record the fields for profiling.  */
 429   if (PROFILE_MODEL_P (current_cpu))
 430     {
 431       FLD (in_src1) = f_r1;
 432       FLD (in_src2) = f_r2;
 433     }
 434 #endif
 435 #undef FLD
 436 }
 437
 438 void
 439 EX_FN_NAME (m32rbf,fmt_cmpi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 440 {
 441 #define FLD(f) abuf->fields.fmt_cmpi.f
 442   EXTRACT_FMT_CMPI_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 443
 444   EXTRACT_FMT_CMPI_CODE
 445
 446   /* Record the fields for the semantic handler.  */
 447   FLD (f_r2) = & CPU (h_gr)[f_r2];
 448   FLD (f_simm16) = f_simm16;
 449   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_cmpi", "src2 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
 450
 451 #if WITH_PROFILE_MODEL_P
 452   /* Record the fields for profiling.  */
 453   if (PROFILE_MODEL_P (current_cpu))
 454     {
 455       FLD (in_src2) = f_r2;
 456     }
 457 #endif
 458 #undef FLD
 459 }
 460
 461 void
 462 EX_FN_NAME (m32rbf,fmt_div) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 463 {
 464 #define FLD(f) abuf->fields.fmt_div.f
 465   EXTRACT_FMT_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 466
 467   EXTRACT_FMT_DIV_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_div", "dr 0x%x", 'x', f_r1, "sr 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_sr) = f_r2;
 479       FLD (in_dr) = f_r1;
 480       FLD (out_dr) = f_r1;
 481     }
 482 #endif
 483 #undef FLD
 484 }
 485
 486 void
 487 EX_FN_NAME (m32rbf,fmt_jl) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 488 {
 489 #define FLD(f) abuf->fields.cti.fields.fmt_jl.f
 490   EXTRACT_FMT_JL_VARS /* f-op1 f-r1 f-op2 f-r2 */
 491
 492   EXTRACT_FMT_JL_CODE
 493
 494   /* Record the fields for the semantic handler.  */
 495   FLD (f_r2) = & CPU (h_gr)[f_r2];
 496   SEM_BRANCH_INIT_EXTRACT (abuf);
 497   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_jl", "sr 0x%x", 'x', f_r2, (char *) 0));
 498
 499 #if WITH_PROFILE_MODEL_P
 500   /* Record the fields for profiling.  */
 501   if (PROFILE_MODEL_P (current_cpu))
 502     {
 503       FLD (in_sr) = f_r2;
 504       FLD (out_h_gr_14) = 14;
 505     }
 506 #endif
 507 #undef FLD
 508 }
 509
 510 void
 511 EX_FN_NAME (m32rbf,fmt_jmp) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 512 {
 513 #define FLD(f) abuf->fields.cti.fields.fmt_jmp.f
 514   EXTRACT_FMT_JMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
 515
 516   EXTRACT_FMT_JMP_CODE
 517
 518   /* Record the fields for the semantic handler.  */
 519   FLD (f_r2) = & CPU (h_gr)[f_r2];
 520   SEM_BRANCH_INIT_EXTRACT (abuf);
 521   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_jmp", "sr 0x%x", 'x', f_r2, (char *) 0));
 522
 523 #if WITH_PROFILE_MODEL_P
 524   /* Record the fields for profiling.  */
 525   if (PROFILE_MODEL_P (current_cpu))
 526     {
 527       FLD (in_sr) = f_r2;
 528     }
 529 #endif
 530 #undef FLD
 531 }
 532
 533 void
 534 EX_FN_NAME (m32rbf,fmt_ld) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 535 {
 536 #define FLD(f) abuf->fields.fmt_ld.f
 537   EXTRACT_FMT_LD_VARS /* f-op1 f-r1 f-op2 f-r2 */
 538
 539   EXTRACT_FMT_LD_CODE
 540
 541   /* Record the fields for the semantic handler.  */
 542   FLD (f_r1) = & CPU (h_gr)[f_r1];
 543   FLD (f_r2) = & CPU (h_gr)[f_r2];
 544   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ld", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 545
 546 #if WITH_PROFILE_MODEL_P
 547   /* Record the fields for profiling.  */
 548   if (PROFILE_MODEL_P (current_cpu))
 549     {
 550       FLD (in_sr) = f_r2;
 551       FLD (out_dr) = f_r1;
 552     }
 553 #endif
 554 #undef FLD
 555 }
 556
 557 void
 558 EX_FN_NAME (m32rbf,fmt_ld_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 559 {
 560 #define FLD(f) abuf->fields.fmt_ld_d.f
 561   EXTRACT_FMT_LD_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 562
 563   EXTRACT_FMT_LD_D_CODE
 564
 565   /* Record the fields for the semantic handler.  */
 566   FLD (f_r1) = & CPU (h_gr)[f_r1];
 567   FLD (f_r2) = & CPU (h_gr)[f_r2];
 568   FLD (f_simm16) = f_simm16;
 569   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));
 570
 571 #if WITH_PROFILE_MODEL_P
 572   /* Record the fields for profiling.  */
 573   if (PROFILE_MODEL_P (current_cpu))
 574     {
 575       FLD (in_sr) = f_r2;
 576       FLD (out_dr) = f_r1;
 577     }
 578 #endif
 579 #undef FLD
 580 }
 581
 582 void
 583 EX_FN_NAME (m32rbf,fmt_ldb) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 584 {
 585 #define FLD(f) abuf->fields.fmt_ldb.f
 586   EXTRACT_FMT_LDB_VARS /* f-op1 f-r1 f-op2 f-r2 */
 587
 588   EXTRACT_FMT_LDB_CODE
 589
 590   /* Record the fields for the semantic handler.  */
 591   FLD (f_r1) = & CPU (h_gr)[f_r1];
 592   FLD (f_r2) = & CPU (h_gr)[f_r2];
 593   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldb", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 594
 595 #if WITH_PROFILE_MODEL_P
 596   /* Record the fields for profiling.  */
 597   if (PROFILE_MODEL_P (current_cpu))
 598     {
 599       FLD (in_sr) = f_r2;
 600       FLD (out_dr) = f_r1;
 601     }
 602 #endif
 603 #undef FLD
 604 }
 605
 606 void
 607 EX_FN_NAME (m32rbf,fmt_ldb_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 608 {
 609 #define FLD(f) abuf->fields.fmt_ldb_d.f
 610   EXTRACT_FMT_LDB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 611
 612   EXTRACT_FMT_LDB_D_CODE
 613
 614   /* Record the fields for the semantic handler.  */
 615   FLD (f_r1) = & CPU (h_gr)[f_r1];
 616   FLD (f_r2) = & CPU (h_gr)[f_r2];
 617   FLD (f_simm16) = f_simm16;
 618   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));
 619
 620 #if WITH_PROFILE_MODEL_P
 621   /* Record the fields for profiling.  */
 622   if (PROFILE_MODEL_P (current_cpu))
 623     {
 624       FLD (in_sr) = f_r2;
 625       FLD (out_dr) = f_r1;
 626     }
 627 #endif
 628 #undef FLD
 629 }
 630
 631 void
 632 EX_FN_NAME (m32rbf,fmt_ldh) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 633 {
 634 #define FLD(f) abuf->fields.fmt_ldh.f
 635   EXTRACT_FMT_LDH_VARS /* f-op1 f-r1 f-op2 f-r2 */
 636
 637   EXTRACT_FMT_LDH_CODE
 638
 639   /* Record the fields for the semantic handler.  */
 640   FLD (f_r1) = & CPU (h_gr)[f_r1];
 641   FLD (f_r2) = & CPU (h_gr)[f_r2];
 642   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldh", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 643
 644 #if WITH_PROFILE_MODEL_P
 645   /* Record the fields for profiling.  */
 646   if (PROFILE_MODEL_P (current_cpu))
 647     {
 648       FLD (in_sr) = f_r2;
 649       FLD (out_dr) = f_r1;
 650     }
 651 #endif
 652 #undef FLD
 653 }
 654
 655 void
 656 EX_FN_NAME (m32rbf,fmt_ldh_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 657 {
 658 #define FLD(f) abuf->fields.fmt_ldh_d.f
 659   EXTRACT_FMT_LDH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 660
 661   EXTRACT_FMT_LDH_D_CODE
 662
 663   /* Record the fields for the semantic handler.  */
 664   FLD (f_r1) = & CPU (h_gr)[f_r1];
 665   FLD (f_r2) = & CPU (h_gr)[f_r2];
 666   FLD (f_simm16) = f_simm16;
 667   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));
 668
 669 #if WITH_PROFILE_MODEL_P
 670   /* Record the fields for profiling.  */
 671   if (PROFILE_MODEL_P (current_cpu))
 672     {
 673       FLD (in_sr) = f_r2;
 674       FLD (out_dr) = f_r1;
 675     }
 676 #endif
 677 #undef FLD
 678 }
 679
 680 void
 681 EX_FN_NAME (m32rbf,fmt_ld_plus) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 682 {
 683 #define FLD(f) abuf->fields.fmt_ld_plus.f
 684   EXTRACT_FMT_LD_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
 685
 686   EXTRACT_FMT_LD_PLUS_CODE
 687
 688   /* Record the fields for the semantic handler.  */
 689   FLD (f_r1) = & CPU (h_gr)[f_r1];
 690   FLD (f_r2) = & CPU (h_gr)[f_r2];
 691   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ld_plus", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 692
 693 #if WITH_PROFILE_MODEL_P
 694   /* Record the fields for profiling.  */
 695   if (PROFILE_MODEL_P (current_cpu))
 696     {
 697       FLD (in_sr) = f_r2;
 698       FLD (out_dr) = f_r1;
 699       FLD (out_sr) = f_r2;
 700     }
 701 #endif
 702 #undef FLD
 703 }
 704
 705 void
 706 EX_FN_NAME (m32rbf,fmt_ld24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 707 {
 708 #define FLD(f) abuf->fields.fmt_ld24.f
 709   EXTRACT_FMT_LD24_VARS /* f-op1 f-r1 f-uimm24 */
 710
 711   EXTRACT_FMT_LD24_CODE
 712
 713   /* Record the fields for the semantic handler.  */
 714   FLD (f_r1) = & CPU (h_gr)[f_r1];
 715   FLD (f_uimm24) = f_uimm24;
 716   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ld24", "dr 0x%x", 'x', f_r1, "uimm24 0x%x", 'x', f_uimm24, (char *) 0));
 717
 718 #if WITH_PROFILE_MODEL_P
 719   /* Record the fields for profiling.  */
 720   if (PROFILE_MODEL_P (current_cpu))
 721     {
 722       FLD (out_dr) = f_r1;
 723     }
 724 #endif
 725 #undef FLD
 726 }
 727
 728 void
 729 EX_FN_NAME (m32rbf,fmt_ldi8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 730 {
 731 #define FLD(f) abuf->fields.fmt_ldi8.f
 732   EXTRACT_FMT_LDI8_VARS /* f-op1 f-r1 f-simm8 */
 733
 734   EXTRACT_FMT_LDI8_CODE
 735
 736   /* Record the fields for the semantic handler.  */
 737   FLD (f_r1) = & CPU (h_gr)[f_r1];
 738   FLD (f_simm8) = f_simm8;
 739   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldi8", "dr 0x%x", 'x', f_r1, "simm8 0x%x", 'x', f_simm8, (char *) 0));
 740
 741 #if WITH_PROFILE_MODEL_P
 742   /* Record the fields for profiling.  */
 743   if (PROFILE_MODEL_P (current_cpu))
 744     {
 745       FLD (out_dr) = f_r1;
 746     }
 747 #endif
 748 #undef FLD
 749 }
 750
 751 void
 752 EX_FN_NAME (m32rbf,fmt_ldi16) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 753 {
 754 #define FLD(f) abuf->fields.fmt_ldi16.f
 755   EXTRACT_FMT_LDI16_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 756
 757   EXTRACT_FMT_LDI16_CODE
 758
 759   /* Record the fields for the semantic handler.  */
 760   FLD (f_r1) = & CPU (h_gr)[f_r1];
 761   FLD (f_simm16) = f_simm16;
 762   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_ldi16", "dr 0x%x", 'x', f_r1, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 763
 764 #if WITH_PROFILE_MODEL_P
 765   /* Record the fields for profiling.  */
 766   if (PROFILE_MODEL_P (current_cpu))
 767     {
 768       FLD (out_dr) = f_r1;
 769     }
 770 #endif
 771 #undef FLD
 772 }
 773
 774 void
 775 EX_FN_NAME (m32rbf,fmt_lock) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 776 {
 777 #define FLD(f) abuf->fields.fmt_lock.f
 778   EXTRACT_FMT_LOCK_VARS /* f-op1 f-r1 f-op2 f-r2 */
 779
 780   EXTRACT_FMT_LOCK_CODE
 781
 782   /* Record the fields for the semantic handler.  */
 783   FLD (f_r1) = & CPU (h_gr)[f_r1];
 784   FLD (f_r2) = & CPU (h_gr)[f_r2];
 785   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_lock", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 786
 787 #if WITH_PROFILE_MODEL_P
 788   /* Record the fields for profiling.  */
 789   if (PROFILE_MODEL_P (current_cpu))
 790     {
 791       FLD (in_sr) = f_r2;
 792       FLD (out_dr) = f_r1;
 793     }
 794 #endif
 795 #undef FLD
 796 }
 797
 798 void
 799 EX_FN_NAME (m32rbf,fmt_machi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 800 {
 801 #define FLD(f) abuf->fields.fmt_machi.f
 802   EXTRACT_FMT_MACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 803
 804   EXTRACT_FMT_MACHI_CODE
 805
 806   /* Record the fields for the semantic handler.  */
 807   FLD (f_r1) = & CPU (h_gr)[f_r1];
 808   FLD (f_r2) = & CPU (h_gr)[f_r2];
 809   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_machi", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
 810
 811 #if WITH_PROFILE_MODEL_P
 812   /* Record the fields for profiling.  */
 813   if (PROFILE_MODEL_P (current_cpu))
 814     {
 815       FLD (in_src1) = f_r1;
 816       FLD (in_src2) = f_r2;
 817     }
 818 #endif
 819 #undef FLD
 820 }
 821
 822 void
 823 EX_FN_NAME (m32rbf,fmt_mulhi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 824 {
 825 #define FLD(f) abuf->fields.fmt_mulhi.f
 826   EXTRACT_FMT_MULHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 827
 828   EXTRACT_FMT_MULHI_CODE
 829
 830   /* Record the fields for the semantic handler.  */
 831   FLD (f_r1) = & CPU (h_gr)[f_r1];
 832   FLD (f_r2) = & CPU (h_gr)[f_r2];
 833   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mulhi", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
 834
 835 #if WITH_PROFILE_MODEL_P
 836   /* Record the fields for profiling.  */
 837   if (PROFILE_MODEL_P (current_cpu))
 838     {
 839       FLD (in_src1) = f_r1;
 840       FLD (in_src2) = f_r2;
 841     }
 842 #endif
 843 #undef FLD
 844 }
 845
 846 void
 847 EX_FN_NAME (m32rbf,fmt_mv) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 848 {
 849 #define FLD(f) abuf->fields.fmt_mv.f
 850   EXTRACT_FMT_MV_VARS /* f-op1 f-r1 f-op2 f-r2 */
 851
 852   EXTRACT_FMT_MV_CODE
 853
 854   /* Record the fields for the semantic handler.  */
 855   FLD (f_r1) = & CPU (h_gr)[f_r1];
 856   FLD (f_r2) = & CPU (h_gr)[f_r2];
 857   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mv", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 858
 859 #if WITH_PROFILE_MODEL_P
 860   /* Record the fields for profiling.  */
 861   if (PROFILE_MODEL_P (current_cpu))
 862     {
 863       FLD (in_sr) = f_r2;
 864       FLD (out_dr) = f_r1;
 865     }
 866 #endif
 867 #undef FLD
 868 }
 869
 870 void
 871 EX_FN_NAME (m32rbf,fmt_mvfachi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 872 {
 873 #define FLD(f) abuf->fields.fmt_mvfachi.f
 874   EXTRACT_FMT_MVFACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 875
 876   EXTRACT_FMT_MVFACHI_CODE
 877
 878   /* Record the fields for the semantic handler.  */
 879   FLD (f_r1) = & CPU (h_gr)[f_r1];
 880   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mvfachi", "dr 0x%x", 'x', f_r1, (char *) 0));
 881
 882 #if WITH_PROFILE_MODEL_P
 883   /* Record the fields for profiling.  */
 884   if (PROFILE_MODEL_P (current_cpu))
 885     {
 886       FLD (out_dr) = f_r1;
 887     }
 888 #endif
 889 #undef FLD
 890 }
 891
 892 void
 893 EX_FN_NAME (m32rbf,fmt_mvfc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 894 {
 895 #define FLD(f) abuf->fields.fmt_mvfc.f
 896   EXTRACT_FMT_MVFC_VARS /* f-op1 f-r1 f-op2 f-r2 */
 897
 898   EXTRACT_FMT_MVFC_CODE
 899
 900   /* Record the fields for the semantic handler.  */
 901   FLD (f_r1) = & CPU (h_gr)[f_r1];
 902   FLD (f_r2) = f_r2;
 903   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mvfc", "dr 0x%x", 'x', f_r1, "scr 0x%x", 'x', f_r2, (char *) 0));
 904
 905 #if WITH_PROFILE_MODEL_P
 906   /* Record the fields for profiling.  */
 907   if (PROFILE_MODEL_P (current_cpu))
 908     {
 909       FLD (out_dr) = f_r1;
 910     }
 911 #endif
 912 #undef FLD
 913 }
 914
 915 void
 916 EX_FN_NAME (m32rbf,fmt_mvtachi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 917 {
 918 #define FLD(f) abuf->fields.fmt_mvtachi.f
 919   EXTRACT_FMT_MVTACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 920
 921   EXTRACT_FMT_MVTACHI_CODE
 922
 923   /* Record the fields for the semantic handler.  */
 924   FLD (f_r1) = & CPU (h_gr)[f_r1];
 925   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mvtachi", "src1 0x%x", 'x', f_r1, (char *) 0));
 926
 927 #if WITH_PROFILE_MODEL_P
 928   /* Record the fields for profiling.  */
 929   if (PROFILE_MODEL_P (current_cpu))
 930     {
 931       FLD (in_src1) = f_r1;
 932     }
 933 #endif
 934 #undef FLD
 935 }
 936
 937 void
 938 EX_FN_NAME (m32rbf,fmt_mvtc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 939 {
 940 #define FLD(f) abuf->fields.fmt_mvtc.f
 941   EXTRACT_FMT_MVTC_VARS /* f-op1 f-r1 f-op2 f-r2 */
 942
 943   EXTRACT_FMT_MVTC_CODE
 944
 945   /* Record the fields for the semantic handler.  */
 946   FLD (f_r1) = f_r1;
 947   FLD (f_r2) = & CPU (h_gr)[f_r2];
 948   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_mvtc", "dcr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 949
 950 #if WITH_PROFILE_MODEL_P
 951   /* Record the fields for profiling.  */
 952   if (PROFILE_MODEL_P (current_cpu))
 953     {
 954       FLD (in_sr) = f_r2;
 955     }
 956 #endif
 957 #undef FLD
 958 }
 959
 960 void
 961 EX_FN_NAME (m32rbf,fmt_nop) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 962 {
 963 #define FLD(f) abuf->fields.fmt_nop.f
 964   EXTRACT_FMT_NOP_VARS /* f-op1 f-r1 f-op2 f-r2 */
 965
 966   EXTRACT_FMT_NOP_CODE
 967
 968   /* Record the fields for the semantic handler.  */
 969   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_nop", (char *) 0));
 970
 971 #undef FLD
 972 }
 973
 974 void
 975 EX_FN_NAME (m32rbf,fmt_rac) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 976 {
 977 #define FLD(f) abuf->fields.fmt_rac.f
 978   EXTRACT_FMT_RAC_VARS /* f-op1 f-r1 f-op2 f-r2 */
 979
 980   EXTRACT_FMT_RAC_CODE
 981
 982   /* Record the fields for the semantic handler.  */
 983   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_rac", (char *) 0));
 984
 985 #undef FLD
 986 }
 987
 988 void
 989 EX_FN_NAME (m32rbf,fmt_rte) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 990 {
 991 #define FLD(f) abuf->fields.cti.fields.fmt_rte.f
 992   EXTRACT_FMT_RTE_VARS /* f-op1 f-r1 f-op2 f-r2 */
 993
 994   EXTRACT_FMT_RTE_CODE
 995
 996   /* Record the fields for the semantic handler.  */
 997   SEM_BRANCH_INIT_EXTRACT (abuf);
 998   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_rte", (char *) 0));
 999
1000 #if WITH_PROFILE_MODEL_P
1001   /* Record the fields for profiling.  */
1002   if (PROFILE_MODEL_P (current_cpu))
1003     {
1004     }
1005 #endif
1006 #undef FLD
1007 }
1008
1009 void
1010 EX_FN_NAME (m32rbf,fmt_seth) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1011 {
1012 #define FLD(f) abuf->fields.fmt_seth.f
1013   EXTRACT_FMT_SETH_VARS /* f-op1 f-r1 f-op2 f-r2 f-hi16 */
1014
1015   EXTRACT_FMT_SETH_CODE
1016
1017   /* Record the fields for the semantic handler.  */
1018   FLD (f_r1) = & CPU (h_gr)[f_r1];
1019   FLD (f_hi16) = f_hi16;
1020   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_seth", "dr 0x%x", 'x', f_r1, "hi16 0x%x", 'x', f_hi16, (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 (out_dr) = f_r1;
1027     }
1028 #endif
1029 #undef FLD
1030 }
1031
1032 void
1033 EX_FN_NAME (m32rbf,fmt_sll3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1034 {
1035 #define FLD(f) abuf->fields.fmt_sll3.f
1036   EXTRACT_FMT_SLL3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1037
1038   EXTRACT_FMT_SLL3_CODE
1039
1040   /* Record the fields for the semantic handler.  */
1041   FLD (f_r1) = & CPU (h_gr)[f_r1];
1042   FLD (f_r2) = & CPU (h_gr)[f_r2];
1043   FLD (f_simm16) = f_simm16;
1044   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));
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       FLD (out_dr) = f_r1;
1052     }
1053 #endif
1054 #undef FLD
1055 }
1056
1057 void
1058 EX_FN_NAME (m32rbf,fmt_slli) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1059 {
1060 #define FLD(f) abuf->fields.fmt_slli.f
1061   EXTRACT_FMT_SLLI_VARS /* f-op1 f-r1 f-shift-op2 f-uimm5 */
1062
1063   EXTRACT_FMT_SLLI_CODE
1064
1065   /* Record the fields for the semantic handler.  */
1066   FLD (f_r1) = & CPU (h_gr)[f_r1];
1067   FLD (f_uimm5) = f_uimm5;
1068   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_slli", "dr 0x%x", 'x', f_r1, "uimm5 0x%x", 'x', f_uimm5, (char *) 0));
1069
1070 #if WITH_PROFILE_MODEL_P
1071   /* Record the fields for profiling.  */
1072   if (PROFILE_MODEL_P (current_cpu))
1073     {
1074       FLD (in_dr) = f_r1;
1075       FLD (out_dr) = f_r1;
1076     }
1077 #endif
1078 #undef FLD
1079 }
1080
1081 void
1082 EX_FN_NAME (m32rbf,fmt_st) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1083 {
1084 #define FLD(f) abuf->fields.fmt_st.f
1085   EXTRACT_FMT_ST_VARS /* f-op1 f-r1 f-op2 f-r2 */
1086
1087   EXTRACT_FMT_ST_CODE
1088
1089   /* Record the fields for the semantic handler.  */
1090   FLD (f_r1) = & CPU (h_gr)[f_r1];
1091   FLD (f_r2) = & CPU (h_gr)[f_r2];
1092   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_st", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1093
1094 #if WITH_PROFILE_MODEL_P
1095   /* Record the fields for profiling.  */
1096   if (PROFILE_MODEL_P (current_cpu))
1097     {
1098       FLD (in_src2) = f_r2;
1099       FLD (in_src1) = f_r1;
1100     }
1101 #endif
1102 #undef FLD
1103 }
1104
1105 void
1106 EX_FN_NAME (m32rbf,fmt_st_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1107 {
1108 #define FLD(f) abuf->fields.fmt_st_d.f
1109   EXTRACT_FMT_ST_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1110
1111   EXTRACT_FMT_ST_D_CODE
1112
1113   /* Record the fields for the semantic handler.  */
1114   FLD (f_r1) = & CPU (h_gr)[f_r1];
1115   FLD (f_r2) = & CPU (h_gr)[f_r2];
1116   FLD (f_simm16) = f_simm16;
1117   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));
1118
1119 #if WITH_PROFILE_MODEL_P
1120   /* Record the fields for profiling.  */
1121   if (PROFILE_MODEL_P (current_cpu))
1122     {
1123       FLD (in_src2) = f_r2;
1124       FLD (in_src1) = f_r1;
1125     }
1126 #endif
1127 #undef FLD
1128 }
1129
1130 void
1131 EX_FN_NAME (m32rbf,fmt_stb) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1132 {
1133 #define FLD(f) abuf->fields.fmt_stb.f
1134   EXTRACT_FMT_STB_VARS /* f-op1 f-r1 f-op2 f-r2 */
1135
1136   EXTRACT_FMT_STB_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   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_stb", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1142
1143 #if WITH_PROFILE_MODEL_P
1144   /* Record the fields for profiling.  */
1145   if (PROFILE_MODEL_P (current_cpu))
1146     {
1147       FLD (in_src2) = f_r2;
1148       FLD (in_src1) = f_r1;
1149     }
1150 #endif
1151 #undef FLD
1152 }
1153
1154 void
1155 EX_FN_NAME (m32rbf,fmt_stb_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1156 {
1157 #define FLD(f) abuf->fields.fmt_stb_d.f
1158   EXTRACT_FMT_STB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1159
1160   EXTRACT_FMT_STB_D_CODE
1161
1162   /* Record the fields for the semantic handler.  */
1163   FLD (f_r1) = & CPU (h_gr)[f_r1];
1164   FLD (f_r2) = & CPU (h_gr)[f_r2];
1165   FLD (f_simm16) = f_simm16;
1166   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));
1167
1168 #if WITH_PROFILE_MODEL_P
1169   /* Record the fields for profiling.  */
1170   if (PROFILE_MODEL_P (current_cpu))
1171     {
1172       FLD (in_src2) = f_r2;
1173       FLD (in_src1) = f_r1;
1174     }
1175 #endif
1176 #undef FLD
1177 }
1178
1179 void
1180 EX_FN_NAME (m32rbf,fmt_sth) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1181 {
1182 #define FLD(f) abuf->fields.fmt_sth.f
1183   EXTRACT_FMT_STH_VARS /* f-op1 f-r1 f-op2 f-r2 */
1184
1185   EXTRACT_FMT_STH_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_sth", "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 (m32rbf,fmt_sth_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1205 {
1206 #define FLD(f) abuf->fields.fmt_sth_d.f
1207   EXTRACT_FMT_STH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1208
1209   EXTRACT_FMT_STH_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_sth_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 (m32rbf,fmt_st_plus) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1230 {
1231 #define FLD(f) abuf->fields.fmt_st_plus.f
1232   EXTRACT_FMT_ST_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
1233
1234   EXTRACT_FMT_ST_PLUS_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_st_plus", "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       FLD (out_src2) = f_r2;
1248     }
1249 #endif
1250 #undef FLD
1251 }
1252
1253 void
1254 EX_FN_NAME (m32rbf,fmt_trap) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1255 {
1256 #define FLD(f) abuf->fields.cti.fields.fmt_trap.f
1257   EXTRACT_FMT_TRAP_VARS /* f-op1 f-r1 f-op2 f-uimm4 */
1258
1259   EXTRACT_FMT_TRAP_CODE
1260
1261   /* Record the fields for the semantic handler.  */
1262   FLD (f_uimm4) = f_uimm4;
1263   SEM_BRANCH_INIT_EXTRACT (abuf);
1264   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_trap", "uimm4 0x%x", 'x', f_uimm4, (char *) 0));
1265
1266 #if WITH_PROFILE_MODEL_P
1267   /* Record the fields for profiling.  */
1268   if (PROFILE_MODEL_P (current_cpu))
1269     {
1270     }
1271 #endif
1272 #undef FLD
1273 }
1274
1275 void
1276 EX_FN_NAME (m32rbf,fmt_unlock) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1277 {
1278 #define FLD(f) abuf->fields.fmt_unlock.f
1279   EXTRACT_FMT_UNLOCK_VARS /* f-op1 f-r1 f-op2 f-r2 */
1280
1281   EXTRACT_FMT_UNLOCK_CODE
1282
1283   /* Record the fields for the semantic handler.  */
1284   FLD (f_r1) = & CPU (h_gr)[f_r1];
1285   FLD (f_r2) = & CPU (h_gr)[f_r2];
1286   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_unlock", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1287
1288 #if WITH_PROFILE_MODEL_P
1289   /* Record the fields for profiling.  */
1290   if (PROFILE_MODEL_P (current_cpu))
1291     {
1292       FLD (in_src2) = f_r2;
1293       FLD (in_src1) = f_r1;
1294     }
1295 #endif
1296 #undef FLD
1297 }
1298
1299 void
1300 EX_FN_NAME (m32rbf,fmt_empty) (SIM_CPU *cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1301 {
1302   /* Empty format handler for virtual insns.  */
1303 }