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_M32R
  27
  28 #include "sim-main.h"
  29 #include "cpu-sim.h"
  30
  31 void
  32 EX_FN_NAME (m32r,fmt_0_add) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
  33 {
  34 #define FLD(f) abuf->fields.fmt_0_add.f
  35   EXTRACT_FMT_0_ADD_VARS /* f-op1 f-r1 f-op2 f-r2 */
  36
  37   EXTRACT_FMT_0_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_0_add", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
  43
  44   abuf->length = length;
  45   abuf->addr = pc;
  46
  47 #if WITH_PROFILE_MODEL_P
  48   /* Record the fields for profiling.  */
  49   if (PROFILE_MODEL_P (current_cpu))
  50     {
  51       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
  52       abuf->h_gr_set = 0 | (1 << f_r1);
  53     }
  54 #endif
  55 #undef FLD
  56 }
  57
  58 void
  59 EX_FN_NAME (m32r,fmt_1_add3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
  60 {
  61 #define FLD(f) abuf->fields.fmt_1_add3.f
  62   EXTRACT_FMT_1_ADD3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
  63
  64   EXTRACT_FMT_1_ADD3_CODE
  65
  66   /* Record the fields for the semantic handler.  */
  67   FLD (f_r1) = & CPU (h_gr)[f_r1];
  68   FLD (f_r2) = & CPU (h_gr)[f_r2];
  69   FLD (f_simm16) = f_simm16;
  70   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_1_add3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
  71
  72   abuf->length = length;
  73   abuf->addr = pc;
  74
  75 #if WITH_PROFILE_MODEL_P
  76   /* Record the fields for profiling.  */
  77   if (PROFILE_MODEL_P (current_cpu))
  78     {
  79       abuf->h_gr_get = 0 | (1 << f_r2);
  80       abuf->h_gr_set = 0 | (1 << f_r1);
  81     }
  82 #endif
  83 #undef FLD
  84 }
  85
  86 void
  87 EX_FN_NAME (m32r,fmt_2_and3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
  88 {
  89 #define FLD(f) abuf->fields.fmt_2_and3.f
  90   EXTRACT_FMT_2_AND3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
  91
  92   EXTRACT_FMT_2_AND3_CODE
  93
  94   /* Record the fields for the semantic handler.  */
  95   FLD (f_r1) = & CPU (h_gr)[f_r1];
  96   FLD (f_r2) = & CPU (h_gr)[f_r2];
  97   FLD (f_uimm16) = f_uimm16;
  98   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_2_and3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "uimm16 0x%x", 'x', f_uimm16, (char *) 0));
  99
 100   abuf->length = length;
 101   abuf->addr = pc;
 102
 103 #if WITH_PROFILE_MODEL_P
 104   /* Record the fields for profiling.  */
 105   if (PROFILE_MODEL_P (current_cpu))
 106     {
 107       abuf->h_gr_get = 0 | (1 << f_r2);
 108       abuf->h_gr_set = 0 | (1 << f_r1);
 109     }
 110 #endif
 111 #undef FLD
 112 }
 113
 114 void
 115 EX_FN_NAME (m32r,fmt_3_or3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 116 {
 117 #define FLD(f) abuf->fields.fmt_3_or3.f
 118   EXTRACT_FMT_3_OR3_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
 119
 120   EXTRACT_FMT_3_OR3_CODE
 121
 122   /* Record the fields for the semantic handler.  */
 123   FLD (f_r1) = & CPU (h_gr)[f_r1];
 124   FLD (f_r2) = & CPU (h_gr)[f_r2];
 125   FLD (f_uimm16) = f_uimm16;
 126   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_3_or3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "ulo16 0x%x", 'x', f_uimm16, (char *) 0));
 127
 128   abuf->length = length;
 129   abuf->addr = pc;
 130
 131 #if WITH_PROFILE_MODEL_P
 132   /* Record the fields for profiling.  */
 133   if (PROFILE_MODEL_P (current_cpu))
 134     {
 135       abuf->h_gr_get = 0 | (1 << f_r2);
 136       abuf->h_gr_set = 0 | (1 << f_r1);
 137     }
 138 #endif
 139 #undef FLD
 140 }
 141
 142 void
 143 EX_FN_NAME (m32r,fmt_4_addi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 144 {
 145 #define FLD(f) abuf->fields.fmt_4_addi.f
 146   EXTRACT_FMT_4_ADDI_VARS /* f-op1 f-r1 f-simm8 */
 147
 148   EXTRACT_FMT_4_ADDI_CODE
 149
 150   /* Record the fields for the semantic handler.  */
 151   FLD (f_r1) = & CPU (h_gr)[f_r1];
 152   FLD (f_simm8) = f_simm8;
 153   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_4_addi", "dr 0x%x", 'x', f_r1, "simm8 0x%x", 'x', f_simm8, (char *) 0));
 154
 155   abuf->length = length;
 156   abuf->addr = pc;
 157
 158 #if WITH_PROFILE_MODEL_P
 159   /* Record the fields for profiling.  */
 160   if (PROFILE_MODEL_P (current_cpu))
 161     {
 162       abuf->h_gr_get = 0 | (1 << f_r1);
 163       abuf->h_gr_set = 0 | (1 << f_r1);
 164     }
 165 #endif
 166 #undef FLD
 167 }
 168
 169 void
 170 EX_FN_NAME (m32r,fmt_5_addv) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 171 {
 172 #define FLD(f) abuf->fields.fmt_5_addv.f
 173   EXTRACT_FMT_5_ADDV_VARS /* f-op1 f-r1 f-op2 f-r2 */
 174
 175   EXTRACT_FMT_5_ADDV_CODE
 176
 177   /* Record the fields for the semantic handler.  */
 178   FLD (f_r1) = & CPU (h_gr)[f_r1];
 179   FLD (f_r2) = & CPU (h_gr)[f_r2];
 180   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_5_addv", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 181
 182   abuf->length = length;
 183   abuf->addr = pc;
 184
 185 #if WITH_PROFILE_MODEL_P
 186   /* Record the fields for profiling.  */
 187   if (PROFILE_MODEL_P (current_cpu))
 188     {
 189       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 190       abuf->h_gr_set = 0 | (1 << f_r1);
 191     }
 192 #endif
 193 #undef FLD
 194 }
 195
 196 void
 197 EX_FN_NAME (m32r,fmt_6_addv3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 198 {
 199 #define FLD(f) abuf->fields.fmt_6_addv3.f
 200   EXTRACT_FMT_6_ADDV3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 201
 202   EXTRACT_FMT_6_ADDV3_CODE
 203
 204   /* Record the fields for the semantic handler.  */
 205   FLD (f_r1) = & CPU (h_gr)[f_r1];
 206   FLD (f_r2) = & CPU (h_gr)[f_r2];
 207   FLD (f_simm16) = f_simm16;
 208   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_6_addv3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
 209
 210   abuf->length = length;
 211   abuf->addr = pc;
 212
 213 #if WITH_PROFILE_MODEL_P
 214   /* Record the fields for profiling.  */
 215   if (PROFILE_MODEL_P (current_cpu))
 216     {
 217       abuf->h_gr_get = 0 | (1 << f_r2);
 218       abuf->h_gr_set = 0 | (1 << f_r1);
 219     }
 220 #endif
 221 #undef FLD
 222 }
 223
 224 void
 225 EX_FN_NAME (m32r,fmt_7_addx) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 226 {
 227 #define FLD(f) abuf->fields.fmt_7_addx.f
 228   EXTRACT_FMT_7_ADDX_VARS /* f-op1 f-r1 f-op2 f-r2 */
 229
 230   EXTRACT_FMT_7_ADDX_CODE
 231
 232   /* Record the fields for the semantic handler.  */
 233   FLD (f_r1) = & CPU (h_gr)[f_r1];
 234   FLD (f_r2) = & CPU (h_gr)[f_r2];
 235   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_7_addx", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 236
 237   abuf->length = length;
 238   abuf->addr = pc;
 239
 240 #if WITH_PROFILE_MODEL_P
 241   /* Record the fields for profiling.  */
 242   if (PROFILE_MODEL_P (current_cpu))
 243     {
 244       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 245       abuf->h_gr_set = 0 | (1 << f_r1);
 246     }
 247 #endif
 248 #undef FLD
 249 }
 250
 251 void
 252 EX_FN_NAME (m32r,fmt_8_bc8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 253 {
 254 #define FLD(f) abuf->fields.fmt_8_bc8.f
 255   EXTRACT_FMT_8_BC8_VARS /* f-op1 f-r1 f-disp8 */
 256
 257   EXTRACT_FMT_8_BC8_CODE
 258
 259   /* Record the fields for the semantic handler.  */
 260   RECORD_IADDR (FLD (f_disp8), (pc & -4L) + f_disp8);
 261   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_8_bc8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
 262
 263   abuf->length = length;
 264   abuf->addr = pc;
 265 #undef FLD
 266 }
 267
 268 void
 269 EX_FN_NAME (m32r,fmt_9_bc24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 270 {
 271 #define FLD(f) abuf->fields.fmt_9_bc24.f
 272   EXTRACT_FMT_9_BC24_VARS /* f-op1 f-r1 f-disp24 */
 273
 274   EXTRACT_FMT_9_BC24_CODE
 275
 276   /* Record the fields for the semantic handler.  */
 277   RECORD_IADDR (FLD (f_disp24), pc + f_disp24);
 278   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_9_bc24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
 279
 280   abuf->length = length;
 281   abuf->addr = pc;
 282 #undef FLD
 283 }
 284
 285 void
 286 EX_FN_NAME (m32r,fmt_10_beq) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 287 {
 288 #define FLD(f) abuf->fields.fmt_10_beq.f
 289   EXTRACT_FMT_10_BEQ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 290
 291   EXTRACT_FMT_10_BEQ_CODE
 292
 293   /* Record the fields for the semantic handler.  */
 294   FLD (f_r1) = & CPU (h_gr)[f_r1];
 295   FLD (f_r2) = & CPU (h_gr)[f_r2];
 296   RECORD_IADDR (FLD (f_disp16), pc + f_disp16);
 297   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_10_beq", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "disp16 0x%x", 'x', f_disp16, (char *) 0));
 298
 299   abuf->length = length;
 300   abuf->addr = pc;
 301
 302 #if WITH_PROFILE_MODEL_P
 303   /* Record the fields for profiling.  */
 304   if (PROFILE_MODEL_P (current_cpu))
 305     {
 306       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 307     }
 308 #endif
 309 #undef FLD
 310 }
 311
 312 void
 313 EX_FN_NAME (m32r,fmt_11_beqz) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 314 {
 315 #define FLD(f) abuf->fields.fmt_11_beqz.f
 316   EXTRACT_FMT_11_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 317
 318   EXTRACT_FMT_11_BEQZ_CODE
 319
 320   /* Record the fields for the semantic handler.  */
 321   FLD (f_r2) = & CPU (h_gr)[f_r2];
 322   RECORD_IADDR (FLD (f_disp16), pc + f_disp16);
 323   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_11_beqz", "src2 0x%x", 'x', f_r2, "disp16 0x%x", 'x', f_disp16, (char *) 0));
 324
 325   abuf->length = length;
 326   abuf->addr = pc;
 327
 328 #if WITH_PROFILE_MODEL_P
 329   /* Record the fields for profiling.  */
 330   if (PROFILE_MODEL_P (current_cpu))
 331     {
 332       abuf->h_gr_get = 0 | (1 << f_r2);
 333     }
 334 #endif
 335 #undef FLD
 336 }
 337
 338 void
 339 EX_FN_NAME (m32r,fmt_12_bl8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 340 {
 341 #define FLD(f) abuf->fields.fmt_12_bl8.f
 342   EXTRACT_FMT_12_BL8_VARS /* f-op1 f-r1 f-disp8 */
 343
 344   EXTRACT_FMT_12_BL8_CODE
 345
 346   /* Record the fields for the semantic handler.  */
 347   RECORD_IADDR (FLD (f_disp8), (pc & -4L) + f_disp8);
 348   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_12_bl8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
 349
 350   abuf->length = length;
 351   abuf->addr = pc;
 352
 353 #if WITH_PROFILE_MODEL_P
 354   /* Record the fields for profiling.  */
 355   if (PROFILE_MODEL_P (current_cpu))
 356     {
 357       abuf->h_gr_set = 0 | (1 << 14);
 358     }
 359 #endif
 360 #undef FLD
 361 }
 362
 363 void
 364 EX_FN_NAME (m32r,fmt_13_bl24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 365 {
 366 #define FLD(f) abuf->fields.fmt_13_bl24.f
 367   EXTRACT_FMT_13_BL24_VARS /* f-op1 f-r1 f-disp24 */
 368
 369   EXTRACT_FMT_13_BL24_CODE
 370
 371   /* Record the fields for the semantic handler.  */
 372   RECORD_IADDR (FLD (f_disp24), pc + f_disp24);
 373   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_13_bl24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
 374
 375   abuf->length = length;
 376   abuf->addr = pc;
 377
 378 #if WITH_PROFILE_MODEL_P
 379   /* Record the fields for profiling.  */
 380   if (PROFILE_MODEL_P (current_cpu))
 381     {
 382       abuf->h_gr_set = 0 | (1 << 14);
 383     }
 384 #endif
 385 #undef FLD
 386 }
 387
 388 void
 389 EX_FN_NAME (m32r,fmt_14_bra8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 390 {
 391 #define FLD(f) abuf->fields.fmt_14_bra8.f
 392   EXTRACT_FMT_14_BRA8_VARS /* f-op1 f-r1 f-disp8 */
 393
 394   EXTRACT_FMT_14_BRA8_CODE
 395
 396   /* Record the fields for the semantic handler.  */
 397   RECORD_IADDR (FLD (f_disp8), (pc & -4L) + f_disp8);
 398   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_14_bra8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
 399
 400   abuf->length = length;
 401   abuf->addr = pc;
 402 #undef FLD
 403 }
 404
 405 void
 406 EX_FN_NAME (m32r,fmt_15_bra24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 407 {
 408 #define FLD(f) abuf->fields.fmt_15_bra24.f
 409   EXTRACT_FMT_15_BRA24_VARS /* f-op1 f-r1 f-disp24 */
 410
 411   EXTRACT_FMT_15_BRA24_CODE
 412
 413   /* Record the fields for the semantic handler.  */
 414   RECORD_IADDR (FLD (f_disp24), pc + f_disp24);
 415   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_15_bra24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
 416
 417   abuf->length = length;
 418   abuf->addr = pc;
 419 #undef FLD
 420 }
 421
 422 void
 423 EX_FN_NAME (m32r,fmt_16_cmp) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 424 {
 425 #define FLD(f) abuf->fields.fmt_16_cmp.f
 426   EXTRACT_FMT_16_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
 427
 428   EXTRACT_FMT_16_CMP_CODE
 429
 430   /* Record the fields for the semantic handler.  */
 431   FLD (f_r1) = & CPU (h_gr)[f_r1];
 432   FLD (f_r2) = & CPU (h_gr)[f_r2];
 433   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_16_cmp", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
 434
 435   abuf->length = length;
 436   abuf->addr = pc;
 437
 438 #if WITH_PROFILE_MODEL_P
 439   /* Record the fields for profiling.  */
 440   if (PROFILE_MODEL_P (current_cpu))
 441     {
 442       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 443     }
 444 #endif
 445 #undef FLD
 446 }
 447
 448 void
 449 EX_FN_NAME (m32r,fmt_17_cmpi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 450 {
 451 #define FLD(f) abuf->fields.fmt_17_cmpi.f
 452   EXTRACT_FMT_17_CMPI_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 453
 454   EXTRACT_FMT_17_CMPI_CODE
 455
 456   /* Record the fields for the semantic handler.  */
 457   FLD (f_r2) = & CPU (h_gr)[f_r2];
 458   FLD (f_simm16) = f_simm16;
 459   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_17_cmpi", "src2 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
 460
 461   abuf->length = length;
 462   abuf->addr = pc;
 463
 464 #if WITH_PROFILE_MODEL_P
 465   /* Record the fields for profiling.  */
 466   if (PROFILE_MODEL_P (current_cpu))
 467     {
 468       abuf->h_gr_get = 0 | (1 << f_r2);
 469     }
 470 #endif
 471 #undef FLD
 472 }
 473
 474 void
 475 EX_FN_NAME (m32r,fmt_18_cmpui) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 476 {
 477 #define FLD(f) abuf->fields.fmt_18_cmpui.f
 478   EXTRACT_FMT_18_CMPUI_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
 479
 480   EXTRACT_FMT_18_CMPUI_CODE
 481
 482   /* Record the fields for the semantic handler.  */
 483   FLD (f_r2) = & CPU (h_gr)[f_r2];
 484   FLD (f_uimm16) = f_uimm16;
 485   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_18_cmpui", "src2 0x%x", 'x', f_r2, "uimm16 0x%x", 'x', f_uimm16, (char *) 0));
 486
 487   abuf->length = length;
 488   abuf->addr = pc;
 489
 490 #if WITH_PROFILE_MODEL_P
 491   /* Record the fields for profiling.  */
 492   if (PROFILE_MODEL_P (current_cpu))
 493     {
 494       abuf->h_gr_get = 0 | (1 << f_r2);
 495     }
 496 #endif
 497 #undef FLD
 498 }
 499
 500 void
 501 EX_FN_NAME (m32r,fmt_19_div) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 502 {
 503 #define FLD(f) abuf->fields.fmt_19_div.f
 504   EXTRACT_FMT_19_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 505
 506   EXTRACT_FMT_19_DIV_CODE
 507
 508   /* Record the fields for the semantic handler.  */
 509   FLD (f_r1) = & CPU (h_gr)[f_r1];
 510   FLD (f_r2) = & CPU (h_gr)[f_r2];
 511   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_19_div", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 512
 513   abuf->length = length;
 514   abuf->addr = pc;
 515
 516 #if WITH_PROFILE_MODEL_P
 517   /* Record the fields for profiling.  */
 518   if (PROFILE_MODEL_P (current_cpu))
 519     {
 520       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 521       abuf->h_gr_set = 0 | (1 << f_r1);
 522     }
 523 #endif
 524 #undef FLD
 525 }
 526
 527 void
 528 EX_FN_NAME (m32r,fmt_20_jl) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 529 {
 530 #define FLD(f) abuf->fields.fmt_20_jl.f
 531   EXTRACT_FMT_20_JL_VARS /* f-op1 f-r1 f-op2 f-r2 */
 532
 533   EXTRACT_FMT_20_JL_CODE
 534
 535   /* Record the fields for the semantic handler.  */
 536   FLD (f_r2) = & CPU (h_gr)[f_r2];
 537   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_20_jl", "sr 0x%x", 'x', f_r2, (char *) 0));
 538
 539   abuf->length = length;
 540   abuf->addr = pc;
 541
 542 #if WITH_PROFILE_MODEL_P
 543   /* Record the fields for profiling.  */
 544   if (PROFILE_MODEL_P (current_cpu))
 545     {
 546       abuf->h_gr_get = 0 | (1 << f_r2);
 547       abuf->h_gr_set = 0 | (1 << 14);
 548     }
 549 #endif
 550 #undef FLD
 551 }
 552
 553 void
 554 EX_FN_NAME (m32r,fmt_21_jmp) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 555 {
 556 #define FLD(f) abuf->fields.fmt_21_jmp.f
 557   EXTRACT_FMT_21_JMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
 558
 559   EXTRACT_FMT_21_JMP_CODE
 560
 561   /* Record the fields for the semantic handler.  */
 562   FLD (f_r2) = & CPU (h_gr)[f_r2];
 563   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_21_jmp", "sr 0x%x", 'x', f_r2, (char *) 0));
 564
 565   abuf->length = length;
 566   abuf->addr = pc;
 567
 568 #if WITH_PROFILE_MODEL_P
 569   /* Record the fields for profiling.  */
 570   if (PROFILE_MODEL_P (current_cpu))
 571     {
 572       abuf->h_gr_get = 0 | (1 << f_r2);
 573     }
 574 #endif
 575 #undef FLD
 576 }
 577
 578 void
 579 EX_FN_NAME (m32r,fmt_22_ld) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 580 {
 581 #define FLD(f) abuf->fields.fmt_22_ld.f
 582   EXTRACT_FMT_22_LD_VARS /* f-op1 f-r1 f-op2 f-r2 */
 583
 584   EXTRACT_FMT_22_LD_CODE
 585
 586   /* Record the fields for the semantic handler.  */
 587   FLD (f_r1) = & CPU (h_gr)[f_r1];
 588   FLD (f_r2) = & CPU (h_gr)[f_r2];
 589   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_22_ld", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 590
 591   abuf->length = length;
 592   abuf->addr = pc;
 593
 594 #if WITH_PROFILE_MODEL_P
 595   /* Record the fields for profiling.  */
 596   if (PROFILE_MODEL_P (current_cpu))
 597     {
 598       abuf->h_gr_get = 0 | (1 << f_r2);
 599       abuf->h_gr_set = 0 | (1 << f_r1);
 600     }
 601 #endif
 602 #undef FLD
 603 }
 604
 605 void
 606 EX_FN_NAME (m32r,fmt_23_ld_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 607 {
 608 #define FLD(f) abuf->fields.fmt_23_ld_d.f
 609   EXTRACT_FMT_23_LD_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 610
 611   EXTRACT_FMT_23_LD_D_CODE
 612
 613   /* Record the fields for the semantic handler.  */
 614   FLD (f_r1) = & CPU (h_gr)[f_r1];
 615   FLD (f_r2) = & CPU (h_gr)[f_r2];
 616   FLD (f_simm16) = f_simm16;
 617   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_23_ld_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 618
 619   abuf->length = length;
 620   abuf->addr = pc;
 621
 622 #if WITH_PROFILE_MODEL_P
 623   /* Record the fields for profiling.  */
 624   if (PROFILE_MODEL_P (current_cpu))
 625     {
 626       abuf->h_gr_get = 0 | (1 << f_r2);
 627       abuf->h_gr_set = 0 | (1 << f_r1);
 628     }
 629 #endif
 630 #undef FLD
 631 }
 632
 633 void
 634 EX_FN_NAME (m32r,fmt_24_ldb) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 635 {
 636 #define FLD(f) abuf->fields.fmt_24_ldb.f
 637   EXTRACT_FMT_24_LDB_VARS /* f-op1 f-r1 f-op2 f-r2 */
 638
 639   EXTRACT_FMT_24_LDB_CODE
 640
 641   /* Record the fields for the semantic handler.  */
 642   FLD (f_r1) = & CPU (h_gr)[f_r1];
 643   FLD (f_r2) = & CPU (h_gr)[f_r2];
 644   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_24_ldb", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 645
 646   abuf->length = length;
 647   abuf->addr = pc;
 648
 649 #if WITH_PROFILE_MODEL_P
 650   /* Record the fields for profiling.  */
 651   if (PROFILE_MODEL_P (current_cpu))
 652     {
 653       abuf->h_gr_get = 0 | (1 << f_r2);
 654       abuf->h_gr_set = 0 | (1 << f_r1);
 655     }
 656 #endif
 657 #undef FLD
 658 }
 659
 660 void
 661 EX_FN_NAME (m32r,fmt_25_ldb_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 662 {
 663 #define FLD(f) abuf->fields.fmt_25_ldb_d.f
 664   EXTRACT_FMT_25_LDB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 665
 666   EXTRACT_FMT_25_LDB_D_CODE
 667
 668   /* Record the fields for the semantic handler.  */
 669   FLD (f_r1) = & CPU (h_gr)[f_r1];
 670   FLD (f_r2) = & CPU (h_gr)[f_r2];
 671   FLD (f_simm16) = f_simm16;
 672   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_25_ldb_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 673
 674   abuf->length = length;
 675   abuf->addr = pc;
 676
 677 #if WITH_PROFILE_MODEL_P
 678   /* Record the fields for profiling.  */
 679   if (PROFILE_MODEL_P (current_cpu))
 680     {
 681       abuf->h_gr_get = 0 | (1 << f_r2);
 682       abuf->h_gr_set = 0 | (1 << f_r1);
 683     }
 684 #endif
 685 #undef FLD
 686 }
 687
 688 void
 689 EX_FN_NAME (m32r,fmt_26_ldh) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 690 {
 691 #define FLD(f) abuf->fields.fmt_26_ldh.f
 692   EXTRACT_FMT_26_LDH_VARS /* f-op1 f-r1 f-op2 f-r2 */
 693
 694   EXTRACT_FMT_26_LDH_CODE
 695
 696   /* Record the fields for the semantic handler.  */
 697   FLD (f_r1) = & CPU (h_gr)[f_r1];
 698   FLD (f_r2) = & CPU (h_gr)[f_r2];
 699   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_26_ldh", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 700
 701   abuf->length = length;
 702   abuf->addr = pc;
 703
 704 #if WITH_PROFILE_MODEL_P
 705   /* Record the fields for profiling.  */
 706   if (PROFILE_MODEL_P (current_cpu))
 707     {
 708       abuf->h_gr_get = 0 | (1 << f_r2);
 709       abuf->h_gr_set = 0 | (1 << f_r1);
 710     }
 711 #endif
 712 #undef FLD
 713 }
 714
 715 void
 716 EX_FN_NAME (m32r,fmt_27_ldh_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 717 {
 718 #define FLD(f) abuf->fields.fmt_27_ldh_d.f
 719   EXTRACT_FMT_27_LDH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 720
 721   EXTRACT_FMT_27_LDH_D_CODE
 722
 723   /* Record the fields for the semantic handler.  */
 724   FLD (f_r1) = & CPU (h_gr)[f_r1];
 725   FLD (f_r2) = & CPU (h_gr)[f_r2];
 726   FLD (f_simm16) = f_simm16;
 727   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_27_ldh_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 728
 729   abuf->length = length;
 730   abuf->addr = pc;
 731
 732 #if WITH_PROFILE_MODEL_P
 733   /* Record the fields for profiling.  */
 734   if (PROFILE_MODEL_P (current_cpu))
 735     {
 736       abuf->h_gr_get = 0 | (1 << f_r2);
 737       abuf->h_gr_set = 0 | (1 << f_r1);
 738     }
 739 #endif
 740 #undef FLD
 741 }
 742
 743 void
 744 EX_FN_NAME (m32r,fmt_28_ld_plus) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 745 {
 746 #define FLD(f) abuf->fields.fmt_28_ld_plus.f
 747   EXTRACT_FMT_28_LD_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
 748
 749   EXTRACT_FMT_28_LD_PLUS_CODE
 750
 751   /* Record the fields for the semantic handler.  */
 752   FLD (f_r1) = & CPU (h_gr)[f_r1];
 753   FLD (f_r2) = & CPU (h_gr)[f_r2];
 754   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_28_ld_plus", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 755
 756   abuf->length = length;
 757   abuf->addr = pc;
 758
 759 #if WITH_PROFILE_MODEL_P
 760   /* Record the fields for profiling.  */
 761   if (PROFILE_MODEL_P (current_cpu))
 762     {
 763       abuf->h_gr_get = 0 | (1 << f_r2);
 764       abuf->h_gr_set = 0 | (1 << f_r1) | (1 << f_r2);
 765     }
 766 #endif
 767 #undef FLD
 768 }
 769
 770 void
 771 EX_FN_NAME (m32r,fmt_29_ld24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 772 {
 773 #define FLD(f) abuf->fields.fmt_29_ld24.f
 774   EXTRACT_FMT_29_LD24_VARS /* f-op1 f-r1 f-uimm24 */
 775
 776   EXTRACT_FMT_29_LD24_CODE
 777
 778   /* Record the fields for the semantic handler.  */
 779   FLD (f_r1) = & CPU (h_gr)[f_r1];
 780   FLD (f_uimm24) = f_uimm24;
 781   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_29_ld24", "dr 0x%x", 'x', f_r1, "uimm24 0x%x", 'x', f_uimm24, (char *) 0));
 782
 783   abuf->length = length;
 784   abuf->addr = pc;
 785
 786 #if WITH_PROFILE_MODEL_P
 787   /* Record the fields for profiling.  */
 788   if (PROFILE_MODEL_P (current_cpu))
 789     {
 790       abuf->h_gr_set = 0 | (1 << f_r1);
 791     }
 792 #endif
 793 #undef FLD
 794 }
 795
 796 void
 797 EX_FN_NAME (m32r,fmt_30_ldi8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 798 {
 799 #define FLD(f) abuf->fields.fmt_30_ldi8.f
 800   EXTRACT_FMT_30_LDI8_VARS /* f-op1 f-r1 f-simm8 */
 801
 802   EXTRACT_FMT_30_LDI8_CODE
 803
 804   /* Record the fields for the semantic handler.  */
 805   FLD (f_r1) = & CPU (h_gr)[f_r1];
 806   FLD (f_simm8) = f_simm8;
 807   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_30_ldi8", "dr 0x%x", 'x', f_r1, "simm8 0x%x", 'x', f_simm8, (char *) 0));
 808
 809   abuf->length = length;
 810   abuf->addr = pc;
 811
 812 #if WITH_PROFILE_MODEL_P
 813   /* Record the fields for profiling.  */
 814   if (PROFILE_MODEL_P (current_cpu))
 815     {
 816       abuf->h_gr_set = 0 | (1 << f_r1);
 817     }
 818 #endif
 819 #undef FLD
 820 }
 821
 822 void
 823 EX_FN_NAME (m32r,fmt_31_ldi16) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 824 {
 825 #define FLD(f) abuf->fields.fmt_31_ldi16.f
 826   EXTRACT_FMT_31_LDI16_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 827
 828   EXTRACT_FMT_31_LDI16_CODE
 829
 830   /* Record the fields for the semantic handler.  */
 831   FLD (f_r1) = & CPU (h_gr)[f_r1];
 832   FLD (f_simm16) = f_simm16;
 833   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_31_ldi16", "dr 0x%x", 'x', f_r1, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 834
 835   abuf->length = length;
 836   abuf->addr = pc;
 837
 838 #if WITH_PROFILE_MODEL_P
 839   /* Record the fields for profiling.  */
 840   if (PROFILE_MODEL_P (current_cpu))
 841     {
 842       abuf->h_gr_set = 0 | (1 << f_r1);
 843     }
 844 #endif
 845 #undef FLD
 846 }
 847
 848 void
 849 EX_FN_NAME (m32r,fmt_32_lock) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 850 {
 851 #define FLD(f) abuf->fields.fmt_32_lock.f
 852   EXTRACT_FMT_32_LOCK_VARS /* f-op1 f-r1 f-op2 f-r2 */
 853
 854   EXTRACT_FMT_32_LOCK_CODE
 855
 856   /* Record the fields for the semantic handler.  */
 857   FLD (f_r1) = & CPU (h_gr)[f_r1];
 858   FLD (f_r2) = & CPU (h_gr)[f_r2];
 859   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_32_lock", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 860
 861   abuf->length = length;
 862   abuf->addr = pc;
 863
 864 #if WITH_PROFILE_MODEL_P
 865   /* Record the fields for profiling.  */
 866   if (PROFILE_MODEL_P (current_cpu))
 867     {
 868       abuf->h_gr_get = 0 | (1 << f_r2);
 869       abuf->h_gr_set = 0 | (1 << f_r1);
 870     }
 871 #endif
 872 #undef FLD
 873 }
 874
 875 void
 876 EX_FN_NAME (m32r,fmt_33_machi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 877 {
 878 #define FLD(f) abuf->fields.fmt_33_machi.f
 879   EXTRACT_FMT_33_MACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 880
 881   EXTRACT_FMT_33_MACHI_CODE
 882
 883   /* Record the fields for the semantic handler.  */
 884   FLD (f_r1) = & CPU (h_gr)[f_r1];
 885   FLD (f_r2) = & CPU (h_gr)[f_r2];
 886   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_33_machi", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
 887
 888   abuf->length = length;
 889   abuf->addr = pc;
 890
 891 #if WITH_PROFILE_MODEL_P
 892   /* Record the fields for profiling.  */
 893   if (PROFILE_MODEL_P (current_cpu))
 894     {
 895       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 896     }
 897 #endif
 898 #undef FLD
 899 }
 900
 901 void
 902 EX_FN_NAME (m32r,fmt_34_mulhi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 903 {
 904 #define FLD(f) abuf->fields.fmt_34_mulhi.f
 905   EXTRACT_FMT_34_MULHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 906
 907   EXTRACT_FMT_34_MULHI_CODE
 908
 909   /* Record the fields for the semantic handler.  */
 910   FLD (f_r1) = & CPU (h_gr)[f_r1];
 911   FLD (f_r2) = & CPU (h_gr)[f_r2];
 912   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_34_mulhi", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
 913
 914   abuf->length = length;
 915   abuf->addr = pc;
 916
 917 #if WITH_PROFILE_MODEL_P
 918   /* Record the fields for profiling.  */
 919   if (PROFILE_MODEL_P (current_cpu))
 920     {
 921       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 922     }
 923 #endif
 924 #undef FLD
 925 }
 926
 927 void
 928 EX_FN_NAME (m32r,fmt_35_mv) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 929 {
 930 #define FLD(f) abuf->fields.fmt_35_mv.f
 931   EXTRACT_FMT_35_MV_VARS /* f-op1 f-r1 f-op2 f-r2 */
 932
 933   EXTRACT_FMT_35_MV_CODE
 934
 935   /* Record the fields for the semantic handler.  */
 936   FLD (f_r1) = & CPU (h_gr)[f_r1];
 937   FLD (f_r2) = & CPU (h_gr)[f_r2];
 938   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_35_mv", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 939
 940   abuf->length = length;
 941   abuf->addr = pc;
 942
 943 #if WITH_PROFILE_MODEL_P
 944   /* Record the fields for profiling.  */
 945   if (PROFILE_MODEL_P (current_cpu))
 946     {
 947       abuf->h_gr_get = 0 | (1 << f_r2);
 948       abuf->h_gr_set = 0 | (1 << f_r1);
 949     }
 950 #endif
 951 #undef FLD
 952 }
 953
 954 void
 955 EX_FN_NAME (m32r,fmt_36_mvfachi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 956 {
 957 #define FLD(f) abuf->fields.fmt_36_mvfachi.f
 958   EXTRACT_FMT_36_MVFACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 959
 960   EXTRACT_FMT_36_MVFACHI_CODE
 961
 962   /* Record the fields for the semantic handler.  */
 963   FLD (f_r1) = & CPU (h_gr)[f_r1];
 964   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_36_mvfachi", "dr 0x%x", 'x', f_r1, (char *) 0));
 965
 966   abuf->length = length;
 967   abuf->addr = pc;
 968
 969 #if WITH_PROFILE_MODEL_P
 970   /* Record the fields for profiling.  */
 971   if (PROFILE_MODEL_P (current_cpu))
 972     {
 973       abuf->h_gr_set = 0 | (1 << f_r1);
 974     }
 975 #endif
 976 #undef FLD
 977 }
 978
 979 void
 980 EX_FN_NAME (m32r,fmt_37_mvfc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 981 {
 982 #define FLD(f) abuf->fields.fmt_37_mvfc.f
 983   EXTRACT_FMT_37_MVFC_VARS /* f-op1 f-r1 f-op2 f-r2 */
 984
 985   EXTRACT_FMT_37_MVFC_CODE
 986
 987   /* Record the fields for the semantic handler.  */
 988   FLD (f_r1) = & CPU (h_gr)[f_r1];
 989   FLD (f_r2) = f_r2;
 990   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_37_mvfc", "dr 0x%x", 'x', f_r1, "scr 0x%x", 'x', f_r2, (char *) 0));
 991
 992   abuf->length = length;
 993   abuf->addr = pc;
 994
 995 #if WITH_PROFILE_MODEL_P
 996   /* Record the fields for profiling.  */
 997   if (PROFILE_MODEL_P (current_cpu))
 998     {
 999       abuf->h_gr_set = 0 | (1 << f_r1);
1000     }
1001 #endif
1002 #undef FLD
1003 }
1004
1005 void
1006 EX_FN_NAME (m32r,fmt_38_mvtachi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1007 {
1008 #define FLD(f) abuf->fields.fmt_38_mvtachi.f
1009   EXTRACT_FMT_38_MVTACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
1010
1011   EXTRACT_FMT_38_MVTACHI_CODE
1012
1013   /* Record the fields for the semantic handler.  */
1014   FLD (f_r1) = & CPU (h_gr)[f_r1];
1015   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_38_mvtachi", "src1 0x%x", 'x', f_r1, (char *) 0));
1016
1017   abuf->length = length;
1018   abuf->addr = pc;
1019
1020 #if WITH_PROFILE_MODEL_P
1021   /* Record the fields for profiling.  */
1022   if (PROFILE_MODEL_P (current_cpu))
1023     {
1024       abuf->h_gr_get = 0 | (1 << f_r1);
1025     }
1026 #endif
1027 #undef FLD
1028 }
1029
1030 void
1031 EX_FN_NAME (m32r,fmt_39_mvtc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1032 {
1033 #define FLD(f) abuf->fields.fmt_39_mvtc.f
1034   EXTRACT_FMT_39_MVTC_VARS /* f-op1 f-r1 f-op2 f-r2 */
1035
1036   EXTRACT_FMT_39_MVTC_CODE
1037
1038   /* Record the fields for the semantic handler.  */
1039   FLD (f_r1) = f_r1;
1040   FLD (f_r2) = & CPU (h_gr)[f_r2];
1041   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_39_mvtc", "dcr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
1042
1043   abuf->length = length;
1044   abuf->addr = pc;
1045
1046 #if WITH_PROFILE_MODEL_P
1047   /* Record the fields for profiling.  */
1048   if (PROFILE_MODEL_P (current_cpu))
1049     {
1050       abuf->h_gr_get = 0 | (1 << f_r2);
1051     }
1052 #endif
1053 #undef FLD
1054 }
1055
1056 void
1057 EX_FN_NAME (m32r,fmt_40_nop) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1058 {
1059 #define FLD(f) abuf->fields.fmt_40_nop.f
1060   EXTRACT_FMT_40_NOP_VARS /* f-op1 f-r1 f-op2 f-r2 */
1061
1062   EXTRACT_FMT_40_NOP_CODE
1063
1064   /* Record the fields for the semantic handler.  */
1065   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_40_nop", (char *) 0));
1066
1067   abuf->length = length;
1068   abuf->addr = pc;
1069 #undef FLD
1070 }
1071
1072 void
1073 EX_FN_NAME (m32r,fmt_41_rac) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1074 {
1075 #define FLD(f) abuf->fields.fmt_41_rac.f
1076   EXTRACT_FMT_41_RAC_VARS /* f-op1 f-r1 f-op2 f-r2 */
1077
1078   EXTRACT_FMT_41_RAC_CODE
1079
1080   /* Record the fields for the semantic handler.  */
1081   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_41_rac", (char *) 0));
1082
1083   abuf->length = length;
1084   abuf->addr = pc;
1085 #undef FLD
1086 }
1087
1088 void
1089 EX_FN_NAME (m32r,fmt_42_rte) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1090 {
1091 #define FLD(f) abuf->fields.fmt_42_rte.f
1092   EXTRACT_FMT_42_RTE_VARS /* f-op1 f-r1 f-op2 f-r2 */
1093
1094   EXTRACT_FMT_42_RTE_CODE
1095
1096   /* Record the fields for the semantic handler.  */
1097   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_42_rte", (char *) 0));
1098
1099   abuf->length = length;
1100   abuf->addr = pc;
1101 #undef FLD
1102 }
1103
1104 void
1105 EX_FN_NAME (m32r,fmt_43_seth) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1106 {
1107 #define FLD(f) abuf->fields.fmt_43_seth.f
1108   EXTRACT_FMT_43_SETH_VARS /* f-op1 f-r1 f-op2 f-r2 f-hi16 */
1109
1110   EXTRACT_FMT_43_SETH_CODE
1111
1112   /* Record the fields for the semantic handler.  */
1113   FLD (f_r1) = & CPU (h_gr)[f_r1];
1114   FLD (f_hi16) = f_hi16;
1115   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_43_seth", "dr 0x%x", 'x', f_r1, "hi16 0x%x", 'x', f_hi16, (char *) 0));
1116
1117   abuf->length = length;
1118   abuf->addr = pc;
1119
1120 #if WITH_PROFILE_MODEL_P
1121   /* Record the fields for profiling.  */
1122   if (PROFILE_MODEL_P (current_cpu))
1123     {
1124       abuf->h_gr_set = 0 | (1 << f_r1);
1125     }
1126 #endif
1127 #undef FLD
1128 }
1129
1130 void
1131 EX_FN_NAME (m32r,fmt_44_sll3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1132 {
1133 #define FLD(f) abuf->fields.fmt_44_sll3.f
1134   EXTRACT_FMT_44_SLL3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1135
1136   EXTRACT_FMT_44_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_44_sll3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
1143
1144   abuf->length = length;
1145   abuf->addr = pc;
1146
1147 #if WITH_PROFILE_MODEL_P
1148   /* Record the fields for profiling.  */
1149   if (PROFILE_MODEL_P (current_cpu))
1150     {
1151       abuf->h_gr_get = 0 | (1 << f_r2);
1152       abuf->h_gr_set = 0 | (1 << f_r1);
1153     }
1154 #endif
1155 #undef FLD
1156 }
1157
1158 void
1159 EX_FN_NAME (m32r,fmt_45_slli) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1160 {
1161 #define FLD(f) abuf->fields.fmt_45_slli.f
1162   EXTRACT_FMT_45_SLLI_VARS /* f-op1 f-r1 f-shift-op2 f-uimm5 */
1163
1164   EXTRACT_FMT_45_SLLI_CODE
1165
1166   /* Record the fields for the semantic handler.  */
1167   FLD (f_r1) = & CPU (h_gr)[f_r1];
1168   FLD (f_uimm5) = f_uimm5;
1169   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_45_slli", "dr 0x%x", 'x', f_r1, "uimm5 0x%x", 'x', f_uimm5, (char *) 0));
1170
1171   abuf->length = length;
1172   abuf->addr = pc;
1173
1174 #if WITH_PROFILE_MODEL_P
1175   /* Record the fields for profiling.  */
1176   if (PROFILE_MODEL_P (current_cpu))
1177     {
1178       abuf->h_gr_get = 0 | (1 << f_r1);
1179       abuf->h_gr_set = 0 | (1 << f_r1);
1180     }
1181 #endif
1182 #undef FLD
1183 }
1184
1185 void
1186 EX_FN_NAME (m32r,fmt_46_st) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1187 {
1188 #define FLD(f) abuf->fields.fmt_46_st.f
1189   EXTRACT_FMT_46_ST_VARS /* f-op1 f-r1 f-op2 f-r2 */
1190
1191   EXTRACT_FMT_46_ST_CODE
1192
1193   /* Record the fields for the semantic handler.  */
1194   FLD (f_r1) = & CPU (h_gr)[f_r1];
1195   FLD (f_r2) = & CPU (h_gr)[f_r2];
1196   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_46_st", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1197
1198   abuf->length = length;
1199   abuf->addr = pc;
1200
1201 #if WITH_PROFILE_MODEL_P
1202   /* Record the fields for profiling.  */
1203   if (PROFILE_MODEL_P (current_cpu))
1204     {
1205       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1206     }
1207 #endif
1208 #undef FLD
1209 }
1210
1211 void
1212 EX_FN_NAME (m32r,fmt_47_st_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1213 {
1214 #define FLD(f) abuf->fields.fmt_47_st_d.f
1215   EXTRACT_FMT_47_ST_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1216
1217   EXTRACT_FMT_47_ST_D_CODE
1218
1219   /* Record the fields for the semantic handler.  */
1220   FLD (f_r1) = & CPU (h_gr)[f_r1];
1221   FLD (f_r2) = & CPU (h_gr)[f_r2];
1222   FLD (f_simm16) = f_simm16;
1223   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_47_st_d", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
1224
1225   abuf->length = length;
1226   abuf->addr = pc;
1227
1228 #if WITH_PROFILE_MODEL_P
1229   /* Record the fields for profiling.  */
1230   if (PROFILE_MODEL_P (current_cpu))
1231     {
1232       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1233     }
1234 #endif
1235 #undef FLD
1236 }
1237
1238 void
1239 EX_FN_NAME (m32r,fmt_48_stb) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1240 {
1241 #define FLD(f) abuf->fields.fmt_48_stb.f
1242   EXTRACT_FMT_48_STB_VARS /* f-op1 f-r1 f-op2 f-r2 */
1243
1244   EXTRACT_FMT_48_STB_CODE
1245
1246   /* Record the fields for the semantic handler.  */
1247   FLD (f_r1) = & CPU (h_gr)[f_r1];
1248   FLD (f_r2) = & CPU (h_gr)[f_r2];
1249   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_48_stb", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1250
1251   abuf->length = length;
1252   abuf->addr = pc;
1253
1254 #if WITH_PROFILE_MODEL_P
1255   /* Record the fields for profiling.  */
1256   if (PROFILE_MODEL_P (current_cpu))
1257     {
1258       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1259     }
1260 #endif
1261 #undef FLD
1262 }
1263
1264 void
1265 EX_FN_NAME (m32r,fmt_49_stb_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1266 {
1267 #define FLD(f) abuf->fields.fmt_49_stb_d.f
1268   EXTRACT_FMT_49_STB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1269
1270   EXTRACT_FMT_49_STB_D_CODE
1271
1272   /* Record the fields for the semantic handler.  */
1273   FLD (f_r1) = & CPU (h_gr)[f_r1];
1274   FLD (f_r2) = & CPU (h_gr)[f_r2];
1275   FLD (f_simm16) = f_simm16;
1276   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_49_stb_d", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
1277
1278   abuf->length = length;
1279   abuf->addr = pc;
1280
1281 #if WITH_PROFILE_MODEL_P
1282   /* Record the fields for profiling.  */
1283   if (PROFILE_MODEL_P (current_cpu))
1284     {
1285       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1286     }
1287 #endif
1288 #undef FLD
1289 }
1290
1291 void
1292 EX_FN_NAME (m32r,fmt_50_sth) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1293 {
1294 #define FLD(f) abuf->fields.fmt_50_sth.f
1295   EXTRACT_FMT_50_STH_VARS /* f-op1 f-r1 f-op2 f-r2 */
1296
1297   EXTRACT_FMT_50_STH_CODE
1298
1299   /* Record the fields for the semantic handler.  */
1300   FLD (f_r1) = & CPU (h_gr)[f_r1];
1301   FLD (f_r2) = & CPU (h_gr)[f_r2];
1302   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_50_sth", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1303
1304   abuf->length = length;
1305   abuf->addr = pc;
1306
1307 #if WITH_PROFILE_MODEL_P
1308   /* Record the fields for profiling.  */
1309   if (PROFILE_MODEL_P (current_cpu))
1310     {
1311       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1312     }
1313 #endif
1314 #undef FLD
1315 }
1316
1317 void
1318 EX_FN_NAME (m32r,fmt_51_sth_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1319 {
1320 #define FLD(f) abuf->fields.fmt_51_sth_d.f
1321   EXTRACT_FMT_51_STH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1322
1323   EXTRACT_FMT_51_STH_D_CODE
1324
1325   /* Record the fields for the semantic handler.  */
1326   FLD (f_r1) = & CPU (h_gr)[f_r1];
1327   FLD (f_r2) = & CPU (h_gr)[f_r2];
1328   FLD (f_simm16) = f_simm16;
1329   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_51_sth_d", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
1330
1331   abuf->length = length;
1332   abuf->addr = pc;
1333
1334 #if WITH_PROFILE_MODEL_P
1335   /* Record the fields for profiling.  */
1336   if (PROFILE_MODEL_P (current_cpu))
1337     {
1338       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1339     }
1340 #endif
1341 #undef FLD
1342 }
1343
1344 void
1345 EX_FN_NAME (m32r,fmt_52_st_plus) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1346 {
1347 #define FLD(f) abuf->fields.fmt_52_st_plus.f
1348   EXTRACT_FMT_52_ST_PLUS_VARS /* f-op1 f-r1 f-op2 f-r2 */
1349
1350   EXTRACT_FMT_52_ST_PLUS_CODE
1351
1352   /* Record the fields for the semantic handler.  */
1353   FLD (f_r1) = & CPU (h_gr)[f_r1];
1354   FLD (f_r2) = & CPU (h_gr)[f_r2];
1355   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_52_st_plus", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1356
1357   abuf->length = length;
1358   abuf->addr = pc;
1359
1360 #if WITH_PROFILE_MODEL_P
1361   /* Record the fields for profiling.  */
1362   if (PROFILE_MODEL_P (current_cpu))
1363     {
1364       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1365       abuf->h_gr_set = 0 | (1 << f_r2);
1366     }
1367 #endif
1368 #undef FLD
1369 }
1370
1371 void
1372 EX_FN_NAME (m32r,fmt_53_trap) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1373 {
1374 #define FLD(f) abuf->fields.fmt_53_trap.f
1375   EXTRACT_FMT_53_TRAP_VARS /* f-op1 f-r1 f-op2 f-uimm4 */
1376
1377   EXTRACT_FMT_53_TRAP_CODE
1378
1379   /* Record the fields for the semantic handler.  */
1380   FLD (f_uimm4) = f_uimm4;
1381   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_53_trap", "uimm4 0x%x", 'x', f_uimm4, (char *) 0));
1382
1383   abuf->length = length;
1384   abuf->addr = pc;
1385 #undef FLD
1386 }
1387
1388 void
1389 EX_FN_NAME (m32r,fmt_54_unlock) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1390 {
1391 #define FLD(f) abuf->fields.fmt_54_unlock.f
1392   EXTRACT_FMT_54_UNLOCK_VARS /* f-op1 f-r1 f-op2 f-r2 */
1393
1394   EXTRACT_FMT_54_UNLOCK_CODE
1395
1396   /* Record the fields for the semantic handler.  */
1397   FLD (f_r1) = & CPU (h_gr)[f_r1];
1398   FLD (f_r2) = & CPU (h_gr)[f_r2];
1399   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_54_unlock", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
1400
1401   abuf->length = length;
1402   abuf->addr = pc;
1403
1404 #if WITH_PROFILE_MODEL_P
1405   /* Record the fields for profiling.  */
1406   if (PROFILE_MODEL_P (current_cpu))
1407     {
1408       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1409     }
1410 #endif
1411 #undef FLD
1412 }
1413
1414 void
1415 EX_FN_NAME (m32r,illegal) (SIM_CPU *cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1416 {
1417   abuf->length = CGEN_BASE_INSN_SIZE;
1418   abuf->addr = pc;
1419   /* Leave signalling to semantic fn.  */
1420 }
1421
1422 #if 0 /*wip*/
1423 void
1424 EXC_FN_NAME (m32r,illegal) (SIM_CPU *cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1425 {
1426   abuf->length = CGEN_BASE_INSN_SIZE;
1427   abuf->addr = pc;
1428   /* Leave signalling to semantic fn.  */
1429 }
1430 #endif