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