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_addv3) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 171 {
 172 #define FLD(f) abuf->fields.fmt_5_addv3.f
 173   EXTRACT_FMT_5_ADDV3_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 174
 175   EXTRACT_FMT_5_ADDV3_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   FLD (f_simm16) = f_simm16;
 181   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_5_addv3", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
 182
 183   abuf->length = length;
 184   abuf->addr = pc;
 185
 186 #if WITH_PROFILE_MODEL_P
 187   /* Record the fields for profiling.  */
 188   if (PROFILE_MODEL_P (current_cpu))
 189     {
 190       abuf->h_gr_get = 0 | (1 << f_r2);
 191       abuf->h_gr_set = 0 | (1 << f_r1);
 192     }
 193 #endif
 194 #undef FLD
 195 }
 196
 197 void
 198 EX_FN_NAME (m32r,fmt_6_addx) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 199 {
 200 #define FLD(f) abuf->fields.fmt_6_addx.f
 201   EXTRACT_FMT_6_ADDX_VARS /* f-op1 f-r1 f-op2 f-r2 */
 202
 203   EXTRACT_FMT_6_ADDX_CODE
 204
 205   /* Record the fields for the semantic handler.  */
 206   FLD (f_r1) = & CPU (h_gr)[f_r1];
 207   FLD (f_r2) = & CPU (h_gr)[f_r2];
 208   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_6_addx", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (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_r1) | (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_bc8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 226 {
 227 #define FLD(f) abuf->fields.fmt_7_bc8.f
 228   EXTRACT_FMT_7_BC8_VARS /* f-op1 f-r1 f-disp8 */
 229
 230   EXTRACT_FMT_7_BC8_CODE
 231
 232   /* Record the fields for the semantic handler.  */
 233   RECORD_IADDR (FLD (f_disp8), (pc & -4L) + f_disp8);
 234   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_7_bc8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
 235
 236   abuf->length = length;
 237   abuf->addr = pc;
 238 #undef FLD
 239 }
 240
 241 void
 242 EX_FN_NAME (m32r,fmt_8_bc24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 243 {
 244 #define FLD(f) abuf->fields.fmt_8_bc24.f
 245   EXTRACT_FMT_8_BC24_VARS /* f-op1 f-r1 f-disp24 */
 246
 247   EXTRACT_FMT_8_BC24_CODE
 248
 249   /* Record the fields for the semantic handler.  */
 250   RECORD_IADDR (FLD (f_disp24), pc + f_disp24);
 251   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_8_bc24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
 252
 253   abuf->length = length;
 254   abuf->addr = pc;
 255 #undef FLD
 256 }
 257
 258 void
 259 EX_FN_NAME (m32r,fmt_9_beq) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 260 {
 261 #define FLD(f) abuf->fields.fmt_9_beq.f
 262   EXTRACT_FMT_9_BEQ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 263
 264   EXTRACT_FMT_9_BEQ_CODE
 265
 266   /* Record the fields for the semantic handler.  */
 267   FLD (f_r1) = & CPU (h_gr)[f_r1];
 268   FLD (f_r2) = & CPU (h_gr)[f_r2];
 269   RECORD_IADDR (FLD (f_disp16), pc + f_disp16);
 270   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_9_beq", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "disp16 0x%x", 'x', f_disp16, (char *) 0));
 271
 272   abuf->length = length;
 273   abuf->addr = pc;
 274
 275 #if WITH_PROFILE_MODEL_P
 276   /* Record the fields for profiling.  */
 277   if (PROFILE_MODEL_P (current_cpu))
 278     {
 279       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 280     }
 281 #endif
 282 #undef FLD
 283 }
 284
 285 void
 286 EX_FN_NAME (m32r,fmt_10_beqz) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 287 {
 288 #define FLD(f) abuf->fields.fmt_10_beqz.f
 289   EXTRACT_FMT_10_BEQZ_VARS /* f-op1 f-r1 f-op2 f-r2 f-disp16 */
 290
 291   EXTRACT_FMT_10_BEQZ_CODE
 292
 293   /* Record the fields for the semantic handler.  */
 294   FLD (f_r2) = & CPU (h_gr)[f_r2];
 295   RECORD_IADDR (FLD (f_disp16), pc + f_disp16);
 296   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_10_beqz", "src2 0x%x", 'x', f_r2, "disp16 0x%x", 'x', f_disp16, (char *) 0));
 297
 298   abuf->length = length;
 299   abuf->addr = pc;
 300
 301 #if WITH_PROFILE_MODEL_P
 302   /* Record the fields for profiling.  */
 303   if (PROFILE_MODEL_P (current_cpu))
 304     {
 305       abuf->h_gr_get = 0 | (1 << f_r2);
 306     }
 307 #endif
 308 #undef FLD
 309 }
 310
 311 void
 312 EX_FN_NAME (m32r,fmt_11_bl8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 313 {
 314 #define FLD(f) abuf->fields.fmt_11_bl8.f
 315   EXTRACT_FMT_11_BL8_VARS /* f-op1 f-r1 f-disp8 */
 316
 317   EXTRACT_FMT_11_BL8_CODE
 318
 319   /* Record the fields for the semantic handler.  */
 320   RECORD_IADDR (FLD (f_disp8), (pc & -4L) + f_disp8);
 321   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_11_bl8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
 322
 323   abuf->length = length;
 324   abuf->addr = pc;
 325
 326 #if WITH_PROFILE_MODEL_P
 327   /* Record the fields for profiling.  */
 328   if (PROFILE_MODEL_P (current_cpu))
 329     {
 330       abuf->h_gr_set = 0 | (1 << 14);
 331     }
 332 #endif
 333 #undef FLD
 334 }
 335
 336 void
 337 EX_FN_NAME (m32r,fmt_12_bl24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 338 {
 339 #define FLD(f) abuf->fields.fmt_12_bl24.f
 340   EXTRACT_FMT_12_BL24_VARS /* f-op1 f-r1 f-disp24 */
 341
 342   EXTRACT_FMT_12_BL24_CODE
 343
 344   /* Record the fields for the semantic handler.  */
 345   RECORD_IADDR (FLD (f_disp24), pc + f_disp24);
 346   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_12_bl24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
 347
 348   abuf->length = length;
 349   abuf->addr = pc;
 350
 351 #if WITH_PROFILE_MODEL_P
 352   /* Record the fields for profiling.  */
 353   if (PROFILE_MODEL_P (current_cpu))
 354     {
 355       abuf->h_gr_set = 0 | (1 << 14);
 356     }
 357 #endif
 358 #undef FLD
 359 }
 360
 361 void
 362 EX_FN_NAME (m32r,fmt_13_bra8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 363 {
 364 #define FLD(f) abuf->fields.fmt_13_bra8.f
 365   EXTRACT_FMT_13_BRA8_VARS /* f-op1 f-r1 f-disp8 */
 366
 367   EXTRACT_FMT_13_BRA8_CODE
 368
 369   /* Record the fields for the semantic handler.  */
 370   RECORD_IADDR (FLD (f_disp8), (pc & -4L) + f_disp8);
 371   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_13_bra8", "disp8 0x%x", 'x', f_disp8, (char *) 0));
 372
 373   abuf->length = length;
 374   abuf->addr = pc;
 375 #undef FLD
 376 }
 377
 378 void
 379 EX_FN_NAME (m32r,fmt_14_bra24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 380 {
 381 #define FLD(f) abuf->fields.fmt_14_bra24.f
 382   EXTRACT_FMT_14_BRA24_VARS /* f-op1 f-r1 f-disp24 */
 383
 384   EXTRACT_FMT_14_BRA24_CODE
 385
 386   /* Record the fields for the semantic handler.  */
 387   RECORD_IADDR (FLD (f_disp24), pc + f_disp24);
 388   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_14_bra24", "disp24 0x%x", 'x', f_disp24, (char *) 0));
 389
 390   abuf->length = length;
 391   abuf->addr = pc;
 392 #undef FLD
 393 }
 394
 395 void
 396 EX_FN_NAME (m32r,fmt_15_cmp) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 397 {
 398 #define FLD(f) abuf->fields.fmt_15_cmp.f
 399   EXTRACT_FMT_15_CMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
 400
 401   EXTRACT_FMT_15_CMP_CODE
 402
 403   /* Record the fields for the semantic handler.  */
 404   FLD (f_r1) = & CPU (h_gr)[f_r1];
 405   FLD (f_r2) = & CPU (h_gr)[f_r2];
 406   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_15_cmp", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
 407
 408   abuf->length = length;
 409   abuf->addr = pc;
 410
 411 #if WITH_PROFILE_MODEL_P
 412   /* Record the fields for profiling.  */
 413   if (PROFILE_MODEL_P (current_cpu))
 414     {
 415       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 416     }
 417 #endif
 418 #undef FLD
 419 }
 420
 421 void
 422 EX_FN_NAME (m32r,fmt_16_cmpi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 423 {
 424 #define FLD(f) abuf->fields.fmt_16_cmpi.f
 425   EXTRACT_FMT_16_CMPI_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 426
 427   EXTRACT_FMT_16_CMPI_CODE
 428
 429   /* Record the fields for the semantic handler.  */
 430   FLD (f_r2) = & CPU (h_gr)[f_r2];
 431   FLD (f_simm16) = f_simm16;
 432   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_16_cmpi", "src2 0x%x", 'x', f_r2, "simm16 0x%x", 'x', f_simm16, (char *) 0));
 433
 434   abuf->length = length;
 435   abuf->addr = pc;
 436
 437 #if WITH_PROFILE_MODEL_P
 438   /* Record the fields for profiling.  */
 439   if (PROFILE_MODEL_P (current_cpu))
 440     {
 441       abuf->h_gr_get = 0 | (1 << f_r2);
 442     }
 443 #endif
 444 #undef FLD
 445 }
 446
 447 void
 448 EX_FN_NAME (m32r,fmt_17_cmpui) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 449 {
 450 #define FLD(f) abuf->fields.fmt_17_cmpui.f
 451   EXTRACT_FMT_17_CMPUI_VARS /* f-op1 f-r1 f-op2 f-r2 f-uimm16 */
 452
 453   EXTRACT_FMT_17_CMPUI_CODE
 454
 455   /* Record the fields for the semantic handler.  */
 456   FLD (f_r2) = & CPU (h_gr)[f_r2];
 457   FLD (f_uimm16) = f_uimm16;
 458   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_17_cmpui", "src2 0x%x", 'x', f_r2, "uimm16 0x%x", 'x', f_uimm16, (char *) 0));
 459
 460   abuf->length = length;
 461   abuf->addr = pc;
 462
 463 #if WITH_PROFILE_MODEL_P
 464   /* Record the fields for profiling.  */
 465   if (PROFILE_MODEL_P (current_cpu))
 466     {
 467       abuf->h_gr_get = 0 | (1 << f_r2);
 468     }
 469 #endif
 470 #undef FLD
 471 }
 472
 473 void
 474 EX_FN_NAME (m32r,fmt_18_div) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 475 {
 476 #define FLD(f) abuf->fields.fmt_18_div.f
 477   EXTRACT_FMT_18_DIV_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 478
 479   EXTRACT_FMT_18_DIV_CODE
 480
 481   /* Record the fields for the semantic handler.  */
 482   FLD (f_r1) = & CPU (h_gr)[f_r1];
 483   FLD (f_r2) = & CPU (h_gr)[f_r2];
 484   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_18_div", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 485
 486   abuf->length = length;
 487   abuf->addr = pc;
 488
 489 #if WITH_PROFILE_MODEL_P
 490   /* Record the fields for profiling.  */
 491   if (PROFILE_MODEL_P (current_cpu))
 492     {
 493       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 494       abuf->h_gr_set = 0 | (1 << f_r1);
 495     }
 496 #endif
 497 #undef FLD
 498 }
 499
 500 void
 501 EX_FN_NAME (m32r,fmt_19_jl) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 502 {
 503 #define FLD(f) abuf->fields.fmt_19_jl.f
 504   EXTRACT_FMT_19_JL_VARS /* f-op1 f-r1 f-op2 f-r2 */
 505
 506   EXTRACT_FMT_19_JL_CODE
 507
 508   /* Record the fields for the semantic handler.  */
 509   FLD (f_r2) = & CPU (h_gr)[f_r2];
 510   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_19_jl", "sr 0x%x", 'x', f_r2, (char *) 0));
 511
 512   abuf->length = length;
 513   abuf->addr = pc;
 514
 515 #if WITH_PROFILE_MODEL_P
 516   /* Record the fields for profiling.  */
 517   if (PROFILE_MODEL_P (current_cpu))
 518     {
 519       abuf->h_gr_get = 0 | (1 << f_r2);
 520       abuf->h_gr_set = 0 | (1 << 14);
 521     }
 522 #endif
 523 #undef FLD
 524 }
 525
 526 void
 527 EX_FN_NAME (m32r,fmt_20_jmp) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 528 {
 529 #define FLD(f) abuf->fields.fmt_20_jmp.f
 530   EXTRACT_FMT_20_JMP_VARS /* f-op1 f-r1 f-op2 f-r2 */
 531
 532   EXTRACT_FMT_20_JMP_CODE
 533
 534   /* Record the fields for the semantic handler.  */
 535   FLD (f_r2) = & CPU (h_gr)[f_r2];
 536   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_20_jmp", "sr 0x%x", 'x', f_r2, (char *) 0));
 537
 538   abuf->length = length;
 539   abuf->addr = pc;
 540
 541 #if WITH_PROFILE_MODEL_P
 542   /* Record the fields for profiling.  */
 543   if (PROFILE_MODEL_P (current_cpu))
 544     {
 545       abuf->h_gr_get = 0 | (1 << f_r2);
 546     }
 547 #endif
 548 #undef FLD
 549 }
 550
 551 void
 552 EX_FN_NAME (m32r,fmt_21_ld) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 553 {
 554 #define FLD(f) abuf->fields.fmt_21_ld.f
 555   EXTRACT_FMT_21_LD_VARS /* f-op1 f-r1 f-op2 f-r2 */
 556
 557   EXTRACT_FMT_21_LD_CODE
 558
 559   /* Record the fields for the semantic handler.  */
 560   FLD (f_r1) = & CPU (h_gr)[f_r1];
 561   FLD (f_r2) = & CPU (h_gr)[f_r2];
 562   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_21_ld", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 563
 564   abuf->length = length;
 565   abuf->addr = pc;
 566
 567 #if WITH_PROFILE_MODEL_P
 568   /* Record the fields for profiling.  */
 569   if (PROFILE_MODEL_P (current_cpu))
 570     {
 571       abuf->h_gr_get = 0 | (1 << f_r2);
 572       abuf->h_gr_set = 0 | (1 << f_r1);
 573     }
 574 #endif
 575 #undef FLD
 576 }
 577
 578 void
 579 EX_FN_NAME (m32r,fmt_22_ld_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 580 {
 581 #define FLD(f) abuf->fields.fmt_22_ld_d.f
 582   EXTRACT_FMT_22_LD_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 583
 584   EXTRACT_FMT_22_LD_D_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   FLD (f_simm16) = f_simm16;
 590   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_22_ld_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 591
 592   abuf->length = length;
 593   abuf->addr = pc;
 594
 595 #if WITH_PROFILE_MODEL_P
 596   /* Record the fields for profiling.  */
 597   if (PROFILE_MODEL_P (current_cpu))
 598     {
 599       abuf->h_gr_get = 0 | (1 << f_r2);
 600       abuf->h_gr_set = 0 | (1 << f_r1);
 601     }
 602 #endif
 603 #undef FLD
 604 }
 605
 606 void
 607 EX_FN_NAME (m32r,fmt_23_ldb) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 608 {
 609 #define FLD(f) abuf->fields.fmt_23_ldb.f
 610   EXTRACT_FMT_23_LDB_VARS /* f-op1 f-r1 f-op2 f-r2 */
 611
 612   EXTRACT_FMT_23_LDB_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   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_23_ldb", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (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_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 635 {
 636 #define FLD(f) abuf->fields.fmt_24_ldb_d.f
 637   EXTRACT_FMT_24_LDB_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 638
 639   EXTRACT_FMT_24_LDB_D_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   FLD (f_simm16) = f_simm16;
 645   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_24_ldb_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 646
 647   abuf->length = length;
 648   abuf->addr = pc;
 649
 650 #if WITH_PROFILE_MODEL_P
 651   /* Record the fields for profiling.  */
 652   if (PROFILE_MODEL_P (current_cpu))
 653     {
 654       abuf->h_gr_get = 0 | (1 << f_r2);
 655       abuf->h_gr_set = 0 | (1 << f_r1);
 656     }
 657 #endif
 658 #undef FLD
 659 }
 660
 661 void
 662 EX_FN_NAME (m32r,fmt_25_ldh) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 663 {
 664 #define FLD(f) abuf->fields.fmt_25_ldh.f
 665   EXTRACT_FMT_25_LDH_VARS /* f-op1 f-r1 f-op2 f-r2 */
 666
 667   EXTRACT_FMT_25_LDH_CODE
 668
 669   /* Record the fields for the semantic handler.  */
 670   FLD (f_r1) = & CPU (h_gr)[f_r1];
 671   FLD (f_r2) = & CPU (h_gr)[f_r2];
 672   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_25_ldh", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (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_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 690 {
 691 #define FLD(f) abuf->fields.fmt_26_ldh_d.f
 692   EXTRACT_FMT_26_LDH_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 693
 694   EXTRACT_FMT_26_LDH_D_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   FLD (f_simm16) = f_simm16;
 700   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_26_ldh_d", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 701
 702   abuf->length = length;
 703   abuf->addr = pc;
 704
 705 #if WITH_PROFILE_MODEL_P
 706   /* Record the fields for profiling.  */
 707   if (PROFILE_MODEL_P (current_cpu))
 708     {
 709       abuf->h_gr_get = 0 | (1 << f_r2);
 710       abuf->h_gr_set = 0 | (1 << f_r1);
 711     }
 712 #endif
 713 #undef FLD
 714 }
 715
 716 void
 717 EX_FN_NAME (m32r,fmt_27_ld24) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 718 {
 719 #define FLD(f) abuf->fields.fmt_27_ld24.f
 720   EXTRACT_FMT_27_LD24_VARS /* f-op1 f-r1 f-uimm24 */
 721
 722   EXTRACT_FMT_27_LD24_CODE
 723
 724   /* Record the fields for the semantic handler.  */
 725   FLD (f_r1) = & CPU (h_gr)[f_r1];
 726   FLD (f_uimm24) = f_uimm24;
 727   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_27_ld24", "dr 0x%x", 'x', f_r1, "uimm24 0x%x", 'x', f_uimm24, (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_set = 0 | (1 << f_r1);
 737     }
 738 #endif
 739 #undef FLD
 740 }
 741
 742 void
 743 EX_FN_NAME (m32r,fmt_28_ldi8) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 744 {
 745 #define FLD(f) abuf->fields.fmt_28_ldi8.f
 746   EXTRACT_FMT_28_LDI8_VARS /* f-op1 f-r1 f-simm8 */
 747
 748   EXTRACT_FMT_28_LDI8_CODE
 749
 750   /* Record the fields for the semantic handler.  */
 751   FLD (f_r1) = & CPU (h_gr)[f_r1];
 752   FLD (f_simm8) = f_simm8;
 753   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_28_ldi8", "dr 0x%x", 'x', f_r1, "simm8 0x%x", 'x', f_simm8, (char *) 0));
 754
 755   abuf->length = length;
 756   abuf->addr = pc;
 757
 758 #if WITH_PROFILE_MODEL_P
 759   /* Record the fields for profiling.  */
 760   if (PROFILE_MODEL_P (current_cpu))
 761     {
 762       abuf->h_gr_set = 0 | (1 << f_r1);
 763     }
 764 #endif
 765 #undef FLD
 766 }
 767
 768 void
 769 EX_FN_NAME (m32r,fmt_29_ldi16) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 770 {
 771 #define FLD(f) abuf->fields.fmt_29_ldi16.f
 772   EXTRACT_FMT_29_LDI16_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
 773
 774   EXTRACT_FMT_29_LDI16_CODE
 775
 776   /* Record the fields for the semantic handler.  */
 777   FLD (f_r1) = & CPU (h_gr)[f_r1];
 778   FLD (f_simm16) = f_simm16;
 779   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_29_ldi16", "dr 0x%x", 'x', f_r1, "slo16 0x%x", 'x', f_simm16, (char *) 0));
 780
 781   abuf->length = length;
 782   abuf->addr = pc;
 783
 784 #if WITH_PROFILE_MODEL_P
 785   /* Record the fields for profiling.  */
 786   if (PROFILE_MODEL_P (current_cpu))
 787     {
 788       abuf->h_gr_set = 0 | (1 << f_r1);
 789     }
 790 #endif
 791 #undef FLD
 792 }
 793
 794 void
 795 EX_FN_NAME (m32r,fmt_30_machi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 796 {
 797 #define FLD(f) abuf->fields.fmt_30_machi.f
 798   EXTRACT_FMT_30_MACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 799
 800   EXTRACT_FMT_30_MACHI_CODE
 801
 802   /* Record the fields for the semantic handler.  */
 803   FLD (f_r1) = & CPU (h_gr)[f_r1];
 804   FLD (f_r2) = & CPU (h_gr)[f_r2];
 805   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_30_machi", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, (char *) 0));
 806
 807   abuf->length = length;
 808   abuf->addr = pc;
 809
 810 #if WITH_PROFILE_MODEL_P
 811   /* Record the fields for profiling.  */
 812   if (PROFILE_MODEL_P (current_cpu))
 813     {
 814       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
 815     }
 816 #endif
 817 #undef FLD
 818 }
 819
 820 void
 821 EX_FN_NAME (m32r,fmt_31_mv) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 822 {
 823 #define FLD(f) abuf->fields.fmt_31_mv.f
 824   EXTRACT_FMT_31_MV_VARS /* f-op1 f-r1 f-op2 f-r2 */
 825
 826   EXTRACT_FMT_31_MV_CODE
 827
 828   /* Record the fields for the semantic handler.  */
 829   FLD (f_r1) = & CPU (h_gr)[f_r1];
 830   FLD (f_r2) = & CPU (h_gr)[f_r2];
 831   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_31_mv", "dr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 832
 833   abuf->length = length;
 834   abuf->addr = pc;
 835
 836 #if WITH_PROFILE_MODEL_P
 837   /* Record the fields for profiling.  */
 838   if (PROFILE_MODEL_P (current_cpu))
 839     {
 840       abuf->h_gr_get = 0 | (1 << f_r2);
 841       abuf->h_gr_set = 0 | (1 << f_r1);
 842     }
 843 #endif
 844 #undef FLD
 845 }
 846
 847 void
 848 EX_FN_NAME (m32r,fmt_32_mvfachi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 849 {
 850 #define FLD(f) abuf->fields.fmt_32_mvfachi.f
 851   EXTRACT_FMT_32_MVFACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 852
 853   EXTRACT_FMT_32_MVFACHI_CODE
 854
 855   /* Record the fields for the semantic handler.  */
 856   FLD (f_r1) = & CPU (h_gr)[f_r1];
 857   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_32_mvfachi", "dr 0x%x", 'x', f_r1, (char *) 0));
 858
 859   abuf->length = length;
 860   abuf->addr = pc;
 861
 862 #if WITH_PROFILE_MODEL_P
 863   /* Record the fields for profiling.  */
 864   if (PROFILE_MODEL_P (current_cpu))
 865     {
 866       abuf->h_gr_set = 0 | (1 << f_r1);
 867     }
 868 #endif
 869 #undef FLD
 870 }
 871
 872 void
 873 EX_FN_NAME (m32r,fmt_33_mvfc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 874 {
 875 #define FLD(f) abuf->fields.fmt_33_mvfc.f
 876   EXTRACT_FMT_33_MVFC_VARS /* f-op1 f-r1 f-op2 f-r2 */
 877
 878   EXTRACT_FMT_33_MVFC_CODE
 879
 880   /* Record the fields for the semantic handler.  */
 881   FLD (f_r1) = & CPU (h_gr)[f_r1];
 882   FLD (f_r2) = f_r2;
 883   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_33_mvfc", "dr 0x%x", 'x', f_r1, "scr 0x%x", 'x', f_r2, (char *) 0));
 884
 885   abuf->length = length;
 886   abuf->addr = pc;
 887
 888 #if WITH_PROFILE_MODEL_P
 889   /* Record the fields for profiling.  */
 890   if (PROFILE_MODEL_P (current_cpu))
 891     {
 892       abuf->h_gr_set = 0 | (1 << f_r1);
 893     }
 894 #endif
 895 #undef FLD
 896 }
 897
 898 void
 899 EX_FN_NAME (m32r,fmt_34_mvtachi) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 900 {
 901 #define FLD(f) abuf->fields.fmt_34_mvtachi.f
 902   EXTRACT_FMT_34_MVTACHI_VARS /* f-op1 f-r1 f-op2 f-r2 */
 903
 904   EXTRACT_FMT_34_MVTACHI_CODE
 905
 906   /* Record the fields for the semantic handler.  */
 907   FLD (f_r1) = & CPU (h_gr)[f_r1];
 908   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_34_mvtachi", "src1 0x%x", 'x', f_r1, (char *) 0));
 909
 910   abuf->length = length;
 911   abuf->addr = pc;
 912
 913 #if WITH_PROFILE_MODEL_P
 914   /* Record the fields for profiling.  */
 915   if (PROFILE_MODEL_P (current_cpu))
 916     {
 917       abuf->h_gr_get = 0 | (1 << f_r1);
 918     }
 919 #endif
 920 #undef FLD
 921 }
 922
 923 void
 924 EX_FN_NAME (m32r,fmt_35_mvtc) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 925 {
 926 #define FLD(f) abuf->fields.fmt_35_mvtc.f
 927   EXTRACT_FMT_35_MVTC_VARS /* f-op1 f-r1 f-op2 f-r2 */
 928
 929   EXTRACT_FMT_35_MVTC_CODE
 930
 931   /* Record the fields for the semantic handler.  */
 932   FLD (f_r1) = f_r1;
 933   FLD (f_r2) = & CPU (h_gr)[f_r2];
 934   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_35_mvtc", "dcr 0x%x", 'x', f_r1, "sr 0x%x", 'x', f_r2, (char *) 0));
 935
 936   abuf->length = length;
 937   abuf->addr = pc;
 938
 939 #if WITH_PROFILE_MODEL_P
 940   /* Record the fields for profiling.  */
 941   if (PROFILE_MODEL_P (current_cpu))
 942     {
 943       abuf->h_gr_get = 0 | (1 << f_r2);
 944     }
 945 #endif
 946 #undef FLD
 947 }
 948
 949 void
 950 EX_FN_NAME (m32r,fmt_36_nop) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 951 {
 952 #define FLD(f) abuf->fields.fmt_36_nop.f
 953   EXTRACT_FMT_36_NOP_VARS /* f-op1 f-r1 f-op2 f-r2 */
 954
 955   EXTRACT_FMT_36_NOP_CODE
 956
 957   /* Record the fields for the semantic handler.  */
 958   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_36_nop", (char *) 0));
 959
 960   abuf->length = length;
 961   abuf->addr = pc;
 962 #undef FLD
 963 }
 964
 965 void
 966 EX_FN_NAME (m32r,fmt_37_rac) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 967 {
 968 #define FLD(f) abuf->fields.fmt_37_rac.f
 969   EXTRACT_FMT_37_RAC_VARS /* f-op1 f-r1 f-op2 f-r2 */
 970
 971   EXTRACT_FMT_37_RAC_CODE
 972
 973   /* Record the fields for the semantic handler.  */
 974   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_37_rac", (char *) 0));
 975
 976   abuf->length = length;
 977   abuf->addr = pc;
 978 #undef FLD
 979 }
 980
 981 void
 982 EX_FN_NAME (m32r,fmt_38_rte) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 983 {
 984 #define FLD(f) abuf->fields.fmt_38_rte.f
 985   EXTRACT_FMT_38_RTE_VARS /* f-op1 f-r1 f-op2 f-r2 */
 986
 987   EXTRACT_FMT_38_RTE_CODE
 988
 989   /* Record the fields for the semantic handler.  */
 990   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_38_rte", (char *) 0));
 991
 992   abuf->length = length;
 993   abuf->addr = pc;
 994 #undef FLD
 995 }
 996
 997 void
 998 EX_FN_NAME (m32r,fmt_39_seth) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
 999 {
1000 #define FLD(f) abuf->fields.fmt_39_seth.f
1001   EXTRACT_FMT_39_SETH_VARS /* f-op1 f-r1 f-op2 f-r2 f-hi16 */
1002
1003   EXTRACT_FMT_39_SETH_CODE
1004
1005   /* Record the fields for the semantic handler.  */
1006   FLD (f_r1) = & CPU (h_gr)[f_r1];
1007   FLD (f_hi16) = f_hi16;
1008   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_39_seth", "dr 0x%x", 'x', f_r1, "hi16 0x%x", 'x', f_hi16, (char *) 0));
1009
1010   abuf->length = length;
1011   abuf->addr = pc;
1012
1013 #if WITH_PROFILE_MODEL_P
1014   /* Record the fields for profiling.  */
1015   if (PROFILE_MODEL_P (current_cpu))
1016     {
1017       abuf->h_gr_set = 0 | (1 << f_r1);
1018     }
1019 #endif
1020 #undef FLD
1021 }
1022
1023 void
1024 EX_FN_NAME (m32r,fmt_40_slli) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1025 {
1026 #define FLD(f) abuf->fields.fmt_40_slli.f
1027   EXTRACT_FMT_40_SLLI_VARS /* f-op1 f-r1 f-shift-op2 f-uimm5 */
1028
1029   EXTRACT_FMT_40_SLLI_CODE
1030
1031   /* Record the fields for the semantic handler.  */
1032   FLD (f_r1) = & CPU (h_gr)[f_r1];
1033   FLD (f_uimm5) = f_uimm5;
1034   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_40_slli", "dr 0x%x", 'x', f_r1, "uimm5 0x%x", 'x', f_uimm5, (char *) 0));
1035
1036   abuf->length = length;
1037   abuf->addr = pc;
1038
1039 #if WITH_PROFILE_MODEL_P
1040   /* Record the fields for profiling.  */
1041   if (PROFILE_MODEL_P (current_cpu))
1042     {
1043       abuf->h_gr_get = 0 | (1 << f_r1);
1044       abuf->h_gr_set = 0 | (1 << f_r1);
1045     }
1046 #endif
1047 #undef FLD
1048 }
1049
1050 void
1051 EX_FN_NAME (m32r,fmt_41_st_d) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1052 {
1053 #define FLD(f) abuf->fields.fmt_41_st_d.f
1054   EXTRACT_FMT_41_ST_D_VARS /* f-op1 f-r1 f-op2 f-r2 f-simm16 */
1055
1056   EXTRACT_FMT_41_ST_D_CODE
1057
1058   /* Record the fields for the semantic handler.  */
1059   FLD (f_r1) = & CPU (h_gr)[f_r1];
1060   FLD (f_r2) = & CPU (h_gr)[f_r2];
1061   FLD (f_simm16) = f_simm16;
1062   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_41_st_d", "src1 0x%x", 'x', f_r1, "src2 0x%x", 'x', f_r2, "slo16 0x%x", 'x', f_simm16, (char *) 0));
1063
1064   abuf->length = length;
1065   abuf->addr = pc;
1066
1067 #if WITH_PROFILE_MODEL_P
1068   /* Record the fields for profiling.  */
1069   if (PROFILE_MODEL_P (current_cpu))
1070     {
1071       abuf->h_gr_get = 0 | (1 << f_r1) | (1 << f_r2);
1072     }
1073 #endif
1074 #undef FLD
1075 }
1076
1077 void
1078 EX_FN_NAME (m32r,fmt_42_trap) (SIM_CPU *current_cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1079 {
1080 #define FLD(f) abuf->fields.fmt_42_trap.f
1081   EXTRACT_FMT_42_TRAP_VARS /* f-op1 f-r1 f-op2 f-uimm4 */
1082
1083   EXTRACT_FMT_42_TRAP_CODE
1084
1085   /* Record the fields for the semantic handler.  */
1086   FLD (f_uimm4) = f_uimm4;
1087   TRACE_EXTRACT (current_cpu, (current_cpu, pc, "fmt_42_trap", "uimm4 0x%x", 'x', f_uimm4, (char *) 0));
1088
1089   abuf->length = length;
1090   abuf->addr = pc;
1091 #undef FLD
1092 }
1093
1094 void
1095 EX_FN_NAME (m32r,illegal) (SIM_CPU *cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1096 {
1097   abuf->length = CGEN_BASE_INSN_SIZE;
1098   abuf->addr = pc;
1099   /* Leave signalling to semantic fn.  */
1100 }
1101
1102 #if 0 /*wip*/
1103 void
1104 EXC_FN_NAME (m32r,illegal) (SIM_CPU *cpu, PCADDR pc, insn_t insn, ARGBUF *abuf)
1105 {
1106   abuf->length = CGEN_BASE_INSN_SIZE;
1107   abuf->addr = pc;
1108   /* Leave signalling to semantic fn.  */
1109 }
1110 #endif