sim/m32r/sem2-switch.c

   1 /* Simulator instruction semantics for m32r2f.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 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 3 of the License, or
  12 (at your option) 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
  20 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21
  22 */
  23
  24 #ifdef DEFINE_LABELS
  25
  26   /* The labels have the case they have because the enum of insn types
  27      is all uppercase and in the non-stdc case the insn symbol is built
  28      into the enum name.  */
  29
  30   static struct {
  31     int index;
  32     void *label;
  33   } labels[] = {
  34     { M32R2F_INSN_X_INVALID, && case_sem_INSN_X_INVALID },
  35     { M32R2F_INSN_X_AFTER, && case_sem_INSN_X_AFTER },
  36     { M32R2F_INSN_X_BEFORE, && case_sem_INSN_X_BEFORE },
  37     { M32R2F_INSN_X_CTI_CHAIN, && case_sem_INSN_X_CTI_CHAIN },
  38     { M32R2F_INSN_X_CHAIN, && case_sem_INSN_X_CHAIN },
  39     { M32R2F_INSN_X_BEGIN, && case_sem_INSN_X_BEGIN },
  40     { M32R2F_INSN_ADD, && case_sem_INSN_ADD },
  41     { M32R2F_INSN_ADD3, && case_sem_INSN_ADD3 },
  42     { M32R2F_INSN_AND, && case_sem_INSN_AND },
  43     { M32R2F_INSN_AND3, && case_sem_INSN_AND3 },
  44     { M32R2F_INSN_OR, && case_sem_INSN_OR },
  45     { M32R2F_INSN_OR3, && case_sem_INSN_OR3 },
  46     { M32R2F_INSN_XOR, && case_sem_INSN_XOR },
  47     { M32R2F_INSN_XOR3, && case_sem_INSN_XOR3 },
  48     { M32R2F_INSN_ADDI, && case_sem_INSN_ADDI },
  49     { M32R2F_INSN_ADDV, && case_sem_INSN_ADDV },
  50     { M32R2F_INSN_ADDV3, && case_sem_INSN_ADDV3 },
  51     { M32R2F_INSN_ADDX, && case_sem_INSN_ADDX },
  52     { M32R2F_INSN_BC8, && case_sem_INSN_BC8 },
  53     { M32R2F_INSN_BC24, && case_sem_INSN_BC24 },
  54     { M32R2F_INSN_BEQ, && case_sem_INSN_BEQ },
  55     { M32R2F_INSN_BEQZ, && case_sem_INSN_BEQZ },
  56     { M32R2F_INSN_BGEZ, && case_sem_INSN_BGEZ },
  57     { M32R2F_INSN_BGTZ, && case_sem_INSN_BGTZ },
  58     { M32R2F_INSN_BLEZ, && case_sem_INSN_BLEZ },
  59     { M32R2F_INSN_BLTZ, && case_sem_INSN_BLTZ },
  60     { M32R2F_INSN_BNEZ, && case_sem_INSN_BNEZ },
  61     { M32R2F_INSN_BL8, && case_sem_INSN_BL8 },
  62     { M32R2F_INSN_BL24, && case_sem_INSN_BL24 },
  63     { M32R2F_INSN_BCL8, && case_sem_INSN_BCL8 },
  64     { M32R2F_INSN_BCL24, && case_sem_INSN_BCL24 },
  65     { M32R2F_INSN_BNC8, && case_sem_INSN_BNC8 },
  66     { M32R2F_INSN_BNC24, && case_sem_INSN_BNC24 },
  67     { M32R2F_INSN_BNE, && case_sem_INSN_BNE },
  68     { M32R2F_INSN_BRA8, && case_sem_INSN_BRA8 },
  69     { M32R2F_INSN_BRA24, && case_sem_INSN_BRA24 },
  70     { M32R2F_INSN_BNCL8, && case_sem_INSN_BNCL8 },
  71     { M32R2F_INSN_BNCL24, && case_sem_INSN_BNCL24 },
  72     { M32R2F_INSN_CMP, && case_sem_INSN_CMP },
  73     { M32R2F_INSN_CMPI, && case_sem_INSN_CMPI },
  74     { M32R2F_INSN_CMPU, && case_sem_INSN_CMPU },
  75     { M32R2F_INSN_CMPUI, && case_sem_INSN_CMPUI },
  76     { M32R2F_INSN_CMPEQ, && case_sem_INSN_CMPEQ },
  77     { M32R2F_INSN_CMPZ, && case_sem_INSN_CMPZ },
  78     { M32R2F_INSN_DIV, && case_sem_INSN_DIV },
  79     { M32R2F_INSN_DIVU, && case_sem_INSN_DIVU },
  80     { M32R2F_INSN_REM, && case_sem_INSN_REM },
  81     { M32R2F_INSN_REMU, && case_sem_INSN_REMU },
  82     { M32R2F_INSN_REMH, && case_sem_INSN_REMH },
  83     { M32R2F_INSN_REMUH, && case_sem_INSN_REMUH },
  84     { M32R2F_INSN_REMB, && case_sem_INSN_REMB },
  85     { M32R2F_INSN_REMUB, && case_sem_INSN_REMUB },
  86     { M32R2F_INSN_DIVUH, && case_sem_INSN_DIVUH },
  87     { M32R2F_INSN_DIVB, && case_sem_INSN_DIVB },
  88     { M32R2F_INSN_DIVUB, && case_sem_INSN_DIVUB },
  89     { M32R2F_INSN_DIVH, && case_sem_INSN_DIVH },
  90     { M32R2F_INSN_JC, && case_sem_INSN_JC },
  91     { M32R2F_INSN_JNC, && case_sem_INSN_JNC },
  92     { M32R2F_INSN_JL, && case_sem_INSN_JL },
  93     { M32R2F_INSN_JMP, && case_sem_INSN_JMP },
  94     { M32R2F_INSN_LD, && case_sem_INSN_LD },
  95     { M32R2F_INSN_LD_D, && case_sem_INSN_LD_D },
  96     { M32R2F_INSN_LDB, && case_sem_INSN_LDB },
  97     { M32R2F_INSN_LDB_D, && case_sem_INSN_LDB_D },
  98     { M32R2F_INSN_LDH, && case_sem_INSN_LDH },
  99     { M32R2F_INSN_LDH_D, && case_sem_INSN_LDH_D },
 100     { M32R2F_INSN_LDUB, && case_sem_INSN_LDUB },
 101     { M32R2F_INSN_LDUB_D, && case_sem_INSN_LDUB_D },
 102     { M32R2F_INSN_LDUH, && case_sem_INSN_LDUH },
 103     { M32R2F_INSN_LDUH_D, && case_sem_INSN_LDUH_D },
 104     { M32R2F_INSN_LD_PLUS, && case_sem_INSN_LD_PLUS },
 105     { M32R2F_INSN_LD24, && case_sem_INSN_LD24 },
 106     { M32R2F_INSN_LDI8, && case_sem_INSN_LDI8 },
 107     { M32R2F_INSN_LDI16, && case_sem_INSN_LDI16 },
 108     { M32R2F_INSN_LOCK, && case_sem_INSN_LOCK },
 109     { M32R2F_INSN_MACHI_A, && case_sem_INSN_MACHI_A },
 110     { M32R2F_INSN_MACLO_A, && case_sem_INSN_MACLO_A },
 111     { M32R2F_INSN_MACWHI_A, && case_sem_INSN_MACWHI_A },
 112     { M32R2F_INSN_MACWLO_A, && case_sem_INSN_MACWLO_A },
 113     { M32R2F_INSN_MUL, && case_sem_INSN_MUL },
 114     { M32R2F_INSN_MULHI_A, && case_sem_INSN_MULHI_A },
 115     { M32R2F_INSN_MULLO_A, && case_sem_INSN_MULLO_A },
 116     { M32R2F_INSN_MULWHI_A, && case_sem_INSN_MULWHI_A },
 117     { M32R2F_INSN_MULWLO_A, && case_sem_INSN_MULWLO_A },
 118     { M32R2F_INSN_MV, && case_sem_INSN_MV },
 119     { M32R2F_INSN_MVFACHI_A, && case_sem_INSN_MVFACHI_A },
 120     { M32R2F_INSN_MVFACLO_A, && case_sem_INSN_MVFACLO_A },
 121     { M32R2F_INSN_MVFACMI_A, && case_sem_INSN_MVFACMI_A },
 122     { M32R2F_INSN_MVFC, && case_sem_INSN_MVFC },
 123     { M32R2F_INSN_MVTACHI_A, && case_sem_INSN_MVTACHI_A },
 124     { M32R2F_INSN_MVTACLO_A, && case_sem_INSN_MVTACLO_A },
 125     { M32R2F_INSN_MVTC, && case_sem_INSN_MVTC },
 126     { M32R2F_INSN_NEG, && case_sem_INSN_NEG },
 127     { M32R2F_INSN_NOP, && case_sem_INSN_NOP },
 128     { M32R2F_INSN_NOT, && case_sem_INSN_NOT },
 129     { M32R2F_INSN_RAC_DSI, && case_sem_INSN_RAC_DSI },
 130     { M32R2F_INSN_RACH_DSI, && case_sem_INSN_RACH_DSI },
 131     { M32R2F_INSN_RTE, && case_sem_INSN_RTE },
 132     { M32R2F_INSN_SETH, && case_sem_INSN_SETH },
 133     { M32R2F_INSN_SLL, && case_sem_INSN_SLL },
 134     { M32R2F_INSN_SLL3, && case_sem_INSN_SLL3 },
 135     { M32R2F_INSN_SLLI, && case_sem_INSN_SLLI },
 136     { M32R2F_INSN_SRA, && case_sem_INSN_SRA },
 137     { M32R2F_INSN_SRA3, && case_sem_INSN_SRA3 },
 138     { M32R2F_INSN_SRAI, && case_sem_INSN_SRAI },
 139     { M32R2F_INSN_SRL, && case_sem_INSN_SRL },
 140     { M32R2F_INSN_SRL3, && case_sem_INSN_SRL3 },
 141     { M32R2F_INSN_SRLI, && case_sem_INSN_SRLI },
 142     { M32R2F_INSN_ST, && case_sem_INSN_ST },
 143     { M32R2F_INSN_ST_D, && case_sem_INSN_ST_D },
 144     { M32R2F_INSN_STB, && case_sem_INSN_STB },
 145     { M32R2F_INSN_STB_D, && case_sem_INSN_STB_D },
 146     { M32R2F_INSN_STH, && case_sem_INSN_STH },
 147     { M32R2F_INSN_STH_D, && case_sem_INSN_STH_D },
 148     { M32R2F_INSN_ST_PLUS, && case_sem_INSN_ST_PLUS },
 149     { M32R2F_INSN_STH_PLUS, && case_sem_INSN_STH_PLUS },
 150     { M32R2F_INSN_STB_PLUS, && case_sem_INSN_STB_PLUS },
 151     { M32R2F_INSN_ST_MINUS, && case_sem_INSN_ST_MINUS },
 152     { M32R2F_INSN_SUB, && case_sem_INSN_SUB },
 153     { M32R2F_INSN_SUBV, && case_sem_INSN_SUBV },
 154     { M32R2F_INSN_SUBX, && case_sem_INSN_SUBX },
 155     { M32R2F_INSN_TRAP, && case_sem_INSN_TRAP },
 156     { M32R2F_INSN_UNLOCK, && case_sem_INSN_UNLOCK },
 157     { M32R2F_INSN_SATB, && case_sem_INSN_SATB },
 158     { M32R2F_INSN_SATH, && case_sem_INSN_SATH },
 159     { M32R2F_INSN_SAT, && case_sem_INSN_SAT },
 160     { M32R2F_INSN_PCMPBZ, && case_sem_INSN_PCMPBZ },
 161     { M32R2F_INSN_SADD, && case_sem_INSN_SADD },
 162     { M32R2F_INSN_MACWU1, && case_sem_INSN_MACWU1 },
 163     { M32R2F_INSN_MSBLO, && case_sem_INSN_MSBLO },
 164     { M32R2F_INSN_MULWU1, && case_sem_INSN_MULWU1 },
 165     { M32R2F_INSN_MACLH1, && case_sem_INSN_MACLH1 },
 166     { M32R2F_INSN_SC, && case_sem_INSN_SC },
 167     { M32R2F_INSN_SNC, && case_sem_INSN_SNC },
 168     { M32R2F_INSN_CLRPSW, && case_sem_INSN_CLRPSW },
 169     { M32R2F_INSN_SETPSW, && case_sem_INSN_SETPSW },
 170     { M32R2F_INSN_BSET, && case_sem_INSN_BSET },
 171     { M32R2F_INSN_BCLR, && case_sem_INSN_BCLR },
 172     { M32R2F_INSN_BTST, && case_sem_INSN_BTST },
 173     { M32R2F_INSN_PAR_ADD, && case_sem_INSN_PAR_ADD },
 174     { M32R2F_INSN_WRITE_ADD, && case_sem_INSN_WRITE_ADD },
 175     { M32R2F_INSN_PAR_AND, && case_sem_INSN_PAR_AND },
 176     { M32R2F_INSN_WRITE_AND, && case_sem_INSN_WRITE_AND },
 177     { M32R2F_INSN_PAR_OR, && case_sem_INSN_PAR_OR },
 178     { M32R2F_INSN_WRITE_OR, && case_sem_INSN_WRITE_OR },
 179     { M32R2F_INSN_PAR_XOR, && case_sem_INSN_PAR_XOR },
 180     { M32R2F_INSN_WRITE_XOR, && case_sem_INSN_WRITE_XOR },
 181     { M32R2F_INSN_PAR_ADDI, && case_sem_INSN_PAR_ADDI },
 182     { M32R2F_INSN_WRITE_ADDI, && case_sem_INSN_WRITE_ADDI },
 183     { M32R2F_INSN_PAR_ADDV, && case_sem_INSN_PAR_ADDV },
 184     { M32R2F_INSN_WRITE_ADDV, && case_sem_INSN_WRITE_ADDV },
 185     { M32R2F_INSN_PAR_ADDX, && case_sem_INSN_PAR_ADDX },
 186     { M32R2F_INSN_WRITE_ADDX, && case_sem_INSN_WRITE_ADDX },
 187     { M32R2F_INSN_PAR_BC8, && case_sem_INSN_PAR_BC8 },
 188     { M32R2F_INSN_WRITE_BC8, && case_sem_INSN_WRITE_BC8 },
 189     { M32R2F_INSN_PAR_BL8, && case_sem_INSN_PAR_BL8 },
 190     { M32R2F_INSN_WRITE_BL8, && case_sem_INSN_WRITE_BL8 },
 191     { M32R2F_INSN_PAR_BCL8, && case_sem_INSN_PAR_BCL8 },
 192     { M32R2F_INSN_WRITE_BCL8, && case_sem_INSN_WRITE_BCL8 },
 193     { M32R2F_INSN_PAR_BNC8, && case_sem_INSN_PAR_BNC8 },
 194     { M32R2F_INSN_WRITE_BNC8, && case_sem_INSN_WRITE_BNC8 },
 195     { M32R2F_INSN_PAR_BRA8, && case_sem_INSN_PAR_BRA8 },
 196     { M32R2F_INSN_WRITE_BRA8, && case_sem_INSN_WRITE_BRA8 },
 197     { M32R2F_INSN_PAR_BNCL8, && case_sem_INSN_PAR_BNCL8 },
 198     { M32R2F_INSN_WRITE_BNCL8, && case_sem_INSN_WRITE_BNCL8 },
 199     { M32R2F_INSN_PAR_CMP, && case_sem_INSN_PAR_CMP },
 200     { M32R2F_INSN_WRITE_CMP, && case_sem_INSN_WRITE_CMP },
 201     { M32R2F_INSN_PAR_CMPU, && case_sem_INSN_PAR_CMPU },
 202     { M32R2F_INSN_WRITE_CMPU, && case_sem_INSN_WRITE_CMPU },
 203     { M32R2F_INSN_PAR_CMPEQ, && case_sem_INSN_PAR_CMPEQ },
 204     { M32R2F_INSN_WRITE_CMPEQ, && case_sem_INSN_WRITE_CMPEQ },
 205     { M32R2F_INSN_PAR_CMPZ, && case_sem_INSN_PAR_CMPZ },
 206     { M32R2F_INSN_WRITE_CMPZ, && case_sem_INSN_WRITE_CMPZ },
 207     { M32R2F_INSN_PAR_JC, && case_sem_INSN_PAR_JC },
 208     { M32R2F_INSN_WRITE_JC, && case_sem_INSN_WRITE_JC },
 209     { M32R2F_INSN_PAR_JNC, && case_sem_INSN_PAR_JNC },
 210     { M32R2F_INSN_WRITE_JNC, && case_sem_INSN_WRITE_JNC },
 211     { M32R2F_INSN_PAR_JL, && case_sem_INSN_PAR_JL },
 212     { M32R2F_INSN_WRITE_JL, && case_sem_INSN_WRITE_JL },
 213     { M32R2F_INSN_PAR_JMP, && case_sem_INSN_PAR_JMP },
 214     { M32R2F_INSN_WRITE_JMP, && case_sem_INSN_WRITE_JMP },
 215     { M32R2F_INSN_PAR_LD, && case_sem_INSN_PAR_LD },
 216     { M32R2F_INSN_WRITE_LD, && case_sem_INSN_WRITE_LD },
 217     { M32R2F_INSN_PAR_LDB, && case_sem_INSN_PAR_LDB },
 218     { M32R2F_INSN_WRITE_LDB, && case_sem_INSN_WRITE_LDB },
 219     { M32R2F_INSN_PAR_LDH, && case_sem_INSN_PAR_LDH },
 220     { M32R2F_INSN_WRITE_LDH, && case_sem_INSN_WRITE_LDH },
 221     { M32R2F_INSN_PAR_LDUB, && case_sem_INSN_PAR_LDUB },
 222     { M32R2F_INSN_WRITE_LDUB, && case_sem_INSN_WRITE_LDUB },
 223     { M32R2F_INSN_PAR_LDUH, && case_sem_INSN_PAR_LDUH },
 224     { M32R2F_INSN_WRITE_LDUH, && case_sem_INSN_WRITE_LDUH },
 225     { M32R2F_INSN_PAR_LD_PLUS, && case_sem_INSN_PAR_LD_PLUS },
 226     { M32R2F_INSN_WRITE_LD_PLUS, && case_sem_INSN_WRITE_LD_PLUS },
 227     { M32R2F_INSN_PAR_LDI8, && case_sem_INSN_PAR_LDI8 },
 228     { M32R2F_INSN_WRITE_LDI8, && case_sem_INSN_WRITE_LDI8 },
 229     { M32R2F_INSN_PAR_LOCK, && case_sem_INSN_PAR_LOCK },
 230     { M32R2F_INSN_WRITE_LOCK, && case_sem_INSN_WRITE_LOCK },
 231     { M32R2F_INSN_PAR_MACHI_A, && case_sem_INSN_PAR_MACHI_A },
 232     { M32R2F_INSN_WRITE_MACHI_A, && case_sem_INSN_WRITE_MACHI_A },
 233     { M32R2F_INSN_PAR_MACLO_A, && case_sem_INSN_PAR_MACLO_A },
 234     { M32R2F_INSN_WRITE_MACLO_A, && case_sem_INSN_WRITE_MACLO_A },
 235     { M32R2F_INSN_PAR_MACWHI_A, && case_sem_INSN_PAR_MACWHI_A },
 236     { M32R2F_INSN_WRITE_MACWHI_A, && case_sem_INSN_WRITE_MACWHI_A },
 237     { M32R2F_INSN_PAR_MACWLO_A, && case_sem_INSN_PAR_MACWLO_A },
 238     { M32R2F_INSN_WRITE_MACWLO_A, && case_sem_INSN_WRITE_MACWLO_A },
 239     { M32R2F_INSN_PAR_MUL, && case_sem_INSN_PAR_MUL },
 240     { M32R2F_INSN_WRITE_MUL, && case_sem_INSN_WRITE_MUL },
 241     { M32R2F_INSN_PAR_MULHI_A, && case_sem_INSN_PAR_MULHI_A },
 242     { M32R2F_INSN_WRITE_MULHI_A, && case_sem_INSN_WRITE_MULHI_A },
 243     { M32R2F_INSN_PAR_MULLO_A, && case_sem_INSN_PAR_MULLO_A },
 244     { M32R2F_INSN_WRITE_MULLO_A, && case_sem_INSN_WRITE_MULLO_A },
 245     { M32R2F_INSN_PAR_MULWHI_A, && case_sem_INSN_PAR_MULWHI_A },
 246     { M32R2F_INSN_WRITE_MULWHI_A, && case_sem_INSN_WRITE_MULWHI_A },
 247     { M32R2F_INSN_PAR_MULWLO_A, && case_sem_INSN_PAR_MULWLO_A },
 248     { M32R2F_INSN_WRITE_MULWLO_A, && case_sem_INSN_WRITE_MULWLO_A },
 249     { M32R2F_INSN_PAR_MV, && case_sem_INSN_PAR_MV },
 250     { M32R2F_INSN_WRITE_MV, && case_sem_INSN_WRITE_MV },
 251     { M32R2F_INSN_PAR_MVFACHI_A, && case_sem_INSN_PAR_MVFACHI_A },
 252     { M32R2F_INSN_WRITE_MVFACHI_A, && case_sem_INSN_WRITE_MVFACHI_A },
 253     { M32R2F_INSN_PAR_MVFACLO_A, && case_sem_INSN_PAR_MVFACLO_A },
 254     { M32R2F_INSN_WRITE_MVFACLO_A, && case_sem_INSN_WRITE_MVFACLO_A },
 255     { M32R2F_INSN_PAR_MVFACMI_A, && case_sem_INSN_PAR_MVFACMI_A },
 256     { M32R2F_INSN_WRITE_MVFACMI_A, && case_sem_INSN_WRITE_MVFACMI_A },
 257     { M32R2F_INSN_PAR_MVFC, && case_sem_INSN_PAR_MVFC },
 258     { M32R2F_INSN_WRITE_MVFC, && case_sem_INSN_WRITE_MVFC },
 259     { M32R2F_INSN_PAR_MVTACHI_A, && case_sem_INSN_PAR_MVTACHI_A },
 260     { M32R2F_INSN_WRITE_MVTACHI_A, && case_sem_INSN_WRITE_MVTACHI_A },
 261     { M32R2F_INSN_PAR_MVTACLO_A, && case_sem_INSN_PAR_MVTACLO_A },
 262     { M32R2F_INSN_WRITE_MVTACLO_A, && case_sem_INSN_WRITE_MVTACLO_A },
 263     { M32R2F_INSN_PAR_MVTC, && case_sem_INSN_PAR_MVTC },
 264     { M32R2F_INSN_WRITE_MVTC, && case_sem_INSN_WRITE_MVTC },
 265     { M32R2F_INSN_PAR_NEG, && case_sem_INSN_PAR_NEG },
 266     { M32R2F_INSN_WRITE_NEG, && case_sem_INSN_WRITE_NEG },
 267     { M32R2F_INSN_PAR_NOP, && case_sem_INSN_PAR_NOP },
 268     { M32R2F_INSN_WRITE_NOP, && case_sem_INSN_WRITE_NOP },
 269     { M32R2F_INSN_PAR_NOT, && case_sem_INSN_PAR_NOT },
 270     { M32R2F_INSN_WRITE_NOT, && case_sem_INSN_WRITE_NOT },
 271     { M32R2F_INSN_PAR_RAC_DSI, && case_sem_INSN_PAR_RAC_DSI },
 272     { M32R2F_INSN_WRITE_RAC_DSI, && case_sem_INSN_WRITE_RAC_DSI },
 273     { M32R2F_INSN_PAR_RACH_DSI, && case_sem_INSN_PAR_RACH_DSI },
 274     { M32R2F_INSN_WRITE_RACH_DSI, && case_sem_INSN_WRITE_RACH_DSI },
 275     { M32R2F_INSN_PAR_RTE, && case_sem_INSN_PAR_RTE },
 276     { M32R2F_INSN_WRITE_RTE, && case_sem_INSN_WRITE_RTE },
 277     { M32R2F_INSN_PAR_SLL, && case_sem_INSN_PAR_SLL },
 278     { M32R2F_INSN_WRITE_SLL, && case_sem_INSN_WRITE_SLL },
 279     { M32R2F_INSN_PAR_SLLI, && case_sem_INSN_PAR_SLLI },
 280     { M32R2F_INSN_WRITE_SLLI, && case_sem_INSN_WRITE_SLLI },
 281     { M32R2F_INSN_PAR_SRA, && case_sem_INSN_PAR_SRA },
 282     { M32R2F_INSN_WRITE_SRA, && case_sem_INSN_WRITE_SRA },
 283     { M32R2F_INSN_PAR_SRAI, && case_sem_INSN_PAR_SRAI },
 284     { M32R2F_INSN_WRITE_SRAI, && case_sem_INSN_WRITE_SRAI },
 285     { M32R2F_INSN_PAR_SRL, && case_sem_INSN_PAR_SRL },
 286     { M32R2F_INSN_WRITE_SRL, && case_sem_INSN_WRITE_SRL },
 287     { M32R2F_INSN_PAR_SRLI, && case_sem_INSN_PAR_SRLI },
 288     { M32R2F_INSN_WRITE_SRLI, && case_sem_INSN_WRITE_SRLI },
 289     { M32R2F_INSN_PAR_ST, && case_sem_INSN_PAR_ST },
 290     { M32R2F_INSN_WRITE_ST, && case_sem_INSN_WRITE_ST },
 291     { M32R2F_INSN_PAR_STB, && case_sem_INSN_PAR_STB },
 292     { M32R2F_INSN_WRITE_STB, && case_sem_INSN_WRITE_STB },
 293     { M32R2F_INSN_PAR_STH, && case_sem_INSN_PAR_STH },
 294     { M32R2F_INSN_WRITE_STH, && case_sem_INSN_WRITE_STH },
 295     { M32R2F_INSN_PAR_ST_PLUS, && case_sem_INSN_PAR_ST_PLUS },
 296     { M32R2F_INSN_WRITE_ST_PLUS, && case_sem_INSN_WRITE_ST_PLUS },
 297     { M32R2F_INSN_PAR_STH_PLUS, && case_sem_INSN_PAR_STH_PLUS },
 298     { M32R2F_INSN_WRITE_STH_PLUS, && case_sem_INSN_WRITE_STH_PLUS },
 299     { M32R2F_INSN_PAR_STB_PLUS, && case_sem_INSN_PAR_STB_PLUS },
 300     { M32R2F_INSN_WRITE_STB_PLUS, && case_sem_INSN_WRITE_STB_PLUS },
 301     { M32R2F_INSN_PAR_ST_MINUS, && case_sem_INSN_PAR_ST_MINUS },
 302     { M32R2F_INSN_WRITE_ST_MINUS, && case_sem_INSN_WRITE_ST_MINUS },
 303     { M32R2F_INSN_PAR_SUB, && case_sem_INSN_PAR_SUB },
 304     { M32R2F_INSN_WRITE_SUB, && case_sem_INSN_WRITE_SUB },
 305     { M32R2F_INSN_PAR_SUBV, && case_sem_INSN_PAR_SUBV },
 306     { M32R2F_INSN_WRITE_SUBV, && case_sem_INSN_WRITE_SUBV },
 307     { M32R2F_INSN_PAR_SUBX, && case_sem_INSN_PAR_SUBX },
 308     { M32R2F_INSN_WRITE_SUBX, && case_sem_INSN_WRITE_SUBX },
 309     { M32R2F_INSN_PAR_TRAP, && case_sem_INSN_PAR_TRAP },
 310     { M32R2F_INSN_WRITE_TRAP, && case_sem_INSN_WRITE_TRAP },
 311     { M32R2F_INSN_PAR_UNLOCK, && case_sem_INSN_PAR_UNLOCK },
 312     { M32R2F_INSN_WRITE_UNLOCK, && case_sem_INSN_WRITE_UNLOCK },
 313     { M32R2F_INSN_PAR_PCMPBZ, && case_sem_INSN_PAR_PCMPBZ },
 314     { M32R2F_INSN_WRITE_PCMPBZ, && case_sem_INSN_WRITE_PCMPBZ },
 315     { M32R2F_INSN_PAR_SADD, && case_sem_INSN_PAR_SADD },
 316     { M32R2F_INSN_WRITE_SADD, && case_sem_INSN_WRITE_SADD },
 317     { M32R2F_INSN_PAR_MACWU1, && case_sem_INSN_PAR_MACWU1 },
 318     { M32R2F_INSN_WRITE_MACWU1, && case_sem_INSN_WRITE_MACWU1 },
 319     { M32R2F_INSN_PAR_MSBLO, && case_sem_INSN_PAR_MSBLO },
 320     { M32R2F_INSN_WRITE_MSBLO, && case_sem_INSN_WRITE_MSBLO },
 321     { M32R2F_INSN_PAR_MULWU1, && case_sem_INSN_PAR_MULWU1 },
 322     { M32R2F_INSN_WRITE_MULWU1, && case_sem_INSN_WRITE_MULWU1 },
 323     { M32R2F_INSN_PAR_MACLH1, && case_sem_INSN_PAR_MACLH1 },
 324     { M32R2F_INSN_WRITE_MACLH1, && case_sem_INSN_WRITE_MACLH1 },
 325     { M32R2F_INSN_PAR_SC, && case_sem_INSN_PAR_SC },
 326     { M32R2F_INSN_WRITE_SC, && case_sem_INSN_WRITE_SC },
 327     { M32R2F_INSN_PAR_SNC, && case_sem_INSN_PAR_SNC },
 328     { M32R2F_INSN_WRITE_SNC, && case_sem_INSN_WRITE_SNC },
 329     { M32R2F_INSN_PAR_CLRPSW, && case_sem_INSN_PAR_CLRPSW },
 330     { M32R2F_INSN_WRITE_CLRPSW, && case_sem_INSN_WRITE_CLRPSW },
 331     { M32R2F_INSN_PAR_SETPSW, && case_sem_INSN_PAR_SETPSW },
 332     { M32R2F_INSN_WRITE_SETPSW, && case_sem_INSN_WRITE_SETPSW },
 333     { M32R2F_INSN_PAR_BTST, && case_sem_INSN_PAR_BTST },
 334     { M32R2F_INSN_WRITE_BTST, && case_sem_INSN_WRITE_BTST },
 335     { 0, 0 }
 336   };
 337   int i;
 338
 339   for (i = 0; labels[i].label != 0; ++i)
 340     {
 341 #if FAST_P
 342       CPU_IDESC (current_cpu) [labels[i].index].sem_fast_lab = labels[i].label;
 343 #else
 344       CPU_IDESC (current_cpu) [labels[i].index].sem_full_lab = labels[i].label;
 345 #endif
 346     }
 347
 348 #undef DEFINE_LABELS
 349 #endif /* DEFINE_LABELS */
 350
 351 #ifdef DEFINE_SWITCH
 352
 353 /* If hyper-fast [well not unnecessarily slow] execution is selected, turn
 354    off frills like tracing and profiling.  */
 355 /* FIXME: A better way would be to have TRACE_RESULT check for something
 356    that can cause it to be optimized out.  Another way would be to emit
 357    special handlers into the instruction "stream".  */
 358
 359 #if FAST_P
 360 #undef TRACE_RESULT
 361 #define TRACE_RESULT(cpu, abuf, name, type, val)
 362 #endif
 363
 364 #undef GET_ATTR
 365 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
 366 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
 367 #else
 368 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_/**/attr)
 369 #endif
 370
 371 {
 372
 373 #if WITH_SCACHE_PBB
 374
 375 /* Branch to next handler without going around main loop.  */
 376 #define NEXT(vpc) goto * SEM_ARGBUF (vpc) -> semantic.sem_case
 377 SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 378
 379 #else /* ! WITH_SCACHE_PBB */
 380
 381 #define NEXT(vpc) BREAK (sem)
 382 #ifdef __GNUC__
 383 #if FAST_P
 384   SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_fast_lab)
 385 #else
 386   SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_full_lab)
 387 #endif
 388 #else
 389   SWITCH (sem, SEM_ARGBUF (sc) -> idesc->num)
 390 #endif
 391
 392 #endif /* ! WITH_SCACHE_PBB */
 393
 394     {
 395
 396   CASE (sem, INSN_X_INVALID) : /* --invalid-- */
 397 {
 398   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 399   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 400 #define FLD(f) abuf->fields.fmt_empty.f
 401   int UNUSED written = 0;
 402   IADDR UNUSED pc = abuf->addr;
 403   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 404
 405   {
 406     /* Update the recorded pc in the cpu state struct.
 407        Only necessary for WITH_SCACHE case, but to avoid the
 408        conditional compilation ....  */
 409     SET_H_PC (pc);
 410     /* Virtual insns have zero size.  Overwrite vpc with address of next insn
 411        using the default-insn-bitsize spec.  When executing insns in parallel
 412        we may want to queue the fault and continue execution.  */
 413     vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 414     vpc = sim_engine_invalid_insn (current_cpu, pc, vpc);
 415   }
 416
 417 #undef FLD
 418 }
 419   NEXT (vpc);
 420
 421   CASE (sem, INSN_X_AFTER) : /* --after-- */
 422 {
 423   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 424   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 425 #define FLD(f) abuf->fields.fmt_empty.f
 426   int UNUSED written = 0;
 427   IADDR UNUSED pc = abuf->addr;
 428   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 429
 430   {
 431 #if WITH_SCACHE_PBB_M32R2F
 432     m32r2f_pbb_after (current_cpu, sem_arg);
 433 #endif
 434   }
 435
 436 #undef FLD
 437 }
 438   NEXT (vpc);
 439
 440   CASE (sem, INSN_X_BEFORE) : /* --before-- */
 441 {
 442   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 443   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 444 #define FLD(f) abuf->fields.fmt_empty.f
 445   int UNUSED written = 0;
 446   IADDR UNUSED pc = abuf->addr;
 447   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 448
 449   {
 450 #if WITH_SCACHE_PBB_M32R2F
 451     m32r2f_pbb_before (current_cpu, sem_arg);
 452 #endif
 453   }
 454
 455 #undef FLD
 456 }
 457   NEXT (vpc);
 458
 459   CASE (sem, INSN_X_CTI_CHAIN) : /* --cti-chain-- */
 460 {
 461   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 462   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 463 #define FLD(f) abuf->fields.fmt_empty.f
 464   int UNUSED written = 0;
 465   IADDR UNUSED pc = abuf->addr;
 466   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 467
 468   {
 469 #if WITH_SCACHE_PBB_M32R2F
 470 #ifdef DEFINE_SWITCH
 471     vpc = m32r2f_pbb_cti_chain (current_cpu, sem_arg,
 472                                pbb_br_type, pbb_br_npc);
 473     BREAK (sem);
 474 #else
 475     /* FIXME: Allow provision of explicit ifmt spec in insn spec.  */
 476     vpc = m32r2f_pbb_cti_chain (current_cpu, sem_arg,
 477                                CPU_PBB_BR_TYPE (current_cpu),
 478                                CPU_PBB_BR_NPC (current_cpu));
 479 #endif
 480 #endif
 481   }
 482
 483 #undef FLD
 484 }
 485   NEXT (vpc);
 486
 487   CASE (sem, INSN_X_CHAIN) : /* --chain-- */
 488 {
 489   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 490   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 491 #define FLD(f) abuf->fields.fmt_empty.f
 492   int UNUSED written = 0;
 493   IADDR UNUSED pc = abuf->addr;
 494   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 495
 496   {
 497 #if WITH_SCACHE_PBB_M32R2F
 498     vpc = m32r2f_pbb_chain (current_cpu, sem_arg);
 499 #ifdef DEFINE_SWITCH
 500     BREAK (sem);
 501 #endif
 502 #endif
 503   }
 504
 505 #undef FLD
 506 }
 507   NEXT (vpc);
 508
 509   CASE (sem, INSN_X_BEGIN) : /* --begin-- */
 510 {
 511   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 512   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 513 #define FLD(f) abuf->fields.fmt_empty.f
 514   int UNUSED written = 0;
 515   IADDR UNUSED pc = abuf->addr;
 516   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 517
 518   {
 519 #if WITH_SCACHE_PBB_M32R2F
 520 #if defined DEFINE_SWITCH || defined FAST_P
 521     /* In the switch case FAST_P is a constant, allowing several optimizations
 522        in any called inline functions.  */
 523     vpc = m32r2f_pbb_begin (current_cpu, FAST_P);
 524 #else
 525 #if 0 /* cgen engine can't handle dynamic fast/full switching yet.  */
 526     vpc = m32r2f_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
 527 #else
 528     vpc = m32r2f_pbb_begin (current_cpu, 0);
 529 #endif
 530 #endif
 531 #endif
 532   }
 533
 534 #undef FLD
 535 }
 536   NEXT (vpc);
 537
 538   CASE (sem, INSN_ADD) : /* add $dr,$sr */
 539 {
 540   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 541   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 542 #define FLD(f) abuf->fields.sfmt_add.f
 543   int UNUSED written = 0;
 544   IADDR UNUSED pc = abuf->addr;
 545   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 546
 547   {
 548     SI opval = ADDSI (* FLD (i_dr), * FLD (i_sr));
 549     * FLD (i_dr) = opval;
 550     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 551   }
 552
 553 #undef FLD
 554 }
 555   NEXT (vpc);
 556
 557   CASE (sem, INSN_ADD3) : /* add3 $dr,$sr,$hash$slo16 */
 558 {
 559   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 560   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 561 #define FLD(f) abuf->fields.sfmt_add3.f
 562   int UNUSED written = 0;
 563   IADDR UNUSED pc = abuf->addr;
 564   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 565
 566   {
 567     SI opval = ADDSI (* FLD (i_sr), FLD (f_simm16));
 568     * FLD (i_dr) = opval;
 569     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 570   }
 571
 572 #undef FLD
 573 }
 574   NEXT (vpc);
 575
 576   CASE (sem, INSN_AND) : /* and $dr,$sr */
 577 {
 578   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 579   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 580 #define FLD(f) abuf->fields.sfmt_add.f
 581   int UNUSED written = 0;
 582   IADDR UNUSED pc = abuf->addr;
 583   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 584
 585   {
 586     SI opval = ANDSI (* FLD (i_dr), * FLD (i_sr));
 587     * FLD (i_dr) = opval;
 588     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 589   }
 590
 591 #undef FLD
 592 }
 593   NEXT (vpc);
 594
 595   CASE (sem, INSN_AND3) : /* and3 $dr,$sr,$uimm16 */
 596 {
 597   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 598   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 599 #define FLD(f) abuf->fields.sfmt_and3.f
 600   int UNUSED written = 0;
 601   IADDR UNUSED pc = abuf->addr;
 602   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 603
 604   {
 605     SI opval = ANDSI (* FLD (i_sr), FLD (f_uimm16));
 606     * FLD (i_dr) = opval;
 607     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 608   }
 609
 610 #undef FLD
 611 }
 612   NEXT (vpc);
 613
 614   CASE (sem, INSN_OR) : /* or $dr,$sr */
 615 {
 616   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 617   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 618 #define FLD(f) abuf->fields.sfmt_add.f
 619   int UNUSED written = 0;
 620   IADDR UNUSED pc = abuf->addr;
 621   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 622
 623   {
 624     SI opval = ORSI (* FLD (i_dr), * FLD (i_sr));
 625     * FLD (i_dr) = opval;
 626     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 627   }
 628
 629 #undef FLD
 630 }
 631   NEXT (vpc);
 632
 633   CASE (sem, INSN_OR3) : /* or3 $dr,$sr,$hash$ulo16 */
 634 {
 635   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 636   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 637 #define FLD(f) abuf->fields.sfmt_and3.f
 638   int UNUSED written = 0;
 639   IADDR UNUSED pc = abuf->addr;
 640   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 641
 642   {
 643     SI opval = ORSI (* FLD (i_sr), FLD (f_uimm16));
 644     * FLD (i_dr) = opval;
 645     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 646   }
 647
 648 #undef FLD
 649 }
 650   NEXT (vpc);
 651
 652   CASE (sem, INSN_XOR) : /* xor $dr,$sr */
 653 {
 654   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 655   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 656 #define FLD(f) abuf->fields.sfmt_add.f
 657   int UNUSED written = 0;
 658   IADDR UNUSED pc = abuf->addr;
 659   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 660
 661   {
 662     SI opval = XORSI (* FLD (i_dr), * FLD (i_sr));
 663     * FLD (i_dr) = opval;
 664     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 665   }
 666
 667 #undef FLD
 668 }
 669   NEXT (vpc);
 670
 671   CASE (sem, INSN_XOR3) : /* xor3 $dr,$sr,$uimm16 */
 672 {
 673   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 674   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 675 #define FLD(f) abuf->fields.sfmt_and3.f
 676   int UNUSED written = 0;
 677   IADDR UNUSED pc = abuf->addr;
 678   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 679
 680   {
 681     SI opval = XORSI (* FLD (i_sr), FLD (f_uimm16));
 682     * FLD (i_dr) = opval;
 683     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 684   }
 685
 686 #undef FLD
 687 }
 688   NEXT (vpc);
 689
 690   CASE (sem, INSN_ADDI) : /* addi $dr,$simm8 */
 691 {
 692   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 693   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 694 #define FLD(f) abuf->fields.sfmt_addi.f
 695   int UNUSED written = 0;
 696   IADDR UNUSED pc = abuf->addr;
 697   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 698
 699   {
 700     SI opval = ADDSI (* FLD (i_dr), FLD (f_simm8));
 701     * FLD (i_dr) = opval;
 702     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 703   }
 704
 705 #undef FLD
 706 }
 707   NEXT (vpc);
 708
 709   CASE (sem, INSN_ADDV) : /* addv $dr,$sr */
 710 {
 711   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 712   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 713 #define FLD(f) abuf->fields.sfmt_add.f
 714   int UNUSED written = 0;
 715   IADDR UNUSED pc = abuf->addr;
 716   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 717
 718 {
 719   SI temp0;BI temp1;
 720   temp0 = ADDSI (* FLD (i_dr), * FLD (i_sr));
 721   temp1 = ADDOFSI (* FLD (i_dr), * FLD (i_sr), 0);
 722   {
 723     SI opval = temp0;
 724     * FLD (i_dr) = opval;
 725     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 726   }
 727   {
 728     BI opval = temp1;
 729     CPU (h_cond) = opval;
 730     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 731   }
 732 }
 733
 734 #undef FLD
 735 }
 736   NEXT (vpc);
 737
 738   CASE (sem, INSN_ADDV3) : /* addv3 $dr,$sr,$simm16 */
 739 {
 740   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 741   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 742 #define FLD(f) abuf->fields.sfmt_add3.f
 743   int UNUSED written = 0;
 744   IADDR UNUSED pc = abuf->addr;
 745   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 746
 747 {
 748   SI temp0;BI temp1;
 749   temp0 = ADDSI (* FLD (i_sr), FLD (f_simm16));
 750   temp1 = ADDOFSI (* FLD (i_sr), FLD (f_simm16), 0);
 751   {
 752     SI opval = temp0;
 753     * FLD (i_dr) = opval;
 754     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 755   }
 756   {
 757     BI opval = temp1;
 758     CPU (h_cond) = opval;
 759     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 760   }
 761 }
 762
 763 #undef FLD
 764 }
 765   NEXT (vpc);
 766
 767   CASE (sem, INSN_ADDX) : /* addx $dr,$sr */
 768 {
 769   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 770   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 771 #define FLD(f) abuf->fields.sfmt_add.f
 772   int UNUSED written = 0;
 773   IADDR UNUSED pc = abuf->addr;
 774   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 775
 776 {
 777   SI temp0;BI temp1;
 778   temp0 = ADDCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
 779   temp1 = ADDCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
 780   {
 781     SI opval = temp0;
 782     * FLD (i_dr) = opval;
 783     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
 784   }
 785   {
 786     BI opval = temp1;
 787     CPU (h_cond) = opval;
 788     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
 789   }
 790 }
 791
 792 #undef FLD
 793 }
 794   NEXT (vpc);
 795
 796   CASE (sem, INSN_BC8) : /* bc.s $disp8 */
 797 {
 798   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 799   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 800 #define FLD(f) abuf->fields.sfmt_bl8.f
 801   int UNUSED written = 0;
 802   IADDR UNUSED pc = abuf->addr;
 803   SEM_BRANCH_INIT
 804   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
 805
 806 if (CPU (h_cond)) {
 807   {
 808     USI opval = FLD (i_disp8);
 809     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 810     written |= (1 << 2);
 811     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 812   }
 813 }
 814
 815   abuf->written = written;
 816   SEM_BRANCH_FINI (vpc);
 817 #undef FLD
 818 }
 819   NEXT (vpc);
 820
 821   CASE (sem, INSN_BC24) : /* bc.l $disp24 */
 822 {
 823   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 824   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 825 #define FLD(f) abuf->fields.sfmt_bl24.f
 826   int UNUSED written = 0;
 827   IADDR UNUSED pc = abuf->addr;
 828   SEM_BRANCH_INIT
 829   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 830
 831 if (CPU (h_cond)) {
 832   {
 833     USI opval = FLD (i_disp24);
 834     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 835     written |= (1 << 2);
 836     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 837   }
 838 }
 839
 840   abuf->written = written;
 841   SEM_BRANCH_FINI (vpc);
 842 #undef FLD
 843 }
 844   NEXT (vpc);
 845
 846   CASE (sem, INSN_BEQ) : /* beq $src1,$src2,$disp16 */
 847 {
 848   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 849   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 850 #define FLD(f) abuf->fields.sfmt_beq.f
 851   int UNUSED written = 0;
 852   IADDR UNUSED pc = abuf->addr;
 853   SEM_BRANCH_INIT
 854   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 855
 856 if (EQSI (* FLD (i_src1), * FLD (i_src2))) {
 857   {
 858     USI opval = FLD (i_disp16);
 859     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 860     written |= (1 << 3);
 861     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 862   }
 863 }
 864
 865   abuf->written = written;
 866   SEM_BRANCH_FINI (vpc);
 867 #undef FLD
 868 }
 869   NEXT (vpc);
 870
 871   CASE (sem, INSN_BEQZ) : /* beqz $src2,$disp16 */
 872 {
 873   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 874   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 875 #define FLD(f) abuf->fields.sfmt_beq.f
 876   int UNUSED written = 0;
 877   IADDR UNUSED pc = abuf->addr;
 878   SEM_BRANCH_INIT
 879   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 880
 881 if (EQSI (* FLD (i_src2), 0)) {
 882   {
 883     USI opval = FLD (i_disp16);
 884     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 885     written |= (1 << 2);
 886     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 887   }
 888 }
 889
 890   abuf->written = written;
 891   SEM_BRANCH_FINI (vpc);
 892 #undef FLD
 893 }
 894   NEXT (vpc);
 895
 896   CASE (sem, INSN_BGEZ) : /* bgez $src2,$disp16 */
 897 {
 898   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 899   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 900 #define FLD(f) abuf->fields.sfmt_beq.f
 901   int UNUSED written = 0;
 902   IADDR UNUSED pc = abuf->addr;
 903   SEM_BRANCH_INIT
 904   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 905
 906 if (GESI (* FLD (i_src2), 0)) {
 907   {
 908     USI opval = FLD (i_disp16);
 909     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 910     written |= (1 << 2);
 911     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 912   }
 913 }
 914
 915   abuf->written = written;
 916   SEM_BRANCH_FINI (vpc);
 917 #undef FLD
 918 }
 919   NEXT (vpc);
 920
 921   CASE (sem, INSN_BGTZ) : /* bgtz $src2,$disp16 */
 922 {
 923   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 924   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 925 #define FLD(f) abuf->fields.sfmt_beq.f
 926   int UNUSED written = 0;
 927   IADDR UNUSED pc = abuf->addr;
 928   SEM_BRANCH_INIT
 929   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 930
 931 if (GTSI (* FLD (i_src2), 0)) {
 932   {
 933     USI opval = FLD (i_disp16);
 934     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 935     written |= (1 << 2);
 936     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 937   }
 938 }
 939
 940   abuf->written = written;
 941   SEM_BRANCH_FINI (vpc);
 942 #undef FLD
 943 }
 944   NEXT (vpc);
 945
 946   CASE (sem, INSN_BLEZ) : /* blez $src2,$disp16 */
 947 {
 948   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 949   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 950 #define FLD(f) abuf->fields.sfmt_beq.f
 951   int UNUSED written = 0;
 952   IADDR UNUSED pc = abuf->addr;
 953   SEM_BRANCH_INIT
 954   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 955
 956 if (LESI (* FLD (i_src2), 0)) {
 957   {
 958     USI opval = FLD (i_disp16);
 959     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 960     written |= (1 << 2);
 961     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 962   }
 963 }
 964
 965   abuf->written = written;
 966   SEM_BRANCH_FINI (vpc);
 967 #undef FLD
 968 }
 969   NEXT (vpc);
 970
 971   CASE (sem, INSN_BLTZ) : /* bltz $src2,$disp16 */
 972 {
 973   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 974   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 975 #define FLD(f) abuf->fields.sfmt_beq.f
 976   int UNUSED written = 0;
 977   IADDR UNUSED pc = abuf->addr;
 978   SEM_BRANCH_INIT
 979   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 980
 981 if (LTSI (* FLD (i_src2), 0)) {
 982   {
 983     USI opval = FLD (i_disp16);
 984     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
 985     written |= (1 << 2);
 986     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
 987   }
 988 }
 989
 990   abuf->written = written;
 991   SEM_BRANCH_FINI (vpc);
 992 #undef FLD
 993 }
 994   NEXT (vpc);
 995
 996   CASE (sem, INSN_BNEZ) : /* bnez $src2,$disp16 */
 997 {
 998   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 999   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1000 #define FLD(f) abuf->fields.sfmt_beq.f
1001   int UNUSED written = 0;
1002   IADDR UNUSED pc = abuf->addr;
1003   SEM_BRANCH_INIT
1004   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1005
1006 if (NESI (* FLD (i_src2), 0)) {
1007   {
1008     USI opval = FLD (i_disp16);
1009     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1010     written |= (1 << 2);
1011     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1012   }
1013 }
1014
1015   abuf->written = written;
1016   SEM_BRANCH_FINI (vpc);
1017 #undef FLD
1018 }
1019   NEXT (vpc);
1020
1021   CASE (sem, INSN_BL8) : /* bl.s $disp8 */
1022 {
1023   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1024   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1025 #define FLD(f) abuf->fields.sfmt_bl8.f
1026   int UNUSED written = 0;
1027   IADDR UNUSED pc = abuf->addr;
1028   SEM_BRANCH_INIT
1029   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1030
1031 {
1032   {
1033     SI opval = ADDSI (ANDSI (pc, -4), 4);
1034     CPU (h_gr[((UINT) 14)]) = opval;
1035     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1036   }
1037   {
1038     USI opval = FLD (i_disp8);
1039     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1040     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1041   }
1042 }
1043
1044   SEM_BRANCH_FINI (vpc);
1045 #undef FLD
1046 }
1047   NEXT (vpc);
1048
1049   CASE (sem, INSN_BL24) : /* bl.l $disp24 */
1050 {
1051   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1052   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1053 #define FLD(f) abuf->fields.sfmt_bl24.f
1054   int UNUSED written = 0;
1055   IADDR UNUSED pc = abuf->addr;
1056   SEM_BRANCH_INIT
1057   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1058
1059 {
1060   {
1061     SI opval = ADDSI (pc, 4);
1062     CPU (h_gr[((UINT) 14)]) = opval;
1063     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1064   }
1065   {
1066     USI opval = FLD (i_disp24);
1067     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1068     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1069   }
1070 }
1071
1072   SEM_BRANCH_FINI (vpc);
1073 #undef FLD
1074 }
1075   NEXT (vpc);
1076
1077   CASE (sem, INSN_BCL8) : /* bcl.s $disp8 */
1078 {
1079   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1080   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1081 #define FLD(f) abuf->fields.sfmt_bl8.f
1082   int UNUSED written = 0;
1083   IADDR UNUSED pc = abuf->addr;
1084   SEM_BRANCH_INIT
1085   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1086
1087 if (CPU (h_cond)) {
1088 {
1089   {
1090     SI opval = ADDSI (ANDSI (pc, -4), 4);
1091     CPU (h_gr[((UINT) 14)]) = opval;
1092     written |= (1 << 3);
1093     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1094   }
1095   {
1096     USI opval = FLD (i_disp8);
1097     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1098     written |= (1 << 4);
1099     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1100   }
1101 }
1102 }
1103
1104   abuf->written = written;
1105   SEM_BRANCH_FINI (vpc);
1106 #undef FLD
1107 }
1108   NEXT (vpc);
1109
1110   CASE (sem, INSN_BCL24) : /* bcl.l $disp24 */
1111 {
1112   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1113   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1114 #define FLD(f) abuf->fields.sfmt_bl24.f
1115   int UNUSED written = 0;
1116   IADDR UNUSED pc = abuf->addr;
1117   SEM_BRANCH_INIT
1118   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1119
1120 if (CPU (h_cond)) {
1121 {
1122   {
1123     SI opval = ADDSI (pc, 4);
1124     CPU (h_gr[((UINT) 14)]) = opval;
1125     written |= (1 << 3);
1126     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1127   }
1128   {
1129     USI opval = FLD (i_disp24);
1130     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1131     written |= (1 << 4);
1132     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1133   }
1134 }
1135 }
1136
1137   abuf->written = written;
1138   SEM_BRANCH_FINI (vpc);
1139 #undef FLD
1140 }
1141   NEXT (vpc);
1142
1143   CASE (sem, INSN_BNC8) : /* bnc.s $disp8 */
1144 {
1145   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1146   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1147 #define FLD(f) abuf->fields.sfmt_bl8.f
1148   int UNUSED written = 0;
1149   IADDR UNUSED pc = abuf->addr;
1150   SEM_BRANCH_INIT
1151   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1152
1153 if (NOTBI (CPU (h_cond))) {
1154   {
1155     USI opval = FLD (i_disp8);
1156     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1157     written |= (1 << 2);
1158     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1159   }
1160 }
1161
1162   abuf->written = written;
1163   SEM_BRANCH_FINI (vpc);
1164 #undef FLD
1165 }
1166   NEXT (vpc);
1167
1168   CASE (sem, INSN_BNC24) : /* bnc.l $disp24 */
1169 {
1170   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1171   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1172 #define FLD(f) abuf->fields.sfmt_bl24.f
1173   int UNUSED written = 0;
1174   IADDR UNUSED pc = abuf->addr;
1175   SEM_BRANCH_INIT
1176   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1177
1178 if (NOTBI (CPU (h_cond))) {
1179   {
1180     USI opval = FLD (i_disp24);
1181     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1182     written |= (1 << 2);
1183     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1184   }
1185 }
1186
1187   abuf->written = written;
1188   SEM_BRANCH_FINI (vpc);
1189 #undef FLD
1190 }
1191   NEXT (vpc);
1192
1193   CASE (sem, INSN_BNE) : /* bne $src1,$src2,$disp16 */
1194 {
1195   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1196   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1197 #define FLD(f) abuf->fields.sfmt_beq.f
1198   int UNUSED written = 0;
1199   IADDR UNUSED pc = abuf->addr;
1200   SEM_BRANCH_INIT
1201   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1202
1203 if (NESI (* FLD (i_src1), * FLD (i_src2))) {
1204   {
1205     USI opval = FLD (i_disp16);
1206     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1207     written |= (1 << 3);
1208     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1209   }
1210 }
1211
1212   abuf->written = written;
1213   SEM_BRANCH_FINI (vpc);
1214 #undef FLD
1215 }
1216   NEXT (vpc);
1217
1218   CASE (sem, INSN_BRA8) : /* bra.s $disp8 */
1219 {
1220   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1221   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1222 #define FLD(f) abuf->fields.sfmt_bl8.f
1223   int UNUSED written = 0;
1224   IADDR UNUSED pc = abuf->addr;
1225   SEM_BRANCH_INIT
1226   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1227
1228   {
1229     USI opval = FLD (i_disp8);
1230     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1231     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1232   }
1233
1234   SEM_BRANCH_FINI (vpc);
1235 #undef FLD
1236 }
1237   NEXT (vpc);
1238
1239   CASE (sem, INSN_BRA24) : /* bra.l $disp24 */
1240 {
1241   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1242   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1243 #define FLD(f) abuf->fields.sfmt_bl24.f
1244   int UNUSED written = 0;
1245   IADDR UNUSED pc = abuf->addr;
1246   SEM_BRANCH_INIT
1247   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1248
1249   {
1250     USI opval = FLD (i_disp24);
1251     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1252     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1253   }
1254
1255   SEM_BRANCH_FINI (vpc);
1256 #undef FLD
1257 }
1258   NEXT (vpc);
1259
1260   CASE (sem, INSN_BNCL8) : /* bncl.s $disp8 */
1261 {
1262   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1263   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1264 #define FLD(f) abuf->fields.sfmt_bl8.f
1265   int UNUSED written = 0;
1266   IADDR UNUSED pc = abuf->addr;
1267   SEM_BRANCH_INIT
1268   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1269
1270 if (NOTBI (CPU (h_cond))) {
1271 {
1272   {
1273     SI opval = ADDSI (ANDSI (pc, -4), 4);
1274     CPU (h_gr[((UINT) 14)]) = opval;
1275     written |= (1 << 3);
1276     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1277   }
1278   {
1279     USI opval = FLD (i_disp8);
1280     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1281     written |= (1 << 4);
1282     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1283   }
1284 }
1285 }
1286
1287   abuf->written = written;
1288   SEM_BRANCH_FINI (vpc);
1289 #undef FLD
1290 }
1291   NEXT (vpc);
1292
1293   CASE (sem, INSN_BNCL24) : /* bncl.l $disp24 */
1294 {
1295   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1296   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1297 #define FLD(f) abuf->fields.sfmt_bl24.f
1298   int UNUSED written = 0;
1299   IADDR UNUSED pc = abuf->addr;
1300   SEM_BRANCH_INIT
1301   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1302
1303 if (NOTBI (CPU (h_cond))) {
1304 {
1305   {
1306     SI opval = ADDSI (pc, 4);
1307     CPU (h_gr[((UINT) 14)]) = opval;
1308     written |= (1 << 3);
1309     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1310   }
1311   {
1312     USI opval = FLD (i_disp24);
1313     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc);
1314     written |= (1 << 4);
1315     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1316   }
1317 }
1318 }
1319
1320   abuf->written = written;
1321   SEM_BRANCH_FINI (vpc);
1322 #undef FLD
1323 }
1324   NEXT (vpc);
1325
1326   CASE (sem, INSN_CMP) : /* cmp $src1,$src2 */
1327 {
1328   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1329   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1330 #define FLD(f) abuf->fields.sfmt_st_plus.f
1331   int UNUSED written = 0;
1332   IADDR UNUSED pc = abuf->addr;
1333   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1334
1335   {
1336     BI opval = LTSI (* FLD (i_src1), * FLD (i_src2));
1337     CPU (h_cond) = opval;
1338     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1339   }
1340
1341 #undef FLD
1342 }
1343   NEXT (vpc);
1344
1345   CASE (sem, INSN_CMPI) : /* cmpi $src2,$simm16 */
1346 {
1347   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1348   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1349 #define FLD(f) abuf->fields.sfmt_st_d.f
1350   int UNUSED written = 0;
1351   IADDR UNUSED pc = abuf->addr;
1352   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1353
1354   {
1355     BI opval = LTSI (* FLD (i_src2), FLD (f_simm16));
1356     CPU (h_cond) = opval;
1357     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1358   }
1359
1360 #undef FLD
1361 }
1362   NEXT (vpc);
1363
1364   CASE (sem, INSN_CMPU) : /* cmpu $src1,$src2 */
1365 {
1366   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1367   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1368 #define FLD(f) abuf->fields.sfmt_st_plus.f
1369   int UNUSED written = 0;
1370   IADDR UNUSED pc = abuf->addr;
1371   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1372
1373   {
1374     BI opval = LTUSI (* FLD (i_src1), * FLD (i_src2));
1375     CPU (h_cond) = opval;
1376     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1377   }
1378
1379 #undef FLD
1380 }
1381   NEXT (vpc);
1382
1383   CASE (sem, INSN_CMPUI) : /* cmpui $src2,$simm16 */
1384 {
1385   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1386   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1387 #define FLD(f) abuf->fields.sfmt_st_d.f
1388   int UNUSED written = 0;
1389   IADDR UNUSED pc = abuf->addr;
1390   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1391
1392   {
1393     BI opval = LTUSI (* FLD (i_src2), FLD (f_simm16));
1394     CPU (h_cond) = opval;
1395     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1396   }
1397
1398 #undef FLD
1399 }
1400   NEXT (vpc);
1401
1402   CASE (sem, INSN_CMPEQ) : /* cmpeq $src1,$src2 */
1403 {
1404   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1405   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1406 #define FLD(f) abuf->fields.sfmt_st_plus.f
1407   int UNUSED written = 0;
1408   IADDR UNUSED pc = abuf->addr;
1409   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1410
1411   {
1412     BI opval = EQSI (* FLD (i_src1), * FLD (i_src2));
1413     CPU (h_cond) = opval;
1414     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1415   }
1416
1417 #undef FLD
1418 }
1419   NEXT (vpc);
1420
1421   CASE (sem, INSN_CMPZ) : /* cmpz $src2 */
1422 {
1423   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1424   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1425 #define FLD(f) abuf->fields.sfmt_st_plus.f
1426   int UNUSED written = 0;
1427   IADDR UNUSED pc = abuf->addr;
1428   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1429
1430   {
1431     BI opval = EQSI (* FLD (i_src2), 0);
1432     CPU (h_cond) = opval;
1433     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
1434   }
1435
1436 #undef FLD
1437 }
1438   NEXT (vpc);
1439
1440   CASE (sem, INSN_DIV) : /* div $dr,$sr */
1441 {
1442   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1443   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1444 #define FLD(f) abuf->fields.sfmt_add.f
1445   int UNUSED written = 0;
1446   IADDR UNUSED pc = abuf->addr;
1447   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1448
1449 if (NESI (* FLD (i_sr), 0)) {
1450   {
1451     SI opval = DIVSI (* FLD (i_dr), * FLD (i_sr));
1452     * FLD (i_dr) = opval;
1453     written |= (1 << 2);
1454     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1455   }
1456 }
1457
1458   abuf->written = written;
1459 #undef FLD
1460 }
1461   NEXT (vpc);
1462
1463   CASE (sem, INSN_DIVU) : /* divu $dr,$sr */
1464 {
1465   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1466   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1467 #define FLD(f) abuf->fields.sfmt_add.f
1468   int UNUSED written = 0;
1469   IADDR UNUSED pc = abuf->addr;
1470   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1471
1472 if (NESI (* FLD (i_sr), 0)) {
1473   {
1474     SI opval = UDIVSI (* FLD (i_dr), * FLD (i_sr));
1475     * FLD (i_dr) = opval;
1476     written |= (1 << 2);
1477     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1478   }
1479 }
1480
1481   abuf->written = written;
1482 #undef FLD
1483 }
1484   NEXT (vpc);
1485
1486   CASE (sem, INSN_REM) : /* rem $dr,$sr */
1487 {
1488   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1489   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1490 #define FLD(f) abuf->fields.sfmt_add.f
1491   int UNUSED written = 0;
1492   IADDR UNUSED pc = abuf->addr;
1493   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1494
1495 if (NESI (* FLD (i_sr), 0)) {
1496   {
1497     SI opval = MODSI (* FLD (i_dr), * FLD (i_sr));
1498     * FLD (i_dr) = opval;
1499     written |= (1 << 2);
1500     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1501   }
1502 }
1503
1504   abuf->written = written;
1505 #undef FLD
1506 }
1507   NEXT (vpc);
1508
1509   CASE (sem, INSN_REMU) : /* remu $dr,$sr */
1510 {
1511   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1512   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1513 #define FLD(f) abuf->fields.sfmt_add.f
1514   int UNUSED written = 0;
1515   IADDR UNUSED pc = abuf->addr;
1516   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1517
1518 if (NESI (* FLD (i_sr), 0)) {
1519   {
1520     SI opval = UMODSI (* FLD (i_dr), * FLD (i_sr));
1521     * FLD (i_dr) = opval;
1522     written |= (1 << 2);
1523     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1524   }
1525 }
1526
1527   abuf->written = written;
1528 #undef FLD
1529 }
1530   NEXT (vpc);
1531
1532   CASE (sem, INSN_REMH) : /* remh $dr,$sr */
1533 {
1534   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1535   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1536 #define FLD(f) abuf->fields.sfmt_add.f
1537   int UNUSED written = 0;
1538   IADDR UNUSED pc = abuf->addr;
1539   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1540
1541 if (NESI (* FLD (i_sr), 0)) {
1542   {
1543     SI opval = MODSI (EXTHISI (TRUNCSIHI (* FLD (i_dr))), * FLD (i_sr));
1544     * FLD (i_dr) = opval;
1545     written |= (1 << 2);
1546     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1547   }
1548 }
1549
1550   abuf->written = written;
1551 #undef FLD
1552 }
1553   NEXT (vpc);
1554
1555   CASE (sem, INSN_REMUH) : /* remuh $dr,$sr */
1556 {
1557   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1558   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1559 #define FLD(f) abuf->fields.sfmt_add.f
1560   int UNUSED written = 0;
1561   IADDR UNUSED pc = abuf->addr;
1562   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1563
1564 if (NESI (* FLD (i_sr), 0)) {
1565   {
1566     SI opval = UMODSI (* FLD (i_dr), * FLD (i_sr));
1567     * FLD (i_dr) = opval;
1568     written |= (1 << 2);
1569     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1570   }
1571 }
1572
1573   abuf->written = written;
1574 #undef FLD
1575 }
1576   NEXT (vpc);
1577
1578   CASE (sem, INSN_REMB) : /* remb $dr,$sr */
1579 {
1580   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1581   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1582 #define FLD(f) abuf->fields.sfmt_add.f
1583   int UNUSED written = 0;
1584   IADDR UNUSED pc = abuf->addr;
1585   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1586
1587 if (NESI (* FLD (i_sr), 0)) {
1588   {
1589     SI opval = MODSI (EXTBISI (TRUNCSIBI (* FLD (i_dr))), * FLD (i_sr));
1590     * FLD (i_dr) = opval;
1591     written |= (1 << 2);
1592     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1593   }
1594 }
1595
1596   abuf->written = written;
1597 #undef FLD
1598 }
1599   NEXT (vpc);
1600
1601   CASE (sem, INSN_REMUB) : /* remub $dr,$sr */
1602 {
1603   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1604   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1605 #define FLD(f) abuf->fields.sfmt_add.f
1606   int UNUSED written = 0;
1607   IADDR UNUSED pc = abuf->addr;
1608   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1609
1610 if (NESI (* FLD (i_sr), 0)) {
1611   {
1612     SI opval = UMODSI (* FLD (i_dr), * FLD (i_sr));
1613     * FLD (i_dr) = opval;
1614     written |= (1 << 2);
1615     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1616   }
1617 }
1618
1619   abuf->written = written;
1620 #undef FLD
1621 }
1622   NEXT (vpc);
1623
1624   CASE (sem, INSN_DIVUH) : /* divuh $dr,$sr */
1625 {
1626   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1627   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1628 #define FLD(f) abuf->fields.sfmt_add.f
1629   int UNUSED written = 0;
1630   IADDR UNUSED pc = abuf->addr;
1631   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1632
1633 if (NESI (* FLD (i_sr), 0)) {
1634   {
1635     SI opval = UDIVSI (* FLD (i_dr), * FLD (i_sr));
1636     * FLD (i_dr) = opval;
1637     written |= (1 << 2);
1638     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1639   }
1640 }
1641
1642   abuf->written = written;
1643 #undef FLD
1644 }
1645   NEXT (vpc);
1646
1647   CASE (sem, INSN_DIVB) : /* divb $dr,$sr */
1648 {
1649   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1650   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1651 #define FLD(f) abuf->fields.sfmt_add.f
1652   int UNUSED written = 0;
1653   IADDR UNUSED pc = abuf->addr;
1654   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1655
1656 if (NESI (* FLD (i_sr), 0)) {
1657   {
1658     SI opval = DIVSI (EXTBISI (TRUNCSIBI (* FLD (i_dr))), * FLD (i_sr));
1659     * FLD (i_dr) = opval;
1660     written |= (1 << 2);
1661     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1662   }
1663 }
1664
1665   abuf->written = written;
1666 #undef FLD
1667 }
1668   NEXT (vpc);
1669
1670   CASE (sem, INSN_DIVUB) : /* divub $dr,$sr */
1671 {
1672   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1673   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1674 #define FLD(f) abuf->fields.sfmt_add.f
1675   int UNUSED written = 0;
1676   IADDR UNUSED pc = abuf->addr;
1677   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1678
1679 if (NESI (* FLD (i_sr), 0)) {
1680   {
1681     SI opval = UDIVSI (* FLD (i_dr), * FLD (i_sr));
1682     * FLD (i_dr) = opval;
1683     written |= (1 << 2);
1684     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1685   }
1686 }
1687
1688   abuf->written = written;
1689 #undef FLD
1690 }
1691   NEXT (vpc);
1692
1693   CASE (sem, INSN_DIVH) : /* divh $dr,$sr */
1694 {
1695   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1696   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1697 #define FLD(f) abuf->fields.sfmt_add.f
1698   int UNUSED written = 0;
1699   IADDR UNUSED pc = abuf->addr;
1700   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1701
1702 if (NESI (* FLD (i_sr), 0)) {
1703   {
1704     SI opval = DIVSI (EXTHISI (TRUNCSIHI (* FLD (i_dr))), * FLD (i_sr));
1705     * FLD (i_dr) = opval;
1706     written |= (1 << 2);
1707     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1708   }
1709 }
1710
1711   abuf->written = written;
1712 #undef FLD
1713 }
1714   NEXT (vpc);
1715
1716   CASE (sem, INSN_JC) : /* jc $sr */
1717 {
1718   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1719   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1720 #define FLD(f) abuf->fields.sfmt_jl.f
1721   int UNUSED written = 0;
1722   IADDR UNUSED pc = abuf->addr;
1723   SEM_BRANCH_INIT
1724   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1725
1726 if (CPU (h_cond)) {
1727   {
1728     USI opval = ANDSI (* FLD (i_sr), -4);
1729     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1730     written |= (1 << 2);
1731     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1732   }
1733 }
1734
1735   abuf->written = written;
1736   SEM_BRANCH_FINI (vpc);
1737 #undef FLD
1738 }
1739   NEXT (vpc);
1740
1741   CASE (sem, INSN_JNC) : /* jnc $sr */
1742 {
1743   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1744   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1745 #define FLD(f) abuf->fields.sfmt_jl.f
1746   int UNUSED written = 0;
1747   IADDR UNUSED pc = abuf->addr;
1748   SEM_BRANCH_INIT
1749   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1750
1751 if (NOTBI (CPU (h_cond))) {
1752   {
1753     USI opval = ANDSI (* FLD (i_sr), -4);
1754     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1755     written |= (1 << 2);
1756     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1757   }
1758 }
1759
1760   abuf->written = written;
1761   SEM_BRANCH_FINI (vpc);
1762 #undef FLD
1763 }
1764   NEXT (vpc);
1765
1766   CASE (sem, INSN_JL) : /* jl $sr */
1767 {
1768   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1769   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1770 #define FLD(f) abuf->fields.sfmt_jl.f
1771   int UNUSED written = 0;
1772   IADDR UNUSED pc = abuf->addr;
1773   SEM_BRANCH_INIT
1774   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1775
1776 {
1777   SI temp0;USI temp1;
1778   temp0 = ADDSI (ANDSI (pc, -4), 4);
1779   temp1 = ANDSI (* FLD (i_sr), -4);
1780   {
1781     SI opval = temp0;
1782     CPU (h_gr[((UINT) 14)]) = opval;
1783     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1784   }
1785   {
1786     USI opval = temp1;
1787     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1788     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1789   }
1790 }
1791
1792   SEM_BRANCH_FINI (vpc);
1793 #undef FLD
1794 }
1795   NEXT (vpc);
1796
1797   CASE (sem, INSN_JMP) : /* jmp $sr */
1798 {
1799   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1800   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1801 #define FLD(f) abuf->fields.sfmt_jl.f
1802   int UNUSED written = 0;
1803   IADDR UNUSED pc = abuf->addr;
1804   SEM_BRANCH_INIT
1805   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1806
1807   {
1808     USI opval = ANDSI (* FLD (i_sr), -4);
1809     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
1810     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
1811   }
1812
1813   SEM_BRANCH_FINI (vpc);
1814 #undef FLD
1815 }
1816   NEXT (vpc);
1817
1818   CASE (sem, INSN_LD) : /* ld $dr,@$sr */
1819 {
1820   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1821   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1822 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1823   int UNUSED written = 0;
1824   IADDR UNUSED pc = abuf->addr;
1825   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1826
1827   {
1828     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
1829     * FLD (i_dr) = opval;
1830     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1831   }
1832
1833 #undef FLD
1834 }
1835   NEXT (vpc);
1836
1837   CASE (sem, INSN_LD_D) : /* ld $dr,@($slo16,$sr) */
1838 {
1839   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1840   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1841 #define FLD(f) abuf->fields.sfmt_add3.f
1842   int UNUSED written = 0;
1843   IADDR UNUSED pc = abuf->addr;
1844   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1845
1846   {
1847     SI opval = GETMEMSI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)));
1848     * FLD (i_dr) = opval;
1849     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1850   }
1851
1852 #undef FLD
1853 }
1854   NEXT (vpc);
1855
1856   CASE (sem, INSN_LDB) : /* ldb $dr,@$sr */
1857 {
1858   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1859   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1860 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1861   int UNUSED written = 0;
1862   IADDR UNUSED pc = abuf->addr;
1863   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1864
1865   {
1866     SI opval = EXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
1867     * FLD (i_dr) = opval;
1868     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1869   }
1870
1871 #undef FLD
1872 }
1873   NEXT (vpc);
1874
1875   CASE (sem, INSN_LDB_D) : /* ldb $dr,@($slo16,$sr) */
1876 {
1877   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1878   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1879 #define FLD(f) abuf->fields.sfmt_add3.f
1880   int UNUSED written = 0;
1881   IADDR UNUSED pc = abuf->addr;
1882   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1883
1884   {
1885     SI opval = EXTQISI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1886     * FLD (i_dr) = opval;
1887     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1888   }
1889
1890 #undef FLD
1891 }
1892   NEXT (vpc);
1893
1894   CASE (sem, INSN_LDH) : /* ldh $dr,@$sr */
1895 {
1896   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1897   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1898 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1899   int UNUSED written = 0;
1900   IADDR UNUSED pc = abuf->addr;
1901   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1902
1903   {
1904     SI opval = EXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
1905     * FLD (i_dr) = opval;
1906     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1907   }
1908
1909 #undef FLD
1910 }
1911   NEXT (vpc);
1912
1913   CASE (sem, INSN_LDH_D) : /* ldh $dr,@($slo16,$sr) */
1914 {
1915   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1916   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1917 #define FLD(f) abuf->fields.sfmt_add3.f
1918   int UNUSED written = 0;
1919   IADDR UNUSED pc = abuf->addr;
1920   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1921
1922   {
1923     SI opval = EXTHISI (GETMEMHI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1924     * FLD (i_dr) = opval;
1925     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1926   }
1927
1928 #undef FLD
1929 }
1930   NEXT (vpc);
1931
1932   CASE (sem, INSN_LDUB) : /* ldub $dr,@$sr */
1933 {
1934   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1935   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1936 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1937   int UNUSED written = 0;
1938   IADDR UNUSED pc = abuf->addr;
1939   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1940
1941   {
1942     SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
1943     * FLD (i_dr) = opval;
1944     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1945   }
1946
1947 #undef FLD
1948 }
1949   NEXT (vpc);
1950
1951   CASE (sem, INSN_LDUB_D) : /* ldub $dr,@($slo16,$sr) */
1952 {
1953   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1954   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1955 #define FLD(f) abuf->fields.sfmt_add3.f
1956   int UNUSED written = 0;
1957   IADDR UNUSED pc = abuf->addr;
1958   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1959
1960   {
1961     SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
1962     * FLD (i_dr) = opval;
1963     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1964   }
1965
1966 #undef FLD
1967 }
1968   NEXT (vpc);
1969
1970   CASE (sem, INSN_LDUH) : /* lduh $dr,@$sr */
1971 {
1972   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1973   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1974 #define FLD(f) abuf->fields.sfmt_ld_plus.f
1975   int UNUSED written = 0;
1976   IADDR UNUSED pc = abuf->addr;
1977   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
1978
1979   {
1980     SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
1981     * FLD (i_dr) = opval;
1982     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
1983   }
1984
1985 #undef FLD
1986 }
1987   NEXT (vpc);
1988
1989   CASE (sem, INSN_LDUH_D) : /* lduh $dr,@($slo16,$sr) */
1990 {
1991   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1992   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1993 #define FLD(f) abuf->fields.sfmt_add3.f
1994   int UNUSED written = 0;
1995   IADDR UNUSED pc = abuf->addr;
1996   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1997
1998   {
1999     SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))));
2000     * FLD (i_dr) = opval;
2001     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2002   }
2003
2004 #undef FLD
2005 }
2006   NEXT (vpc);
2007
2008   CASE (sem, INSN_LD_PLUS) : /* ld $dr,@$sr+ */
2009 {
2010   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2011   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2012 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2013   int UNUSED written = 0;
2014   IADDR UNUSED pc = abuf->addr;
2015   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2016
2017 {
2018   SI temp0;SI temp1;
2019   temp0 = GETMEMSI (current_cpu, pc, * FLD (i_sr));
2020   temp1 = ADDSI (* FLD (i_sr), 4);
2021   {
2022     SI opval = temp0;
2023     * FLD (i_dr) = opval;
2024     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2025   }
2026   {
2027     SI opval = temp1;
2028     * FLD (i_sr) = opval;
2029     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2030   }
2031 }
2032
2033 #undef FLD
2034 }
2035   NEXT (vpc);
2036
2037   CASE (sem, INSN_LD24) : /* ld24 $dr,$uimm24 */
2038 {
2039   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2040   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2041 #define FLD(f) abuf->fields.sfmt_ld24.f
2042   int UNUSED written = 0;
2043   IADDR UNUSED pc = abuf->addr;
2044   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2045
2046   {
2047     SI opval = FLD (i_uimm24);
2048     * FLD (i_dr) = opval;
2049     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2050   }
2051
2052 #undef FLD
2053 }
2054   NEXT (vpc);
2055
2056   CASE (sem, INSN_LDI8) : /* ldi8 $dr,$simm8 */
2057 {
2058   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2059   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2060 #define FLD(f) abuf->fields.sfmt_addi.f
2061   int UNUSED written = 0;
2062   IADDR UNUSED pc = abuf->addr;
2063   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2064
2065   {
2066     SI opval = FLD (f_simm8);
2067     * FLD (i_dr) = opval;
2068     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2069   }
2070
2071 #undef FLD
2072 }
2073   NEXT (vpc);
2074
2075   CASE (sem, INSN_LDI16) : /* ldi16 $dr,$hash$slo16 */
2076 {
2077   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2078   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2079 #define FLD(f) abuf->fields.sfmt_add3.f
2080   int UNUSED written = 0;
2081   IADDR UNUSED pc = abuf->addr;
2082   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2083
2084   {
2085     SI opval = FLD (f_simm16);
2086     * FLD (i_dr) = opval;
2087     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2088   }
2089
2090 #undef FLD
2091 }
2092   NEXT (vpc);
2093
2094   CASE (sem, INSN_LOCK) : /* lock $dr,@$sr */
2095 {
2096   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2097   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2098 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2099   int UNUSED written = 0;
2100   IADDR UNUSED pc = abuf->addr;
2101   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2102
2103 {
2104   {
2105     BI opval = 1;
2106     CPU (h_lock) = opval;
2107     TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
2108   }
2109   {
2110     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
2111     * FLD (i_dr) = opval;
2112     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2113   }
2114 }
2115
2116 #undef FLD
2117 }
2118   NEXT (vpc);
2119
2120   CASE (sem, INSN_MACHI_A) : /* machi $src1,$src2,$acc */
2121 {
2122   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2123   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2124 #define FLD(f) abuf->fields.sfmt_machi_a.f
2125   int UNUSED written = 0;
2126   IADDR UNUSED pc = abuf->addr;
2127   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2128
2129   {
2130     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))))), 8), 8);
2131     SET_H_ACCUMS (FLD (f_acc), opval);
2132     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2133   }
2134
2135 #undef FLD
2136 }
2137   NEXT (vpc);
2138
2139   CASE (sem, INSN_MACLO_A) : /* maclo $src1,$src2,$acc */
2140 {
2141   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2142   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2143 #define FLD(f) abuf->fields.sfmt_machi_a.f
2144   int UNUSED written = 0;
2145   IADDR UNUSED pc = abuf->addr;
2146   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2147
2148   {
2149     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))))), 8), 8);
2150     SET_H_ACCUMS (FLD (f_acc), opval);
2151     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2152   }
2153
2154 #undef FLD
2155 }
2156   NEXT (vpc);
2157
2158   CASE (sem, INSN_MACWHI_A) : /* macwhi $src1,$src2,$acc */
2159 {
2160   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2161   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2162 #define FLD(f) abuf->fields.sfmt_machi_a.f
2163   int UNUSED written = 0;
2164   IADDR UNUSED pc = abuf->addr;
2165   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2166
2167   {
2168     DI opval = ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))));
2169     SET_H_ACCUMS (FLD (f_acc), opval);
2170     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2171   }
2172
2173 #undef FLD
2174 }
2175   NEXT (vpc);
2176
2177   CASE (sem, INSN_MACWLO_A) : /* macwlo $src1,$src2,$acc */
2178 {
2179   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2180   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2181 #define FLD(f) abuf->fields.sfmt_machi_a.f
2182   int UNUSED written = 0;
2183   IADDR UNUSED pc = abuf->addr;
2184   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2185
2186   {
2187     DI opval = ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))));
2188     SET_H_ACCUMS (FLD (f_acc), opval);
2189     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2190   }
2191
2192 #undef FLD
2193 }
2194   NEXT (vpc);
2195
2196   CASE (sem, INSN_MUL) : /* mul $dr,$sr */
2197 {
2198   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2199   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2200 #define FLD(f) abuf->fields.sfmt_add.f
2201   int UNUSED written = 0;
2202   IADDR UNUSED pc = abuf->addr;
2203   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2204
2205   {
2206     SI opval = MULSI (* FLD (i_dr), * FLD (i_sr));
2207     * FLD (i_dr) = opval;
2208     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2209   }
2210
2211 #undef FLD
2212 }
2213   NEXT (vpc);
2214
2215   CASE (sem, INSN_MULHI_A) : /* mulhi $src1,$src2,$acc */
2216 {
2217   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2218   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2219 #define FLD(f) abuf->fields.sfmt_machi_a.f
2220   int UNUSED written = 0;
2221   IADDR UNUSED pc = abuf->addr;
2222   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2223
2224   {
2225     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))), 16), 16);
2226     SET_H_ACCUMS (FLD (f_acc), opval);
2227     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2228   }
2229
2230 #undef FLD
2231 }
2232   NEXT (vpc);
2233
2234   CASE (sem, INSN_MULLO_A) : /* mullo $src1,$src2,$acc */
2235 {
2236   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2237   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2238 #define FLD(f) abuf->fields.sfmt_machi_a.f
2239   int UNUSED written = 0;
2240   IADDR UNUSED pc = abuf->addr;
2241   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2242
2243   {
2244     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 16), 16);
2245     SET_H_ACCUMS (FLD (f_acc), opval);
2246     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2247   }
2248
2249 #undef FLD
2250 }
2251   NEXT (vpc);
2252
2253   CASE (sem, INSN_MULWHI_A) : /* mulwhi $src1,$src2,$acc */
2254 {
2255   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2256   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2257 #define FLD(f) abuf->fields.sfmt_machi_a.f
2258   int UNUSED written = 0;
2259   IADDR UNUSED pc = abuf->addr;
2260   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2261
2262   {
2263     DI opval = MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))));
2264     SET_H_ACCUMS (FLD (f_acc), opval);
2265     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2266   }
2267
2268 #undef FLD
2269 }
2270   NEXT (vpc);
2271
2272   CASE (sem, INSN_MULWLO_A) : /* mulwlo $src1,$src2,$acc */
2273 {
2274   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2275   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2276 #define FLD(f) abuf->fields.sfmt_machi_a.f
2277   int UNUSED written = 0;
2278   IADDR UNUSED pc = abuf->addr;
2279   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2280
2281   {
2282     DI opval = MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))));
2283     SET_H_ACCUMS (FLD (f_acc), opval);
2284     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2285   }
2286
2287 #undef FLD
2288 }
2289   NEXT (vpc);
2290
2291   CASE (sem, INSN_MV) : /* mv $dr,$sr */
2292 {
2293   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2294   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2295 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2296   int UNUSED written = 0;
2297   IADDR UNUSED pc = abuf->addr;
2298   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2299
2300   {
2301     SI opval = * FLD (i_sr);
2302     * FLD (i_dr) = opval;
2303     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2304   }
2305
2306 #undef FLD
2307 }
2308   NEXT (vpc);
2309
2310   CASE (sem, INSN_MVFACHI_A) : /* mvfachi $dr,$accs */
2311 {
2312   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2313   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2314 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
2315   int UNUSED written = 0;
2316   IADDR UNUSED pc = abuf->addr;
2317   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2318
2319   {
2320     SI opval = TRUNCDISI (SRADI (GET_H_ACCUMS (FLD (f_accs)), 32));
2321     * FLD (i_dr) = opval;
2322     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2323   }
2324
2325 #undef FLD
2326 }
2327   NEXT (vpc);
2328
2329   CASE (sem, INSN_MVFACLO_A) : /* mvfaclo $dr,$accs */
2330 {
2331   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2332   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2333 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
2334   int UNUSED written = 0;
2335   IADDR UNUSED pc = abuf->addr;
2336   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2337
2338   {
2339     SI opval = TRUNCDISI (GET_H_ACCUMS (FLD (f_accs)));
2340     * FLD (i_dr) = opval;
2341     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2342   }
2343
2344 #undef FLD
2345 }
2346   NEXT (vpc);
2347
2348   CASE (sem, INSN_MVFACMI_A) : /* mvfacmi $dr,$accs */
2349 {
2350   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2351   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2352 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
2353   int UNUSED written = 0;
2354   IADDR UNUSED pc = abuf->addr;
2355   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2356
2357   {
2358     SI opval = TRUNCDISI (SRADI (GET_H_ACCUMS (FLD (f_accs)), 16));
2359     * FLD (i_dr) = opval;
2360     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2361   }
2362
2363 #undef FLD
2364 }
2365   NEXT (vpc);
2366
2367   CASE (sem, INSN_MVFC) : /* mvfc $dr,$scr */
2368 {
2369   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2370   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2371 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2372   int UNUSED written = 0;
2373   IADDR UNUSED pc = abuf->addr;
2374   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2375
2376   {
2377     SI opval = GET_H_CR (FLD (f_r2));
2378     * FLD (i_dr) = opval;
2379     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2380   }
2381
2382 #undef FLD
2383 }
2384   NEXT (vpc);
2385
2386   CASE (sem, INSN_MVTACHI_A) : /* mvtachi $src1,$accs */
2387 {
2388   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2389   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2390 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
2391   int UNUSED written = 0;
2392   IADDR UNUSED pc = abuf->addr;
2393   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2394
2395   {
2396     DI opval = ORDI (ANDDI (GET_H_ACCUMS (FLD (f_accs)), MAKEDI (0, 0xffffffff)), SLLDI (EXTSIDI (* FLD (i_src1)), 32));
2397     SET_H_ACCUMS (FLD (f_accs), opval);
2398     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2399   }
2400
2401 #undef FLD
2402 }
2403   NEXT (vpc);
2404
2405   CASE (sem, INSN_MVTACLO_A) : /* mvtaclo $src1,$accs */
2406 {
2407   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2408   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2409 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
2410   int UNUSED written = 0;
2411   IADDR UNUSED pc = abuf->addr;
2412   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2413
2414   {
2415     DI opval = ORDI (ANDDI (GET_H_ACCUMS (FLD (f_accs)), MAKEDI (0xffffffff, 0)), ZEXTSIDI (* FLD (i_src1)));
2416     SET_H_ACCUMS (FLD (f_accs), opval);
2417     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2418   }
2419
2420 #undef FLD
2421 }
2422   NEXT (vpc);
2423
2424   CASE (sem, INSN_MVTC) : /* mvtc $sr,$dcr */
2425 {
2426   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2427   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2428 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2429   int UNUSED written = 0;
2430   IADDR UNUSED pc = abuf->addr;
2431   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2432
2433   {
2434     USI opval = * FLD (i_sr);
2435     SET_H_CR (FLD (f_r1), opval);
2436     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
2437   }
2438
2439 #undef FLD
2440 }
2441   NEXT (vpc);
2442
2443   CASE (sem, INSN_NEG) : /* neg $dr,$sr */
2444 {
2445   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2446   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2447 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2448   int UNUSED written = 0;
2449   IADDR UNUSED pc = abuf->addr;
2450   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2451
2452   {
2453     SI opval = NEGSI (* FLD (i_sr));
2454     * FLD (i_dr) = opval;
2455     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2456   }
2457
2458 #undef FLD
2459 }
2460   NEXT (vpc);
2461
2462   CASE (sem, INSN_NOP) : /* nop */
2463 {
2464   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2465   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2466 #define FLD(f) abuf->fields.fmt_empty.f
2467   int UNUSED written = 0;
2468   IADDR UNUSED pc = abuf->addr;
2469   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2470
2471 PROFILE_COUNT_FILLNOPS (current_cpu, abuf->addr);
2472
2473 #undef FLD
2474 }
2475   NEXT (vpc);
2476
2477   CASE (sem, INSN_NOT) : /* not $dr,$sr */
2478 {
2479   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2480   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2481 #define FLD(f) abuf->fields.sfmt_ld_plus.f
2482   int UNUSED written = 0;
2483   IADDR UNUSED pc = abuf->addr;
2484   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2485
2486   {
2487     SI opval = INVSI (* FLD (i_sr));
2488     * FLD (i_dr) = opval;
2489     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2490   }
2491
2492 #undef FLD
2493 }
2494   NEXT (vpc);
2495
2496   CASE (sem, INSN_RAC_DSI) : /* rac $accd,$accs,$imm1 */
2497 {
2498   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2499   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2500 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
2501   int UNUSED written = 0;
2502   IADDR UNUSED pc = abuf->addr;
2503   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2504
2505 {
2506   DI tmp_tmp1;
2507   tmp_tmp1 = SLLDI (GET_H_ACCUMS (FLD (f_accs)), FLD (f_imm1));
2508   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
2509   {
2510     DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0xffff0000))) ? (MAKEDI (32767, 0xffff0000)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0xffff0000)));
2511     SET_H_ACCUMS (FLD (f_accd), opval);
2512     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2513   }
2514 }
2515
2516 #undef FLD
2517 }
2518   NEXT (vpc);
2519
2520   CASE (sem, INSN_RACH_DSI) : /* rach $accd,$accs,$imm1 */
2521 {
2522   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2523   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2524 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
2525   int UNUSED written = 0;
2526   IADDR UNUSED pc = abuf->addr;
2527   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2528
2529 {
2530   DI tmp_tmp1;
2531   tmp_tmp1 = SLLDI (GET_H_ACCUMS (FLD (f_accs)), FLD (f_imm1));
2532   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 0x80000000));
2533   {
2534     DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0))) ? (MAKEDI (32767, 0)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0)));
2535     SET_H_ACCUMS (FLD (f_accd), opval);
2536     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
2537   }
2538 }
2539
2540 #undef FLD
2541 }
2542   NEXT (vpc);
2543
2544   CASE (sem, INSN_RTE) : /* rte */
2545 {
2546   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2547   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2548 #define FLD(f) abuf->fields.fmt_empty.f
2549   int UNUSED written = 0;
2550   IADDR UNUSED pc = abuf->addr;
2551   SEM_BRANCH_INIT
2552   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2553
2554 {
2555   {
2556     USI opval = ANDSI (GET_H_CR (((UINT) 6)), -4);
2557     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
2558     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
2559   }
2560   {
2561     USI opval = GET_H_CR (((UINT) 14));
2562     SET_H_CR (((UINT) 6), opval);
2563     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
2564   }
2565   {
2566     UQI opval = CPU (h_bpsw);
2567     SET_H_PSW (opval);
2568     TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
2569   }
2570   {
2571     UQI opval = CPU (h_bbpsw);
2572     CPU (h_bpsw) = opval;
2573     TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
2574   }
2575 }
2576
2577   SEM_BRANCH_FINI (vpc);
2578 #undef FLD
2579 }
2580   NEXT (vpc);
2581
2582   CASE (sem, INSN_SETH) : /* seth $dr,$hash$hi16 */
2583 {
2584   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2585   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2586 #define FLD(f) abuf->fields.sfmt_seth.f
2587   int UNUSED written = 0;
2588   IADDR UNUSED pc = abuf->addr;
2589   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2590
2591   {
2592     SI opval = SLLSI (FLD (f_hi16), 16);
2593     * FLD (i_dr) = opval;
2594     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2595   }
2596
2597 #undef FLD
2598 }
2599   NEXT (vpc);
2600
2601   CASE (sem, INSN_SLL) : /* sll $dr,$sr */
2602 {
2603   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2604   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2605 #define FLD(f) abuf->fields.sfmt_add.f
2606   int UNUSED written = 0;
2607   IADDR UNUSED pc = abuf->addr;
2608   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2609
2610   {
2611     SI opval = SLLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2612     * FLD (i_dr) = opval;
2613     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2614   }
2615
2616 #undef FLD
2617 }
2618   NEXT (vpc);
2619
2620   CASE (sem, INSN_SLL3) : /* sll3 $dr,$sr,$simm16 */
2621 {
2622   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2623   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2624 #define FLD(f) abuf->fields.sfmt_add3.f
2625   int UNUSED written = 0;
2626   IADDR UNUSED pc = abuf->addr;
2627   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2628
2629   {
2630     SI opval = SLLSI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2631     * FLD (i_dr) = opval;
2632     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2633   }
2634
2635 #undef FLD
2636 }
2637   NEXT (vpc);
2638
2639   CASE (sem, INSN_SLLI) : /* slli $dr,$uimm5 */
2640 {
2641   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2642   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2643 #define FLD(f) abuf->fields.sfmt_slli.f
2644   int UNUSED written = 0;
2645   IADDR UNUSED pc = abuf->addr;
2646   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2647
2648   {
2649     SI opval = SLLSI (* FLD (i_dr), FLD (f_uimm5));
2650     * FLD (i_dr) = opval;
2651     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2652   }
2653
2654 #undef FLD
2655 }
2656   NEXT (vpc);
2657
2658   CASE (sem, INSN_SRA) : /* sra $dr,$sr */
2659 {
2660   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2661   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2662 #define FLD(f) abuf->fields.sfmt_add.f
2663   int UNUSED written = 0;
2664   IADDR UNUSED pc = abuf->addr;
2665   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2666
2667   {
2668     SI opval = SRASI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2669     * FLD (i_dr) = opval;
2670     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2671   }
2672
2673 #undef FLD
2674 }
2675   NEXT (vpc);
2676
2677   CASE (sem, INSN_SRA3) : /* sra3 $dr,$sr,$simm16 */
2678 {
2679   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2680   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2681 #define FLD(f) abuf->fields.sfmt_add3.f
2682   int UNUSED written = 0;
2683   IADDR UNUSED pc = abuf->addr;
2684   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2685
2686   {
2687     SI opval = SRASI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2688     * FLD (i_dr) = opval;
2689     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2690   }
2691
2692 #undef FLD
2693 }
2694   NEXT (vpc);
2695
2696   CASE (sem, INSN_SRAI) : /* srai $dr,$uimm5 */
2697 {
2698   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2699   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2700 #define FLD(f) abuf->fields.sfmt_slli.f
2701   int UNUSED written = 0;
2702   IADDR UNUSED pc = abuf->addr;
2703   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2704
2705   {
2706     SI opval = SRASI (* FLD (i_dr), FLD (f_uimm5));
2707     * FLD (i_dr) = opval;
2708     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2709   }
2710
2711 #undef FLD
2712 }
2713   NEXT (vpc);
2714
2715   CASE (sem, INSN_SRL) : /* srl $dr,$sr */
2716 {
2717   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2718   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2719 #define FLD(f) abuf->fields.sfmt_add.f
2720   int UNUSED written = 0;
2721   IADDR UNUSED pc = abuf->addr;
2722   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2723
2724   {
2725     SI opval = SRLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
2726     * FLD (i_dr) = opval;
2727     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2728   }
2729
2730 #undef FLD
2731 }
2732   NEXT (vpc);
2733
2734   CASE (sem, INSN_SRL3) : /* srl3 $dr,$sr,$simm16 */
2735 {
2736   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2737   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2738 #define FLD(f) abuf->fields.sfmt_add3.f
2739   int UNUSED written = 0;
2740   IADDR UNUSED pc = abuf->addr;
2741   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2742
2743   {
2744     SI opval = SRLSI (* FLD (i_sr), ANDSI (FLD (f_simm16), 31));
2745     * FLD (i_dr) = opval;
2746     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2747   }
2748
2749 #undef FLD
2750 }
2751   NEXT (vpc);
2752
2753   CASE (sem, INSN_SRLI) : /* srli $dr,$uimm5 */
2754 {
2755   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2756   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2757 #define FLD(f) abuf->fields.sfmt_slli.f
2758   int UNUSED written = 0;
2759   IADDR UNUSED pc = abuf->addr;
2760   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2761
2762   {
2763     SI opval = SRLSI (* FLD (i_dr), FLD (f_uimm5));
2764     * FLD (i_dr) = opval;
2765     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2766   }
2767
2768 #undef FLD
2769 }
2770   NEXT (vpc);
2771
2772   CASE (sem, INSN_ST) : /* st $src1,@$src2 */
2773 {
2774   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2775   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2776 #define FLD(f) abuf->fields.sfmt_st_plus.f
2777   int UNUSED written = 0;
2778   IADDR UNUSED pc = abuf->addr;
2779   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2780
2781   {
2782     SI opval = * FLD (i_src1);
2783     SETMEMSI (current_cpu, pc, * FLD (i_src2), opval);
2784     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2785   }
2786
2787 #undef FLD
2788 }
2789   NEXT (vpc);
2790
2791   CASE (sem, INSN_ST_D) : /* st $src1,@($slo16,$src2) */
2792 {
2793   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2794   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2795 #define FLD(f) abuf->fields.sfmt_st_d.f
2796   int UNUSED written = 0;
2797   IADDR UNUSED pc = abuf->addr;
2798   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2799
2800   {
2801     SI opval = * FLD (i_src1);
2802     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2803     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2804   }
2805
2806 #undef FLD
2807 }
2808   NEXT (vpc);
2809
2810   CASE (sem, INSN_STB) : /* stb $src1,@$src2 */
2811 {
2812   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2813   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2814 #define FLD(f) abuf->fields.sfmt_st_plus.f
2815   int UNUSED written = 0;
2816   IADDR UNUSED pc = abuf->addr;
2817   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2818
2819   {
2820     QI opval = * FLD (i_src1);
2821     SETMEMQI (current_cpu, pc, * FLD (i_src2), opval);
2822     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2823   }
2824
2825 #undef FLD
2826 }
2827   NEXT (vpc);
2828
2829   CASE (sem, INSN_STB_D) : /* stb $src1,@($slo16,$src2) */
2830 {
2831   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2832   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2833 #define FLD(f) abuf->fields.sfmt_st_d.f
2834   int UNUSED written = 0;
2835   IADDR UNUSED pc = abuf->addr;
2836   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2837
2838   {
2839     QI opval = * FLD (i_src1);
2840     SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2841     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2842   }
2843
2844 #undef FLD
2845 }
2846   NEXT (vpc);
2847
2848   CASE (sem, INSN_STH) : /* sth $src1,@$src2 */
2849 {
2850   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2851   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2852 #define FLD(f) abuf->fields.sfmt_st_plus.f
2853   int UNUSED written = 0;
2854   IADDR UNUSED pc = abuf->addr;
2855   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2856
2857   {
2858     HI opval = * FLD (i_src1);
2859     SETMEMHI (current_cpu, pc, * FLD (i_src2), opval);
2860     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2861   }
2862
2863 #undef FLD
2864 }
2865   NEXT (vpc);
2866
2867   CASE (sem, INSN_STH_D) : /* sth $src1,@($slo16,$src2) */
2868 {
2869   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2870   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2871 #define FLD(f) abuf->fields.sfmt_st_d.f
2872   int UNUSED written = 0;
2873   IADDR UNUSED pc = abuf->addr;
2874   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2875
2876   {
2877     HI opval = * FLD (i_src1);
2878     SETMEMHI (current_cpu, pc, ADDSI (* FLD (i_src2), FLD (f_simm16)), opval);
2879     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2880   }
2881
2882 #undef FLD
2883 }
2884   NEXT (vpc);
2885
2886   CASE (sem, INSN_ST_PLUS) : /* st $src1,@+$src2 */
2887 {
2888   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2889   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2890 #define FLD(f) abuf->fields.sfmt_st_plus.f
2891   int UNUSED written = 0;
2892   IADDR UNUSED pc = abuf->addr;
2893   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2894
2895 {
2896   SI tmp_new_src2;
2897   tmp_new_src2 = ADDSI (* FLD (i_src2), 4);
2898   {
2899     SI opval = * FLD (i_src1);
2900     SETMEMSI (current_cpu, pc, tmp_new_src2, opval);
2901     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2902   }
2903   {
2904     SI opval = tmp_new_src2;
2905     * FLD (i_src2) = opval;
2906     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2907   }
2908 }
2909
2910 #undef FLD
2911 }
2912   NEXT (vpc);
2913
2914   CASE (sem, INSN_STH_PLUS) : /* sth $src1,@$src2+ */
2915 {
2916   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2917   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2918 #define FLD(f) abuf->fields.sfmt_st_plus.f
2919   int UNUSED written = 0;
2920   IADDR UNUSED pc = abuf->addr;
2921   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2922
2923 {
2924   HI tmp_new_src2;
2925   {
2926     HI opval = * FLD (i_src1);
2927     SETMEMHI (current_cpu, pc, tmp_new_src2, opval);
2928     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2929   }
2930   tmp_new_src2 = ADDSI (* FLD (i_src2), 2);
2931   {
2932     SI opval = tmp_new_src2;
2933     * FLD (i_src2) = opval;
2934     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2935   }
2936 }
2937
2938 #undef FLD
2939 }
2940   NEXT (vpc);
2941
2942   CASE (sem, INSN_STB_PLUS) : /* stb $src1,@$src2+ */
2943 {
2944   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2945   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2946 #define FLD(f) abuf->fields.sfmt_st_plus.f
2947   int UNUSED written = 0;
2948   IADDR UNUSED pc = abuf->addr;
2949   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2950
2951 {
2952   QI tmp_new_src2;
2953   {
2954     QI opval = * FLD (i_src1);
2955     SETMEMQI (current_cpu, pc, tmp_new_src2, opval);
2956     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2957   }
2958   tmp_new_src2 = ADDSI (* FLD (i_src2), 1);
2959   {
2960     SI opval = tmp_new_src2;
2961     * FLD (i_src2) = opval;
2962     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2963   }
2964 }
2965
2966 #undef FLD
2967 }
2968   NEXT (vpc);
2969
2970   CASE (sem, INSN_ST_MINUS) : /* st $src1,@-$src2 */
2971 {
2972   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2973   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2974 #define FLD(f) abuf->fields.sfmt_st_plus.f
2975   int UNUSED written = 0;
2976   IADDR UNUSED pc = abuf->addr;
2977   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
2978
2979 {
2980   SI tmp_new_src2;
2981   tmp_new_src2 = SUBSI (* FLD (i_src2), 4);
2982   {
2983     SI opval = * FLD (i_src1);
2984     SETMEMSI (current_cpu, pc, tmp_new_src2, opval);
2985     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
2986   }
2987   {
2988     SI opval = tmp_new_src2;
2989     * FLD (i_src2) = opval;
2990     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
2991   }
2992 }
2993
2994 #undef FLD
2995 }
2996   NEXT (vpc);
2997
2998   CASE (sem, INSN_SUB) : /* sub $dr,$sr */
2999 {
3000   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3001   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3002 #define FLD(f) abuf->fields.sfmt_add.f
3003   int UNUSED written = 0;
3004   IADDR UNUSED pc = abuf->addr;
3005   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3006
3007   {
3008     SI opval = SUBSI (* FLD (i_dr), * FLD (i_sr));
3009     * FLD (i_dr) = opval;
3010     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3011   }
3012
3013 #undef FLD
3014 }
3015   NEXT (vpc);
3016
3017   CASE (sem, INSN_SUBV) : /* subv $dr,$sr */
3018 {
3019   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3020   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3021 #define FLD(f) abuf->fields.sfmt_add.f
3022   int UNUSED written = 0;
3023   IADDR UNUSED pc = abuf->addr;
3024   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3025
3026 {
3027   SI temp0;BI temp1;
3028   temp0 = SUBSI (* FLD (i_dr), * FLD (i_sr));
3029   temp1 = SUBOFSI (* FLD (i_dr), * FLD (i_sr), 0);
3030   {
3031     SI opval = temp0;
3032     * FLD (i_dr) = opval;
3033     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3034   }
3035   {
3036     BI opval = temp1;
3037     CPU (h_cond) = opval;
3038     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3039   }
3040 }
3041
3042 #undef FLD
3043 }
3044   NEXT (vpc);
3045
3046   CASE (sem, INSN_SUBX) : /* subx $dr,$sr */
3047 {
3048   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3049   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3050 #define FLD(f) abuf->fields.sfmt_add.f
3051   int UNUSED written = 0;
3052   IADDR UNUSED pc = abuf->addr;
3053   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3054
3055 {
3056   SI temp0;BI temp1;
3057   temp0 = SUBCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
3058   temp1 = SUBCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
3059   {
3060     SI opval = temp0;
3061     * FLD (i_dr) = opval;
3062     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3063   }
3064   {
3065     BI opval = temp1;
3066     CPU (h_cond) = opval;
3067     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3068   }
3069 }
3070
3071 #undef FLD
3072 }
3073   NEXT (vpc);
3074
3075   CASE (sem, INSN_TRAP) : /* trap $uimm4 */
3076 {
3077   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3078   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3079 #define FLD(f) abuf->fields.sfmt_trap.f
3080   int UNUSED written = 0;
3081   IADDR UNUSED pc = abuf->addr;
3082   SEM_BRANCH_INIT
3083   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3084
3085 {
3086   {
3087     USI opval = GET_H_CR (((UINT) 6));
3088     SET_H_CR (((UINT) 14), opval);
3089     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
3090   }
3091   {
3092     USI opval = ADDSI (pc, 4);
3093     SET_H_CR (((UINT) 6), opval);
3094     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
3095   }
3096   {
3097     UQI opval = CPU (h_bpsw);
3098     CPU (h_bbpsw) = opval;
3099     TRACE_RESULT (current_cpu, abuf, "bbpsw", 'x', opval);
3100   }
3101   {
3102     UQI opval = GET_H_PSW ();
3103     CPU (h_bpsw) = opval;
3104     TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
3105   }
3106   {
3107     UQI opval = ANDQI (GET_H_PSW (), 128);
3108     SET_H_PSW (opval);
3109     TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
3110   }
3111   {
3112     SI opval = m32r_trap (current_cpu, pc, FLD (f_uimm4));
3113     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
3114     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3115   }
3116 }
3117
3118   SEM_BRANCH_FINI (vpc);
3119 #undef FLD
3120 }
3121   NEXT (vpc);
3122
3123   CASE (sem, INSN_UNLOCK) : /* unlock $src1,@$src2 */
3124 {
3125   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3126   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3127 #define FLD(f) abuf->fields.sfmt_st_plus.f
3128   int UNUSED written = 0;
3129   IADDR UNUSED pc = abuf->addr;
3130   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3131
3132 {
3133 if (CPU (h_lock)) {
3134   {
3135     SI opval = * FLD (i_src1);
3136     SETMEMSI (current_cpu, pc, * FLD (i_src2), opval);
3137     written |= (1 << 4);
3138     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3139   }
3140 }
3141   {
3142     BI opval = 0;
3143     CPU (h_lock) = opval;
3144     TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
3145   }
3146 }
3147
3148   abuf->written = written;
3149 #undef FLD
3150 }
3151   NEXT (vpc);
3152
3153   CASE (sem, INSN_SATB) : /* satb $dr,$sr */
3154 {
3155   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3156   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3157 #define FLD(f) abuf->fields.sfmt_ld_plus.f
3158   int UNUSED written = 0;
3159   IADDR UNUSED pc = abuf->addr;
3160   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3161
3162   {
3163     SI opval = (GESI (* FLD (i_sr), 127)) ? (127) : (LESI (* FLD (i_sr), -128)) ? (-128) : (* FLD (i_sr));
3164     * FLD (i_dr) = opval;
3165     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3166   }
3167
3168 #undef FLD
3169 }
3170   NEXT (vpc);
3171
3172   CASE (sem, INSN_SATH) : /* sath $dr,$sr */
3173 {
3174   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3175   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3176 #define FLD(f) abuf->fields.sfmt_ld_plus.f
3177   int UNUSED written = 0;
3178   IADDR UNUSED pc = abuf->addr;
3179   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3180
3181   {
3182     SI opval = (GESI (* FLD (i_sr), 32767)) ? (32767) : (LESI (* FLD (i_sr), -32768)) ? (-32768) : (* FLD (i_sr));
3183     * FLD (i_dr) = opval;
3184     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3185   }
3186
3187 #undef FLD
3188 }
3189   NEXT (vpc);
3190
3191   CASE (sem, INSN_SAT) : /* sat $dr,$sr */
3192 {
3193   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3194   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3195 #define FLD(f) abuf->fields.sfmt_ld_plus.f
3196   int UNUSED written = 0;
3197   IADDR UNUSED pc = abuf->addr;
3198   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3199
3200   {
3201     SI opval = ((CPU (h_cond)) ? (((LTSI (* FLD (i_sr), 0)) ? (2147483647) : (0x80000000))) : (* FLD (i_sr)));
3202     * FLD (i_dr) = opval;
3203     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3204   }
3205
3206 #undef FLD
3207 }
3208   NEXT (vpc);
3209
3210   CASE (sem, INSN_PCMPBZ) : /* pcmpbz $src2 */
3211 {
3212   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3213   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3214 #define FLD(f) abuf->fields.sfmt_st_plus.f
3215   int UNUSED written = 0;
3216   IADDR UNUSED pc = abuf->addr;
3217   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3218
3219   {
3220     BI opval = (EQSI (ANDSI (* FLD (i_src2), 255), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 65280), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 16711680), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 0xff000000), 0)) ? (1) : (0);
3221     CPU (h_cond) = opval;
3222     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3223   }
3224
3225 #undef FLD
3226 }
3227   NEXT (vpc);
3228
3229   CASE (sem, INSN_SADD) : /* sadd */
3230 {
3231   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3232   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3233 #define FLD(f) abuf->fields.fmt_empty.f
3234   int UNUSED written = 0;
3235   IADDR UNUSED pc = abuf->addr;
3236   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3237
3238   {
3239     DI opval = ADDDI (SRADI (GET_H_ACCUMS (((UINT) 1)), 16), GET_H_ACCUMS (((UINT) 0)));
3240     SET_H_ACCUMS (((UINT) 0), opval);
3241     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
3242   }
3243
3244 #undef FLD
3245 }
3246   NEXT (vpc);
3247
3248   CASE (sem, INSN_MACWU1) : /* macwu1 $src1,$src2 */
3249 {
3250   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3251   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3252 #define FLD(f) abuf->fields.sfmt_st_plus.f
3253   int UNUSED written = 0;
3254   IADDR UNUSED pc = abuf->addr;
3255   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3256
3257   {
3258     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (((UINT) 1)), MULDI (EXTSIDI (* FLD (i_src1)), EXTSIDI (ANDSI (* FLD (i_src2), 65535)))), 8), 8);
3259     SET_H_ACCUMS (((UINT) 1), opval);
3260     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
3261   }
3262
3263 #undef FLD
3264 }
3265   NEXT (vpc);
3266
3267   CASE (sem, INSN_MSBLO) : /* msblo $src1,$src2 */
3268 {
3269   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3270   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3271 #define FLD(f) abuf->fields.sfmt_st_plus.f
3272   int UNUSED written = 0;
3273   IADDR UNUSED pc = abuf->addr;
3274   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3275
3276   {
3277     DI opval = SRADI (SLLDI (SUBDI (GET_H_ACCUM (), SRADI (SLLDI (MULDI (EXTHIDI (TRUNCSIHI (* FLD (i_src1))), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 32), 16)), 8), 8);
3278     SET_H_ACCUM (opval);
3279     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
3280   }
3281
3282 #undef FLD
3283 }
3284   NEXT (vpc);
3285
3286   CASE (sem, INSN_MULWU1) : /* mulwu1 $src1,$src2 */
3287 {
3288   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3289   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3290 #define FLD(f) abuf->fields.sfmt_st_plus.f
3291   int UNUSED written = 0;
3292   IADDR UNUSED pc = abuf->addr;
3293   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3294
3295   {
3296     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (* FLD (i_src1)), EXTSIDI (ANDSI (* FLD (i_src2), 65535))), 16), 16);
3297     SET_H_ACCUMS (((UINT) 1), opval);
3298     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
3299   }
3300
3301 #undef FLD
3302 }
3303   NEXT (vpc);
3304
3305   CASE (sem, INSN_MACLH1) : /* maclh1 $src1,$src2 */
3306 {
3307   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3308   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3309 #define FLD(f) abuf->fields.sfmt_st_plus.f
3310   int UNUSED written = 0;
3311   IADDR UNUSED pc = abuf->addr;
3312   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3313
3314   {
3315     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (((UINT) 1)), SLLDI (EXTSIDI (MULSI (EXTHISI (TRUNCSIHI (* FLD (i_src1))), SRASI (* FLD (i_src2), 16))), 16)), 8), 8);
3316     SET_H_ACCUMS (((UINT) 1), opval);
3317     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
3318   }
3319
3320 #undef FLD
3321 }
3322   NEXT (vpc);
3323
3324   CASE (sem, INSN_SC) : /* sc */
3325 {
3326   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3327   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3328 #define FLD(f) abuf->fields.fmt_empty.f
3329   int UNUSED written = 0;
3330   IADDR UNUSED pc = abuf->addr;
3331   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3332
3333 if (ZEXTBISI (CPU (h_cond)))
3334   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
3335
3336 #undef FLD
3337 }
3338   NEXT (vpc);
3339
3340   CASE (sem, INSN_SNC) : /* snc */
3341 {
3342   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3343   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3344 #define FLD(f) abuf->fields.fmt_empty.f
3345   int UNUSED written = 0;
3346   IADDR UNUSED pc = abuf->addr;
3347   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3348
3349 if (ZEXTBISI (NOTBI (CPU (h_cond))))
3350   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
3351
3352 #undef FLD
3353 }
3354   NEXT (vpc);
3355
3356   CASE (sem, INSN_CLRPSW) : /* clrpsw $uimm8 */
3357 {
3358   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3359   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3360 #define FLD(f) abuf->fields.sfmt_clrpsw.f
3361   int UNUSED written = 0;
3362   IADDR UNUSED pc = abuf->addr;
3363   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3364
3365   {
3366     SI opval = ANDSI (GET_H_CR (((UINT) 0)), ORSI (INVBI (FLD (f_uimm8)), 65280));
3367     SET_H_CR (((UINT) 0), opval);
3368     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
3369   }
3370
3371 #undef FLD
3372 }
3373   NEXT (vpc);
3374
3375   CASE (sem, INSN_SETPSW) : /* setpsw $uimm8 */
3376 {
3377   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3378   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3379 #define FLD(f) abuf->fields.sfmt_clrpsw.f
3380   int UNUSED written = 0;
3381   IADDR UNUSED pc = abuf->addr;
3382   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3383
3384   {
3385     SI opval = FLD (f_uimm8);
3386     SET_H_CR (((UINT) 0), opval);
3387     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
3388   }
3389
3390 #undef FLD
3391 }
3392   NEXT (vpc);
3393
3394   CASE (sem, INSN_BSET) : /* bset $uimm3,@($slo16,$sr) */
3395 {
3396   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3397   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3398 #define FLD(f) abuf->fields.sfmt_bset.f
3399   int UNUSED written = 0;
3400   IADDR UNUSED pc = abuf->addr;
3401   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3402
3403   {
3404     QI opval = ORQI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))), SLLSI (1, SUBSI (7, FLD (f_uimm3))));
3405     SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)), opval);
3406     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3407   }
3408
3409 #undef FLD
3410 }
3411   NEXT (vpc);
3412
3413   CASE (sem, INSN_BCLR) : /* bclr $uimm3,@($slo16,$sr) */
3414 {
3415   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3416   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3417 #define FLD(f) abuf->fields.sfmt_bset.f
3418   int UNUSED written = 0;
3419   IADDR UNUSED pc = abuf->addr;
3420   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3421
3422   {
3423     QI opval = ANDQI (GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16))), INVQI (SLLSI (1, SUBSI (7, FLD (f_uimm3)))));
3424     SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_sr), FLD (f_simm16)), opval);
3425     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
3426   }
3427
3428 #undef FLD
3429 }
3430   NEXT (vpc);
3431
3432   CASE (sem, INSN_BTST) : /* btst $uimm3,$sr */
3433 {
3434   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3435   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3436 #define FLD(f) abuf->fields.sfmt_bset.f
3437   int UNUSED written = 0;
3438   IADDR UNUSED pc = abuf->addr;
3439   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3440
3441   {
3442     BI opval = ANDQI (SRLSI (* FLD (i_sr), SUBSI (7, FLD (f_uimm3))), 1);
3443     CPU (h_cond) = opval;
3444     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3445   }
3446
3447 #undef FLD
3448 }
3449   NEXT (vpc);
3450
3451   CASE (sem, INSN_PAR_ADD) : /* add $dr,$sr */
3452 {
3453   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3454   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3455 #define FLD(f) abuf->fields.sfmt_add.f
3456 #define OPRND(f) par_exec->operands.sfmt_add.f
3457   int UNUSED written = 0;
3458   IADDR UNUSED pc = abuf->addr;
3459   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3460
3461   {
3462     SI opval = ADDSI (* FLD (i_dr), * FLD (i_sr));
3463     OPRND (dr) = opval;
3464     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3465   }
3466
3467 #undef OPRND
3468 #undef FLD
3469 }
3470   NEXT (vpc);
3471
3472 CASE (sem, INSN_WRITE_ADD) : /* add $dr,$sr */
3473   {
3474     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3475     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3476 #define FLD(f) abuf->fields.sfmt_add.f
3477 #define OPRND(f) par_exec->operands.sfmt_add.f
3478     int UNUSED written = abuf->written;
3479     IADDR UNUSED pc = abuf->addr;
3480     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3481
3482   * FLD (i_dr) = OPRND (dr);
3483
3484 #undef OPRND
3485 #undef FLD
3486   }
3487   NEXT (vpc);
3488
3489   CASE (sem, INSN_PAR_AND) : /* and $dr,$sr */
3490 {
3491   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3492   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3493 #define FLD(f) abuf->fields.sfmt_add.f
3494 #define OPRND(f) par_exec->operands.sfmt_add.f
3495   int UNUSED written = 0;
3496   IADDR UNUSED pc = abuf->addr;
3497   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3498
3499   {
3500     SI opval = ANDSI (* FLD (i_dr), * FLD (i_sr));
3501     OPRND (dr) = opval;
3502     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3503   }
3504
3505 #undef OPRND
3506 #undef FLD
3507 }
3508   NEXT (vpc);
3509
3510 CASE (sem, INSN_WRITE_AND) : /* and $dr,$sr */
3511   {
3512     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3513     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3514 #define FLD(f) abuf->fields.sfmt_add.f
3515 #define OPRND(f) par_exec->operands.sfmt_add.f
3516     int UNUSED written = abuf->written;
3517     IADDR UNUSED pc = abuf->addr;
3518     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3519
3520   * FLD (i_dr) = OPRND (dr);
3521
3522 #undef OPRND
3523 #undef FLD
3524   }
3525   NEXT (vpc);
3526
3527   CASE (sem, INSN_PAR_OR) : /* or $dr,$sr */
3528 {
3529   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3530   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3531 #define FLD(f) abuf->fields.sfmt_add.f
3532 #define OPRND(f) par_exec->operands.sfmt_add.f
3533   int UNUSED written = 0;
3534   IADDR UNUSED pc = abuf->addr;
3535   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3536
3537   {
3538     SI opval = ORSI (* FLD (i_dr), * FLD (i_sr));
3539     OPRND (dr) = opval;
3540     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3541   }
3542
3543 #undef OPRND
3544 #undef FLD
3545 }
3546   NEXT (vpc);
3547
3548 CASE (sem, INSN_WRITE_OR) : /* or $dr,$sr */
3549   {
3550     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3551     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3552 #define FLD(f) abuf->fields.sfmt_add.f
3553 #define OPRND(f) par_exec->operands.sfmt_add.f
3554     int UNUSED written = abuf->written;
3555     IADDR UNUSED pc = abuf->addr;
3556     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3557
3558   * FLD (i_dr) = OPRND (dr);
3559
3560 #undef OPRND
3561 #undef FLD
3562   }
3563   NEXT (vpc);
3564
3565   CASE (sem, INSN_PAR_XOR) : /* xor $dr,$sr */
3566 {
3567   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3568   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3569 #define FLD(f) abuf->fields.sfmt_add.f
3570 #define OPRND(f) par_exec->operands.sfmt_add.f
3571   int UNUSED written = 0;
3572   IADDR UNUSED pc = abuf->addr;
3573   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3574
3575   {
3576     SI opval = XORSI (* FLD (i_dr), * FLD (i_sr));
3577     OPRND (dr) = opval;
3578     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3579   }
3580
3581 #undef OPRND
3582 #undef FLD
3583 }
3584   NEXT (vpc);
3585
3586 CASE (sem, INSN_WRITE_XOR) : /* xor $dr,$sr */
3587   {
3588     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3589     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3590 #define FLD(f) abuf->fields.sfmt_add.f
3591 #define OPRND(f) par_exec->operands.sfmt_add.f
3592     int UNUSED written = abuf->written;
3593     IADDR UNUSED pc = abuf->addr;
3594     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3595
3596   * FLD (i_dr) = OPRND (dr);
3597
3598 #undef OPRND
3599 #undef FLD
3600   }
3601   NEXT (vpc);
3602
3603   CASE (sem, INSN_PAR_ADDI) : /* addi $dr,$simm8 */
3604 {
3605   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3606   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3607 #define FLD(f) abuf->fields.sfmt_addi.f
3608 #define OPRND(f) par_exec->operands.sfmt_addi.f
3609   int UNUSED written = 0;
3610   IADDR UNUSED pc = abuf->addr;
3611   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3612
3613   {
3614     SI opval = ADDSI (* FLD (i_dr), FLD (f_simm8));
3615     OPRND (dr) = opval;
3616     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3617   }
3618
3619 #undef OPRND
3620 #undef FLD
3621 }
3622   NEXT (vpc);
3623
3624 CASE (sem, INSN_WRITE_ADDI) : /* addi $dr,$simm8 */
3625   {
3626     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3627     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3628 #define FLD(f) abuf->fields.sfmt_addi.f
3629 #define OPRND(f) par_exec->operands.sfmt_addi.f
3630     int UNUSED written = abuf->written;
3631     IADDR UNUSED pc = abuf->addr;
3632     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3633
3634   * FLD (i_dr) = OPRND (dr);
3635
3636 #undef OPRND
3637 #undef FLD
3638   }
3639   NEXT (vpc);
3640
3641   CASE (sem, INSN_PAR_ADDV) : /* addv $dr,$sr */
3642 {
3643   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3644   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3645 #define FLD(f) abuf->fields.sfmt_add.f
3646 #define OPRND(f) par_exec->operands.sfmt_addv.f
3647   int UNUSED written = 0;
3648   IADDR UNUSED pc = abuf->addr;
3649   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3650
3651 {
3652   SI temp0;BI temp1;
3653   temp0 = ADDSI (* FLD (i_dr), * FLD (i_sr));
3654   temp1 = ADDOFSI (* FLD (i_dr), * FLD (i_sr), 0);
3655   {
3656     SI opval = temp0;
3657     OPRND (dr) = opval;
3658     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3659   }
3660   {
3661     BI opval = temp1;
3662     OPRND (condbit) = opval;
3663     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3664   }
3665 }
3666
3667 #undef OPRND
3668 #undef FLD
3669 }
3670   NEXT (vpc);
3671
3672 CASE (sem, INSN_WRITE_ADDV) : /* addv $dr,$sr */
3673   {
3674     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3675     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3676 #define FLD(f) abuf->fields.sfmt_add.f
3677 #define OPRND(f) par_exec->operands.sfmt_addv.f
3678     int UNUSED written = abuf->written;
3679     IADDR UNUSED pc = abuf->addr;
3680     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3681
3682   CPU (h_cond) = OPRND (condbit);
3683   * FLD (i_dr) = OPRND (dr);
3684
3685 #undef OPRND
3686 #undef FLD
3687   }
3688   NEXT (vpc);
3689
3690   CASE (sem, INSN_PAR_ADDX) : /* addx $dr,$sr */
3691 {
3692   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3693   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3694 #define FLD(f) abuf->fields.sfmt_add.f
3695 #define OPRND(f) par_exec->operands.sfmt_addx.f
3696   int UNUSED written = 0;
3697   IADDR UNUSED pc = abuf->addr;
3698   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3699
3700 {
3701   SI temp0;BI temp1;
3702   temp0 = ADDCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
3703   temp1 = ADDCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
3704   {
3705     SI opval = temp0;
3706     OPRND (dr) = opval;
3707     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3708   }
3709   {
3710     BI opval = temp1;
3711     OPRND (condbit) = opval;
3712     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
3713   }
3714 }
3715
3716 #undef OPRND
3717 #undef FLD
3718 }
3719   NEXT (vpc);
3720
3721 CASE (sem, INSN_WRITE_ADDX) : /* addx $dr,$sr */
3722   {
3723     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3724     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3725 #define FLD(f) abuf->fields.sfmt_add.f
3726 #define OPRND(f) par_exec->operands.sfmt_addx.f
3727     int UNUSED written = abuf->written;
3728     IADDR UNUSED pc = abuf->addr;
3729     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3730
3731   CPU (h_cond) = OPRND (condbit);
3732   * FLD (i_dr) = OPRND (dr);
3733
3734 #undef OPRND
3735 #undef FLD
3736   }
3737   NEXT (vpc);
3738
3739   CASE (sem, INSN_PAR_BC8) : /* bc.s $disp8 */
3740 {
3741   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3742   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3743 #define FLD(f) abuf->fields.sfmt_bl8.f
3744 #define OPRND(f) par_exec->operands.sfmt_bc8.f
3745   int UNUSED written = 0;
3746   IADDR UNUSED pc = abuf->addr;
3747   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3748
3749 if (CPU (h_cond)) {
3750   {
3751     USI opval = FLD (i_disp8);
3752     OPRND (pc) = opval;
3753     written |= (1 << 2);
3754     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3755   }
3756 }
3757
3758   abuf->written = written;
3759 #undef OPRND
3760 #undef FLD
3761 }
3762   NEXT (vpc);
3763
3764 CASE (sem, INSN_WRITE_BC8) : /* bc.s $disp8 */
3765   {
3766     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3767     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3768 #define FLD(f) abuf->fields.sfmt_bl8.f
3769 #define OPRND(f) par_exec->operands.sfmt_bc8.f
3770     int UNUSED written = abuf->written;
3771     IADDR UNUSED pc = abuf->addr;
3772     SEM_BRANCH_INIT
3773     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3774
3775   if (written & (1 << 2))
3776     {
3777       SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3778     }
3779
3780   SEM_BRANCH_FINI (vpc);
3781 #undef OPRND
3782 #undef FLD
3783   }
3784   NEXT (vpc);
3785
3786   CASE (sem, INSN_PAR_BL8) : /* bl.s $disp8 */
3787 {
3788   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3789   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3790 #define FLD(f) abuf->fields.sfmt_bl8.f
3791 #define OPRND(f) par_exec->operands.sfmt_bl8.f
3792   int UNUSED written = 0;
3793   IADDR UNUSED pc = abuf->addr;
3794   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3795
3796 {
3797   {
3798     SI opval = ADDSI (ANDSI (pc, -4), 4);
3799     OPRND (h_gr_SI_14) = opval;
3800     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3801   }
3802   {
3803     USI opval = FLD (i_disp8);
3804     OPRND (pc) = opval;
3805     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3806   }
3807 }
3808
3809 #undef OPRND
3810 #undef FLD
3811 }
3812   NEXT (vpc);
3813
3814 CASE (sem, INSN_WRITE_BL8) : /* bl.s $disp8 */
3815   {
3816     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3817     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3818 #define FLD(f) abuf->fields.sfmt_bl8.f
3819 #define OPRND(f) par_exec->operands.sfmt_bl8.f
3820     int UNUSED written = abuf->written;
3821     IADDR UNUSED pc = abuf->addr;
3822     SEM_BRANCH_INIT
3823     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3824
3825   CPU (h_gr[((UINT) 14)]) = OPRND (h_gr_SI_14);
3826   SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3827
3828   SEM_BRANCH_FINI (vpc);
3829 #undef OPRND
3830 #undef FLD
3831   }
3832   NEXT (vpc);
3833
3834   CASE (sem, INSN_PAR_BCL8) : /* bcl.s $disp8 */
3835 {
3836   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3837   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3838 #define FLD(f) abuf->fields.sfmt_bl8.f
3839 #define OPRND(f) par_exec->operands.sfmt_bcl8.f
3840   int UNUSED written = 0;
3841   IADDR UNUSED pc = abuf->addr;
3842   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3843
3844 if (CPU (h_cond)) {
3845 {
3846   {
3847     SI opval = ADDSI (ANDSI (pc, -4), 4);
3848     OPRND (h_gr_SI_14) = opval;
3849     written |= (1 << 3);
3850     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3851   }
3852   {
3853     USI opval = FLD (i_disp8);
3854     OPRND (pc) = opval;
3855     written |= (1 << 4);
3856     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3857   }
3858 }
3859 }
3860
3861   abuf->written = written;
3862 #undef OPRND
3863 #undef FLD
3864 }
3865   NEXT (vpc);
3866
3867 CASE (sem, INSN_WRITE_BCL8) : /* bcl.s $disp8 */
3868   {
3869     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3870     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3871 #define FLD(f) abuf->fields.sfmt_bl8.f
3872 #define OPRND(f) par_exec->operands.sfmt_bcl8.f
3873     int UNUSED written = abuf->written;
3874     IADDR UNUSED pc = abuf->addr;
3875     SEM_BRANCH_INIT
3876     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3877
3878   if (written & (1 << 3))
3879     {
3880       CPU (h_gr[((UINT) 14)]) = OPRND (h_gr_SI_14);
3881     }
3882   if (written & (1 << 4))
3883     {
3884       SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3885     }
3886
3887   SEM_BRANCH_FINI (vpc);
3888 #undef OPRND
3889 #undef FLD
3890   }
3891   NEXT (vpc);
3892
3893   CASE (sem, INSN_PAR_BNC8) : /* bnc.s $disp8 */
3894 {
3895   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3896   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3897 #define FLD(f) abuf->fields.sfmt_bl8.f
3898 #define OPRND(f) par_exec->operands.sfmt_bc8.f
3899   int UNUSED written = 0;
3900   IADDR UNUSED pc = abuf->addr;
3901   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3902
3903 if (NOTBI (CPU (h_cond))) {
3904   {
3905     USI opval = FLD (i_disp8);
3906     OPRND (pc) = opval;
3907     written |= (1 << 2);
3908     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3909   }
3910 }
3911
3912   abuf->written = written;
3913 #undef OPRND
3914 #undef FLD
3915 }
3916   NEXT (vpc);
3917
3918 CASE (sem, INSN_WRITE_BNC8) : /* bnc.s $disp8 */
3919   {
3920     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3921     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3922 #define FLD(f) abuf->fields.sfmt_bl8.f
3923 #define OPRND(f) par_exec->operands.sfmt_bc8.f
3924     int UNUSED written = abuf->written;
3925     IADDR UNUSED pc = abuf->addr;
3926     SEM_BRANCH_INIT
3927     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3928
3929   if (written & (1 << 2))
3930     {
3931       SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3932     }
3933
3934   SEM_BRANCH_FINI (vpc);
3935 #undef OPRND
3936 #undef FLD
3937   }
3938   NEXT (vpc);
3939
3940   CASE (sem, INSN_PAR_BRA8) : /* bra.s $disp8 */
3941 {
3942   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3943   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3944 #define FLD(f) abuf->fields.sfmt_bl8.f
3945 #define OPRND(f) par_exec->operands.sfmt_bra8.f
3946   int UNUSED written = 0;
3947   IADDR UNUSED pc = abuf->addr;
3948   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3949
3950   {
3951     USI opval = FLD (i_disp8);
3952     OPRND (pc) = opval;
3953     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
3954   }
3955
3956 #undef OPRND
3957 #undef FLD
3958 }
3959   NEXT (vpc);
3960
3961 CASE (sem, INSN_WRITE_BRA8) : /* bra.s $disp8 */
3962   {
3963     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3964     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
3965 #define FLD(f) abuf->fields.sfmt_bl8.f
3966 #define OPRND(f) par_exec->operands.sfmt_bra8.f
3967     int UNUSED written = abuf->written;
3968     IADDR UNUSED pc = abuf->addr;
3969     SEM_BRANCH_INIT
3970     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
3971
3972   SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
3973
3974   SEM_BRANCH_FINI (vpc);
3975 #undef OPRND
3976 #undef FLD
3977   }
3978   NEXT (vpc);
3979
3980   CASE (sem, INSN_PAR_BNCL8) : /* bncl.s $disp8 */
3981 {
3982   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3983   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3984 #define FLD(f) abuf->fields.sfmt_bl8.f
3985 #define OPRND(f) par_exec->operands.sfmt_bcl8.f
3986   int UNUSED written = 0;
3987   IADDR UNUSED pc = abuf->addr;
3988   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
3989
3990 if (NOTBI (CPU (h_cond))) {
3991 {
3992   {
3993     SI opval = ADDSI (ANDSI (pc, -4), 4);
3994     OPRND (h_gr_SI_14) = opval;
3995     written |= (1 << 3);
3996     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
3997   }
3998   {
3999     USI opval = FLD (i_disp8);
4000     OPRND (pc) = opval;
4001     written |= (1 << 4);
4002     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4003   }
4004 }
4005 }
4006
4007   abuf->written = written;
4008 #undef OPRND
4009 #undef FLD
4010 }
4011   NEXT (vpc);
4012
4013 CASE (sem, INSN_WRITE_BNCL8) : /* bncl.s $disp8 */
4014   {
4015     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4016     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4017 #define FLD(f) abuf->fields.sfmt_bl8.f
4018 #define OPRND(f) par_exec->operands.sfmt_bcl8.f
4019     int UNUSED written = abuf->written;
4020     IADDR UNUSED pc = abuf->addr;
4021     SEM_BRANCH_INIT
4022     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4023
4024   if (written & (1 << 3))
4025     {
4026       CPU (h_gr[((UINT) 14)]) = OPRND (h_gr_SI_14);
4027     }
4028   if (written & (1 << 4))
4029     {
4030       SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4031     }
4032
4033   SEM_BRANCH_FINI (vpc);
4034 #undef OPRND
4035 #undef FLD
4036   }
4037   NEXT (vpc);
4038
4039   CASE (sem, INSN_PAR_CMP) : /* cmp $src1,$src2 */
4040 {
4041   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4042   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4043 #define FLD(f) abuf->fields.sfmt_st_plus.f
4044 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4045   int UNUSED written = 0;
4046   IADDR UNUSED pc = abuf->addr;
4047   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4048
4049   {
4050     BI opval = LTSI (* FLD (i_src1), * FLD (i_src2));
4051     OPRND (condbit) = opval;
4052     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
4053   }
4054
4055 #undef OPRND
4056 #undef FLD
4057 }
4058   NEXT (vpc);
4059
4060 CASE (sem, INSN_WRITE_CMP) : /* cmp $src1,$src2 */
4061   {
4062     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4063     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4064 #define FLD(f) abuf->fields.sfmt_st_plus.f
4065 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4066     int UNUSED written = abuf->written;
4067     IADDR UNUSED pc = abuf->addr;
4068     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4069
4070   CPU (h_cond) = OPRND (condbit);
4071
4072 #undef OPRND
4073 #undef FLD
4074   }
4075   NEXT (vpc);
4076
4077   CASE (sem, INSN_PAR_CMPU) : /* cmpu $src1,$src2 */
4078 {
4079   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4080   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4081 #define FLD(f) abuf->fields.sfmt_st_plus.f
4082 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4083   int UNUSED written = 0;
4084   IADDR UNUSED pc = abuf->addr;
4085   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4086
4087   {
4088     BI opval = LTUSI (* FLD (i_src1), * FLD (i_src2));
4089     OPRND (condbit) = opval;
4090     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
4091   }
4092
4093 #undef OPRND
4094 #undef FLD
4095 }
4096   NEXT (vpc);
4097
4098 CASE (sem, INSN_WRITE_CMPU) : /* cmpu $src1,$src2 */
4099   {
4100     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4101     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4102 #define FLD(f) abuf->fields.sfmt_st_plus.f
4103 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4104     int UNUSED written = abuf->written;
4105     IADDR UNUSED pc = abuf->addr;
4106     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4107
4108   CPU (h_cond) = OPRND (condbit);
4109
4110 #undef OPRND
4111 #undef FLD
4112   }
4113   NEXT (vpc);
4114
4115   CASE (sem, INSN_PAR_CMPEQ) : /* cmpeq $src1,$src2 */
4116 {
4117   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4118   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4119 #define FLD(f) abuf->fields.sfmt_st_plus.f
4120 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4121   int UNUSED written = 0;
4122   IADDR UNUSED pc = abuf->addr;
4123   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4124
4125   {
4126     BI opval = EQSI (* FLD (i_src1), * FLD (i_src2));
4127     OPRND (condbit) = opval;
4128     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
4129   }
4130
4131 #undef OPRND
4132 #undef FLD
4133 }
4134   NEXT (vpc);
4135
4136 CASE (sem, INSN_WRITE_CMPEQ) : /* cmpeq $src1,$src2 */
4137   {
4138     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4139     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4140 #define FLD(f) abuf->fields.sfmt_st_plus.f
4141 #define OPRND(f) par_exec->operands.sfmt_cmp.f
4142     int UNUSED written = abuf->written;
4143     IADDR UNUSED pc = abuf->addr;
4144     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4145
4146   CPU (h_cond) = OPRND (condbit);
4147
4148 #undef OPRND
4149 #undef FLD
4150   }
4151   NEXT (vpc);
4152
4153   CASE (sem, INSN_PAR_CMPZ) : /* cmpz $src2 */
4154 {
4155   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4156   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4157 #define FLD(f) abuf->fields.sfmt_st_plus.f
4158 #define OPRND(f) par_exec->operands.sfmt_cmpz.f
4159   int UNUSED written = 0;
4160   IADDR UNUSED pc = abuf->addr;
4161   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4162
4163   {
4164     BI opval = EQSI (* FLD (i_src2), 0);
4165     OPRND (condbit) = opval;
4166     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
4167   }
4168
4169 #undef OPRND
4170 #undef FLD
4171 }
4172   NEXT (vpc);
4173
4174 CASE (sem, INSN_WRITE_CMPZ) : /* cmpz $src2 */
4175   {
4176     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4177     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4178 #define FLD(f) abuf->fields.sfmt_st_plus.f
4179 #define OPRND(f) par_exec->operands.sfmt_cmpz.f
4180     int UNUSED written = abuf->written;
4181     IADDR UNUSED pc = abuf->addr;
4182     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4183
4184   CPU (h_cond) = OPRND (condbit);
4185
4186 #undef OPRND
4187 #undef FLD
4188   }
4189   NEXT (vpc);
4190
4191   CASE (sem, INSN_PAR_JC) : /* jc $sr */
4192 {
4193   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4194   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4195 #define FLD(f) abuf->fields.sfmt_jl.f
4196 #define OPRND(f) par_exec->operands.sfmt_jc.f
4197   int UNUSED written = 0;
4198   IADDR UNUSED pc = abuf->addr;
4199   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4200
4201 if (CPU (h_cond)) {
4202   {
4203     USI opval = ANDSI (* FLD (i_sr), -4);
4204     OPRND (pc) = opval;
4205     written |= (1 << 2);
4206     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4207   }
4208 }
4209
4210   abuf->written = written;
4211 #undef OPRND
4212 #undef FLD
4213 }
4214   NEXT (vpc);
4215
4216 CASE (sem, INSN_WRITE_JC) : /* jc $sr */
4217   {
4218     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4219     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4220 #define FLD(f) abuf->fields.sfmt_jl.f
4221 #define OPRND(f) par_exec->operands.sfmt_jc.f
4222     int UNUSED written = abuf->written;
4223     IADDR UNUSED pc = abuf->addr;
4224     SEM_BRANCH_INIT
4225     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4226
4227   if (written & (1 << 2))
4228     {
4229       SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4230     }
4231
4232   SEM_BRANCH_FINI (vpc);
4233 #undef OPRND
4234 #undef FLD
4235   }
4236   NEXT (vpc);
4237
4238   CASE (sem, INSN_PAR_JNC) : /* jnc $sr */
4239 {
4240   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4241   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4242 #define FLD(f) abuf->fields.sfmt_jl.f
4243 #define OPRND(f) par_exec->operands.sfmt_jc.f
4244   int UNUSED written = 0;
4245   IADDR UNUSED pc = abuf->addr;
4246   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4247
4248 if (NOTBI (CPU (h_cond))) {
4249   {
4250     USI opval = ANDSI (* FLD (i_sr), -4);
4251     OPRND (pc) = opval;
4252     written |= (1 << 2);
4253     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4254   }
4255 }
4256
4257   abuf->written = written;
4258 #undef OPRND
4259 #undef FLD
4260 }
4261   NEXT (vpc);
4262
4263 CASE (sem, INSN_WRITE_JNC) : /* jnc $sr */
4264   {
4265     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4266     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4267 #define FLD(f) abuf->fields.sfmt_jl.f
4268 #define OPRND(f) par_exec->operands.sfmt_jc.f
4269     int UNUSED written = abuf->written;
4270     IADDR UNUSED pc = abuf->addr;
4271     SEM_BRANCH_INIT
4272     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4273
4274   if (written & (1 << 2))
4275     {
4276       SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4277     }
4278
4279   SEM_BRANCH_FINI (vpc);
4280 #undef OPRND
4281 #undef FLD
4282   }
4283   NEXT (vpc);
4284
4285   CASE (sem, INSN_PAR_JL) : /* jl $sr */
4286 {
4287   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4288   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4289 #define FLD(f) abuf->fields.sfmt_jl.f
4290 #define OPRND(f) par_exec->operands.sfmt_jl.f
4291   int UNUSED written = 0;
4292   IADDR UNUSED pc = abuf->addr;
4293   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4294
4295 {
4296   SI temp0;USI temp1;
4297   temp0 = ADDSI (ANDSI (pc, -4), 4);
4298   temp1 = ANDSI (* FLD (i_sr), -4);
4299   {
4300     SI opval = temp0;
4301     OPRND (h_gr_SI_14) = opval;
4302     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4303   }
4304   {
4305     USI opval = temp1;
4306     OPRND (pc) = opval;
4307     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4308   }
4309 }
4310
4311 #undef OPRND
4312 #undef FLD
4313 }
4314   NEXT (vpc);
4315
4316 CASE (sem, INSN_WRITE_JL) : /* jl $sr */
4317   {
4318     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4319     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4320 #define FLD(f) abuf->fields.sfmt_jl.f
4321 #define OPRND(f) par_exec->operands.sfmt_jl.f
4322     int UNUSED written = abuf->written;
4323     IADDR UNUSED pc = abuf->addr;
4324     SEM_BRANCH_INIT
4325     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4326
4327   CPU (h_gr[((UINT) 14)]) = OPRND (h_gr_SI_14);
4328   SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4329
4330   SEM_BRANCH_FINI (vpc);
4331 #undef OPRND
4332 #undef FLD
4333   }
4334   NEXT (vpc);
4335
4336   CASE (sem, INSN_PAR_JMP) : /* jmp $sr */
4337 {
4338   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4339   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4340 #define FLD(f) abuf->fields.sfmt_jl.f
4341 #define OPRND(f) par_exec->operands.sfmt_jmp.f
4342   int UNUSED written = 0;
4343   IADDR UNUSED pc = abuf->addr;
4344   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4345
4346   {
4347     USI opval = ANDSI (* FLD (i_sr), -4);
4348     OPRND (pc) = opval;
4349     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
4350   }
4351
4352 #undef OPRND
4353 #undef FLD
4354 }
4355   NEXT (vpc);
4356
4357 CASE (sem, INSN_WRITE_JMP) : /* jmp $sr */
4358   {
4359     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4360     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4361 #define FLD(f) abuf->fields.sfmt_jl.f
4362 #define OPRND(f) par_exec->operands.sfmt_jmp.f
4363     int UNUSED written = abuf->written;
4364     IADDR UNUSED pc = abuf->addr;
4365     SEM_BRANCH_INIT
4366     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4367
4368   SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
4369
4370   SEM_BRANCH_FINI (vpc);
4371 #undef OPRND
4372 #undef FLD
4373   }
4374   NEXT (vpc);
4375
4376   CASE (sem, INSN_PAR_LD) : /* ld $dr,@$sr */
4377 {
4378   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4379   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4380 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4381 #define OPRND(f) par_exec->operands.sfmt_ld.f
4382   int UNUSED written = 0;
4383   IADDR UNUSED pc = abuf->addr;
4384   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4385
4386   {
4387     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
4388     OPRND (dr) = opval;
4389     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4390   }
4391
4392 #undef OPRND
4393 #undef FLD
4394 }
4395   NEXT (vpc);
4396
4397 CASE (sem, INSN_WRITE_LD) : /* ld $dr,@$sr */
4398   {
4399     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4400     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4401 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4402 #define OPRND(f) par_exec->operands.sfmt_ld.f
4403     int UNUSED written = abuf->written;
4404     IADDR UNUSED pc = abuf->addr;
4405     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4406
4407   * FLD (i_dr) = OPRND (dr);
4408
4409 #undef OPRND
4410 #undef FLD
4411   }
4412   NEXT (vpc);
4413
4414   CASE (sem, INSN_PAR_LDB) : /* ldb $dr,@$sr */
4415 {
4416   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4417   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4418 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4419 #define OPRND(f) par_exec->operands.sfmt_ldb.f
4420   int UNUSED written = 0;
4421   IADDR UNUSED pc = abuf->addr;
4422   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4423
4424   {
4425     SI opval = EXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
4426     OPRND (dr) = opval;
4427     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4428   }
4429
4430 #undef OPRND
4431 #undef FLD
4432 }
4433   NEXT (vpc);
4434
4435 CASE (sem, INSN_WRITE_LDB) : /* ldb $dr,@$sr */
4436   {
4437     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4438     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4439 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4440 #define OPRND(f) par_exec->operands.sfmt_ldb.f
4441     int UNUSED written = abuf->written;
4442     IADDR UNUSED pc = abuf->addr;
4443     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4444
4445   * FLD (i_dr) = OPRND (dr);
4446
4447 #undef OPRND
4448 #undef FLD
4449   }
4450   NEXT (vpc);
4451
4452   CASE (sem, INSN_PAR_LDH) : /* ldh $dr,@$sr */
4453 {
4454   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4455   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4456 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4457 #define OPRND(f) par_exec->operands.sfmt_ldh.f
4458   int UNUSED written = 0;
4459   IADDR UNUSED pc = abuf->addr;
4460   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4461
4462   {
4463     SI opval = EXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
4464     OPRND (dr) = opval;
4465     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4466   }
4467
4468 #undef OPRND
4469 #undef FLD
4470 }
4471   NEXT (vpc);
4472
4473 CASE (sem, INSN_WRITE_LDH) : /* ldh $dr,@$sr */
4474   {
4475     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4476     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4477 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4478 #define OPRND(f) par_exec->operands.sfmt_ldh.f
4479     int UNUSED written = abuf->written;
4480     IADDR UNUSED pc = abuf->addr;
4481     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4482
4483   * FLD (i_dr) = OPRND (dr);
4484
4485 #undef OPRND
4486 #undef FLD
4487   }
4488   NEXT (vpc);
4489
4490   CASE (sem, INSN_PAR_LDUB) : /* ldub $dr,@$sr */
4491 {
4492   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4493   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4494 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4495 #define OPRND(f) par_exec->operands.sfmt_ldb.f
4496   int UNUSED written = 0;
4497   IADDR UNUSED pc = abuf->addr;
4498   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4499
4500   {
4501     SI opval = ZEXTQISI (GETMEMQI (current_cpu, pc, * FLD (i_sr)));
4502     OPRND (dr) = opval;
4503     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4504   }
4505
4506 #undef OPRND
4507 #undef FLD
4508 }
4509   NEXT (vpc);
4510
4511 CASE (sem, INSN_WRITE_LDUB) : /* ldub $dr,@$sr */
4512   {
4513     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4514     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4515 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4516 #define OPRND(f) par_exec->operands.sfmt_ldb.f
4517     int UNUSED written = abuf->written;
4518     IADDR UNUSED pc = abuf->addr;
4519     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4520
4521   * FLD (i_dr) = OPRND (dr);
4522
4523 #undef OPRND
4524 #undef FLD
4525   }
4526   NEXT (vpc);
4527
4528   CASE (sem, INSN_PAR_LDUH) : /* lduh $dr,@$sr */
4529 {
4530   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4531   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4532 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4533 #define OPRND(f) par_exec->operands.sfmt_ldh.f
4534   int UNUSED written = 0;
4535   IADDR UNUSED pc = abuf->addr;
4536   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4537
4538   {
4539     SI opval = ZEXTHISI (GETMEMHI (current_cpu, pc, * FLD (i_sr)));
4540     OPRND (dr) = opval;
4541     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4542   }
4543
4544 #undef OPRND
4545 #undef FLD
4546 }
4547   NEXT (vpc);
4548
4549 CASE (sem, INSN_WRITE_LDUH) : /* lduh $dr,@$sr */
4550   {
4551     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4552     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4553 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4554 #define OPRND(f) par_exec->operands.sfmt_ldh.f
4555     int UNUSED written = abuf->written;
4556     IADDR UNUSED pc = abuf->addr;
4557     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4558
4559   * FLD (i_dr) = OPRND (dr);
4560
4561 #undef OPRND
4562 #undef FLD
4563   }
4564   NEXT (vpc);
4565
4566   CASE (sem, INSN_PAR_LD_PLUS) : /* ld $dr,@$sr+ */
4567 {
4568   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4569   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4570 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4571 #define OPRND(f) par_exec->operands.sfmt_ld_plus.f
4572   int UNUSED written = 0;
4573   IADDR UNUSED pc = abuf->addr;
4574   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4575
4576 {
4577   SI temp0;SI temp1;
4578   temp0 = GETMEMSI (current_cpu, pc, * FLD (i_sr));
4579   temp1 = ADDSI (* FLD (i_sr), 4);
4580   {
4581     SI opval = temp0;
4582     OPRND (dr) = opval;
4583     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4584   }
4585   {
4586     SI opval = temp1;
4587     OPRND (sr) = opval;
4588     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4589   }
4590 }
4591
4592 #undef OPRND
4593 #undef FLD
4594 }
4595   NEXT (vpc);
4596
4597 CASE (sem, INSN_WRITE_LD_PLUS) : /* ld $dr,@$sr+ */
4598   {
4599     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4600     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4601 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4602 #define OPRND(f) par_exec->operands.sfmt_ld_plus.f
4603     int UNUSED written = abuf->written;
4604     IADDR UNUSED pc = abuf->addr;
4605     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4606
4607   * FLD (i_dr) = OPRND (dr);
4608   * FLD (i_sr) = OPRND (sr);
4609
4610 #undef OPRND
4611 #undef FLD
4612   }
4613   NEXT (vpc);
4614
4615   CASE (sem, INSN_PAR_LDI8) : /* ldi8 $dr,$simm8 */
4616 {
4617   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4618   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4619 #define FLD(f) abuf->fields.sfmt_addi.f
4620 #define OPRND(f) par_exec->operands.sfmt_ldi8.f
4621   int UNUSED written = 0;
4622   IADDR UNUSED pc = abuf->addr;
4623   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4624
4625   {
4626     SI opval = FLD (f_simm8);
4627     OPRND (dr) = opval;
4628     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4629   }
4630
4631 #undef OPRND
4632 #undef FLD
4633 }
4634   NEXT (vpc);
4635
4636 CASE (sem, INSN_WRITE_LDI8) : /* ldi8 $dr,$simm8 */
4637   {
4638     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4639     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4640 #define FLD(f) abuf->fields.sfmt_addi.f
4641 #define OPRND(f) par_exec->operands.sfmt_ldi8.f
4642     int UNUSED written = abuf->written;
4643     IADDR UNUSED pc = abuf->addr;
4644     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4645
4646   * FLD (i_dr) = OPRND (dr);
4647
4648 #undef OPRND
4649 #undef FLD
4650   }
4651   NEXT (vpc);
4652
4653   CASE (sem, INSN_PAR_LOCK) : /* lock $dr,@$sr */
4654 {
4655   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4656   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4657 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4658 #define OPRND(f) par_exec->operands.sfmt_lock.f
4659   int UNUSED written = 0;
4660   IADDR UNUSED pc = abuf->addr;
4661   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4662
4663 {
4664   {
4665     BI opval = 1;
4666     OPRND (h_lock_BI) = opval;
4667     TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
4668   }
4669   {
4670     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_sr));
4671     OPRND (dr) = opval;
4672     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4673   }
4674 }
4675
4676 #undef OPRND
4677 #undef FLD
4678 }
4679   NEXT (vpc);
4680
4681 CASE (sem, INSN_WRITE_LOCK) : /* lock $dr,@$sr */
4682   {
4683     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4684     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4685 #define FLD(f) abuf->fields.sfmt_ld_plus.f
4686 #define OPRND(f) par_exec->operands.sfmt_lock.f
4687     int UNUSED written = abuf->written;
4688     IADDR UNUSED pc = abuf->addr;
4689     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4690
4691   * FLD (i_dr) = OPRND (dr);
4692   CPU (h_lock) = OPRND (h_lock_BI);
4693
4694 #undef OPRND
4695 #undef FLD
4696   }
4697   NEXT (vpc);
4698
4699   CASE (sem, INSN_PAR_MACHI_A) : /* machi $src1,$src2,$acc */
4700 {
4701   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4702   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4703 #define FLD(f) abuf->fields.sfmt_machi_a.f
4704 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4705   int UNUSED written = 0;
4706   IADDR UNUSED pc = abuf->addr;
4707   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4708
4709   {
4710     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))))), 8), 8);
4711     OPRND (acc) = opval;
4712     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4713   }
4714
4715 #undef OPRND
4716 #undef FLD
4717 }
4718   NEXT (vpc);
4719
4720 CASE (sem, INSN_WRITE_MACHI_A) : /* machi $src1,$src2,$acc */
4721   {
4722     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4723     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4724 #define FLD(f) abuf->fields.sfmt_machi_a.f
4725 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4726     int UNUSED written = abuf->written;
4727     IADDR UNUSED pc = abuf->addr;
4728     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4729
4730   SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4731
4732 #undef OPRND
4733 #undef FLD
4734   }
4735   NEXT (vpc);
4736
4737   CASE (sem, INSN_PAR_MACLO_A) : /* maclo $src1,$src2,$acc */
4738 {
4739   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4740   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4741 #define FLD(f) abuf->fields.sfmt_machi_a.f
4742 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4743   int UNUSED written = 0;
4744   IADDR UNUSED pc = abuf->addr;
4745   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4746
4747   {
4748     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))))), 8), 8);
4749     OPRND (acc) = opval;
4750     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4751   }
4752
4753 #undef OPRND
4754 #undef FLD
4755 }
4756   NEXT (vpc);
4757
4758 CASE (sem, INSN_WRITE_MACLO_A) : /* maclo $src1,$src2,$acc */
4759   {
4760     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4761     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4762 #define FLD(f) abuf->fields.sfmt_machi_a.f
4763 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4764     int UNUSED written = abuf->written;
4765     IADDR UNUSED pc = abuf->addr;
4766     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4767
4768   SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4769
4770 #undef OPRND
4771 #undef FLD
4772   }
4773   NEXT (vpc);
4774
4775   CASE (sem, INSN_PAR_MACWHI_A) : /* macwhi $src1,$src2,$acc */
4776 {
4777   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4778   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4779 #define FLD(f) abuf->fields.sfmt_machi_a.f
4780 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4781   int UNUSED written = 0;
4782   IADDR UNUSED pc = abuf->addr;
4783   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4784
4785   {
4786     DI opval = ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))));
4787     OPRND (acc) = opval;
4788     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4789   }
4790
4791 #undef OPRND
4792 #undef FLD
4793 }
4794   NEXT (vpc);
4795
4796 CASE (sem, INSN_WRITE_MACWHI_A) : /* macwhi $src1,$src2,$acc */
4797   {
4798     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4799     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4800 #define FLD(f) abuf->fields.sfmt_machi_a.f
4801 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4802     int UNUSED written = abuf->written;
4803     IADDR UNUSED pc = abuf->addr;
4804     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4805
4806   SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4807
4808 #undef OPRND
4809 #undef FLD
4810   }
4811   NEXT (vpc);
4812
4813   CASE (sem, INSN_PAR_MACWLO_A) : /* macwlo $src1,$src2,$acc */
4814 {
4815   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4816   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4817 #define FLD(f) abuf->fields.sfmt_machi_a.f
4818 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4819   int UNUSED written = 0;
4820   IADDR UNUSED pc = abuf->addr;
4821   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4822
4823   {
4824     DI opval = ADDDI (GET_H_ACCUMS (FLD (f_acc)), MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))));
4825     OPRND (acc) = opval;
4826     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4827   }
4828
4829 #undef OPRND
4830 #undef FLD
4831 }
4832   NEXT (vpc);
4833
4834 CASE (sem, INSN_WRITE_MACWLO_A) : /* macwlo $src1,$src2,$acc */
4835   {
4836     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4837     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4838 #define FLD(f) abuf->fields.sfmt_machi_a.f
4839 #define OPRND(f) par_exec->operands.sfmt_machi_a.f
4840     int UNUSED written = abuf->written;
4841     IADDR UNUSED pc = abuf->addr;
4842     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4843
4844   SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4845
4846 #undef OPRND
4847 #undef FLD
4848   }
4849   NEXT (vpc);
4850
4851   CASE (sem, INSN_PAR_MUL) : /* mul $dr,$sr */
4852 {
4853   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4854   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4855 #define FLD(f) abuf->fields.sfmt_add.f
4856 #define OPRND(f) par_exec->operands.sfmt_add.f
4857   int UNUSED written = 0;
4858   IADDR UNUSED pc = abuf->addr;
4859   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4860
4861   {
4862     SI opval = MULSI (* FLD (i_dr), * FLD (i_sr));
4863     OPRND (dr) = opval;
4864     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
4865   }
4866
4867 #undef OPRND
4868 #undef FLD
4869 }
4870   NEXT (vpc);
4871
4872 CASE (sem, INSN_WRITE_MUL) : /* mul $dr,$sr */
4873   {
4874     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4875     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4876 #define FLD(f) abuf->fields.sfmt_add.f
4877 #define OPRND(f) par_exec->operands.sfmt_add.f
4878     int UNUSED written = abuf->written;
4879     IADDR UNUSED pc = abuf->addr;
4880     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4881
4882   * FLD (i_dr) = OPRND (dr);
4883
4884 #undef OPRND
4885 #undef FLD
4886   }
4887   NEXT (vpc);
4888
4889   CASE (sem, INSN_PAR_MULHI_A) : /* mulhi $src1,$src2,$acc */
4890 {
4891   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4892   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4893 #define FLD(f) abuf->fields.sfmt_machi_a.f
4894 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4895   int UNUSED written = 0;
4896   IADDR UNUSED pc = abuf->addr;
4897   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4898
4899   {
4900     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (ANDSI (* FLD (i_src1), 0xffff0000)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16)))), 16), 16);
4901     OPRND (acc) = opval;
4902     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4903   }
4904
4905 #undef OPRND
4906 #undef FLD
4907 }
4908   NEXT (vpc);
4909
4910 CASE (sem, INSN_WRITE_MULHI_A) : /* mulhi $src1,$src2,$acc */
4911   {
4912     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4913     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4914 #define FLD(f) abuf->fields.sfmt_machi_a.f
4915 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4916     int UNUSED written = abuf->written;
4917     IADDR UNUSED pc = abuf->addr;
4918     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4919
4920   SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4921
4922 #undef OPRND
4923 #undef FLD
4924   }
4925   NEXT (vpc);
4926
4927   CASE (sem, INSN_PAR_MULLO_A) : /* mullo $src1,$src2,$acc */
4928 {
4929   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4930   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4931 #define FLD(f) abuf->fields.sfmt_machi_a.f
4932 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4933   int UNUSED written = 0;
4934   IADDR UNUSED pc = abuf->addr;
4935   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4936
4937   {
4938     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (SLLSI (* FLD (i_src1), 16)), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 16), 16);
4939     OPRND (acc) = opval;
4940     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4941   }
4942
4943 #undef OPRND
4944 #undef FLD
4945 }
4946   NEXT (vpc);
4947
4948 CASE (sem, INSN_WRITE_MULLO_A) : /* mullo $src1,$src2,$acc */
4949   {
4950     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4951     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4952 #define FLD(f) abuf->fields.sfmt_machi_a.f
4953 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4954     int UNUSED written = abuf->written;
4955     IADDR UNUSED pc = abuf->addr;
4956     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4957
4958   SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4959
4960 #undef OPRND
4961 #undef FLD
4962   }
4963   NEXT (vpc);
4964
4965   CASE (sem, INSN_PAR_MULWHI_A) : /* mulwhi $src1,$src2,$acc */
4966 {
4967   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4968   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4969 #define FLD(f) abuf->fields.sfmt_machi_a.f
4970 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4971   int UNUSED written = 0;
4972   IADDR UNUSED pc = abuf->addr;
4973   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
4974
4975   {
4976     DI opval = MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (SRASI (* FLD (i_src2), 16))));
4977     OPRND (acc) = opval;
4978     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
4979   }
4980
4981 #undef OPRND
4982 #undef FLD
4983 }
4984   NEXT (vpc);
4985
4986 CASE (sem, INSN_WRITE_MULWHI_A) : /* mulwhi $src1,$src2,$acc */
4987   {
4988     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4989     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
4990 #define FLD(f) abuf->fields.sfmt_machi_a.f
4991 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
4992     int UNUSED written = abuf->written;
4993     IADDR UNUSED pc = abuf->addr;
4994     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
4995
4996   SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
4997
4998 #undef OPRND
4999 #undef FLD
5000   }
5001   NEXT (vpc);
5002
5003   CASE (sem, INSN_PAR_MULWLO_A) : /* mulwlo $src1,$src2,$acc */
5004 {
5005   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5006   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5007 #define FLD(f) abuf->fields.sfmt_machi_a.f
5008 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
5009   int UNUSED written = 0;
5010   IADDR UNUSED pc = abuf->addr;
5011   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5012
5013   {
5014     DI opval = MULDI (EXTSIDI (* FLD (i_src1)), EXTHIDI (TRUNCSIHI (* FLD (i_src2))));
5015     OPRND (acc) = opval;
5016     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5017   }
5018
5019 #undef OPRND
5020 #undef FLD
5021 }
5022   NEXT (vpc);
5023
5024 CASE (sem, INSN_WRITE_MULWLO_A) : /* mulwlo $src1,$src2,$acc */
5025   {
5026     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5027     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5028 #define FLD(f) abuf->fields.sfmt_machi_a.f
5029 #define OPRND(f) par_exec->operands.sfmt_mulhi_a.f
5030     int UNUSED written = abuf->written;
5031     IADDR UNUSED pc = abuf->addr;
5032     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5033
5034   SET_H_ACCUMS (FLD (f_acc), OPRND (acc));
5035
5036 #undef OPRND
5037 #undef FLD
5038   }
5039   NEXT (vpc);
5040
5041   CASE (sem, INSN_PAR_MV) : /* mv $dr,$sr */
5042 {
5043   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5044   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5045 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5046 #define OPRND(f) par_exec->operands.sfmt_mv.f
5047   int UNUSED written = 0;
5048   IADDR UNUSED pc = abuf->addr;
5049   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5050
5051   {
5052     SI opval = * FLD (i_sr);
5053     OPRND (dr) = opval;
5054     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5055   }
5056
5057 #undef OPRND
5058 #undef FLD
5059 }
5060   NEXT (vpc);
5061
5062 CASE (sem, INSN_WRITE_MV) : /* mv $dr,$sr */
5063   {
5064     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5065     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5066 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5067 #define OPRND(f) par_exec->operands.sfmt_mv.f
5068     int UNUSED written = abuf->written;
5069     IADDR UNUSED pc = abuf->addr;
5070     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5071
5072   * FLD (i_dr) = OPRND (dr);
5073
5074 #undef OPRND
5075 #undef FLD
5076   }
5077   NEXT (vpc);
5078
5079   CASE (sem, INSN_PAR_MVFACHI_A) : /* mvfachi $dr,$accs */
5080 {
5081   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5082   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5083 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5084 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5085   int UNUSED written = 0;
5086   IADDR UNUSED pc = abuf->addr;
5087   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5088
5089   {
5090     SI opval = TRUNCDISI (SRADI (GET_H_ACCUMS (FLD (f_accs)), 32));
5091     OPRND (dr) = opval;
5092     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5093   }
5094
5095 #undef OPRND
5096 #undef FLD
5097 }
5098   NEXT (vpc);
5099
5100 CASE (sem, INSN_WRITE_MVFACHI_A) : /* mvfachi $dr,$accs */
5101   {
5102     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5103     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5104 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5105 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5106     int UNUSED written = abuf->written;
5107     IADDR UNUSED pc = abuf->addr;
5108     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5109
5110   * FLD (i_dr) = OPRND (dr);
5111
5112 #undef OPRND
5113 #undef FLD
5114   }
5115   NEXT (vpc);
5116
5117   CASE (sem, INSN_PAR_MVFACLO_A) : /* mvfaclo $dr,$accs */
5118 {
5119   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5120   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5121 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5122 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5123   int UNUSED written = 0;
5124   IADDR UNUSED pc = abuf->addr;
5125   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5126
5127   {
5128     SI opval = TRUNCDISI (GET_H_ACCUMS (FLD (f_accs)));
5129     OPRND (dr) = opval;
5130     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5131   }
5132
5133 #undef OPRND
5134 #undef FLD
5135 }
5136   NEXT (vpc);
5137
5138 CASE (sem, INSN_WRITE_MVFACLO_A) : /* mvfaclo $dr,$accs */
5139   {
5140     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5141     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5142 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5143 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5144     int UNUSED written = abuf->written;
5145     IADDR UNUSED pc = abuf->addr;
5146     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5147
5148   * FLD (i_dr) = OPRND (dr);
5149
5150 #undef OPRND
5151 #undef FLD
5152   }
5153   NEXT (vpc);
5154
5155   CASE (sem, INSN_PAR_MVFACMI_A) : /* mvfacmi $dr,$accs */
5156 {
5157   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5158   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5159 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5160 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5161   int UNUSED written = 0;
5162   IADDR UNUSED pc = abuf->addr;
5163   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5164
5165   {
5166     SI opval = TRUNCDISI (SRADI (GET_H_ACCUMS (FLD (f_accs)), 16));
5167     OPRND (dr) = opval;
5168     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5169   }
5170
5171 #undef OPRND
5172 #undef FLD
5173 }
5174   NEXT (vpc);
5175
5176 CASE (sem, INSN_WRITE_MVFACMI_A) : /* mvfacmi $dr,$accs */
5177   {
5178     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5179     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5180 #define FLD(f) abuf->fields.sfmt_mvfachi_a.f
5181 #define OPRND(f) par_exec->operands.sfmt_mvfachi_a.f
5182     int UNUSED written = abuf->written;
5183     IADDR UNUSED pc = abuf->addr;
5184     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5185
5186   * FLD (i_dr) = OPRND (dr);
5187
5188 #undef OPRND
5189 #undef FLD
5190   }
5191   NEXT (vpc);
5192
5193   CASE (sem, INSN_PAR_MVFC) : /* mvfc $dr,$scr */
5194 {
5195   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5196   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5197 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5198 #define OPRND(f) par_exec->operands.sfmt_mvfc.f
5199   int UNUSED written = 0;
5200   IADDR UNUSED pc = abuf->addr;
5201   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5202
5203   {
5204     SI opval = GET_H_CR (FLD (f_r2));
5205     OPRND (dr) = opval;
5206     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5207   }
5208
5209 #undef OPRND
5210 #undef FLD
5211 }
5212   NEXT (vpc);
5213
5214 CASE (sem, INSN_WRITE_MVFC) : /* mvfc $dr,$scr */
5215   {
5216     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5217     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5218 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5219 #define OPRND(f) par_exec->operands.sfmt_mvfc.f
5220     int UNUSED written = abuf->written;
5221     IADDR UNUSED pc = abuf->addr;
5222     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5223
5224   * FLD (i_dr) = OPRND (dr);
5225
5226 #undef OPRND
5227 #undef FLD
5228   }
5229   NEXT (vpc);
5230
5231   CASE (sem, INSN_PAR_MVTACHI_A) : /* mvtachi $src1,$accs */
5232 {
5233   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5234   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5235 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
5236 #define OPRND(f) par_exec->operands.sfmt_mvtachi_a.f
5237   int UNUSED written = 0;
5238   IADDR UNUSED pc = abuf->addr;
5239   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5240
5241   {
5242     DI opval = ORDI (ANDDI (GET_H_ACCUMS (FLD (f_accs)), MAKEDI (0, 0xffffffff)), SLLDI (EXTSIDI (* FLD (i_src1)), 32));
5243     OPRND (accs) = opval;
5244     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5245   }
5246
5247 #undef OPRND
5248 #undef FLD
5249 }
5250   NEXT (vpc);
5251
5252 CASE (sem, INSN_WRITE_MVTACHI_A) : /* mvtachi $src1,$accs */
5253   {
5254     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5255     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5256 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
5257 #define OPRND(f) par_exec->operands.sfmt_mvtachi_a.f
5258     int UNUSED written = abuf->written;
5259     IADDR UNUSED pc = abuf->addr;
5260     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5261
5262   SET_H_ACCUMS (FLD (f_accs), OPRND (accs));
5263
5264 #undef OPRND
5265 #undef FLD
5266   }
5267   NEXT (vpc);
5268
5269   CASE (sem, INSN_PAR_MVTACLO_A) : /* mvtaclo $src1,$accs */
5270 {
5271   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5272   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5273 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
5274 #define OPRND(f) par_exec->operands.sfmt_mvtachi_a.f
5275   int UNUSED written = 0;
5276   IADDR UNUSED pc = abuf->addr;
5277   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5278
5279   {
5280     DI opval = ORDI (ANDDI (GET_H_ACCUMS (FLD (f_accs)), MAKEDI (0xffffffff, 0)), ZEXTSIDI (* FLD (i_src1)));
5281     OPRND (accs) = opval;
5282     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5283   }
5284
5285 #undef OPRND
5286 #undef FLD
5287 }
5288   NEXT (vpc);
5289
5290 CASE (sem, INSN_WRITE_MVTACLO_A) : /* mvtaclo $src1,$accs */
5291   {
5292     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5293     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5294 #define FLD(f) abuf->fields.sfmt_mvtachi_a.f
5295 #define OPRND(f) par_exec->operands.sfmt_mvtachi_a.f
5296     int UNUSED written = abuf->written;
5297     IADDR UNUSED pc = abuf->addr;
5298     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5299
5300   SET_H_ACCUMS (FLD (f_accs), OPRND (accs));
5301
5302 #undef OPRND
5303 #undef FLD
5304   }
5305   NEXT (vpc);
5306
5307   CASE (sem, INSN_PAR_MVTC) : /* mvtc $sr,$dcr */
5308 {
5309   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5310   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5311 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5312 #define OPRND(f) par_exec->operands.sfmt_mvtc.f
5313   int UNUSED written = 0;
5314   IADDR UNUSED pc = abuf->addr;
5315   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5316
5317   {
5318     USI opval = * FLD (i_sr);
5319     OPRND (dcr) = opval;
5320     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
5321   }
5322
5323 #undef OPRND
5324 #undef FLD
5325 }
5326   NEXT (vpc);
5327
5328 CASE (sem, INSN_WRITE_MVTC) : /* mvtc $sr,$dcr */
5329   {
5330     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5331     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5332 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5333 #define OPRND(f) par_exec->operands.sfmt_mvtc.f
5334     int UNUSED written = abuf->written;
5335     IADDR UNUSED pc = abuf->addr;
5336     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5337
5338   SET_H_CR (FLD (f_r1), OPRND (dcr));
5339
5340 #undef OPRND
5341 #undef FLD
5342   }
5343   NEXT (vpc);
5344
5345   CASE (sem, INSN_PAR_NEG) : /* neg $dr,$sr */
5346 {
5347   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5348   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5349 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5350 #define OPRND(f) par_exec->operands.sfmt_mv.f
5351   int UNUSED written = 0;
5352   IADDR UNUSED pc = abuf->addr;
5353   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5354
5355   {
5356     SI opval = NEGSI (* FLD (i_sr));
5357     OPRND (dr) = opval;
5358     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5359   }
5360
5361 #undef OPRND
5362 #undef FLD
5363 }
5364   NEXT (vpc);
5365
5366 CASE (sem, INSN_WRITE_NEG) : /* neg $dr,$sr */
5367   {
5368     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5369     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5370 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5371 #define OPRND(f) par_exec->operands.sfmt_mv.f
5372     int UNUSED written = abuf->written;
5373     IADDR UNUSED pc = abuf->addr;
5374     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5375
5376   * FLD (i_dr) = OPRND (dr);
5377
5378 #undef OPRND
5379 #undef FLD
5380   }
5381   NEXT (vpc);
5382
5383   CASE (sem, INSN_PAR_NOP) : /* nop */
5384 {
5385   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5386   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5387 #define FLD(f) abuf->fields.fmt_empty.f
5388 #define OPRND(f) par_exec->operands.sfmt_nop.f
5389   int UNUSED written = 0;
5390   IADDR UNUSED pc = abuf->addr;
5391   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5392
5393 PROFILE_COUNT_FILLNOPS (current_cpu, abuf->addr);
5394
5395 #undef OPRND
5396 #undef FLD
5397 }
5398   NEXT (vpc);
5399
5400 CASE (sem, INSN_WRITE_NOP) : /* nop */
5401   {
5402     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5403     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5404 #define FLD(f) abuf->fields.fmt_empty.f
5405 #define OPRND(f) par_exec->operands.sfmt_nop.f
5406     int UNUSED written = abuf->written;
5407     IADDR UNUSED pc = abuf->addr;
5408     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5409
5410
5411 #undef OPRND
5412 #undef FLD
5413   }
5414   NEXT (vpc);
5415
5416   CASE (sem, INSN_PAR_NOT) : /* not $dr,$sr */
5417 {
5418   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5419   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5420 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5421 #define OPRND(f) par_exec->operands.sfmt_mv.f
5422   int UNUSED written = 0;
5423   IADDR UNUSED pc = abuf->addr;
5424   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5425
5426   {
5427     SI opval = INVSI (* FLD (i_sr));
5428     OPRND (dr) = opval;
5429     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5430   }
5431
5432 #undef OPRND
5433 #undef FLD
5434 }
5435   NEXT (vpc);
5436
5437 CASE (sem, INSN_WRITE_NOT) : /* not $dr,$sr */
5438   {
5439     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5440     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5441 #define FLD(f) abuf->fields.sfmt_ld_plus.f
5442 #define OPRND(f) par_exec->operands.sfmt_mv.f
5443     int UNUSED written = abuf->written;
5444     IADDR UNUSED pc = abuf->addr;
5445     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5446
5447   * FLD (i_dr) = OPRND (dr);
5448
5449 #undef OPRND
5450 #undef FLD
5451   }
5452   NEXT (vpc);
5453
5454   CASE (sem, INSN_PAR_RAC_DSI) : /* rac $accd,$accs,$imm1 */
5455 {
5456   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5457   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5458 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
5459 #define OPRND(f) par_exec->operands.sfmt_rac_dsi.f
5460   int UNUSED written = 0;
5461   IADDR UNUSED pc = abuf->addr;
5462   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5463
5464 {
5465   DI tmp_tmp1;
5466   tmp_tmp1 = SLLDI (GET_H_ACCUMS (FLD (f_accs)), FLD (f_imm1));
5467   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 32768));
5468   {
5469     DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0xffff0000))) ? (MAKEDI (32767, 0xffff0000)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0xffff0000)));
5470     OPRND (accd) = opval;
5471     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5472   }
5473 }
5474
5475 #undef OPRND
5476 #undef FLD
5477 }
5478   NEXT (vpc);
5479
5480 CASE (sem, INSN_WRITE_RAC_DSI) : /* rac $accd,$accs,$imm1 */
5481   {
5482     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5483     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5484 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
5485 #define OPRND(f) par_exec->operands.sfmt_rac_dsi.f
5486     int UNUSED written = abuf->written;
5487     IADDR UNUSED pc = abuf->addr;
5488     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5489
5490   SET_H_ACCUMS (FLD (f_accd), OPRND (accd));
5491
5492 #undef OPRND
5493 #undef FLD
5494   }
5495   NEXT (vpc);
5496
5497   CASE (sem, INSN_PAR_RACH_DSI) : /* rach $accd,$accs,$imm1 */
5498 {
5499   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5500   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5501 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
5502 #define OPRND(f) par_exec->operands.sfmt_rac_dsi.f
5503   int UNUSED written = 0;
5504   IADDR UNUSED pc = abuf->addr;
5505   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5506
5507 {
5508   DI tmp_tmp1;
5509   tmp_tmp1 = SLLDI (GET_H_ACCUMS (FLD (f_accs)), FLD (f_imm1));
5510   tmp_tmp1 = ADDDI (tmp_tmp1, MAKEDI (0, 0x80000000));
5511   {
5512     DI opval = (GTDI (tmp_tmp1, MAKEDI (32767, 0))) ? (MAKEDI (32767, 0)) : (LTDI (tmp_tmp1, MAKEDI (0xffff8000, 0))) ? (MAKEDI (0xffff8000, 0)) : (ANDDI (tmp_tmp1, MAKEDI (0xffffffff, 0)));
5513     OPRND (accd) = opval;
5514     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
5515   }
5516 }
5517
5518 #undef OPRND
5519 #undef FLD
5520 }
5521   NEXT (vpc);
5522
5523 CASE (sem, INSN_WRITE_RACH_DSI) : /* rach $accd,$accs,$imm1 */
5524   {
5525     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5526     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5527 #define FLD(f) abuf->fields.sfmt_rac_dsi.f
5528 #define OPRND(f) par_exec->operands.sfmt_rac_dsi.f
5529     int UNUSED written = abuf->written;
5530     IADDR UNUSED pc = abuf->addr;
5531     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5532
5533   SET_H_ACCUMS (FLD (f_accd), OPRND (accd));
5534
5535 #undef OPRND
5536 #undef FLD
5537   }
5538   NEXT (vpc);
5539
5540   CASE (sem, INSN_PAR_RTE) : /* rte */
5541 {
5542   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5543   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5544 #define FLD(f) abuf->fields.fmt_empty.f
5545 #define OPRND(f) par_exec->operands.sfmt_rte.f
5546   int UNUSED written = 0;
5547   IADDR UNUSED pc = abuf->addr;
5548   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5549
5550 {
5551   {
5552     USI opval = ANDSI (GET_H_CR (((UINT) 6)), -4);
5553     OPRND (pc) = opval;
5554     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5555   }
5556   {
5557     USI opval = GET_H_CR (((UINT) 14));
5558     OPRND (h_cr_USI_6) = opval;
5559     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
5560   }
5561   {
5562     UQI opval = CPU (h_bpsw);
5563     OPRND (h_psw_UQI) = opval;
5564     TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
5565   }
5566   {
5567     UQI opval = CPU (h_bbpsw);
5568     OPRND (h_bpsw_UQI) = opval;
5569     TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
5570   }
5571 }
5572
5573 #undef OPRND
5574 #undef FLD
5575 }
5576   NEXT (vpc);
5577
5578 CASE (sem, INSN_WRITE_RTE) : /* rte */
5579   {
5580     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5581     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5582 #define FLD(f) abuf->fields.fmt_empty.f
5583 #define OPRND(f) par_exec->operands.sfmt_rte.f
5584     int UNUSED written = abuf->written;
5585     IADDR UNUSED pc = abuf->addr;
5586     SEM_BRANCH_INIT
5587     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5588
5589   CPU (h_bpsw) = OPRND (h_bpsw_UQI);
5590   SET_H_CR (((UINT) 6), OPRND (h_cr_USI_6));
5591   SET_H_PSW (OPRND (h_psw_UQI));
5592   SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
5593
5594   SEM_BRANCH_FINI (vpc);
5595 #undef OPRND
5596 #undef FLD
5597   }
5598   NEXT (vpc);
5599
5600   CASE (sem, INSN_PAR_SLL) : /* sll $dr,$sr */
5601 {
5602   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5603   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5604 #define FLD(f) abuf->fields.sfmt_add.f
5605 #define OPRND(f) par_exec->operands.sfmt_add.f
5606   int UNUSED written = 0;
5607   IADDR UNUSED pc = abuf->addr;
5608   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5609
5610   {
5611     SI opval = SLLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
5612     OPRND (dr) = opval;
5613     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5614   }
5615
5616 #undef OPRND
5617 #undef FLD
5618 }
5619   NEXT (vpc);
5620
5621 CASE (sem, INSN_WRITE_SLL) : /* sll $dr,$sr */
5622   {
5623     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5624     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5625 #define FLD(f) abuf->fields.sfmt_add.f
5626 #define OPRND(f) par_exec->operands.sfmt_add.f
5627     int UNUSED written = abuf->written;
5628     IADDR UNUSED pc = abuf->addr;
5629     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5630
5631   * FLD (i_dr) = OPRND (dr);
5632
5633 #undef OPRND
5634 #undef FLD
5635   }
5636   NEXT (vpc);
5637
5638   CASE (sem, INSN_PAR_SLLI) : /* slli $dr,$uimm5 */
5639 {
5640   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5641   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5642 #define FLD(f) abuf->fields.sfmt_slli.f
5643 #define OPRND(f) par_exec->operands.sfmt_slli.f
5644   int UNUSED written = 0;
5645   IADDR UNUSED pc = abuf->addr;
5646   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5647
5648   {
5649     SI opval = SLLSI (* FLD (i_dr), FLD (f_uimm5));
5650     OPRND (dr) = opval;
5651     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5652   }
5653
5654 #undef OPRND
5655 #undef FLD
5656 }
5657   NEXT (vpc);
5658
5659 CASE (sem, INSN_WRITE_SLLI) : /* slli $dr,$uimm5 */
5660   {
5661     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5662     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5663 #define FLD(f) abuf->fields.sfmt_slli.f
5664 #define OPRND(f) par_exec->operands.sfmt_slli.f
5665     int UNUSED written = abuf->written;
5666     IADDR UNUSED pc = abuf->addr;
5667     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5668
5669   * FLD (i_dr) = OPRND (dr);
5670
5671 #undef OPRND
5672 #undef FLD
5673   }
5674   NEXT (vpc);
5675
5676   CASE (sem, INSN_PAR_SRA) : /* sra $dr,$sr */
5677 {
5678   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5679   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5680 #define FLD(f) abuf->fields.sfmt_add.f
5681 #define OPRND(f) par_exec->operands.sfmt_add.f
5682   int UNUSED written = 0;
5683   IADDR UNUSED pc = abuf->addr;
5684   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5685
5686   {
5687     SI opval = SRASI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
5688     OPRND (dr) = opval;
5689     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5690   }
5691
5692 #undef OPRND
5693 #undef FLD
5694 }
5695   NEXT (vpc);
5696
5697 CASE (sem, INSN_WRITE_SRA) : /* sra $dr,$sr */
5698   {
5699     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5700     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5701 #define FLD(f) abuf->fields.sfmt_add.f
5702 #define OPRND(f) par_exec->operands.sfmt_add.f
5703     int UNUSED written = abuf->written;
5704     IADDR UNUSED pc = abuf->addr;
5705     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5706
5707   * FLD (i_dr) = OPRND (dr);
5708
5709 #undef OPRND
5710 #undef FLD
5711   }
5712   NEXT (vpc);
5713
5714   CASE (sem, INSN_PAR_SRAI) : /* srai $dr,$uimm5 */
5715 {
5716   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5717   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5718 #define FLD(f) abuf->fields.sfmt_slli.f
5719 #define OPRND(f) par_exec->operands.sfmt_slli.f
5720   int UNUSED written = 0;
5721   IADDR UNUSED pc = abuf->addr;
5722   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5723
5724   {
5725     SI opval = SRASI (* FLD (i_dr), FLD (f_uimm5));
5726     OPRND (dr) = opval;
5727     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5728   }
5729
5730 #undef OPRND
5731 #undef FLD
5732 }
5733   NEXT (vpc);
5734
5735 CASE (sem, INSN_WRITE_SRAI) : /* srai $dr,$uimm5 */
5736   {
5737     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5738     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5739 #define FLD(f) abuf->fields.sfmt_slli.f
5740 #define OPRND(f) par_exec->operands.sfmt_slli.f
5741     int UNUSED written = abuf->written;
5742     IADDR UNUSED pc = abuf->addr;
5743     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5744
5745   * FLD (i_dr) = OPRND (dr);
5746
5747 #undef OPRND
5748 #undef FLD
5749   }
5750   NEXT (vpc);
5751
5752   CASE (sem, INSN_PAR_SRL) : /* srl $dr,$sr */
5753 {
5754   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5755   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5756 #define FLD(f) abuf->fields.sfmt_add.f
5757 #define OPRND(f) par_exec->operands.sfmt_add.f
5758   int UNUSED written = 0;
5759   IADDR UNUSED pc = abuf->addr;
5760   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5761
5762   {
5763     SI opval = SRLSI (* FLD (i_dr), ANDSI (* FLD (i_sr), 31));
5764     OPRND (dr) = opval;
5765     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5766   }
5767
5768 #undef OPRND
5769 #undef FLD
5770 }
5771   NEXT (vpc);
5772
5773 CASE (sem, INSN_WRITE_SRL) : /* srl $dr,$sr */
5774   {
5775     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5776     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5777 #define FLD(f) abuf->fields.sfmt_add.f
5778 #define OPRND(f) par_exec->operands.sfmt_add.f
5779     int UNUSED written = abuf->written;
5780     IADDR UNUSED pc = abuf->addr;
5781     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5782
5783   * FLD (i_dr) = OPRND (dr);
5784
5785 #undef OPRND
5786 #undef FLD
5787   }
5788   NEXT (vpc);
5789
5790   CASE (sem, INSN_PAR_SRLI) : /* srli $dr,$uimm5 */
5791 {
5792   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5793   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5794 #define FLD(f) abuf->fields.sfmt_slli.f
5795 #define OPRND(f) par_exec->operands.sfmt_slli.f
5796   int UNUSED written = 0;
5797   IADDR UNUSED pc = abuf->addr;
5798   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5799
5800   {
5801     SI opval = SRLSI (* FLD (i_dr), FLD (f_uimm5));
5802     OPRND (dr) = opval;
5803     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5804   }
5805
5806 #undef OPRND
5807 #undef FLD
5808 }
5809   NEXT (vpc);
5810
5811 CASE (sem, INSN_WRITE_SRLI) : /* srli $dr,$uimm5 */
5812   {
5813     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5814     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5815 #define FLD(f) abuf->fields.sfmt_slli.f
5816 #define OPRND(f) par_exec->operands.sfmt_slli.f
5817     int UNUSED written = abuf->written;
5818     IADDR UNUSED pc = abuf->addr;
5819     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5820
5821   * FLD (i_dr) = OPRND (dr);
5822
5823 #undef OPRND
5824 #undef FLD
5825   }
5826   NEXT (vpc);
5827
5828   CASE (sem, INSN_PAR_ST) : /* st $src1,@$src2 */
5829 {
5830   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5831   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5832 #define FLD(f) abuf->fields.sfmt_st_plus.f
5833 #define OPRND(f) par_exec->operands.sfmt_st.f
5834   int UNUSED written = 0;
5835   IADDR UNUSED pc = abuf->addr;
5836   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5837
5838   {
5839     SI opval = * FLD (i_src1);
5840     OPRND (h_memory_SI_src2_idx) = * FLD (i_src2);
5841     OPRND (h_memory_SI_src2) = opval;
5842     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5843   }
5844
5845 #undef OPRND
5846 #undef FLD
5847 }
5848   NEXT (vpc);
5849
5850 CASE (sem, INSN_WRITE_ST) : /* st $src1,@$src2 */
5851   {
5852     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5853     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5854 #define FLD(f) abuf->fields.sfmt_st_plus.f
5855 #define OPRND(f) par_exec->operands.sfmt_st.f
5856     int UNUSED written = abuf->written;
5857     IADDR UNUSED pc = abuf->addr;
5858     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5859
5860   SETMEMSI (current_cpu, pc, OPRND (h_memory_SI_src2_idx), OPRND (h_memory_SI_src2));
5861
5862 #undef OPRND
5863 #undef FLD
5864   }
5865   NEXT (vpc);
5866
5867   CASE (sem, INSN_PAR_STB) : /* stb $src1,@$src2 */
5868 {
5869   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5870   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5871 #define FLD(f) abuf->fields.sfmt_st_plus.f
5872 #define OPRND(f) par_exec->operands.sfmt_stb.f
5873   int UNUSED written = 0;
5874   IADDR UNUSED pc = abuf->addr;
5875   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5876
5877   {
5878     QI opval = * FLD (i_src1);
5879     OPRND (h_memory_QI_src2_idx) = * FLD (i_src2);
5880     OPRND (h_memory_QI_src2) = opval;
5881     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5882   }
5883
5884 #undef OPRND
5885 #undef FLD
5886 }
5887   NEXT (vpc);
5888
5889 CASE (sem, INSN_WRITE_STB) : /* stb $src1,@$src2 */
5890   {
5891     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5892     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5893 #define FLD(f) abuf->fields.sfmt_st_plus.f
5894 #define OPRND(f) par_exec->operands.sfmt_stb.f
5895     int UNUSED written = abuf->written;
5896     IADDR UNUSED pc = abuf->addr;
5897     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5898
5899   SETMEMQI (current_cpu, pc, OPRND (h_memory_QI_src2_idx), OPRND (h_memory_QI_src2));
5900
5901 #undef OPRND
5902 #undef FLD
5903   }
5904   NEXT (vpc);
5905
5906   CASE (sem, INSN_PAR_STH) : /* sth $src1,@$src2 */
5907 {
5908   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5909   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5910 #define FLD(f) abuf->fields.sfmt_st_plus.f
5911 #define OPRND(f) par_exec->operands.sfmt_sth.f
5912   int UNUSED written = 0;
5913   IADDR UNUSED pc = abuf->addr;
5914   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5915
5916   {
5917     HI opval = * FLD (i_src1);
5918     OPRND (h_memory_HI_src2_idx) = * FLD (i_src2);
5919     OPRND (h_memory_HI_src2) = opval;
5920     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5921   }
5922
5923 #undef OPRND
5924 #undef FLD
5925 }
5926   NEXT (vpc);
5927
5928 CASE (sem, INSN_WRITE_STH) : /* sth $src1,@$src2 */
5929   {
5930     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5931     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5932 #define FLD(f) abuf->fields.sfmt_st_plus.f
5933 #define OPRND(f) par_exec->operands.sfmt_sth.f
5934     int UNUSED written = abuf->written;
5935     IADDR UNUSED pc = abuf->addr;
5936     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5937
5938   SETMEMHI (current_cpu, pc, OPRND (h_memory_HI_src2_idx), OPRND (h_memory_HI_src2));
5939
5940 #undef OPRND
5941 #undef FLD
5942   }
5943   NEXT (vpc);
5944
5945   CASE (sem, INSN_PAR_ST_PLUS) : /* st $src1,@+$src2 */
5946 {
5947   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5948   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5949 #define FLD(f) abuf->fields.sfmt_st_plus.f
5950 #define OPRND(f) par_exec->operands.sfmt_st_plus.f
5951   int UNUSED written = 0;
5952   IADDR UNUSED pc = abuf->addr;
5953   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
5954
5955 {
5956   SI tmp_new_src2;
5957   tmp_new_src2 = ADDSI (* FLD (i_src2), 4);
5958   {
5959     SI opval = * FLD (i_src1);
5960     OPRND (h_memory_SI_new_src2_idx) = tmp_new_src2;
5961     OPRND (h_memory_SI_new_src2) = opval;
5962     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5963   }
5964   {
5965     SI opval = tmp_new_src2;
5966     OPRND (src2) = opval;
5967     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
5968   }
5969 }
5970
5971 #undef OPRND
5972 #undef FLD
5973 }
5974   NEXT (vpc);
5975
5976 CASE (sem, INSN_WRITE_ST_PLUS) : /* st $src1,@+$src2 */
5977   {
5978     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5979     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
5980 #define FLD(f) abuf->fields.sfmt_st_plus.f
5981 #define OPRND(f) par_exec->operands.sfmt_st_plus.f
5982     int UNUSED written = abuf->written;
5983     IADDR UNUSED pc = abuf->addr;
5984     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
5985
5986   SETMEMSI (current_cpu, pc, OPRND (h_memory_SI_new_src2_idx), OPRND (h_memory_SI_new_src2));
5987   * FLD (i_src2) = OPRND (src2);
5988
5989 #undef OPRND
5990 #undef FLD
5991   }
5992   NEXT (vpc);
5993
5994   CASE (sem, INSN_PAR_STH_PLUS) : /* sth $src1,@$src2+ */
5995 {
5996   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5997   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5998 #define FLD(f) abuf->fields.sfmt_st_plus.f
5999 #define OPRND(f) par_exec->operands.sfmt_sth_plus.f
6000   int UNUSED written = 0;
6001   IADDR UNUSED pc = abuf->addr;
6002   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6003
6004 {
6005   HI tmp_new_src2;
6006   {
6007     HI opval = * FLD (i_src1);
6008     OPRND (h_memory_HI_new_src2_idx) = tmp_new_src2;
6009     OPRND (h_memory_HI_new_src2) = opval;
6010     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
6011   }
6012   tmp_new_src2 = ADDSI (* FLD (i_src2), 2);
6013   {
6014     SI opval = tmp_new_src2;
6015     OPRND (src2) = opval;
6016     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6017   }
6018 }
6019
6020 #undef OPRND
6021 #undef FLD
6022 }
6023   NEXT (vpc);
6024
6025 CASE (sem, INSN_WRITE_STH_PLUS) : /* sth $src1,@$src2+ */
6026   {
6027     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6028     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6029 #define FLD(f) abuf->fields.sfmt_st_plus.f
6030 #define OPRND(f) par_exec->operands.sfmt_sth_plus.f
6031     int UNUSED written = abuf->written;
6032     IADDR UNUSED pc = abuf->addr;
6033     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6034
6035   SETMEMHI (current_cpu, pc, OPRND (h_memory_HI_new_src2_idx), OPRND (h_memory_HI_new_src2));
6036   * FLD (i_src2) = OPRND (src2);
6037
6038 #undef OPRND
6039 #undef FLD
6040   }
6041   NEXT (vpc);
6042
6043   CASE (sem, INSN_PAR_STB_PLUS) : /* stb $src1,@$src2+ */
6044 {
6045   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6046   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6047 #define FLD(f) abuf->fields.sfmt_st_plus.f
6048 #define OPRND(f) par_exec->operands.sfmt_stb_plus.f
6049   int UNUSED written = 0;
6050   IADDR UNUSED pc = abuf->addr;
6051   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6052
6053 {
6054   QI tmp_new_src2;
6055   {
6056     QI opval = * FLD (i_src1);
6057     OPRND (h_memory_QI_new_src2_idx) = tmp_new_src2;
6058     OPRND (h_memory_QI_new_src2) = opval;
6059     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
6060   }
6061   tmp_new_src2 = ADDSI (* FLD (i_src2), 1);
6062   {
6063     SI opval = tmp_new_src2;
6064     OPRND (src2) = opval;
6065     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6066   }
6067 }
6068
6069 #undef OPRND
6070 #undef FLD
6071 }
6072   NEXT (vpc);
6073
6074 CASE (sem, INSN_WRITE_STB_PLUS) : /* stb $src1,@$src2+ */
6075   {
6076     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6077     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6078 #define FLD(f) abuf->fields.sfmt_st_plus.f
6079 #define OPRND(f) par_exec->operands.sfmt_stb_plus.f
6080     int UNUSED written = abuf->written;
6081     IADDR UNUSED pc = abuf->addr;
6082     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6083
6084   SETMEMQI (current_cpu, pc, OPRND (h_memory_QI_new_src2_idx), OPRND (h_memory_QI_new_src2));
6085   * FLD (i_src2) = OPRND (src2);
6086
6087 #undef OPRND
6088 #undef FLD
6089   }
6090   NEXT (vpc);
6091
6092   CASE (sem, INSN_PAR_ST_MINUS) : /* st $src1,@-$src2 */
6093 {
6094   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6095   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6096 #define FLD(f) abuf->fields.sfmt_st_plus.f
6097 #define OPRND(f) par_exec->operands.sfmt_st_plus.f
6098   int UNUSED written = 0;
6099   IADDR UNUSED pc = abuf->addr;
6100   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6101
6102 {
6103   SI tmp_new_src2;
6104   tmp_new_src2 = SUBSI (* FLD (i_src2), 4);
6105   {
6106     SI opval = * FLD (i_src1);
6107     OPRND (h_memory_SI_new_src2_idx) = tmp_new_src2;
6108     OPRND (h_memory_SI_new_src2) = opval;
6109     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
6110   }
6111   {
6112     SI opval = tmp_new_src2;
6113     OPRND (src2) = opval;
6114     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6115   }
6116 }
6117
6118 #undef OPRND
6119 #undef FLD
6120 }
6121   NEXT (vpc);
6122
6123 CASE (sem, INSN_WRITE_ST_MINUS) : /* st $src1,@-$src2 */
6124   {
6125     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6126     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6127 #define FLD(f) abuf->fields.sfmt_st_plus.f
6128 #define OPRND(f) par_exec->operands.sfmt_st_plus.f
6129     int UNUSED written = abuf->written;
6130     IADDR UNUSED pc = abuf->addr;
6131     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6132
6133   SETMEMSI (current_cpu, pc, OPRND (h_memory_SI_new_src2_idx), OPRND (h_memory_SI_new_src2));
6134   * FLD (i_src2) = OPRND (src2);
6135
6136 #undef OPRND
6137 #undef FLD
6138   }
6139   NEXT (vpc);
6140
6141   CASE (sem, INSN_PAR_SUB) : /* sub $dr,$sr */
6142 {
6143   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6144   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6145 #define FLD(f) abuf->fields.sfmt_add.f
6146 #define OPRND(f) par_exec->operands.sfmt_add.f
6147   int UNUSED written = 0;
6148   IADDR UNUSED pc = abuf->addr;
6149   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6150
6151   {
6152     SI opval = SUBSI (* FLD (i_dr), * FLD (i_sr));
6153     OPRND (dr) = opval;
6154     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6155   }
6156
6157 #undef OPRND
6158 #undef FLD
6159 }
6160   NEXT (vpc);
6161
6162 CASE (sem, INSN_WRITE_SUB) : /* sub $dr,$sr */
6163   {
6164     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6165     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6166 #define FLD(f) abuf->fields.sfmt_add.f
6167 #define OPRND(f) par_exec->operands.sfmt_add.f
6168     int UNUSED written = abuf->written;
6169     IADDR UNUSED pc = abuf->addr;
6170     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6171
6172   * FLD (i_dr) = OPRND (dr);
6173
6174 #undef OPRND
6175 #undef FLD
6176   }
6177   NEXT (vpc);
6178
6179   CASE (sem, INSN_PAR_SUBV) : /* subv $dr,$sr */
6180 {
6181   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6182   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6183 #define FLD(f) abuf->fields.sfmt_add.f
6184 #define OPRND(f) par_exec->operands.sfmt_addv.f
6185   int UNUSED written = 0;
6186   IADDR UNUSED pc = abuf->addr;
6187   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6188
6189 {
6190   SI temp0;BI temp1;
6191   temp0 = SUBSI (* FLD (i_dr), * FLD (i_sr));
6192   temp1 = SUBOFSI (* FLD (i_dr), * FLD (i_sr), 0);
6193   {
6194     SI opval = temp0;
6195     OPRND (dr) = opval;
6196     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6197   }
6198   {
6199     BI opval = temp1;
6200     OPRND (condbit) = opval;
6201     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
6202   }
6203 }
6204
6205 #undef OPRND
6206 #undef FLD
6207 }
6208   NEXT (vpc);
6209
6210 CASE (sem, INSN_WRITE_SUBV) : /* subv $dr,$sr */
6211   {
6212     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6213     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6214 #define FLD(f) abuf->fields.sfmt_add.f
6215 #define OPRND(f) par_exec->operands.sfmt_addv.f
6216     int UNUSED written = abuf->written;
6217     IADDR UNUSED pc = abuf->addr;
6218     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6219
6220   CPU (h_cond) = OPRND (condbit);
6221   * FLD (i_dr) = OPRND (dr);
6222
6223 #undef OPRND
6224 #undef FLD
6225   }
6226   NEXT (vpc);
6227
6228   CASE (sem, INSN_PAR_SUBX) : /* subx $dr,$sr */
6229 {
6230   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6231   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6232 #define FLD(f) abuf->fields.sfmt_add.f
6233 #define OPRND(f) par_exec->operands.sfmt_addx.f
6234   int UNUSED written = 0;
6235   IADDR UNUSED pc = abuf->addr;
6236   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6237
6238 {
6239   SI temp0;BI temp1;
6240   temp0 = SUBCSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
6241   temp1 = SUBCFSI (* FLD (i_dr), * FLD (i_sr), CPU (h_cond));
6242   {
6243     SI opval = temp0;
6244     OPRND (dr) = opval;
6245     TRACE_RESULT (current_cpu, abuf, "gr", 'x', opval);
6246   }
6247   {
6248     BI opval = temp1;
6249     OPRND (condbit) = opval;
6250     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
6251   }
6252 }
6253
6254 #undef OPRND
6255 #undef FLD
6256 }
6257   NEXT (vpc);
6258
6259 CASE (sem, INSN_WRITE_SUBX) : /* subx $dr,$sr */
6260   {
6261     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6262     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6263 #define FLD(f) abuf->fields.sfmt_add.f
6264 #define OPRND(f) par_exec->operands.sfmt_addx.f
6265     int UNUSED written = abuf->written;
6266     IADDR UNUSED pc = abuf->addr;
6267     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6268
6269   CPU (h_cond) = OPRND (condbit);
6270   * FLD (i_dr) = OPRND (dr);
6271
6272 #undef OPRND
6273 #undef FLD
6274   }
6275   NEXT (vpc);
6276
6277   CASE (sem, INSN_PAR_TRAP) : /* trap $uimm4 */
6278 {
6279   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6280   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6281 #define FLD(f) abuf->fields.sfmt_trap.f
6282 #define OPRND(f) par_exec->operands.sfmt_trap.f
6283   int UNUSED written = 0;
6284   IADDR UNUSED pc = abuf->addr;
6285   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6286
6287 {
6288   {
6289     USI opval = GET_H_CR (((UINT) 6));
6290     OPRND (h_cr_USI_14) = opval;
6291     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
6292   }
6293   {
6294     USI opval = ADDSI (pc, 4);
6295     OPRND (h_cr_USI_6) = opval;
6296     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
6297   }
6298   {
6299     UQI opval = CPU (h_bpsw);
6300     OPRND (h_bbpsw_UQI) = opval;
6301     TRACE_RESULT (current_cpu, abuf, "bbpsw", 'x', opval);
6302   }
6303   {
6304     UQI opval = GET_H_PSW ();
6305     OPRND (h_bpsw_UQI) = opval;
6306     TRACE_RESULT (current_cpu, abuf, "bpsw", 'x', opval);
6307   }
6308   {
6309     UQI opval = ANDQI (GET_H_PSW (), 128);
6310     OPRND (h_psw_UQI) = opval;
6311     TRACE_RESULT (current_cpu, abuf, "psw", 'x', opval);
6312   }
6313   {
6314     SI opval = m32r_trap (current_cpu, pc, FLD (f_uimm4));
6315     OPRND (pc) = opval;
6316     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6317   }
6318 }
6319
6320 #undef OPRND
6321 #undef FLD
6322 }
6323   NEXT (vpc);
6324
6325 CASE (sem, INSN_WRITE_TRAP) : /* trap $uimm4 */
6326   {
6327     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6328     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6329 #define FLD(f) abuf->fields.sfmt_trap.f
6330 #define OPRND(f) par_exec->operands.sfmt_trap.f
6331     int UNUSED written = abuf->written;
6332     IADDR UNUSED pc = abuf->addr;
6333     SEM_BRANCH_INIT
6334     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6335
6336   CPU (h_bbpsw) = OPRND (h_bbpsw_UQI);
6337   CPU (h_bpsw) = OPRND (h_bpsw_UQI);
6338   SET_H_CR (((UINT) 14), OPRND (h_cr_USI_14));
6339   SET_H_CR (((UINT) 6), OPRND (h_cr_USI_6));
6340   SET_H_PSW (OPRND (h_psw_UQI));
6341   SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, OPRND (pc), vpc);
6342
6343   SEM_BRANCH_FINI (vpc);
6344 #undef OPRND
6345 #undef FLD
6346   }
6347   NEXT (vpc);
6348
6349   CASE (sem, INSN_PAR_UNLOCK) : /* unlock $src1,@$src2 */
6350 {
6351   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6352   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6353 #define FLD(f) abuf->fields.sfmt_st_plus.f
6354 #define OPRND(f) par_exec->operands.sfmt_unlock.f
6355   int UNUSED written = 0;
6356   IADDR UNUSED pc = abuf->addr;
6357   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6358
6359 {
6360 if (CPU (h_lock)) {
6361   {
6362     SI opval = * FLD (i_src1);
6363     OPRND (h_memory_SI_src2_idx) = * FLD (i_src2);
6364     OPRND (h_memory_SI_src2) = opval;
6365     written |= (1 << 4);
6366     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
6367   }
6368 }
6369   {
6370     BI opval = 0;
6371     OPRND (h_lock_BI) = opval;
6372     TRACE_RESULT (current_cpu, abuf, "lock", 'x', opval);
6373   }
6374 }
6375
6376   abuf->written = written;
6377 #undef OPRND
6378 #undef FLD
6379 }
6380   NEXT (vpc);
6381
6382 CASE (sem, INSN_WRITE_UNLOCK) : /* unlock $src1,@$src2 */
6383   {
6384     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6385     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6386 #define FLD(f) abuf->fields.sfmt_st_plus.f
6387 #define OPRND(f) par_exec->operands.sfmt_unlock.f
6388     int UNUSED written = abuf->written;
6389     IADDR UNUSED pc = abuf->addr;
6390     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6391
6392   CPU (h_lock) = OPRND (h_lock_BI);
6393   if (written & (1 << 4))
6394     {
6395       SETMEMSI (current_cpu, pc, OPRND (h_memory_SI_src2_idx), OPRND (h_memory_SI_src2));
6396     }
6397
6398 #undef OPRND
6399 #undef FLD
6400   }
6401   NEXT (vpc);
6402
6403   CASE (sem, INSN_PAR_PCMPBZ) : /* pcmpbz $src2 */
6404 {
6405   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6406   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6407 #define FLD(f) abuf->fields.sfmt_st_plus.f
6408 #define OPRND(f) par_exec->operands.sfmt_cmpz.f
6409   int UNUSED written = 0;
6410   IADDR UNUSED pc = abuf->addr;
6411   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6412
6413   {
6414     BI opval = (EQSI (ANDSI (* FLD (i_src2), 255), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 65280), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 16711680), 0)) ? (1) : (EQSI (ANDSI (* FLD (i_src2), 0xff000000), 0)) ? (1) : (0);
6415     OPRND (condbit) = opval;
6416     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
6417   }
6418
6419 #undef OPRND
6420 #undef FLD
6421 }
6422   NEXT (vpc);
6423
6424 CASE (sem, INSN_WRITE_PCMPBZ) : /* pcmpbz $src2 */
6425   {
6426     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6427     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6428 #define FLD(f) abuf->fields.sfmt_st_plus.f
6429 #define OPRND(f) par_exec->operands.sfmt_cmpz.f
6430     int UNUSED written = abuf->written;
6431     IADDR UNUSED pc = abuf->addr;
6432     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6433
6434   CPU (h_cond) = OPRND (condbit);
6435
6436 #undef OPRND
6437 #undef FLD
6438   }
6439   NEXT (vpc);
6440
6441   CASE (sem, INSN_PAR_SADD) : /* sadd */
6442 {
6443   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6444   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6445 #define FLD(f) abuf->fields.fmt_empty.f
6446 #define OPRND(f) par_exec->operands.sfmt_sadd.f
6447   int UNUSED written = 0;
6448   IADDR UNUSED pc = abuf->addr;
6449   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6450
6451   {
6452     DI opval = ADDDI (SRADI (GET_H_ACCUMS (((UINT) 1)), 16), GET_H_ACCUMS (((UINT) 0)));
6453     OPRND (h_accums_DI_0) = opval;
6454     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
6455   }
6456
6457 #undef OPRND
6458 #undef FLD
6459 }
6460   NEXT (vpc);
6461
6462 CASE (sem, INSN_WRITE_SADD) : /* sadd */
6463   {
6464     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6465     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6466 #define FLD(f) abuf->fields.fmt_empty.f
6467 #define OPRND(f) par_exec->operands.sfmt_sadd.f
6468     int UNUSED written = abuf->written;
6469     IADDR UNUSED pc = abuf->addr;
6470     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6471
6472   SET_H_ACCUMS (((UINT) 0), OPRND (h_accums_DI_0));
6473
6474 #undef OPRND
6475 #undef FLD
6476   }
6477   NEXT (vpc);
6478
6479   CASE (sem, INSN_PAR_MACWU1) : /* macwu1 $src1,$src2 */
6480 {
6481   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6482   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6483 #define FLD(f) abuf->fields.sfmt_st_plus.f
6484 #define OPRND(f) par_exec->operands.sfmt_macwu1.f
6485   int UNUSED written = 0;
6486   IADDR UNUSED pc = abuf->addr;
6487   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6488
6489   {
6490     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (((UINT) 1)), MULDI (EXTSIDI (* FLD (i_src1)), EXTSIDI (ANDSI (* FLD (i_src2), 65535)))), 8), 8);
6491     OPRND (h_accums_DI_1) = opval;
6492     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
6493   }
6494
6495 #undef OPRND
6496 #undef FLD
6497 }
6498   NEXT (vpc);
6499
6500 CASE (sem, INSN_WRITE_MACWU1) : /* macwu1 $src1,$src2 */
6501   {
6502     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6503     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6504 #define FLD(f) abuf->fields.sfmt_st_plus.f
6505 #define OPRND(f) par_exec->operands.sfmt_macwu1.f
6506     int UNUSED written = abuf->written;
6507     IADDR UNUSED pc = abuf->addr;
6508     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6509
6510   SET_H_ACCUMS (((UINT) 1), OPRND (h_accums_DI_1));
6511
6512 #undef OPRND
6513 #undef FLD
6514   }
6515   NEXT (vpc);
6516
6517   CASE (sem, INSN_PAR_MSBLO) : /* msblo $src1,$src2 */
6518 {
6519   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6520   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6521 #define FLD(f) abuf->fields.sfmt_st_plus.f
6522 #define OPRND(f) par_exec->operands.sfmt_msblo.f
6523   int UNUSED written = 0;
6524   IADDR UNUSED pc = abuf->addr;
6525   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6526
6527   {
6528     DI opval = SRADI (SLLDI (SUBDI (GET_H_ACCUM (), SRADI (SLLDI (MULDI (EXTHIDI (TRUNCSIHI (* FLD (i_src1))), EXTHIDI (TRUNCSIHI (* FLD (i_src2)))), 32), 16)), 8), 8);
6529     OPRND (accum) = opval;
6530     TRACE_RESULT (current_cpu, abuf, "accum", 'D', opval);
6531   }
6532
6533 #undef OPRND
6534 #undef FLD
6535 }
6536   NEXT (vpc);
6537
6538 CASE (sem, INSN_WRITE_MSBLO) : /* msblo $src1,$src2 */
6539   {
6540     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6541     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6542 #define FLD(f) abuf->fields.sfmt_st_plus.f
6543 #define OPRND(f) par_exec->operands.sfmt_msblo.f
6544     int UNUSED written = abuf->written;
6545     IADDR UNUSED pc = abuf->addr;
6546     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6547
6548   SET_H_ACCUM (OPRND (accum));
6549
6550 #undef OPRND
6551 #undef FLD
6552   }
6553   NEXT (vpc);
6554
6555   CASE (sem, INSN_PAR_MULWU1) : /* mulwu1 $src1,$src2 */
6556 {
6557   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6558   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6559 #define FLD(f) abuf->fields.sfmt_st_plus.f
6560 #define OPRND(f) par_exec->operands.sfmt_mulwu1.f
6561   int UNUSED written = 0;
6562   IADDR UNUSED pc = abuf->addr;
6563   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6564
6565   {
6566     DI opval = SRADI (SLLDI (MULDI (EXTSIDI (* FLD (i_src1)), EXTSIDI (ANDSI (* FLD (i_src2), 65535))), 16), 16);
6567     OPRND (h_accums_DI_1) = opval;
6568     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
6569   }
6570
6571 #undef OPRND
6572 #undef FLD
6573 }
6574   NEXT (vpc);
6575
6576 CASE (sem, INSN_WRITE_MULWU1) : /* mulwu1 $src1,$src2 */
6577   {
6578     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6579     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6580 #define FLD(f) abuf->fields.sfmt_st_plus.f
6581 #define OPRND(f) par_exec->operands.sfmt_mulwu1.f
6582     int UNUSED written = abuf->written;
6583     IADDR UNUSED pc = abuf->addr;
6584     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6585
6586   SET_H_ACCUMS (((UINT) 1), OPRND (h_accums_DI_1));
6587
6588 #undef OPRND
6589 #undef FLD
6590   }
6591   NEXT (vpc);
6592
6593   CASE (sem, INSN_PAR_MACLH1) : /* maclh1 $src1,$src2 */
6594 {
6595   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6596   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6597 #define FLD(f) abuf->fields.sfmt_st_plus.f
6598 #define OPRND(f) par_exec->operands.sfmt_macwu1.f
6599   int UNUSED written = 0;
6600   IADDR UNUSED pc = abuf->addr;
6601   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6602
6603   {
6604     DI opval = SRADI (SLLDI (ADDDI (GET_H_ACCUMS (((UINT) 1)), SLLDI (EXTSIDI (MULSI (EXTHISI (TRUNCSIHI (* FLD (i_src1))), SRASI (* FLD (i_src2), 16))), 16)), 8), 8);
6605     OPRND (h_accums_DI_1) = opval;
6606     TRACE_RESULT (current_cpu, abuf, "accums", 'D', opval);
6607   }
6608
6609 #undef OPRND
6610 #undef FLD
6611 }
6612   NEXT (vpc);
6613
6614 CASE (sem, INSN_WRITE_MACLH1) : /* maclh1 $src1,$src2 */
6615   {
6616     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6617     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6618 #define FLD(f) abuf->fields.sfmt_st_plus.f
6619 #define OPRND(f) par_exec->operands.sfmt_macwu1.f
6620     int UNUSED written = abuf->written;
6621     IADDR UNUSED pc = abuf->addr;
6622     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6623
6624   SET_H_ACCUMS (((UINT) 1), OPRND (h_accums_DI_1));
6625
6626 #undef OPRND
6627 #undef FLD
6628   }
6629   NEXT (vpc);
6630
6631   CASE (sem, INSN_PAR_SC) : /* sc */
6632 {
6633   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6634   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6635 #define FLD(f) abuf->fields.fmt_empty.f
6636 #define OPRND(f) par_exec->operands.sfmt_sc.f
6637   int UNUSED written = 0;
6638   IADDR UNUSED pc = abuf->addr;
6639   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6640
6641 if (ZEXTBISI (CPU (h_cond)))
6642   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
6643
6644 #undef OPRND
6645 #undef FLD
6646 }
6647   NEXT (vpc);
6648
6649 CASE (sem, INSN_WRITE_SC) : /* sc */
6650   {
6651     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6652     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6653 #define FLD(f) abuf->fields.fmt_empty.f
6654 #define OPRND(f) par_exec->operands.sfmt_sc.f
6655     int UNUSED written = abuf->written;
6656     IADDR UNUSED pc = abuf->addr;
6657     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6658
6659
6660 #undef OPRND
6661 #undef FLD
6662   }
6663   NEXT (vpc);
6664
6665   CASE (sem, INSN_PAR_SNC) : /* snc */
6666 {
6667   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6668   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6669 #define FLD(f) abuf->fields.fmt_empty.f
6670 #define OPRND(f) par_exec->operands.sfmt_sc.f
6671   int UNUSED written = 0;
6672   IADDR UNUSED pc = abuf->addr;
6673   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6674
6675 if (ZEXTBISI (NOTBI (CPU (h_cond))))
6676   SEM_SKIP_INSN (current_cpu, sem_arg, vpc);
6677
6678 #undef OPRND
6679 #undef FLD
6680 }
6681   NEXT (vpc);
6682
6683 CASE (sem, INSN_WRITE_SNC) : /* snc */
6684   {
6685     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6686     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6687 #define FLD(f) abuf->fields.fmt_empty.f
6688 #define OPRND(f) par_exec->operands.sfmt_sc.f
6689     int UNUSED written = abuf->written;
6690     IADDR UNUSED pc = abuf->addr;
6691     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6692
6693
6694 #undef OPRND
6695 #undef FLD
6696   }
6697   NEXT (vpc);
6698
6699   CASE (sem, INSN_PAR_CLRPSW) : /* clrpsw $uimm8 */
6700 {
6701   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6702   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6703 #define FLD(f) abuf->fields.sfmt_clrpsw.f
6704 #define OPRND(f) par_exec->operands.sfmt_clrpsw.f
6705   int UNUSED written = 0;
6706   IADDR UNUSED pc = abuf->addr;
6707   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6708
6709   {
6710     SI opval = ANDSI (GET_H_CR (((UINT) 0)), ORSI (INVBI (FLD (f_uimm8)), 65280));
6711     OPRND (h_cr_USI_0) = opval;
6712     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
6713   }
6714
6715 #undef OPRND
6716 #undef FLD
6717 }
6718   NEXT (vpc);
6719
6720 CASE (sem, INSN_WRITE_CLRPSW) : /* clrpsw $uimm8 */
6721   {
6722     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6723     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6724 #define FLD(f) abuf->fields.sfmt_clrpsw.f
6725 #define OPRND(f) par_exec->operands.sfmt_clrpsw.f
6726     int UNUSED written = abuf->written;
6727     IADDR UNUSED pc = abuf->addr;
6728     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6729
6730   SET_H_CR (((UINT) 0), OPRND (h_cr_USI_0));
6731
6732 #undef OPRND
6733 #undef FLD
6734   }
6735   NEXT (vpc);
6736
6737   CASE (sem, INSN_PAR_SETPSW) : /* setpsw $uimm8 */
6738 {
6739   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6740   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6741 #define FLD(f) abuf->fields.sfmt_clrpsw.f
6742 #define OPRND(f) par_exec->operands.sfmt_setpsw.f
6743   int UNUSED written = 0;
6744   IADDR UNUSED pc = abuf->addr;
6745   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6746
6747   {
6748     SI opval = FLD (f_uimm8);
6749     OPRND (h_cr_USI_0) = opval;
6750     TRACE_RESULT (current_cpu, abuf, "cr", 'x', opval);
6751   }
6752
6753 #undef OPRND
6754 #undef FLD
6755 }
6756   NEXT (vpc);
6757
6758 CASE (sem, INSN_WRITE_SETPSW) : /* setpsw $uimm8 */
6759   {
6760     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6761     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6762 #define FLD(f) abuf->fields.sfmt_clrpsw.f
6763 #define OPRND(f) par_exec->operands.sfmt_setpsw.f
6764     int UNUSED written = abuf->written;
6765     IADDR UNUSED pc = abuf->addr;
6766     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6767
6768   SET_H_CR (((UINT) 0), OPRND (h_cr_USI_0));
6769
6770 #undef OPRND
6771 #undef FLD
6772   }
6773   NEXT (vpc);
6774
6775   CASE (sem, INSN_PAR_BTST) : /* btst $uimm3,$sr */
6776 {
6777   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6778   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6779 #define FLD(f) abuf->fields.sfmt_bset.f
6780 #define OPRND(f) par_exec->operands.sfmt_btst.f
6781   int UNUSED written = 0;
6782   IADDR UNUSED pc = abuf->addr;
6783   vpc = SEM_NEXT_VPC (sem_arg, pc, 2);
6784
6785   {
6786     BI opval = ANDQI (SRLSI (* FLD (i_sr), SUBSI (7, FLD (f_uimm3))), 1);
6787     OPRND (condbit) = opval;
6788     TRACE_RESULT (current_cpu, abuf, "cond", 'x', opval);
6789   }
6790
6791 #undef OPRND
6792 #undef FLD
6793 }
6794   NEXT (vpc);
6795
6796 CASE (sem, INSN_WRITE_BTST) : /* btst $uimm3,$sr */
6797   {
6798     SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6799     const ARGBUF *abuf = SEM_ARGBUF (sem_arg)->fields.write.abuf;
6800 #define FLD(f) abuf->fields.sfmt_bset.f
6801 #define OPRND(f) par_exec->operands.sfmt_btst.f
6802     int UNUSED written = abuf->written;
6803     IADDR UNUSED pc = abuf->addr;
6804     vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
6805
6806   CPU (h_cond) = OPRND (condbit);
6807
6808 #undef OPRND
6809 #undef FLD
6810   }
6811   NEXT (vpc);
6812
6813
6814     }
6815   ENDSWITCH (sem) /* End of semantic switch.  */
6816
6817   /* At this point `vpc' contains the next insn to execute.  */
6818 }
6819
6820 #undef DEFINE_SWITCH
6821 #endif /* DEFINE_SWITCH */