sim/i960/sem-switch.c

   1 /* Simulator instruction semantics for i960base.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
   6
   7 This file is part of the GNU Simulators.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License along
  20 with this program; if not, write to the Free Software Foundation, Inc.,
  21 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  22
  23 */
  24
  25 #ifdef DEFINE_LABELS
  26
  27   /* The labels have the case they have because the enum of insn types
  28      is all uppercase and in the non-stdc case the insn symbol is built
  29      into the enum name.  */
  30
  31   static struct {
  32     int index;
  33     void *label;
  34   } labels[] = {
  35     { I960BASE_INSN_X_INVALID, && case_sem_INSN_X_INVALID },
  36     { I960BASE_INSN_X_AFTER, && case_sem_INSN_X_AFTER },
  37     { I960BASE_INSN_X_BEFORE, && case_sem_INSN_X_BEFORE },
  38     { I960BASE_INSN_X_CTI_CHAIN, && case_sem_INSN_X_CTI_CHAIN },
  39     { I960BASE_INSN_X_CHAIN, && case_sem_INSN_X_CHAIN },
  40     { I960BASE_INSN_X_BEGIN, && case_sem_INSN_X_BEGIN },
  41     { I960BASE_INSN_MULO, && case_sem_INSN_MULO },
  42     { I960BASE_INSN_MULO1, && case_sem_INSN_MULO1 },
  43     { I960BASE_INSN_MULO2, && case_sem_INSN_MULO2 },
  44     { I960BASE_INSN_MULO3, && case_sem_INSN_MULO3 },
  45     { I960BASE_INSN_REMO, && case_sem_INSN_REMO },
  46     { I960BASE_INSN_REMO1, && case_sem_INSN_REMO1 },
  47     { I960BASE_INSN_REMO2, && case_sem_INSN_REMO2 },
  48     { I960BASE_INSN_REMO3, && case_sem_INSN_REMO3 },
  49     { I960BASE_INSN_DIVO, && case_sem_INSN_DIVO },
  50     { I960BASE_INSN_DIVO1, && case_sem_INSN_DIVO1 },
  51     { I960BASE_INSN_DIVO2, && case_sem_INSN_DIVO2 },
  52     { I960BASE_INSN_DIVO3, && case_sem_INSN_DIVO3 },
  53     { I960BASE_INSN_REMI, && case_sem_INSN_REMI },
  54     { I960BASE_INSN_REMI1, && case_sem_INSN_REMI1 },
  55     { I960BASE_INSN_REMI2, && case_sem_INSN_REMI2 },
  56     { I960BASE_INSN_REMI3, && case_sem_INSN_REMI3 },
  57     { I960BASE_INSN_DIVI, && case_sem_INSN_DIVI },
  58     { I960BASE_INSN_DIVI1, && case_sem_INSN_DIVI1 },
  59     { I960BASE_INSN_DIVI2, && case_sem_INSN_DIVI2 },
  60     { I960BASE_INSN_DIVI3, && case_sem_INSN_DIVI3 },
  61     { I960BASE_INSN_ADDO, && case_sem_INSN_ADDO },
  62     { I960BASE_INSN_ADDO1, && case_sem_INSN_ADDO1 },
  63     { I960BASE_INSN_ADDO2, && case_sem_INSN_ADDO2 },
  64     { I960BASE_INSN_ADDO3, && case_sem_INSN_ADDO3 },
  65     { I960BASE_INSN_SUBO, && case_sem_INSN_SUBO },
  66     { I960BASE_INSN_SUBO1, && case_sem_INSN_SUBO1 },
  67     { I960BASE_INSN_SUBO2, && case_sem_INSN_SUBO2 },
  68     { I960BASE_INSN_SUBO3, && case_sem_INSN_SUBO3 },
  69     { I960BASE_INSN_NOTBIT, && case_sem_INSN_NOTBIT },
  70     { I960BASE_INSN_NOTBIT1, && case_sem_INSN_NOTBIT1 },
  71     { I960BASE_INSN_NOTBIT2, && case_sem_INSN_NOTBIT2 },
  72     { I960BASE_INSN_NOTBIT3, && case_sem_INSN_NOTBIT3 },
  73     { I960BASE_INSN_AND, && case_sem_INSN_AND },
  74     { I960BASE_INSN_AND1, && case_sem_INSN_AND1 },
  75     { I960BASE_INSN_AND2, && case_sem_INSN_AND2 },
  76     { I960BASE_INSN_AND3, && case_sem_INSN_AND3 },
  77     { I960BASE_INSN_ANDNOT, && case_sem_INSN_ANDNOT },
  78     { I960BASE_INSN_ANDNOT1, && case_sem_INSN_ANDNOT1 },
  79     { I960BASE_INSN_ANDNOT2, && case_sem_INSN_ANDNOT2 },
  80     { I960BASE_INSN_ANDNOT3, && case_sem_INSN_ANDNOT3 },
  81     { I960BASE_INSN_SETBIT, && case_sem_INSN_SETBIT },
  82     { I960BASE_INSN_SETBIT1, && case_sem_INSN_SETBIT1 },
  83     { I960BASE_INSN_SETBIT2, && case_sem_INSN_SETBIT2 },
  84     { I960BASE_INSN_SETBIT3, && case_sem_INSN_SETBIT3 },
  85     { I960BASE_INSN_NOTAND, && case_sem_INSN_NOTAND },
  86     { I960BASE_INSN_NOTAND1, && case_sem_INSN_NOTAND1 },
  87     { I960BASE_INSN_NOTAND2, && case_sem_INSN_NOTAND2 },
  88     { I960BASE_INSN_NOTAND3, && case_sem_INSN_NOTAND3 },
  89     { I960BASE_INSN_XOR, && case_sem_INSN_XOR },
  90     { I960BASE_INSN_XOR1, && case_sem_INSN_XOR1 },
  91     { I960BASE_INSN_XOR2, && case_sem_INSN_XOR2 },
  92     { I960BASE_INSN_XOR3, && case_sem_INSN_XOR3 },
  93     { I960BASE_INSN_OR, && case_sem_INSN_OR },
  94     { I960BASE_INSN_OR1, && case_sem_INSN_OR1 },
  95     { I960BASE_INSN_OR2, && case_sem_INSN_OR2 },
  96     { I960BASE_INSN_OR3, && case_sem_INSN_OR3 },
  97     { I960BASE_INSN_NOR, && case_sem_INSN_NOR },
  98     { I960BASE_INSN_NOR1, && case_sem_INSN_NOR1 },
  99     { I960BASE_INSN_NOR2, && case_sem_INSN_NOR2 },
 100     { I960BASE_INSN_NOR3, && case_sem_INSN_NOR3 },
 101     { I960BASE_INSN_NOT, && case_sem_INSN_NOT },
 102     { I960BASE_INSN_NOT1, && case_sem_INSN_NOT1 },
 103     { I960BASE_INSN_NOT2, && case_sem_INSN_NOT2 },
 104     { I960BASE_INSN_NOT3, && case_sem_INSN_NOT3 },
 105     { I960BASE_INSN_CLRBIT, && case_sem_INSN_CLRBIT },
 106     { I960BASE_INSN_CLRBIT1, && case_sem_INSN_CLRBIT1 },
 107     { I960BASE_INSN_CLRBIT2, && case_sem_INSN_CLRBIT2 },
 108     { I960BASE_INSN_CLRBIT3, && case_sem_INSN_CLRBIT3 },
 109     { I960BASE_INSN_SHLO, && case_sem_INSN_SHLO },
 110     { I960BASE_INSN_SHLO1, && case_sem_INSN_SHLO1 },
 111     { I960BASE_INSN_SHLO2, && case_sem_INSN_SHLO2 },
 112     { I960BASE_INSN_SHLO3, && case_sem_INSN_SHLO3 },
 113     { I960BASE_INSN_SHRO, && case_sem_INSN_SHRO },
 114     { I960BASE_INSN_SHRO1, && case_sem_INSN_SHRO1 },
 115     { I960BASE_INSN_SHRO2, && case_sem_INSN_SHRO2 },
 116     { I960BASE_INSN_SHRO3, && case_sem_INSN_SHRO3 },
 117     { I960BASE_INSN_SHLI, && case_sem_INSN_SHLI },
 118     { I960BASE_INSN_SHLI1, && case_sem_INSN_SHLI1 },
 119     { I960BASE_INSN_SHLI2, && case_sem_INSN_SHLI2 },
 120     { I960BASE_INSN_SHLI3, && case_sem_INSN_SHLI3 },
 121     { I960BASE_INSN_SHRI, && case_sem_INSN_SHRI },
 122     { I960BASE_INSN_SHRI1, && case_sem_INSN_SHRI1 },
 123     { I960BASE_INSN_SHRI2, && case_sem_INSN_SHRI2 },
 124     { I960BASE_INSN_SHRI3, && case_sem_INSN_SHRI3 },
 125     { I960BASE_INSN_EMUL, && case_sem_INSN_EMUL },
 126     { I960BASE_INSN_EMUL1, && case_sem_INSN_EMUL1 },
 127     { I960BASE_INSN_EMUL2, && case_sem_INSN_EMUL2 },
 128     { I960BASE_INSN_EMUL3, && case_sem_INSN_EMUL3 },
 129     { I960BASE_INSN_MOV, && case_sem_INSN_MOV },
 130     { I960BASE_INSN_MOV1, && case_sem_INSN_MOV1 },
 131     { I960BASE_INSN_MOVL, && case_sem_INSN_MOVL },
 132     { I960BASE_INSN_MOVL1, && case_sem_INSN_MOVL1 },
 133     { I960BASE_INSN_MOVT, && case_sem_INSN_MOVT },
 134     { I960BASE_INSN_MOVT1, && case_sem_INSN_MOVT1 },
 135     { I960BASE_INSN_MOVQ, && case_sem_INSN_MOVQ },
 136     { I960BASE_INSN_MOVQ1, && case_sem_INSN_MOVQ1 },
 137     { I960BASE_INSN_MODPC, && case_sem_INSN_MODPC },
 138     { I960BASE_INSN_MODAC, && case_sem_INSN_MODAC },
 139     { I960BASE_INSN_LDA_OFFSET, && case_sem_INSN_LDA_OFFSET },
 140     { I960BASE_INSN_LDA_INDIRECT_OFFSET, && case_sem_INSN_LDA_INDIRECT_OFFSET },
 141     { I960BASE_INSN_LDA_INDIRECT, && case_sem_INSN_LDA_INDIRECT },
 142     { I960BASE_INSN_LDA_INDIRECT_INDEX, && case_sem_INSN_LDA_INDIRECT_INDEX },
 143     { I960BASE_INSN_LDA_DISP, && case_sem_INSN_LDA_DISP },
 144     { I960BASE_INSN_LDA_INDIRECT_DISP, && case_sem_INSN_LDA_INDIRECT_DISP },
 145     { I960BASE_INSN_LDA_INDEX_DISP, && case_sem_INSN_LDA_INDEX_DISP },
 146     { I960BASE_INSN_LDA_INDIRECT_INDEX_DISP, && case_sem_INSN_LDA_INDIRECT_INDEX_DISP },
 147     { I960BASE_INSN_LD_OFFSET, && case_sem_INSN_LD_OFFSET },
 148     { I960BASE_INSN_LD_INDIRECT_OFFSET, && case_sem_INSN_LD_INDIRECT_OFFSET },
 149     { I960BASE_INSN_LD_INDIRECT, && case_sem_INSN_LD_INDIRECT },
 150     { I960BASE_INSN_LD_INDIRECT_INDEX, && case_sem_INSN_LD_INDIRECT_INDEX },
 151     { I960BASE_INSN_LD_DISP, && case_sem_INSN_LD_DISP },
 152     { I960BASE_INSN_LD_INDIRECT_DISP, && case_sem_INSN_LD_INDIRECT_DISP },
 153     { I960BASE_INSN_LD_INDEX_DISP, && case_sem_INSN_LD_INDEX_DISP },
 154     { I960BASE_INSN_LD_INDIRECT_INDEX_DISP, && case_sem_INSN_LD_INDIRECT_INDEX_DISP },
 155     { I960BASE_INSN_LDOB_OFFSET, && case_sem_INSN_LDOB_OFFSET },
 156     { I960BASE_INSN_LDOB_INDIRECT_OFFSET, && case_sem_INSN_LDOB_INDIRECT_OFFSET },
 157     { I960BASE_INSN_LDOB_INDIRECT, && case_sem_INSN_LDOB_INDIRECT },
 158     { I960BASE_INSN_LDOB_INDIRECT_INDEX, && case_sem_INSN_LDOB_INDIRECT_INDEX },
 159     { I960BASE_INSN_LDOB_DISP, && case_sem_INSN_LDOB_DISP },
 160     { I960BASE_INSN_LDOB_INDIRECT_DISP, && case_sem_INSN_LDOB_INDIRECT_DISP },
 161     { I960BASE_INSN_LDOB_INDEX_DISP, && case_sem_INSN_LDOB_INDEX_DISP },
 162     { I960BASE_INSN_LDOB_INDIRECT_INDEX_DISP, && case_sem_INSN_LDOB_INDIRECT_INDEX_DISP },
 163     { I960BASE_INSN_LDOS_OFFSET, && case_sem_INSN_LDOS_OFFSET },
 164     { I960BASE_INSN_LDOS_INDIRECT_OFFSET, && case_sem_INSN_LDOS_INDIRECT_OFFSET },
 165     { I960BASE_INSN_LDOS_INDIRECT, && case_sem_INSN_LDOS_INDIRECT },
 166     { I960BASE_INSN_LDOS_INDIRECT_INDEX, && case_sem_INSN_LDOS_INDIRECT_INDEX },
 167     { I960BASE_INSN_LDOS_DISP, && case_sem_INSN_LDOS_DISP },
 168     { I960BASE_INSN_LDOS_INDIRECT_DISP, && case_sem_INSN_LDOS_INDIRECT_DISP },
 169     { I960BASE_INSN_LDOS_INDEX_DISP, && case_sem_INSN_LDOS_INDEX_DISP },
 170     { I960BASE_INSN_LDOS_INDIRECT_INDEX_DISP, && case_sem_INSN_LDOS_INDIRECT_INDEX_DISP },
 171     { I960BASE_INSN_LDIB_OFFSET, && case_sem_INSN_LDIB_OFFSET },
 172     { I960BASE_INSN_LDIB_INDIRECT_OFFSET, && case_sem_INSN_LDIB_INDIRECT_OFFSET },
 173     { I960BASE_INSN_LDIB_INDIRECT, && case_sem_INSN_LDIB_INDIRECT },
 174     { I960BASE_INSN_LDIB_INDIRECT_INDEX, && case_sem_INSN_LDIB_INDIRECT_INDEX },
 175     { I960BASE_INSN_LDIB_DISP, && case_sem_INSN_LDIB_DISP },
 176     { I960BASE_INSN_LDIB_INDIRECT_DISP, && case_sem_INSN_LDIB_INDIRECT_DISP },
 177     { I960BASE_INSN_LDIB_INDEX_DISP, && case_sem_INSN_LDIB_INDEX_DISP },
 178     { I960BASE_INSN_LDIB_INDIRECT_INDEX_DISP, && case_sem_INSN_LDIB_INDIRECT_INDEX_DISP },
 179     { I960BASE_INSN_LDIS_OFFSET, && case_sem_INSN_LDIS_OFFSET },
 180     { I960BASE_INSN_LDIS_INDIRECT_OFFSET, && case_sem_INSN_LDIS_INDIRECT_OFFSET },
 181     { I960BASE_INSN_LDIS_INDIRECT, && case_sem_INSN_LDIS_INDIRECT },
 182     { I960BASE_INSN_LDIS_INDIRECT_INDEX, && case_sem_INSN_LDIS_INDIRECT_INDEX },
 183     { I960BASE_INSN_LDIS_DISP, && case_sem_INSN_LDIS_DISP },
 184     { I960BASE_INSN_LDIS_INDIRECT_DISP, && case_sem_INSN_LDIS_INDIRECT_DISP },
 185     { I960BASE_INSN_LDIS_INDEX_DISP, && case_sem_INSN_LDIS_INDEX_DISP },
 186     { I960BASE_INSN_LDIS_INDIRECT_INDEX_DISP, && case_sem_INSN_LDIS_INDIRECT_INDEX_DISP },
 187     { I960BASE_INSN_LDL_OFFSET, && case_sem_INSN_LDL_OFFSET },
 188     { I960BASE_INSN_LDL_INDIRECT_OFFSET, && case_sem_INSN_LDL_INDIRECT_OFFSET },
 189     { I960BASE_INSN_LDL_INDIRECT, && case_sem_INSN_LDL_INDIRECT },
 190     { I960BASE_INSN_LDL_INDIRECT_INDEX, && case_sem_INSN_LDL_INDIRECT_INDEX },
 191     { I960BASE_INSN_LDL_DISP, && case_sem_INSN_LDL_DISP },
 192     { I960BASE_INSN_LDL_INDIRECT_DISP, && case_sem_INSN_LDL_INDIRECT_DISP },
 193     { I960BASE_INSN_LDL_INDEX_DISP, && case_sem_INSN_LDL_INDEX_DISP },
 194     { I960BASE_INSN_LDL_INDIRECT_INDEX_DISP, && case_sem_INSN_LDL_INDIRECT_INDEX_DISP },
 195     { I960BASE_INSN_LDT_OFFSET, && case_sem_INSN_LDT_OFFSET },
 196     { I960BASE_INSN_LDT_INDIRECT_OFFSET, && case_sem_INSN_LDT_INDIRECT_OFFSET },
 197     { I960BASE_INSN_LDT_INDIRECT, && case_sem_INSN_LDT_INDIRECT },
 198     { I960BASE_INSN_LDT_INDIRECT_INDEX, && case_sem_INSN_LDT_INDIRECT_INDEX },
 199     { I960BASE_INSN_LDT_DISP, && case_sem_INSN_LDT_DISP },
 200     { I960BASE_INSN_LDT_INDIRECT_DISP, && case_sem_INSN_LDT_INDIRECT_DISP },
 201     { I960BASE_INSN_LDT_INDEX_DISP, && case_sem_INSN_LDT_INDEX_DISP },
 202     { I960BASE_INSN_LDT_INDIRECT_INDEX_DISP, && case_sem_INSN_LDT_INDIRECT_INDEX_DISP },
 203     { I960BASE_INSN_LDQ_OFFSET, && case_sem_INSN_LDQ_OFFSET },
 204     { I960BASE_INSN_LDQ_INDIRECT_OFFSET, && case_sem_INSN_LDQ_INDIRECT_OFFSET },
 205     { I960BASE_INSN_LDQ_INDIRECT, && case_sem_INSN_LDQ_INDIRECT },
 206     { I960BASE_INSN_LDQ_INDIRECT_INDEX, && case_sem_INSN_LDQ_INDIRECT_INDEX },
 207     { I960BASE_INSN_LDQ_DISP, && case_sem_INSN_LDQ_DISP },
 208     { I960BASE_INSN_LDQ_INDIRECT_DISP, && case_sem_INSN_LDQ_INDIRECT_DISP },
 209     { I960BASE_INSN_LDQ_INDEX_DISP, && case_sem_INSN_LDQ_INDEX_DISP },
 210     { I960BASE_INSN_LDQ_INDIRECT_INDEX_DISP, && case_sem_INSN_LDQ_INDIRECT_INDEX_DISP },
 211     { I960BASE_INSN_ST_OFFSET, && case_sem_INSN_ST_OFFSET },
 212     { I960BASE_INSN_ST_INDIRECT_OFFSET, && case_sem_INSN_ST_INDIRECT_OFFSET },
 213     { I960BASE_INSN_ST_INDIRECT, && case_sem_INSN_ST_INDIRECT },
 214     { I960BASE_INSN_ST_INDIRECT_INDEX, && case_sem_INSN_ST_INDIRECT_INDEX },
 215     { I960BASE_INSN_ST_DISP, && case_sem_INSN_ST_DISP },
 216     { I960BASE_INSN_ST_INDIRECT_DISP, && case_sem_INSN_ST_INDIRECT_DISP },
 217     { I960BASE_INSN_ST_INDEX_DISP, && case_sem_INSN_ST_INDEX_DISP },
 218     { I960BASE_INSN_ST_INDIRECT_INDEX_DISP, && case_sem_INSN_ST_INDIRECT_INDEX_DISP },
 219     { I960BASE_INSN_STOB_OFFSET, && case_sem_INSN_STOB_OFFSET },
 220     { I960BASE_INSN_STOB_INDIRECT_OFFSET, && case_sem_INSN_STOB_INDIRECT_OFFSET },
 221     { I960BASE_INSN_STOB_INDIRECT, && case_sem_INSN_STOB_INDIRECT },
 222     { I960BASE_INSN_STOB_INDIRECT_INDEX, && case_sem_INSN_STOB_INDIRECT_INDEX },
 223     { I960BASE_INSN_STOB_DISP, && case_sem_INSN_STOB_DISP },
 224     { I960BASE_INSN_STOB_INDIRECT_DISP, && case_sem_INSN_STOB_INDIRECT_DISP },
 225     { I960BASE_INSN_STOB_INDEX_DISP, && case_sem_INSN_STOB_INDEX_DISP },
 226     { I960BASE_INSN_STOB_INDIRECT_INDEX_DISP, && case_sem_INSN_STOB_INDIRECT_INDEX_DISP },
 227     { I960BASE_INSN_STOS_OFFSET, && case_sem_INSN_STOS_OFFSET },
 228     { I960BASE_INSN_STOS_INDIRECT_OFFSET, && case_sem_INSN_STOS_INDIRECT_OFFSET },
 229     { I960BASE_INSN_STOS_INDIRECT, && case_sem_INSN_STOS_INDIRECT },
 230     { I960BASE_INSN_STOS_INDIRECT_INDEX, && case_sem_INSN_STOS_INDIRECT_INDEX },
 231     { I960BASE_INSN_STOS_DISP, && case_sem_INSN_STOS_DISP },
 232     { I960BASE_INSN_STOS_INDIRECT_DISP, && case_sem_INSN_STOS_INDIRECT_DISP },
 233     { I960BASE_INSN_STOS_INDEX_DISP, && case_sem_INSN_STOS_INDEX_DISP },
 234     { I960BASE_INSN_STOS_INDIRECT_INDEX_DISP, && case_sem_INSN_STOS_INDIRECT_INDEX_DISP },
 235     { I960BASE_INSN_STL_OFFSET, && case_sem_INSN_STL_OFFSET },
 236     { I960BASE_INSN_STL_INDIRECT_OFFSET, && case_sem_INSN_STL_INDIRECT_OFFSET },
 237     { I960BASE_INSN_STL_INDIRECT, && case_sem_INSN_STL_INDIRECT },
 238     { I960BASE_INSN_STL_INDIRECT_INDEX, && case_sem_INSN_STL_INDIRECT_INDEX },
 239     { I960BASE_INSN_STL_DISP, && case_sem_INSN_STL_DISP },
 240     { I960BASE_INSN_STL_INDIRECT_DISP, && case_sem_INSN_STL_INDIRECT_DISP },
 241     { I960BASE_INSN_STL_INDEX_DISP, && case_sem_INSN_STL_INDEX_DISP },
 242     { I960BASE_INSN_STL_INDIRECT_INDEX_DISP, && case_sem_INSN_STL_INDIRECT_INDEX_DISP },
 243     { I960BASE_INSN_STT_OFFSET, && case_sem_INSN_STT_OFFSET },
 244     { I960BASE_INSN_STT_INDIRECT_OFFSET, && case_sem_INSN_STT_INDIRECT_OFFSET },
 245     { I960BASE_INSN_STT_INDIRECT, && case_sem_INSN_STT_INDIRECT },
 246     { I960BASE_INSN_STT_INDIRECT_INDEX, && case_sem_INSN_STT_INDIRECT_INDEX },
 247     { I960BASE_INSN_STT_DISP, && case_sem_INSN_STT_DISP },
 248     { I960BASE_INSN_STT_INDIRECT_DISP, && case_sem_INSN_STT_INDIRECT_DISP },
 249     { I960BASE_INSN_STT_INDEX_DISP, && case_sem_INSN_STT_INDEX_DISP },
 250     { I960BASE_INSN_STT_INDIRECT_INDEX_DISP, && case_sem_INSN_STT_INDIRECT_INDEX_DISP },
 251     { I960BASE_INSN_STQ_OFFSET, && case_sem_INSN_STQ_OFFSET },
 252     { I960BASE_INSN_STQ_INDIRECT_OFFSET, && case_sem_INSN_STQ_INDIRECT_OFFSET },
 253     { I960BASE_INSN_STQ_INDIRECT, && case_sem_INSN_STQ_INDIRECT },
 254     { I960BASE_INSN_STQ_INDIRECT_INDEX, && case_sem_INSN_STQ_INDIRECT_INDEX },
 255     { I960BASE_INSN_STQ_DISP, && case_sem_INSN_STQ_DISP },
 256     { I960BASE_INSN_STQ_INDIRECT_DISP, && case_sem_INSN_STQ_INDIRECT_DISP },
 257     { I960BASE_INSN_STQ_INDEX_DISP, && case_sem_INSN_STQ_INDEX_DISP },
 258     { I960BASE_INSN_STQ_INDIRECT_INDEX_DISP, && case_sem_INSN_STQ_INDIRECT_INDEX_DISP },
 259     { I960BASE_INSN_CMPOBE_REG, && case_sem_INSN_CMPOBE_REG },
 260     { I960BASE_INSN_CMPOBE_LIT, && case_sem_INSN_CMPOBE_LIT },
 261     { I960BASE_INSN_CMPOBNE_REG, && case_sem_INSN_CMPOBNE_REG },
 262     { I960BASE_INSN_CMPOBNE_LIT, && case_sem_INSN_CMPOBNE_LIT },
 263     { I960BASE_INSN_CMPOBL_REG, && case_sem_INSN_CMPOBL_REG },
 264     { I960BASE_INSN_CMPOBL_LIT, && case_sem_INSN_CMPOBL_LIT },
 265     { I960BASE_INSN_CMPOBLE_REG, && case_sem_INSN_CMPOBLE_REG },
 266     { I960BASE_INSN_CMPOBLE_LIT, && case_sem_INSN_CMPOBLE_LIT },
 267     { I960BASE_INSN_CMPOBG_REG, && case_sem_INSN_CMPOBG_REG },
 268     { I960BASE_INSN_CMPOBG_LIT, && case_sem_INSN_CMPOBG_LIT },
 269     { I960BASE_INSN_CMPOBGE_REG, && case_sem_INSN_CMPOBGE_REG },
 270     { I960BASE_INSN_CMPOBGE_LIT, && case_sem_INSN_CMPOBGE_LIT },
 271     { I960BASE_INSN_CMPIBE_REG, && case_sem_INSN_CMPIBE_REG },
 272     { I960BASE_INSN_CMPIBE_LIT, && case_sem_INSN_CMPIBE_LIT },
 273     { I960BASE_INSN_CMPIBNE_REG, && case_sem_INSN_CMPIBNE_REG },
 274     { I960BASE_INSN_CMPIBNE_LIT, && case_sem_INSN_CMPIBNE_LIT },
 275     { I960BASE_INSN_CMPIBL_REG, && case_sem_INSN_CMPIBL_REG },
 276     { I960BASE_INSN_CMPIBL_LIT, && case_sem_INSN_CMPIBL_LIT },
 277     { I960BASE_INSN_CMPIBLE_REG, && case_sem_INSN_CMPIBLE_REG },
 278     { I960BASE_INSN_CMPIBLE_LIT, && case_sem_INSN_CMPIBLE_LIT },
 279     { I960BASE_INSN_CMPIBG_REG, && case_sem_INSN_CMPIBG_REG },
 280     { I960BASE_INSN_CMPIBG_LIT, && case_sem_INSN_CMPIBG_LIT },
 281     { I960BASE_INSN_CMPIBGE_REG, && case_sem_INSN_CMPIBGE_REG },
 282     { I960BASE_INSN_CMPIBGE_LIT, && case_sem_INSN_CMPIBGE_LIT },
 283     { I960BASE_INSN_BBC_REG, && case_sem_INSN_BBC_REG },
 284     { I960BASE_INSN_BBC_LIT, && case_sem_INSN_BBC_LIT },
 285     { I960BASE_INSN_BBS_REG, && case_sem_INSN_BBS_REG },
 286     { I960BASE_INSN_BBS_LIT, && case_sem_INSN_BBS_LIT },
 287     { I960BASE_INSN_CMPI, && case_sem_INSN_CMPI },
 288     { I960BASE_INSN_CMPI1, && case_sem_INSN_CMPI1 },
 289     { I960BASE_INSN_CMPI2, && case_sem_INSN_CMPI2 },
 290     { I960BASE_INSN_CMPI3, && case_sem_INSN_CMPI3 },
 291     { I960BASE_INSN_CMPO, && case_sem_INSN_CMPO },
 292     { I960BASE_INSN_CMPO1, && case_sem_INSN_CMPO1 },
 293     { I960BASE_INSN_CMPO2, && case_sem_INSN_CMPO2 },
 294     { I960BASE_INSN_CMPO3, && case_sem_INSN_CMPO3 },
 295     { I960BASE_INSN_TESTNO_REG, && case_sem_INSN_TESTNO_REG },
 296     { I960BASE_INSN_TESTG_REG, && case_sem_INSN_TESTG_REG },
 297     { I960BASE_INSN_TESTE_REG, && case_sem_INSN_TESTE_REG },
 298     { I960BASE_INSN_TESTGE_REG, && case_sem_INSN_TESTGE_REG },
 299     { I960BASE_INSN_TESTL_REG, && case_sem_INSN_TESTL_REG },
 300     { I960BASE_INSN_TESTNE_REG, && case_sem_INSN_TESTNE_REG },
 301     { I960BASE_INSN_TESTLE_REG, && case_sem_INSN_TESTLE_REG },
 302     { I960BASE_INSN_TESTO_REG, && case_sem_INSN_TESTO_REG },
 303     { I960BASE_INSN_BNO, && case_sem_INSN_BNO },
 304     { I960BASE_INSN_BG, && case_sem_INSN_BG },
 305     { I960BASE_INSN_BE, && case_sem_INSN_BE },
 306     { I960BASE_INSN_BGE, && case_sem_INSN_BGE },
 307     { I960BASE_INSN_BL, && case_sem_INSN_BL },
 308     { I960BASE_INSN_BNE, && case_sem_INSN_BNE },
 309     { I960BASE_INSN_BLE, && case_sem_INSN_BLE },
 310     { I960BASE_INSN_BO, && case_sem_INSN_BO },
 311     { I960BASE_INSN_B, && case_sem_INSN_B },
 312     { I960BASE_INSN_BX_INDIRECT_OFFSET, && case_sem_INSN_BX_INDIRECT_OFFSET },
 313     { I960BASE_INSN_BX_INDIRECT, && case_sem_INSN_BX_INDIRECT },
 314     { I960BASE_INSN_BX_INDIRECT_INDEX, && case_sem_INSN_BX_INDIRECT_INDEX },
 315     { I960BASE_INSN_BX_DISP, && case_sem_INSN_BX_DISP },
 316     { I960BASE_INSN_BX_INDIRECT_DISP, && case_sem_INSN_BX_INDIRECT_DISP },
 317     { I960BASE_INSN_CALLX_DISP, && case_sem_INSN_CALLX_DISP },
 318     { I960BASE_INSN_CALLX_INDIRECT, && case_sem_INSN_CALLX_INDIRECT },
 319     { I960BASE_INSN_CALLX_INDIRECT_OFFSET, && case_sem_INSN_CALLX_INDIRECT_OFFSET },
 320     { I960BASE_INSN_RET, && case_sem_INSN_RET },
 321     { I960BASE_INSN_CALLS, && case_sem_INSN_CALLS },
 322     { I960BASE_INSN_FMARK, && case_sem_INSN_FMARK },
 323     { I960BASE_INSN_FLUSHREG, && case_sem_INSN_FLUSHREG },
 324     { 0, 0 }
 325   };
 326   int i;
 327
 328   for (i = 0; labels[i].label != 0; ++i)
 329 #if FAST_P
 330     CPU_IDESC (current_cpu) [labels[i].index].sem_fast_lab = labels[i].label;
 331 #else
 332     CPU_IDESC (current_cpu) [labels[i].index].sem_full_lab = labels[i].label;
 333 #endif
 334
 335 #undef DEFINE_LABELS
 336 #endif /* DEFINE_LABELS */
 337
 338 #ifdef DEFINE_SWITCH
 339
 340 /* If hyper-fast [well not unnecessarily slow] execution is selected, turn
 341    off frills like tracing and profiling.  */
 342 /* FIXME: A better way would be to have TRACE_RESULT check for something
 343    that can cause it to be optimized out.  Another way would be to emit
 344    special handlers into the instruction "stream".  */
 345
 346 #if FAST_P
 347 #undef TRACE_RESULT
 348 #define TRACE_RESULT(cpu, abuf, name, type, val)
 349 #endif
 350
 351 #undef GET_ATTR
 352 #define GET_ATTR(cpu, num, attr) CGEN_ATTR_VALUE (NULL, abuf->idesc->attrs, CGEN_INSN_##attr)
 353
 354 {
 355
 356 #if WITH_SCACHE_PBB
 357
 358 /* Branch to next handler without going around main loop.  */
 359 #define NEXT(vpc) goto * SEM_ARGBUF (vpc) -> semantic.sem_case
 360 SWITCH (sem, SEM_ARGBUF (vpc) -> semantic.sem_case)
 361
 362 #else /* ! WITH_SCACHE_PBB */
 363
 364 #define NEXT(vpc) BREAK (sem)
 365 #ifdef __GNUC__
 366 #if FAST_P
 367   SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_fast_lab)
 368 #else
 369   SWITCH (sem, SEM_ARGBUF (sc) -> idesc->sem_full_lab)
 370 #endif
 371 #else
 372   SWITCH (sem, SEM_ARGBUF (sc) -> idesc->num)
 373 #endif
 374
 375 #endif /* ! WITH_SCACHE_PBB */
 376
 377     {
 378
 379   CASE (sem, INSN_X_INVALID) : /* --invalid-- */
 380 {
 381   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 382   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 383 #define FLD(f) abuf->fields.fmt_empty.f
 384   int UNUSED written = 0;
 385   IADDR UNUSED pc = abuf->addr;
 386   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 387
 388   {
 389 #if WITH_SCACHE
 390     /* Update the recorded pc in the cpu state struct.  */
 391     SET_H_PC (pc);
 392 #endif
 393     sim_engine_invalid_insn (current_cpu, pc);
 394     sim_io_error (CPU_STATE (current_cpu), "invalid insn not handled\n");
 395     /* NOTREACHED */
 396   }
 397
 398 #undef FLD
 399 }
 400   NEXT (vpc);
 401
 402   CASE (sem, INSN_X_AFTER) : /* --after-- */
 403 {
 404   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 405   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 406 #define FLD(f) abuf->fields.fmt_empty.f
 407   int UNUSED written = 0;
 408   IADDR UNUSED pc = abuf->addr;
 409   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 410
 411   {
 412 #if WITH_SCACHE_PBB_I960BASE
 413     i960base_pbb_after (current_cpu, sem_arg);
 414 #endif
 415   }
 416
 417 #undef FLD
 418 }
 419   NEXT (vpc);
 420
 421   CASE (sem, INSN_X_BEFORE) : /* --before-- */
 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_I960BASE
 432     i960base_pbb_before (current_cpu, sem_arg);
 433 #endif
 434   }
 435
 436 #undef FLD
 437 }
 438   NEXT (vpc);
 439
 440   CASE (sem, INSN_X_CTI_CHAIN) : /* --cti-chain-- */
 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_I960BASE
 451 #ifdef DEFINE_SWITCH
 452     vpc = i960base_pbb_cti_chain (current_cpu, sem_arg,
 453                                pbb_br_npc_ptr, pbb_br_npc);
 454     BREAK (sem);
 455 #else
 456     /* FIXME: Allow provision of explicit ifmt spec in insn spec.  */
 457     vpc = i960base_pbb_cti_chain (current_cpu, sem_arg,
 458                                CPU_PBB_BR_NPC_PTR (current_cpu),
 459                                CPU_PBB_BR_NPC (current_cpu));
 460 #endif
 461 #endif
 462   }
 463
 464 #undef FLD
 465 }
 466   NEXT (vpc);
 467
 468   CASE (sem, INSN_X_CHAIN) : /* --chain-- */
 469 {
 470   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 471   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 472 #define FLD(f) abuf->fields.fmt_empty.f
 473   int UNUSED written = 0;
 474   IADDR UNUSED pc = abuf->addr;
 475   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 476
 477   {
 478 #if WITH_SCACHE_PBB_I960BASE
 479     vpc = i960base_pbb_chain (current_cpu, sem_arg);
 480 #ifdef DEFINE_SWITCH
 481     BREAK (sem);
 482 #endif
 483 #endif
 484   }
 485
 486 #undef FLD
 487 }
 488   NEXT (vpc);
 489
 490   CASE (sem, INSN_X_BEGIN) : /* --begin-- */
 491 {
 492   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 493   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 494 #define FLD(f) abuf->fields.fmt_empty.f
 495   int UNUSED written = 0;
 496   IADDR UNUSED pc = abuf->addr;
 497   vpc = SEM_NEXT_VPC (sem_arg, pc, 0);
 498
 499   {
 500 #if WITH_SCACHE_PBB_I960BASE
 501 #ifdef DEFINE_SWITCH
 502     /* In the switch case FAST_P is a constant, allowing several optimizations
 503        in any called inline functions.  */
 504     vpc = i960base_pbb_begin (current_cpu, FAST_P);
 505 #else
 506     vpc = i960base_pbb_begin (current_cpu, STATE_RUN_FAST_P (CPU_STATE (current_cpu)));
 507 #endif
 508 #endif
 509   }
 510
 511 #undef FLD
 512 }
 513   NEXT (vpc);
 514
 515   CASE (sem, INSN_MULO) : /* mulo $src1, $src2, $dst */
 516 {
 517   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 518   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 519 #define FLD(f) abuf->fields.fmt_mulo.f
 520   int UNUSED written = 0;
 521   IADDR UNUSED pc = abuf->addr;
 522   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 523
 524   {
 525     SI opval = MULSI (* FLD (i_src1), * FLD (i_src2));
 526     * FLD (i_dst) = opval;
 527     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 528   }
 529
 530 #undef FLD
 531 }
 532   NEXT (vpc);
 533
 534   CASE (sem, INSN_MULO1) : /* mulo $lit1, $src2, $dst */
 535 {
 536   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 537   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 538 #define FLD(f) abuf->fields.fmt_mulo1.f
 539   int UNUSED written = 0;
 540   IADDR UNUSED pc = abuf->addr;
 541   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 542
 543   {
 544     SI opval = MULSI (FLD (f_src1), * FLD (i_src2));
 545     * FLD (i_dst) = opval;
 546     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 547   }
 548
 549 #undef FLD
 550 }
 551   NEXT (vpc);
 552
 553   CASE (sem, INSN_MULO2) : /* mulo $src1, $lit2, $dst */
 554 {
 555   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 556   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 557 #define FLD(f) abuf->fields.fmt_mulo2.f
 558   int UNUSED written = 0;
 559   IADDR UNUSED pc = abuf->addr;
 560   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 561
 562   {
 563     SI opval = MULSI (* FLD (i_src1), FLD (f_src2));
 564     * FLD (i_dst) = opval;
 565     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 566   }
 567
 568 #undef FLD
 569 }
 570   NEXT (vpc);
 571
 572   CASE (sem, INSN_MULO3) : /* mulo $lit1, $lit2, $dst */
 573 {
 574   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 575   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 576 #define FLD(f) abuf->fields.fmt_mulo3.f
 577   int UNUSED written = 0;
 578   IADDR UNUSED pc = abuf->addr;
 579   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 580
 581   {
 582     SI opval = MULSI (FLD (f_src1), FLD (f_src2));
 583     * FLD (i_dst) = opval;
 584     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 585   }
 586
 587 #undef FLD
 588 }
 589   NEXT (vpc);
 590
 591   CASE (sem, INSN_REMO) : /* remo $src1, $src2, $dst */
 592 {
 593   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 594   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 595 #define FLD(f) abuf->fields.fmt_mulo.f
 596   int UNUSED written = 0;
 597   IADDR UNUSED pc = abuf->addr;
 598   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 599
 600   {
 601     SI opval = UMODSI (* FLD (i_src2), * FLD (i_src1));
 602     * FLD (i_dst) = opval;
 603     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 604   }
 605
 606 #undef FLD
 607 }
 608   NEXT (vpc);
 609
 610   CASE (sem, INSN_REMO1) : /* remo $lit1, $src2, $dst */
 611 {
 612   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 613   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 614 #define FLD(f) abuf->fields.fmt_mulo1.f
 615   int UNUSED written = 0;
 616   IADDR UNUSED pc = abuf->addr;
 617   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 618
 619   {
 620     SI opval = UMODSI (* FLD (i_src2), FLD (f_src1));
 621     * FLD (i_dst) = opval;
 622     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 623   }
 624
 625 #undef FLD
 626 }
 627   NEXT (vpc);
 628
 629   CASE (sem, INSN_REMO2) : /* remo $src1, $lit2, $dst */
 630 {
 631   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 632   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 633 #define FLD(f) abuf->fields.fmt_mulo2.f
 634   int UNUSED written = 0;
 635   IADDR UNUSED pc = abuf->addr;
 636   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 637
 638   {
 639     SI opval = UMODSI (FLD (f_src2), * FLD (i_src1));
 640     * FLD (i_dst) = opval;
 641     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 642   }
 643
 644 #undef FLD
 645 }
 646   NEXT (vpc);
 647
 648   CASE (sem, INSN_REMO3) : /* remo $lit1, $lit2, $dst */
 649 {
 650   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 651   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 652 #define FLD(f) abuf->fields.fmt_mulo3.f
 653   int UNUSED written = 0;
 654   IADDR UNUSED pc = abuf->addr;
 655   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 656
 657   {
 658     SI opval = UMODSI (FLD (f_src2), FLD (f_src1));
 659     * FLD (i_dst) = opval;
 660     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 661   }
 662
 663 #undef FLD
 664 }
 665   NEXT (vpc);
 666
 667   CASE (sem, INSN_DIVO) : /* divo $src1, $src2, $dst */
 668 {
 669   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 670   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 671 #define FLD(f) abuf->fields.fmt_mulo.f
 672   int UNUSED written = 0;
 673   IADDR UNUSED pc = abuf->addr;
 674   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 675
 676   {
 677     SI opval = UDIVSI (* FLD (i_src2), * FLD (i_src1));
 678     * FLD (i_dst) = opval;
 679     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 680   }
 681
 682 #undef FLD
 683 }
 684   NEXT (vpc);
 685
 686   CASE (sem, INSN_DIVO1) : /* divo $lit1, $src2, $dst */
 687 {
 688   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 689   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 690 #define FLD(f) abuf->fields.fmt_mulo1.f
 691   int UNUSED written = 0;
 692   IADDR UNUSED pc = abuf->addr;
 693   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 694
 695   {
 696     SI opval = UDIVSI (* FLD (i_src2), FLD (f_src1));
 697     * FLD (i_dst) = opval;
 698     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 699   }
 700
 701 #undef FLD
 702 }
 703   NEXT (vpc);
 704
 705   CASE (sem, INSN_DIVO2) : /* divo $src1, $lit2, $dst */
 706 {
 707   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 708   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 709 #define FLD(f) abuf->fields.fmt_mulo2.f
 710   int UNUSED written = 0;
 711   IADDR UNUSED pc = abuf->addr;
 712   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 713
 714   {
 715     SI opval = UDIVSI (FLD (f_src2), * FLD (i_src1));
 716     * FLD (i_dst) = opval;
 717     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 718   }
 719
 720 #undef FLD
 721 }
 722   NEXT (vpc);
 723
 724   CASE (sem, INSN_DIVO3) : /* divo $lit1, $lit2, $dst */
 725 {
 726   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 727   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 728 #define FLD(f) abuf->fields.fmt_mulo3.f
 729   int UNUSED written = 0;
 730   IADDR UNUSED pc = abuf->addr;
 731   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 732
 733   {
 734     SI opval = UDIVSI (FLD (f_src2), FLD (f_src1));
 735     * FLD (i_dst) = opval;
 736     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 737   }
 738
 739 #undef FLD
 740 }
 741   NEXT (vpc);
 742
 743   CASE (sem, INSN_REMI) : /* remi $src1, $src2, $dst */
 744 {
 745   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 746   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 747 #define FLD(f) abuf->fields.fmt_mulo.f
 748   int UNUSED written = 0;
 749   IADDR UNUSED pc = abuf->addr;
 750   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 751
 752   {
 753     SI opval = MODSI (* FLD (i_src2), * FLD (i_src1));
 754     * FLD (i_dst) = opval;
 755     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 756   }
 757
 758 #undef FLD
 759 }
 760   NEXT (vpc);
 761
 762   CASE (sem, INSN_REMI1) : /* remi $lit1, $src2, $dst */
 763 {
 764   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 765   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 766 #define FLD(f) abuf->fields.fmt_mulo1.f
 767   int UNUSED written = 0;
 768   IADDR UNUSED pc = abuf->addr;
 769   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 770
 771   {
 772     SI opval = MODSI (* FLD (i_src2), FLD (f_src1));
 773     * FLD (i_dst) = opval;
 774     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 775   }
 776
 777 #undef FLD
 778 }
 779   NEXT (vpc);
 780
 781   CASE (sem, INSN_REMI2) : /* remi $src1, $lit2, $dst */
 782 {
 783   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 784   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 785 #define FLD(f) abuf->fields.fmt_mulo2.f
 786   int UNUSED written = 0;
 787   IADDR UNUSED pc = abuf->addr;
 788   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 789
 790   {
 791     SI opval = MODSI (FLD (f_src2), * FLD (i_src1));
 792     * FLD (i_dst) = opval;
 793     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 794   }
 795
 796 #undef FLD
 797 }
 798   NEXT (vpc);
 799
 800   CASE (sem, INSN_REMI3) : /* remi $lit1, $lit2, $dst */
 801 {
 802   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 803   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 804 #define FLD(f) abuf->fields.fmt_mulo3.f
 805   int UNUSED written = 0;
 806   IADDR UNUSED pc = abuf->addr;
 807   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 808
 809   {
 810     SI opval = MODSI (FLD (f_src2), FLD (f_src1));
 811     * FLD (i_dst) = opval;
 812     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 813   }
 814
 815 #undef FLD
 816 }
 817   NEXT (vpc);
 818
 819   CASE (sem, INSN_DIVI) : /* divi $src1, $src2, $dst */
 820 {
 821   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 822   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 823 #define FLD(f) abuf->fields.fmt_mulo.f
 824   int UNUSED written = 0;
 825   IADDR UNUSED pc = abuf->addr;
 826   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 827
 828   {
 829     SI opval = DIVSI (* FLD (i_src2), * FLD (i_src1));
 830     * FLD (i_dst) = opval;
 831     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 832   }
 833
 834 #undef FLD
 835 }
 836   NEXT (vpc);
 837
 838   CASE (sem, INSN_DIVI1) : /* divi $lit1, $src2, $dst */
 839 {
 840   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 841   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 842 #define FLD(f) abuf->fields.fmt_mulo1.f
 843   int UNUSED written = 0;
 844   IADDR UNUSED pc = abuf->addr;
 845   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 846
 847   {
 848     SI opval = DIVSI (* FLD (i_src2), FLD (f_src1));
 849     * FLD (i_dst) = opval;
 850     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 851   }
 852
 853 #undef FLD
 854 }
 855   NEXT (vpc);
 856
 857   CASE (sem, INSN_DIVI2) : /* divi $src1, $lit2, $dst */
 858 {
 859   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 860   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 861 #define FLD(f) abuf->fields.fmt_mulo2.f
 862   int UNUSED written = 0;
 863   IADDR UNUSED pc = abuf->addr;
 864   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 865
 866   {
 867     SI opval = DIVSI (FLD (f_src2), * FLD (i_src1));
 868     * FLD (i_dst) = opval;
 869     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 870   }
 871
 872 #undef FLD
 873 }
 874   NEXT (vpc);
 875
 876   CASE (sem, INSN_DIVI3) : /* divi $lit1, $lit2, $dst */
 877 {
 878   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 879   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 880 #define FLD(f) abuf->fields.fmt_mulo3.f
 881   int UNUSED written = 0;
 882   IADDR UNUSED pc = abuf->addr;
 883   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 884
 885   {
 886     SI opval = DIVSI (FLD (f_src2), FLD (f_src1));
 887     * FLD (i_dst) = opval;
 888     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 889   }
 890
 891 #undef FLD
 892 }
 893   NEXT (vpc);
 894
 895   CASE (sem, INSN_ADDO) : /* addo $src1, $src2, $dst */
 896 {
 897   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 898   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 899 #define FLD(f) abuf->fields.fmt_mulo.f
 900   int UNUSED written = 0;
 901   IADDR UNUSED pc = abuf->addr;
 902   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 903
 904   {
 905     SI opval = ADDSI (* FLD (i_src1), * FLD (i_src2));
 906     * FLD (i_dst) = opval;
 907     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 908   }
 909
 910 #undef FLD
 911 }
 912   NEXT (vpc);
 913
 914   CASE (sem, INSN_ADDO1) : /* addo $lit1, $src2, $dst */
 915 {
 916   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 917   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 918 #define FLD(f) abuf->fields.fmt_mulo1.f
 919   int UNUSED written = 0;
 920   IADDR UNUSED pc = abuf->addr;
 921   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 922
 923   {
 924     SI opval = ADDSI (FLD (f_src1), * FLD (i_src2));
 925     * FLD (i_dst) = opval;
 926     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 927   }
 928
 929 #undef FLD
 930 }
 931   NEXT (vpc);
 932
 933   CASE (sem, INSN_ADDO2) : /* addo $src1, $lit2, $dst */
 934 {
 935   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 936   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 937 #define FLD(f) abuf->fields.fmt_mulo2.f
 938   int UNUSED written = 0;
 939   IADDR UNUSED pc = abuf->addr;
 940   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 941
 942   {
 943     SI opval = ADDSI (* FLD (i_src1), FLD (f_src2));
 944     * FLD (i_dst) = opval;
 945     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 946   }
 947
 948 #undef FLD
 949 }
 950   NEXT (vpc);
 951
 952   CASE (sem, INSN_ADDO3) : /* addo $lit1, $lit2, $dst */
 953 {
 954   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 955   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 956 #define FLD(f) abuf->fields.fmt_mulo3.f
 957   int UNUSED written = 0;
 958   IADDR UNUSED pc = abuf->addr;
 959   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 960
 961   {
 962     SI opval = ADDSI (FLD (f_src1), FLD (f_src2));
 963     * FLD (i_dst) = opval;
 964     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 965   }
 966
 967 #undef FLD
 968 }
 969   NEXT (vpc);
 970
 971   CASE (sem, INSN_SUBO) : /* subo $src1, $src2, $dst */
 972 {
 973   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 974   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 975 #define FLD(f) abuf->fields.fmt_mulo.f
 976   int UNUSED written = 0;
 977   IADDR UNUSED pc = abuf->addr;
 978   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 979
 980   {
 981     SI opval = SUBSI (* FLD (i_src2), * FLD (i_src1));
 982     * FLD (i_dst) = opval;
 983     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
 984   }
 985
 986 #undef FLD
 987 }
 988   NEXT (vpc);
 989
 990   CASE (sem, INSN_SUBO1) : /* subo $lit1, $src2, $dst */
 991 {
 992   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
 993   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
 994 #define FLD(f) abuf->fields.fmt_mulo1.f
 995   int UNUSED written = 0;
 996   IADDR UNUSED pc = abuf->addr;
 997   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
 998
 999   {
1000     SI opval = SUBSI (* FLD (i_src2), FLD (f_src1));
1001     * FLD (i_dst) = opval;
1002     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1003   }
1004
1005 #undef FLD
1006 }
1007   NEXT (vpc);
1008
1009   CASE (sem, INSN_SUBO2) : /* subo $src1, $lit2, $dst */
1010 {
1011   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1012   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1013 #define FLD(f) abuf->fields.fmt_mulo2.f
1014   int UNUSED written = 0;
1015   IADDR UNUSED pc = abuf->addr;
1016   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1017
1018   {
1019     SI opval = SUBSI (FLD (f_src2), * FLD (i_src1));
1020     * FLD (i_dst) = opval;
1021     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1022   }
1023
1024 #undef FLD
1025 }
1026   NEXT (vpc);
1027
1028   CASE (sem, INSN_SUBO3) : /* subo $lit1, $lit2, $dst */
1029 {
1030   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1031   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1032 #define FLD(f) abuf->fields.fmt_mulo3.f
1033   int UNUSED written = 0;
1034   IADDR UNUSED pc = abuf->addr;
1035   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1036
1037   {
1038     SI opval = SUBSI (FLD (f_src2), FLD (f_src1));
1039     * FLD (i_dst) = opval;
1040     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1041   }
1042
1043 #undef FLD
1044 }
1045   NEXT (vpc);
1046
1047   CASE (sem, INSN_NOTBIT) : /* notbit $src1, $src2, $dst */
1048 {
1049   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1050   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1051 #define FLD(f) abuf->fields.fmt_notbit.f
1052   int UNUSED written = 0;
1053   IADDR UNUSED pc = abuf->addr;
1054   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1055
1056   {
1057     SI opval = XORSI (SLLSI (1, * FLD (i_src1)), * FLD (i_src2));
1058     * FLD (i_dst) = opval;
1059     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1060   }
1061
1062 #undef FLD
1063 }
1064   NEXT (vpc);
1065
1066   CASE (sem, INSN_NOTBIT1) : /* notbit $lit1, $src2, $dst */
1067 {
1068   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1069   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1070 #define FLD(f) abuf->fields.fmt_notbit1.f
1071   int UNUSED written = 0;
1072   IADDR UNUSED pc = abuf->addr;
1073   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1074
1075   {
1076     SI opval = XORSI (SLLSI (1, FLD (f_src1)), * FLD (i_src2));
1077     * FLD (i_dst) = opval;
1078     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1079   }
1080
1081 #undef FLD
1082 }
1083   NEXT (vpc);
1084
1085   CASE (sem, INSN_NOTBIT2) : /* notbit $src1, $lit2, $dst */
1086 {
1087   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1088   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1089 #define FLD(f) abuf->fields.fmt_notbit2.f
1090   int UNUSED written = 0;
1091   IADDR UNUSED pc = abuf->addr;
1092   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1093
1094   {
1095     SI opval = XORSI (SLLSI (1, * FLD (i_src1)), FLD (f_src2));
1096     * FLD (i_dst) = opval;
1097     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1098   }
1099
1100 #undef FLD
1101 }
1102   NEXT (vpc);
1103
1104   CASE (sem, INSN_NOTBIT3) : /* notbit $lit1, $lit2, $dst */
1105 {
1106   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1107   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1108 #define FLD(f) abuf->fields.fmt_notbit3.f
1109   int UNUSED written = 0;
1110   IADDR UNUSED pc = abuf->addr;
1111   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1112
1113   {
1114     SI opval = XORSI (SLLSI (1, FLD (f_src1)), FLD (f_src2));
1115     * FLD (i_dst) = opval;
1116     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1117   }
1118
1119 #undef FLD
1120 }
1121   NEXT (vpc);
1122
1123   CASE (sem, INSN_AND) : /* and $src1, $src2, $dst */
1124 {
1125   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1126   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1127 #define FLD(f) abuf->fields.fmt_mulo.f
1128   int UNUSED written = 0;
1129   IADDR UNUSED pc = abuf->addr;
1130   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1131
1132   {
1133     SI opval = ANDSI (* FLD (i_src1), * FLD (i_src2));
1134     * FLD (i_dst) = opval;
1135     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1136   }
1137
1138 #undef FLD
1139 }
1140   NEXT (vpc);
1141
1142   CASE (sem, INSN_AND1) : /* and $lit1, $src2, $dst */
1143 {
1144   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1145   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1146 #define FLD(f) abuf->fields.fmt_mulo1.f
1147   int UNUSED written = 0;
1148   IADDR UNUSED pc = abuf->addr;
1149   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1150
1151   {
1152     SI opval = ANDSI (FLD (f_src1), * FLD (i_src2));
1153     * FLD (i_dst) = opval;
1154     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1155   }
1156
1157 #undef FLD
1158 }
1159   NEXT (vpc);
1160
1161   CASE (sem, INSN_AND2) : /* and $src1, $lit2, $dst */
1162 {
1163   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1164   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1165 #define FLD(f) abuf->fields.fmt_mulo2.f
1166   int UNUSED written = 0;
1167   IADDR UNUSED pc = abuf->addr;
1168   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1169
1170   {
1171     SI opval = ANDSI (* FLD (i_src1), FLD (f_src2));
1172     * FLD (i_dst) = opval;
1173     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1174   }
1175
1176 #undef FLD
1177 }
1178   NEXT (vpc);
1179
1180   CASE (sem, INSN_AND3) : /* and $lit1, $lit2, $dst */
1181 {
1182   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1183   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1184 #define FLD(f) abuf->fields.fmt_mulo3.f
1185   int UNUSED written = 0;
1186   IADDR UNUSED pc = abuf->addr;
1187   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1188
1189   {
1190     SI opval = ANDSI (FLD (f_src1), FLD (f_src2));
1191     * FLD (i_dst) = opval;
1192     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1193   }
1194
1195 #undef FLD
1196 }
1197   NEXT (vpc);
1198
1199   CASE (sem, INSN_ANDNOT) : /* andnot $src1, $src2, $dst */
1200 {
1201   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1202   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1203 #define FLD(f) abuf->fields.fmt_mulo.f
1204   int UNUSED written = 0;
1205   IADDR UNUSED pc = abuf->addr;
1206   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1207
1208   {
1209     SI opval = ANDSI (* FLD (i_src2), INVSI (* FLD (i_src1)));
1210     * FLD (i_dst) = opval;
1211     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1212   }
1213
1214 #undef FLD
1215 }
1216   NEXT (vpc);
1217
1218   CASE (sem, INSN_ANDNOT1) : /* andnot $lit1, $src2, $dst */
1219 {
1220   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1221   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1222 #define FLD(f) abuf->fields.fmt_mulo1.f
1223   int UNUSED written = 0;
1224   IADDR UNUSED pc = abuf->addr;
1225   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1226
1227   {
1228     SI opval = ANDSI (* FLD (i_src2), INVSI (FLD (f_src1)));
1229     * FLD (i_dst) = opval;
1230     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1231   }
1232
1233 #undef FLD
1234 }
1235   NEXT (vpc);
1236
1237   CASE (sem, INSN_ANDNOT2) : /* andnot $src1, $lit2, $dst */
1238 {
1239   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1240   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1241 #define FLD(f) abuf->fields.fmt_mulo2.f
1242   int UNUSED written = 0;
1243   IADDR UNUSED pc = abuf->addr;
1244   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1245
1246   {
1247     SI opval = ANDSI (FLD (f_src2), INVSI (* FLD (i_src1)));
1248     * FLD (i_dst) = opval;
1249     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1250   }
1251
1252 #undef FLD
1253 }
1254   NEXT (vpc);
1255
1256   CASE (sem, INSN_ANDNOT3) : /* andnot $lit1, $lit2, $dst */
1257 {
1258   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1259   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1260 #define FLD(f) abuf->fields.fmt_mulo3.f
1261   int UNUSED written = 0;
1262   IADDR UNUSED pc = abuf->addr;
1263   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1264
1265   {
1266     SI opval = ANDSI (FLD (f_src2), INVSI (FLD (f_src1)));
1267     * FLD (i_dst) = opval;
1268     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1269   }
1270
1271 #undef FLD
1272 }
1273   NEXT (vpc);
1274
1275   CASE (sem, INSN_SETBIT) : /* setbit $src1, $src2, $dst */
1276 {
1277   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1278   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1279 #define FLD(f) abuf->fields.fmt_notbit.f
1280   int UNUSED written = 0;
1281   IADDR UNUSED pc = abuf->addr;
1282   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1283
1284   {
1285     SI opval = ORSI (SLLSI (1, * FLD (i_src1)), * FLD (i_src2));
1286     * FLD (i_dst) = opval;
1287     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1288   }
1289
1290 #undef FLD
1291 }
1292   NEXT (vpc);
1293
1294   CASE (sem, INSN_SETBIT1) : /* setbit $lit1, $src2, $dst */
1295 {
1296   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1297   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1298 #define FLD(f) abuf->fields.fmt_notbit1.f
1299   int UNUSED written = 0;
1300   IADDR UNUSED pc = abuf->addr;
1301   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1302
1303   {
1304     SI opval = ORSI (SLLSI (1, FLD (f_src1)), * FLD (i_src2));
1305     * FLD (i_dst) = opval;
1306     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1307   }
1308
1309 #undef FLD
1310 }
1311   NEXT (vpc);
1312
1313   CASE (sem, INSN_SETBIT2) : /* setbit $src1, $lit2, $dst */
1314 {
1315   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1316   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1317 #define FLD(f) abuf->fields.fmt_notbit2.f
1318   int UNUSED written = 0;
1319   IADDR UNUSED pc = abuf->addr;
1320   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1321
1322   {
1323     SI opval = ORSI (SLLSI (1, * FLD (i_src1)), FLD (f_src2));
1324     * FLD (i_dst) = opval;
1325     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1326   }
1327
1328 #undef FLD
1329 }
1330   NEXT (vpc);
1331
1332   CASE (sem, INSN_SETBIT3) : /* setbit $lit1, $lit2, $dst */
1333 {
1334   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1335   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1336 #define FLD(f) abuf->fields.fmt_notbit3.f
1337   int UNUSED written = 0;
1338   IADDR UNUSED pc = abuf->addr;
1339   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1340
1341   {
1342     SI opval = ORSI (SLLSI (1, FLD (f_src1)), FLD (f_src2));
1343     * FLD (i_dst) = opval;
1344     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1345   }
1346
1347 #undef FLD
1348 }
1349   NEXT (vpc);
1350
1351   CASE (sem, INSN_NOTAND) : /* notand $src1, $src2, $dst */
1352 {
1353   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1354   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1355 #define FLD(f) abuf->fields.fmt_mulo.f
1356   int UNUSED written = 0;
1357   IADDR UNUSED pc = abuf->addr;
1358   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1359
1360   {
1361     SI opval = ANDSI (INVSI (* FLD (i_src2)), * FLD (i_src1));
1362     * FLD (i_dst) = opval;
1363     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1364   }
1365
1366 #undef FLD
1367 }
1368   NEXT (vpc);
1369
1370   CASE (sem, INSN_NOTAND1) : /* notand $lit1, $src2, $dst */
1371 {
1372   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1373   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1374 #define FLD(f) abuf->fields.fmt_mulo1.f
1375   int UNUSED written = 0;
1376   IADDR UNUSED pc = abuf->addr;
1377   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1378
1379   {
1380     SI opval = ANDSI (INVSI (* FLD (i_src2)), FLD (f_src1));
1381     * FLD (i_dst) = opval;
1382     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1383   }
1384
1385 #undef FLD
1386 }
1387   NEXT (vpc);
1388
1389   CASE (sem, INSN_NOTAND2) : /* notand $src1, $lit2, $dst */
1390 {
1391   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1392   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1393 #define FLD(f) abuf->fields.fmt_mulo2.f
1394   int UNUSED written = 0;
1395   IADDR UNUSED pc = abuf->addr;
1396   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1397
1398   {
1399     SI opval = ANDSI (INVSI (FLD (f_src2)), * FLD (i_src1));
1400     * FLD (i_dst) = opval;
1401     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1402   }
1403
1404 #undef FLD
1405 }
1406   NEXT (vpc);
1407
1408   CASE (sem, INSN_NOTAND3) : /* notand $lit1, $lit2, $dst */
1409 {
1410   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1411   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1412 #define FLD(f) abuf->fields.fmt_mulo3.f
1413   int UNUSED written = 0;
1414   IADDR UNUSED pc = abuf->addr;
1415   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1416
1417   {
1418     SI opval = ANDSI (INVSI (FLD (f_src2)), FLD (f_src1));
1419     * FLD (i_dst) = opval;
1420     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1421   }
1422
1423 #undef FLD
1424 }
1425   NEXT (vpc);
1426
1427   CASE (sem, INSN_XOR) : /* xor $src1, $src2, $dst */
1428 {
1429   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1430   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1431 #define FLD(f) abuf->fields.fmt_mulo.f
1432   int UNUSED written = 0;
1433   IADDR UNUSED pc = abuf->addr;
1434   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1435
1436   {
1437     SI opval = XORSI (* FLD (i_src1), * FLD (i_src2));
1438     * FLD (i_dst) = opval;
1439     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1440   }
1441
1442 #undef FLD
1443 }
1444   NEXT (vpc);
1445
1446   CASE (sem, INSN_XOR1) : /* xor $lit1, $src2, $dst */
1447 {
1448   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1449   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1450 #define FLD(f) abuf->fields.fmt_mulo1.f
1451   int UNUSED written = 0;
1452   IADDR UNUSED pc = abuf->addr;
1453   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1454
1455   {
1456     SI opval = XORSI (FLD (f_src1), * FLD (i_src2));
1457     * FLD (i_dst) = opval;
1458     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1459   }
1460
1461 #undef FLD
1462 }
1463   NEXT (vpc);
1464
1465   CASE (sem, INSN_XOR2) : /* xor $src1, $lit2, $dst */
1466 {
1467   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1468   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1469 #define FLD(f) abuf->fields.fmt_mulo2.f
1470   int UNUSED written = 0;
1471   IADDR UNUSED pc = abuf->addr;
1472   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1473
1474   {
1475     SI opval = XORSI (* FLD (i_src1), FLD (f_src2));
1476     * FLD (i_dst) = opval;
1477     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1478   }
1479
1480 #undef FLD
1481 }
1482   NEXT (vpc);
1483
1484   CASE (sem, INSN_XOR3) : /* xor $lit1, $lit2, $dst */
1485 {
1486   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1487   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1488 #define FLD(f) abuf->fields.fmt_mulo3.f
1489   int UNUSED written = 0;
1490   IADDR UNUSED pc = abuf->addr;
1491   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1492
1493   {
1494     SI opval = XORSI (FLD (f_src1), FLD (f_src2));
1495     * FLD (i_dst) = opval;
1496     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1497   }
1498
1499 #undef FLD
1500 }
1501   NEXT (vpc);
1502
1503   CASE (sem, INSN_OR) : /* or $src1, $src2, $dst */
1504 {
1505   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1506   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1507 #define FLD(f) abuf->fields.fmt_mulo.f
1508   int UNUSED written = 0;
1509   IADDR UNUSED pc = abuf->addr;
1510   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1511
1512   {
1513     SI opval = ORSI (* FLD (i_src1), * FLD (i_src2));
1514     * FLD (i_dst) = opval;
1515     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1516   }
1517
1518 #undef FLD
1519 }
1520   NEXT (vpc);
1521
1522   CASE (sem, INSN_OR1) : /* or $lit1, $src2, $dst */
1523 {
1524   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1525   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1526 #define FLD(f) abuf->fields.fmt_mulo1.f
1527   int UNUSED written = 0;
1528   IADDR UNUSED pc = abuf->addr;
1529   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1530
1531   {
1532     SI opval = ORSI (FLD (f_src1), * FLD (i_src2));
1533     * FLD (i_dst) = opval;
1534     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1535   }
1536
1537 #undef FLD
1538 }
1539   NEXT (vpc);
1540
1541   CASE (sem, INSN_OR2) : /* or $src1, $lit2, $dst */
1542 {
1543   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1544   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1545 #define FLD(f) abuf->fields.fmt_mulo2.f
1546   int UNUSED written = 0;
1547   IADDR UNUSED pc = abuf->addr;
1548   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1549
1550   {
1551     SI opval = ORSI (* FLD (i_src1), FLD (f_src2));
1552     * FLD (i_dst) = opval;
1553     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1554   }
1555
1556 #undef FLD
1557 }
1558   NEXT (vpc);
1559
1560   CASE (sem, INSN_OR3) : /* or $lit1, $lit2, $dst */
1561 {
1562   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1563   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1564 #define FLD(f) abuf->fields.fmt_mulo3.f
1565   int UNUSED written = 0;
1566   IADDR UNUSED pc = abuf->addr;
1567   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1568
1569   {
1570     SI opval = ORSI (FLD (f_src1), FLD (f_src2));
1571     * FLD (i_dst) = opval;
1572     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1573   }
1574
1575 #undef FLD
1576 }
1577   NEXT (vpc);
1578
1579   CASE (sem, INSN_NOR) : /* nor $src1, $src2, $dst */
1580 {
1581   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1582   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1583 #define FLD(f) abuf->fields.fmt_mulo.f
1584   int UNUSED written = 0;
1585   IADDR UNUSED pc = abuf->addr;
1586   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1587
1588   {
1589     SI opval = ANDSI (INVSI (* FLD (i_src2)), INVSI (* FLD (i_src1)));
1590     * FLD (i_dst) = opval;
1591     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1592   }
1593
1594 #undef FLD
1595 }
1596   NEXT (vpc);
1597
1598   CASE (sem, INSN_NOR1) : /* nor $lit1, $src2, $dst */
1599 {
1600   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1601   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1602 #define FLD(f) abuf->fields.fmt_mulo1.f
1603   int UNUSED written = 0;
1604   IADDR UNUSED pc = abuf->addr;
1605   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1606
1607   {
1608     SI opval = ANDSI (INVSI (* FLD (i_src2)), INVSI (FLD (f_src1)));
1609     * FLD (i_dst) = opval;
1610     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1611   }
1612
1613 #undef FLD
1614 }
1615   NEXT (vpc);
1616
1617   CASE (sem, INSN_NOR2) : /* nor $src1, $lit2, $dst */
1618 {
1619   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1620   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1621 #define FLD(f) abuf->fields.fmt_mulo2.f
1622   int UNUSED written = 0;
1623   IADDR UNUSED pc = abuf->addr;
1624   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1625
1626   {
1627     SI opval = ANDSI (INVSI (FLD (f_src2)), INVSI (* FLD (i_src1)));
1628     * FLD (i_dst) = opval;
1629     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1630   }
1631
1632 #undef FLD
1633 }
1634   NEXT (vpc);
1635
1636   CASE (sem, INSN_NOR3) : /* nor $lit1, $lit2, $dst */
1637 {
1638   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1639   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1640 #define FLD(f) abuf->fields.fmt_mulo3.f
1641   int UNUSED written = 0;
1642   IADDR UNUSED pc = abuf->addr;
1643   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1644
1645   {
1646     SI opval = ANDSI (INVSI (FLD (f_src2)), INVSI (FLD (f_src1)));
1647     * FLD (i_dst) = opval;
1648     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1649   }
1650
1651 #undef FLD
1652 }
1653   NEXT (vpc);
1654
1655   CASE (sem, INSN_NOT) : /* not $src1, $src2, $dst */
1656 {
1657   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1658   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1659 #define FLD(f) abuf->fields.fmt_not.f
1660   int UNUSED written = 0;
1661   IADDR UNUSED pc = abuf->addr;
1662   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1663
1664   {
1665     SI opval = INVSI (* FLD (i_src1));
1666     * FLD (i_dst) = opval;
1667     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1668   }
1669
1670 #undef FLD
1671 }
1672   NEXT (vpc);
1673
1674   CASE (sem, INSN_NOT1) : /* not $lit1, $src2, $dst */
1675 {
1676   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1677   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1678 #define FLD(f) abuf->fields.fmt_not1.f
1679   int UNUSED written = 0;
1680   IADDR UNUSED pc = abuf->addr;
1681   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1682
1683   {
1684     SI opval = INVSI (FLD (f_src1));
1685     * FLD (i_dst) = opval;
1686     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1687   }
1688
1689 #undef FLD
1690 }
1691   NEXT (vpc);
1692
1693   CASE (sem, INSN_NOT2) : /* not $src1, $lit2, $dst */
1694 {
1695   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1696   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1697 #define FLD(f) abuf->fields.fmt_not2.f
1698   int UNUSED written = 0;
1699   IADDR UNUSED pc = abuf->addr;
1700   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1701
1702   {
1703     SI opval = INVSI (* FLD (i_src1));
1704     * FLD (i_dst) = opval;
1705     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1706   }
1707
1708 #undef FLD
1709 }
1710   NEXT (vpc);
1711
1712   CASE (sem, INSN_NOT3) : /* not $lit1, $lit2, $dst */
1713 {
1714   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1715   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1716 #define FLD(f) abuf->fields.fmt_not3.f
1717   int UNUSED written = 0;
1718   IADDR UNUSED pc = abuf->addr;
1719   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1720
1721   {
1722     SI opval = INVSI (FLD (f_src1));
1723     * FLD (i_dst) = opval;
1724     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1725   }
1726
1727 #undef FLD
1728 }
1729   NEXT (vpc);
1730
1731   CASE (sem, INSN_CLRBIT) : /* clrbit $src1, $src2, $dst */
1732 {
1733   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1734   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1735 #define FLD(f) abuf->fields.fmt_notbit.f
1736   int UNUSED written = 0;
1737   IADDR UNUSED pc = abuf->addr;
1738   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1739
1740   {
1741     SI opval = ANDSI (INVSI (SLLSI (1, * FLD (i_src1))), * FLD (i_src2));
1742     * FLD (i_dst) = opval;
1743     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1744   }
1745
1746 #undef FLD
1747 }
1748   NEXT (vpc);
1749
1750   CASE (sem, INSN_CLRBIT1) : /* clrbit $lit1, $src2, $dst */
1751 {
1752   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1753   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1754 #define FLD(f) abuf->fields.fmt_notbit1.f
1755   int UNUSED written = 0;
1756   IADDR UNUSED pc = abuf->addr;
1757   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1758
1759   {
1760     SI opval = ANDSI (INVSI (SLLSI (1, FLD (f_src1))), * FLD (i_src2));
1761     * FLD (i_dst) = opval;
1762     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1763   }
1764
1765 #undef FLD
1766 }
1767   NEXT (vpc);
1768
1769   CASE (sem, INSN_CLRBIT2) : /* clrbit $src1, $lit2, $dst */
1770 {
1771   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1772   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1773 #define FLD(f) abuf->fields.fmt_notbit2.f
1774   int UNUSED written = 0;
1775   IADDR UNUSED pc = abuf->addr;
1776   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1777
1778   {
1779     SI opval = ANDSI (INVSI (SLLSI (1, * FLD (i_src1))), FLD (f_src2));
1780     * FLD (i_dst) = opval;
1781     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1782   }
1783
1784 #undef FLD
1785 }
1786   NEXT (vpc);
1787
1788   CASE (sem, INSN_CLRBIT3) : /* clrbit $lit1, $lit2, $dst */
1789 {
1790   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1791   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1792 #define FLD(f) abuf->fields.fmt_notbit3.f
1793   int UNUSED written = 0;
1794   IADDR UNUSED pc = abuf->addr;
1795   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1796
1797   {
1798     SI opval = ANDSI (INVSI (SLLSI (1, FLD (f_src1))), FLD (f_src2));
1799     * FLD (i_dst) = opval;
1800     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1801   }
1802
1803 #undef FLD
1804 }
1805   NEXT (vpc);
1806
1807   CASE (sem, INSN_SHLO) : /* shlo $src1, $src2, $dst */
1808 {
1809   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1810   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1811 #define FLD(f) abuf->fields.fmt_notbit.f
1812   int UNUSED written = 0;
1813   IADDR UNUSED pc = abuf->addr;
1814   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1815
1816   {
1817     SI opval = SLLSI (* FLD (i_src2), * FLD (i_src1));
1818     * FLD (i_dst) = opval;
1819     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1820   }
1821
1822 #undef FLD
1823 }
1824   NEXT (vpc);
1825
1826   CASE (sem, INSN_SHLO1) : /* shlo $lit1, $src2, $dst */
1827 {
1828   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1829   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1830 #define FLD(f) abuf->fields.fmt_notbit1.f
1831   int UNUSED written = 0;
1832   IADDR UNUSED pc = abuf->addr;
1833   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1834
1835   {
1836     SI opval = SLLSI (* FLD (i_src2), FLD (f_src1));
1837     * FLD (i_dst) = opval;
1838     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1839   }
1840
1841 #undef FLD
1842 }
1843   NEXT (vpc);
1844
1845   CASE (sem, INSN_SHLO2) : /* shlo $src1, $lit2, $dst */
1846 {
1847   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1848   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1849 #define FLD(f) abuf->fields.fmt_notbit2.f
1850   int UNUSED written = 0;
1851   IADDR UNUSED pc = abuf->addr;
1852   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1853
1854   {
1855     SI opval = SLLSI (FLD (f_src2), * FLD (i_src1));
1856     * FLD (i_dst) = opval;
1857     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1858   }
1859
1860 #undef FLD
1861 }
1862   NEXT (vpc);
1863
1864   CASE (sem, INSN_SHLO3) : /* shlo $lit1, $lit2, $dst */
1865 {
1866   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1867   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1868 #define FLD(f) abuf->fields.fmt_notbit3.f
1869   int UNUSED written = 0;
1870   IADDR UNUSED pc = abuf->addr;
1871   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1872
1873   {
1874     SI opval = SLLSI (FLD (f_src2), FLD (f_src1));
1875     * FLD (i_dst) = opval;
1876     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1877   }
1878
1879 #undef FLD
1880 }
1881   NEXT (vpc);
1882
1883   CASE (sem, INSN_SHRO) : /* shro $src1, $src2, $dst */
1884 {
1885   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1886   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1887 #define FLD(f) abuf->fields.fmt_notbit.f
1888   int UNUSED written = 0;
1889   IADDR UNUSED pc = abuf->addr;
1890   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1891
1892   {
1893     SI opval = SRLSI (* FLD (i_src2), * FLD (i_src1));
1894     * FLD (i_dst) = opval;
1895     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1896   }
1897
1898 #undef FLD
1899 }
1900   NEXT (vpc);
1901
1902   CASE (sem, INSN_SHRO1) : /* shro $lit1, $src2, $dst */
1903 {
1904   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1905   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1906 #define FLD(f) abuf->fields.fmt_notbit1.f
1907   int UNUSED written = 0;
1908   IADDR UNUSED pc = abuf->addr;
1909   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1910
1911   {
1912     SI opval = SRLSI (* FLD (i_src2), FLD (f_src1));
1913     * FLD (i_dst) = opval;
1914     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1915   }
1916
1917 #undef FLD
1918 }
1919   NEXT (vpc);
1920
1921   CASE (sem, INSN_SHRO2) : /* shro $src1, $lit2, $dst */
1922 {
1923   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1924   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1925 #define FLD(f) abuf->fields.fmt_notbit2.f
1926   int UNUSED written = 0;
1927   IADDR UNUSED pc = abuf->addr;
1928   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1929
1930   {
1931     SI opval = SRLSI (FLD (f_src2), * FLD (i_src1));
1932     * FLD (i_dst) = opval;
1933     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1934   }
1935
1936 #undef FLD
1937 }
1938   NEXT (vpc);
1939
1940   CASE (sem, INSN_SHRO3) : /* shro $lit1, $lit2, $dst */
1941 {
1942   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1943   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1944 #define FLD(f) abuf->fields.fmt_notbit3.f
1945   int UNUSED written = 0;
1946   IADDR UNUSED pc = abuf->addr;
1947   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1948
1949   {
1950     SI opval = SRLSI (FLD (f_src2), FLD (f_src1));
1951     * FLD (i_dst) = opval;
1952     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1953   }
1954
1955 #undef FLD
1956 }
1957   NEXT (vpc);
1958
1959   CASE (sem, INSN_SHLI) : /* shli $src1, $src2, $dst */
1960 {
1961   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1962   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1963 #define FLD(f) abuf->fields.fmt_notbit.f
1964   int UNUSED written = 0;
1965   IADDR UNUSED pc = abuf->addr;
1966   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1967
1968   {
1969     SI opval = SLLSI (* FLD (i_src2), * FLD (i_src1));
1970     * FLD (i_dst) = opval;
1971     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1972   }
1973
1974 #undef FLD
1975 }
1976   NEXT (vpc);
1977
1978   CASE (sem, INSN_SHLI1) : /* shli $lit1, $src2, $dst */
1979 {
1980   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
1981   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
1982 #define FLD(f) abuf->fields.fmt_notbit1.f
1983   int UNUSED written = 0;
1984   IADDR UNUSED pc = abuf->addr;
1985   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
1986
1987   {
1988     SI opval = SLLSI (* FLD (i_src2), FLD (f_src1));
1989     * FLD (i_dst) = opval;
1990     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
1991   }
1992
1993 #undef FLD
1994 }
1995   NEXT (vpc);
1996
1997   CASE (sem, INSN_SHLI2) : /* shli $src1, $lit2, $dst */
1998 {
1999   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2000   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2001 #define FLD(f) abuf->fields.fmt_notbit2.f
2002   int UNUSED written = 0;
2003   IADDR UNUSED pc = abuf->addr;
2004   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2005
2006   {
2007     SI opval = SLLSI (FLD (f_src2), * FLD (i_src1));
2008     * FLD (i_dst) = opval;
2009     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2010   }
2011
2012 #undef FLD
2013 }
2014   NEXT (vpc);
2015
2016   CASE (sem, INSN_SHLI3) : /* shli $lit1, $lit2, $dst */
2017 {
2018   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2019   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2020 #define FLD(f) abuf->fields.fmt_notbit3.f
2021   int UNUSED written = 0;
2022   IADDR UNUSED pc = abuf->addr;
2023   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2024
2025   {
2026     SI opval = SLLSI (FLD (f_src2), FLD (f_src1));
2027     * FLD (i_dst) = opval;
2028     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2029   }
2030
2031 #undef FLD
2032 }
2033   NEXT (vpc);
2034
2035   CASE (sem, INSN_SHRI) : /* shri $src1, $src2, $dst */
2036 {
2037   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2038   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2039 #define FLD(f) abuf->fields.fmt_notbit.f
2040   int UNUSED written = 0;
2041   IADDR UNUSED pc = abuf->addr;
2042   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2043
2044   {
2045     SI opval = SRASI (* FLD (i_src2), * FLD (i_src1));
2046     * FLD (i_dst) = opval;
2047     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2048   }
2049
2050 #undef FLD
2051 }
2052   NEXT (vpc);
2053
2054   CASE (sem, INSN_SHRI1) : /* shri $lit1, $src2, $dst */
2055 {
2056   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2057   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2058 #define FLD(f) abuf->fields.fmt_notbit1.f
2059   int UNUSED written = 0;
2060   IADDR UNUSED pc = abuf->addr;
2061   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2062
2063   {
2064     SI opval = SRASI (* FLD (i_src2), FLD (f_src1));
2065     * FLD (i_dst) = opval;
2066     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2067   }
2068
2069 #undef FLD
2070 }
2071   NEXT (vpc);
2072
2073   CASE (sem, INSN_SHRI2) : /* shri $src1, $lit2, $dst */
2074 {
2075   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2076   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2077 #define FLD(f) abuf->fields.fmt_notbit2.f
2078   int UNUSED written = 0;
2079   IADDR UNUSED pc = abuf->addr;
2080   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2081
2082   {
2083     SI opval = SRASI (FLD (f_src2), * FLD (i_src1));
2084     * FLD (i_dst) = opval;
2085     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2086   }
2087
2088 #undef FLD
2089 }
2090   NEXT (vpc);
2091
2092   CASE (sem, INSN_SHRI3) : /* shri $lit1, $lit2, $dst */
2093 {
2094   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2095   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2096 #define FLD(f) abuf->fields.fmt_notbit3.f
2097   int UNUSED written = 0;
2098   IADDR UNUSED pc = abuf->addr;
2099   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2100
2101   {
2102     SI opval = SRASI (FLD (f_src2), FLD (f_src1));
2103     * FLD (i_dst) = opval;
2104     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2105   }
2106
2107 #undef FLD
2108 }
2109   NEXT (vpc);
2110
2111   CASE (sem, INSN_EMUL) : /* emul $src1, $src2, $dst */
2112 {
2113   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2114   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2115 #define FLD(f) abuf->fields.fmt_emul.f
2116   int UNUSED written = 0;
2117   IADDR UNUSED pc = abuf->addr;
2118   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2119
2120 do {
2121   SI tmp_dregno;
2122   DI tmp_temp;
2123   tmp_temp = MULDI (ZEXTSIDI (* FLD (i_src1)), ZEXTSIDI (* FLD (i_src2)));
2124   tmp_dregno = FLD (f_srcdst);
2125   {
2126     SI opval = TRUNCDISI (tmp_temp);
2127     * FLD (i_dst) = opval;
2128     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2129   }
2130   {
2131     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
2132     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2133     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2134   }
2135 } while (0);
2136
2137 #undef FLD
2138 }
2139   NEXT (vpc);
2140
2141   CASE (sem, INSN_EMUL1) : /* emul $lit1, $src2, $dst */
2142 {
2143   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2144   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2145 #define FLD(f) abuf->fields.fmt_emul1.f
2146   int UNUSED written = 0;
2147   IADDR UNUSED pc = abuf->addr;
2148   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2149
2150 do {
2151   SI tmp_dregno;
2152   DI tmp_temp;
2153   tmp_temp = MULDI (ZEXTSIDI (FLD (f_src1)), ZEXTSIDI (* FLD (i_src2)));
2154   tmp_dregno = FLD (f_srcdst);
2155   {
2156     SI opval = TRUNCDISI (tmp_temp);
2157     * FLD (i_dst) = opval;
2158     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2159   }
2160   {
2161     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
2162     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2163     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2164   }
2165 } while (0);
2166
2167 #undef FLD
2168 }
2169   NEXT (vpc);
2170
2171   CASE (sem, INSN_EMUL2) : /* emul $src1, $lit2, $dst */
2172 {
2173   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2174   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2175 #define FLD(f) abuf->fields.fmt_emul2.f
2176   int UNUSED written = 0;
2177   IADDR UNUSED pc = abuf->addr;
2178   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2179
2180 do {
2181   SI tmp_dregno;
2182   DI tmp_temp;
2183   tmp_temp = MULDI (ZEXTSIDI (* FLD (i_src1)), ZEXTSIDI (FLD (f_src2)));
2184   tmp_dregno = FLD (f_srcdst);
2185   {
2186     SI opval = TRUNCDISI (tmp_temp);
2187     * FLD (i_dst) = opval;
2188     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2189   }
2190   {
2191     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
2192     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2193     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2194   }
2195 } while (0);
2196
2197 #undef FLD
2198 }
2199   NEXT (vpc);
2200
2201   CASE (sem, INSN_EMUL3) : /* emul $lit1, $lit2, $dst */
2202 {
2203   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2204   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2205 #define FLD(f) abuf->fields.fmt_emul3.f
2206   int UNUSED written = 0;
2207   IADDR UNUSED pc = abuf->addr;
2208   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2209
2210 do {
2211   SI tmp_dregno;
2212   DI tmp_temp;
2213   tmp_temp = MULDI (ZEXTSIDI (FLD (f_src1)), ZEXTSIDI (FLD (f_src2)));
2214   tmp_dregno = FLD (f_srcdst);
2215   {
2216     SI opval = TRUNCDISI (tmp_temp);
2217     * FLD (i_dst) = opval;
2218     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2219   }
2220   {
2221     SI opval = TRUNCDISI (SRLDI (tmp_temp, 32));
2222     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2223     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2224   }
2225 } while (0);
2226
2227 #undef FLD
2228 }
2229   NEXT (vpc);
2230
2231   CASE (sem, INSN_MOV) : /* mov $src1, $dst */
2232 {
2233   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2234   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2235 #define FLD(f) abuf->fields.fmt_not2.f
2236   int UNUSED written = 0;
2237   IADDR UNUSED pc = abuf->addr;
2238   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2239
2240   {
2241     SI opval = * FLD (i_src1);
2242     * FLD (i_dst) = opval;
2243     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2244   }
2245
2246 #undef FLD
2247 }
2248   NEXT (vpc);
2249
2250   CASE (sem, INSN_MOV1) : /* mov $lit1, $dst */
2251 {
2252   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2253   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2254 #define FLD(f) abuf->fields.fmt_not3.f
2255   int UNUSED written = 0;
2256   IADDR UNUSED pc = abuf->addr;
2257   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2258
2259   {
2260     SI opval = FLD (f_src1);
2261     * FLD (i_dst) = opval;
2262     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2263   }
2264
2265 #undef FLD
2266 }
2267   NEXT (vpc);
2268
2269   CASE (sem, INSN_MOVL) : /* movl $src1, $dst */
2270 {
2271   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2272   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2273 #define FLD(f) abuf->fields.fmt_movl.f
2274   int UNUSED written = 0;
2275   IADDR UNUSED pc = abuf->addr;
2276   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2277
2278 do {
2279   SI tmp_sregno;
2280   SI tmp_dregno;
2281   tmp_dregno = FLD (f_srcdst);
2282   tmp_sregno = FLD (f_src1);
2283   {
2284     SI opval = * FLD (i_src1);
2285     * FLD (i_dst) = opval;
2286     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2287   }
2288   {
2289     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
2290     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2291     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2292   }
2293 } while (0);
2294
2295 #undef FLD
2296 }
2297   NEXT (vpc);
2298
2299   CASE (sem, INSN_MOVL1) : /* movl $lit1, $dst */
2300 {
2301   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2302   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2303 #define FLD(f) abuf->fields.fmt_movl1.f
2304   int UNUSED written = 0;
2305   IADDR UNUSED pc = abuf->addr;
2306   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2307
2308 do {
2309   SI tmp_dregno;
2310   tmp_dregno = FLD (f_srcdst);
2311   {
2312     SI opval = FLD (f_src1);
2313     * FLD (i_dst) = opval;
2314     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2315   }
2316   {
2317     SI opval = 0;
2318     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2319     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2320   }
2321 } while (0);
2322
2323 #undef FLD
2324 }
2325   NEXT (vpc);
2326
2327   CASE (sem, INSN_MOVT) : /* movt $src1, $dst */
2328 {
2329   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2330   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2331 #define FLD(f) abuf->fields.fmt_movt.f
2332   int UNUSED written = 0;
2333   IADDR UNUSED pc = abuf->addr;
2334   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2335
2336 do {
2337   SI tmp_sregno;
2338   SI tmp_dregno;
2339   tmp_dregno = FLD (f_srcdst);
2340   tmp_sregno = FLD (f_src1);
2341   {
2342     SI opval = * FLD (i_src1);
2343     * FLD (i_dst) = opval;
2344     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2345   }
2346   {
2347     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
2348     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2349     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2350   }
2351   {
2352     SI opval = CPU (h_gr[((FLD (f_src1)) + (2))]);
2353     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
2354     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
2355   }
2356 } while (0);
2357
2358 #undef FLD
2359 }
2360   NEXT (vpc);
2361
2362   CASE (sem, INSN_MOVT1) : /* movt $lit1, $dst */
2363 {
2364   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2365   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2366 #define FLD(f) abuf->fields.fmt_movt1.f
2367   int UNUSED written = 0;
2368   IADDR UNUSED pc = abuf->addr;
2369   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2370
2371 do {
2372   SI tmp_dregno;
2373   tmp_dregno = FLD (f_srcdst);
2374   {
2375     SI opval = FLD (f_src1);
2376     * FLD (i_dst) = opval;
2377     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2378   }
2379   {
2380     SI opval = 0;
2381     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2382     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2383   }
2384   {
2385     SI opval = 0;
2386     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
2387     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
2388   }
2389 } while (0);
2390
2391 #undef FLD
2392 }
2393   NEXT (vpc);
2394
2395   CASE (sem, INSN_MOVQ) : /* movq $src1, $dst */
2396 {
2397   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2398   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2399 #define FLD(f) abuf->fields.fmt_movq.f
2400   int UNUSED written = 0;
2401   IADDR UNUSED pc = abuf->addr;
2402   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2403
2404 do {
2405   SI tmp_sregno;
2406   SI tmp_dregno;
2407   tmp_dregno = FLD (f_srcdst);
2408   tmp_sregno = FLD (f_src1);
2409   {
2410     SI opval = * FLD (i_src1);
2411     * FLD (i_dst) = opval;
2412     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2413   }
2414   {
2415     SI opval = CPU (h_gr[((FLD (f_src1)) + (1))]);
2416     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2417     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2418   }
2419   {
2420     SI opval = CPU (h_gr[((FLD (f_src1)) + (2))]);
2421     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
2422     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
2423   }
2424   {
2425     SI opval = CPU (h_gr[((FLD (f_src1)) + (3))]);
2426     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
2427     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
2428   }
2429 } while (0);
2430
2431 #undef FLD
2432 }
2433   NEXT (vpc);
2434
2435   CASE (sem, INSN_MOVQ1) : /* movq $lit1, $dst */
2436 {
2437   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2438   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2439 #define FLD(f) abuf->fields.fmt_movq1.f
2440   int UNUSED written = 0;
2441   IADDR UNUSED pc = abuf->addr;
2442   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2443
2444 do {
2445   SI tmp_dregno;
2446   tmp_dregno = FLD (f_srcdst);
2447   {
2448     SI opval = FLD (f_src1);
2449     * FLD (i_dst) = opval;
2450     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2451   }
2452   {
2453     SI opval = 0;
2454     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
2455     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
2456   }
2457   {
2458     SI opval = 0;
2459     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
2460     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
2461   }
2462   {
2463     SI opval = 0;
2464     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
2465     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
2466   }
2467 } while (0);
2468
2469 #undef FLD
2470 }
2471   NEXT (vpc);
2472
2473   CASE (sem, INSN_MODPC) : /* modpc $src1, $src2, $dst */
2474 {
2475   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2476   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2477 #define FLD(f) abuf->fields.fmt_modpc.f
2478   int UNUSED written = 0;
2479   IADDR UNUSED pc = abuf->addr;
2480   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2481
2482   {
2483     SI opval = * FLD (i_src2);
2484     * FLD (i_dst) = opval;
2485     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2486   }
2487
2488 #undef FLD
2489 }
2490   NEXT (vpc);
2491
2492   CASE (sem, INSN_MODAC) : /* modac $src1, $src2, $dst */
2493 {
2494   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2495   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2496 #define FLD(f) abuf->fields.fmt_modpc.f
2497   int UNUSED written = 0;
2498   IADDR UNUSED pc = abuf->addr;
2499   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2500
2501   {
2502     SI opval = * FLD (i_src2);
2503     * FLD (i_dst) = opval;
2504     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2505   }
2506
2507 #undef FLD
2508 }
2509   NEXT (vpc);
2510
2511   CASE (sem, INSN_LDA_OFFSET) : /* lda $offset, $dst */
2512 {
2513   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2514   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2515 #define FLD(f) abuf->fields.fmt_lda_offset.f
2516   int UNUSED written = 0;
2517   IADDR UNUSED pc = abuf->addr;
2518   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2519
2520   {
2521     SI opval = FLD (f_offset);
2522     * FLD (i_dst) = opval;
2523     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2524   }
2525
2526 #undef FLD
2527 }
2528   NEXT (vpc);
2529
2530   CASE (sem, INSN_LDA_INDIRECT_OFFSET) : /* lda $offset($abase), $dst */
2531 {
2532   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2533   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2534 #define FLD(f) abuf->fields.fmt_lda_indirect_offset.f
2535   int UNUSED written = 0;
2536   IADDR UNUSED pc = abuf->addr;
2537   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2538
2539   {
2540     SI opval = ADDSI (FLD (f_offset), * FLD (i_abase));
2541     * FLD (i_dst) = opval;
2542     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2543   }
2544
2545 #undef FLD
2546 }
2547   NEXT (vpc);
2548
2549   CASE (sem, INSN_LDA_INDIRECT) : /* lda ($abase), $dst */
2550 {
2551   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2552   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2553 #define FLD(f) abuf->fields.fmt_lda_indirect.f
2554   int UNUSED written = 0;
2555   IADDR UNUSED pc = abuf->addr;
2556   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2557
2558   {
2559     SI opval = * FLD (i_abase);
2560     * FLD (i_dst) = opval;
2561     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2562   }
2563
2564 #undef FLD
2565 }
2566   NEXT (vpc);
2567
2568   CASE (sem, INSN_LDA_INDIRECT_INDEX) : /* lda ($abase)[$index*S$scale], $dst */
2569 {
2570   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2571   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2572 #define FLD(f) abuf->fields.fmt_lda_indirect_index.f
2573   int UNUSED written = 0;
2574   IADDR UNUSED pc = abuf->addr;
2575   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2576
2577   {
2578     SI opval = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
2579     * FLD (i_dst) = opval;
2580     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2581   }
2582
2583 #undef FLD
2584 }
2585   NEXT (vpc);
2586
2587   CASE (sem, INSN_LDA_DISP) : /* lda $optdisp, $dst */
2588 {
2589   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2590   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2591 #define FLD(f) abuf->fields.fmt_lda_disp.f
2592   int UNUSED written = 0;
2593   IADDR UNUSED pc = abuf->addr;
2594   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2595
2596   {
2597     SI opval = FLD (f_optdisp);
2598     * FLD (i_dst) = opval;
2599     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2600   }
2601
2602 #undef FLD
2603 }
2604   NEXT (vpc);
2605
2606   CASE (sem, INSN_LDA_INDIRECT_DISP) : /* lda $optdisp($abase), $dst */
2607 {
2608   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2609   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2610 #define FLD(f) abuf->fields.fmt_lda_indirect_disp.f
2611   int UNUSED written = 0;
2612   IADDR UNUSED pc = abuf->addr;
2613   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2614
2615   {
2616     SI opval = ADDSI (FLD (f_optdisp), * FLD (i_abase));
2617     * FLD (i_dst) = opval;
2618     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2619   }
2620
2621 #undef FLD
2622 }
2623   NEXT (vpc);
2624
2625   CASE (sem, INSN_LDA_INDEX_DISP) : /* lda $optdisp[$index*S$scale], $dst */
2626 {
2627   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2628   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2629 #define FLD(f) abuf->fields.fmt_lda_index_disp.f
2630   int UNUSED written = 0;
2631   IADDR UNUSED pc = abuf->addr;
2632   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2633
2634   {
2635     SI opval = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
2636     * FLD (i_dst) = opval;
2637     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2638   }
2639
2640 #undef FLD
2641 }
2642   NEXT (vpc);
2643
2644   CASE (sem, INSN_LDA_INDIRECT_INDEX_DISP) : /* lda $optdisp($abase)[$index*S$scale], $dst */
2645 {
2646   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2647   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2648 #define FLD(f) abuf->fields.fmt_lda_indirect_index_disp.f
2649   int UNUSED written = 0;
2650   IADDR UNUSED pc = abuf->addr;
2651   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2652
2653   {
2654     SI opval = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2655     * FLD (i_dst) = opval;
2656     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2657   }
2658
2659 #undef FLD
2660 }
2661   NEXT (vpc);
2662
2663   CASE (sem, INSN_LD_OFFSET) : /* ld $offset, $dst */
2664 {
2665   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2666   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2667 #define FLD(f) abuf->fields.fmt_ld_offset.f
2668   int UNUSED written = 0;
2669   IADDR UNUSED pc = abuf->addr;
2670   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2671
2672   {
2673     SI opval = GETMEMSI (current_cpu, pc, FLD (f_offset));
2674     * FLD (i_dst) = opval;
2675     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2676   }
2677
2678 #undef FLD
2679 }
2680   NEXT (vpc);
2681
2682   CASE (sem, INSN_LD_INDIRECT_OFFSET) : /* ld $offset($abase), $dst */
2683 {
2684   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2685   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2686 #define FLD(f) abuf->fields.fmt_ld_indirect_offset.f
2687   int UNUSED written = 0;
2688   IADDR UNUSED pc = abuf->addr;
2689   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2690
2691   {
2692     SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
2693     * FLD (i_dst) = opval;
2694     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2695   }
2696
2697 #undef FLD
2698 }
2699   NEXT (vpc);
2700
2701   CASE (sem, INSN_LD_INDIRECT) : /* ld ($abase), $dst */
2702 {
2703   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2704   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2705 #define FLD(f) abuf->fields.fmt_ld_indirect.f
2706   int UNUSED written = 0;
2707   IADDR UNUSED pc = abuf->addr;
2708   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2709
2710   {
2711     SI opval = GETMEMSI (current_cpu, pc, * FLD (i_abase));
2712     * FLD (i_dst) = opval;
2713     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2714   }
2715
2716 #undef FLD
2717 }
2718   NEXT (vpc);
2719
2720   CASE (sem, INSN_LD_INDIRECT_INDEX) : /* ld ($abase)[$index*S$scale], $dst */
2721 {
2722   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2723   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2724 #define FLD(f) abuf->fields.fmt_ld_indirect_index.f
2725   int UNUSED written = 0;
2726   IADDR UNUSED pc = abuf->addr;
2727   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2728
2729   {
2730     SI opval = GETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2731     * FLD (i_dst) = opval;
2732     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2733   }
2734
2735 #undef FLD
2736 }
2737   NEXT (vpc);
2738
2739   CASE (sem, INSN_LD_DISP) : /* ld $optdisp, $dst */
2740 {
2741   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2742   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2743 #define FLD(f) abuf->fields.fmt_ld_disp.f
2744   int UNUSED written = 0;
2745   IADDR UNUSED pc = abuf->addr;
2746   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2747
2748   {
2749     SI opval = GETMEMSI (current_cpu, pc, FLD (f_optdisp));
2750     * FLD (i_dst) = opval;
2751     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2752   }
2753
2754 #undef FLD
2755 }
2756   NEXT (vpc);
2757
2758   CASE (sem, INSN_LD_INDIRECT_DISP) : /* ld $optdisp($abase), $dst */
2759 {
2760   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2761   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2762 #define FLD(f) abuf->fields.fmt_ld_indirect_disp.f
2763   int UNUSED written = 0;
2764   IADDR UNUSED pc = abuf->addr;
2765   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2766
2767   {
2768     SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
2769     * FLD (i_dst) = opval;
2770     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2771   }
2772
2773 #undef FLD
2774 }
2775   NEXT (vpc);
2776
2777   CASE (sem, INSN_LD_INDEX_DISP) : /* ld $optdisp[$index*S$scale], $dst */
2778 {
2779   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2780   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2781 #define FLD(f) abuf->fields.fmt_ld_index_disp.f
2782   int UNUSED written = 0;
2783   IADDR UNUSED pc = abuf->addr;
2784   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2785
2786   {
2787     SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2788     * FLD (i_dst) = opval;
2789     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2790   }
2791
2792 #undef FLD
2793 }
2794   NEXT (vpc);
2795
2796   CASE (sem, INSN_LD_INDIRECT_INDEX_DISP) : /* ld $optdisp($abase)[$index*S$scale], $dst */
2797 {
2798   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2799   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2800 #define FLD(f) abuf->fields.fmt_ld_indirect_index_disp.f
2801   int UNUSED written = 0;
2802   IADDR UNUSED pc = abuf->addr;
2803   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2804
2805   {
2806     SI opval = GETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
2807     * FLD (i_dst) = opval;
2808     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2809   }
2810
2811 #undef FLD
2812 }
2813   NEXT (vpc);
2814
2815   CASE (sem, INSN_LDOB_OFFSET) : /* ldob $offset, $dst */
2816 {
2817   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2818   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2819 #define FLD(f) abuf->fields.fmt_ldob_offset.f
2820   int UNUSED written = 0;
2821   IADDR UNUSED pc = abuf->addr;
2822   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2823
2824   {
2825     SI opval = GETMEMUQI (current_cpu, pc, FLD (f_offset));
2826     * FLD (i_dst) = opval;
2827     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2828   }
2829
2830 #undef FLD
2831 }
2832   NEXT (vpc);
2833
2834   CASE (sem, INSN_LDOB_INDIRECT_OFFSET) : /* ldob $offset($abase), $dst */
2835 {
2836   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2837   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2838 #define FLD(f) abuf->fields.fmt_ldob_indirect_offset.f
2839   int UNUSED written = 0;
2840   IADDR UNUSED pc = abuf->addr;
2841   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2842
2843   {
2844     SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
2845     * FLD (i_dst) = opval;
2846     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2847   }
2848
2849 #undef FLD
2850 }
2851   NEXT (vpc);
2852
2853   CASE (sem, INSN_LDOB_INDIRECT) : /* ldob ($abase), $dst */
2854 {
2855   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2856   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2857 #define FLD(f) abuf->fields.fmt_ldob_indirect.f
2858   int UNUSED written = 0;
2859   IADDR UNUSED pc = abuf->addr;
2860   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2861
2862   {
2863     SI opval = GETMEMUQI (current_cpu, pc, * FLD (i_abase));
2864     * FLD (i_dst) = opval;
2865     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2866   }
2867
2868 #undef FLD
2869 }
2870   NEXT (vpc);
2871
2872   CASE (sem, INSN_LDOB_INDIRECT_INDEX) : /* ldob ($abase)[$index*S$scale], $dst */
2873 {
2874   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2875   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2876 #define FLD(f) abuf->fields.fmt_ldob_indirect_index.f
2877   int UNUSED written = 0;
2878   IADDR UNUSED pc = abuf->addr;
2879   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2880
2881   {
2882     SI opval = GETMEMUQI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2883     * FLD (i_dst) = opval;
2884     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2885   }
2886
2887 #undef FLD
2888 }
2889   NEXT (vpc);
2890
2891   CASE (sem, INSN_LDOB_DISP) : /* ldob $optdisp, $dst */
2892 {
2893   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2894   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2895 #define FLD(f) abuf->fields.fmt_ldob_disp.f
2896   int UNUSED written = 0;
2897   IADDR UNUSED pc = abuf->addr;
2898   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2899
2900   {
2901     SI opval = GETMEMUQI (current_cpu, pc, FLD (f_optdisp));
2902     * FLD (i_dst) = opval;
2903     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2904   }
2905
2906 #undef FLD
2907 }
2908   NEXT (vpc);
2909
2910   CASE (sem, INSN_LDOB_INDIRECT_DISP) : /* ldob $optdisp($abase), $dst */
2911 {
2912   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2913   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2914 #define FLD(f) abuf->fields.fmt_ldob_indirect_disp.f
2915   int UNUSED written = 0;
2916   IADDR UNUSED pc = abuf->addr;
2917   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2918
2919   {
2920     SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
2921     * FLD (i_dst) = opval;
2922     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2923   }
2924
2925 #undef FLD
2926 }
2927   NEXT (vpc);
2928
2929   CASE (sem, INSN_LDOB_INDEX_DISP) : /* ldob $optdisp[$index*S$scale], $dst */
2930 {
2931   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2932   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2933 #define FLD(f) abuf->fields.fmt_ldob_index_disp.f
2934   int UNUSED written = 0;
2935   IADDR UNUSED pc = abuf->addr;
2936   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2937
2938   {
2939     SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
2940     * FLD (i_dst) = opval;
2941     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2942   }
2943
2944 #undef FLD
2945 }
2946   NEXT (vpc);
2947
2948   CASE (sem, INSN_LDOB_INDIRECT_INDEX_DISP) : /* ldob $optdisp($abase)[$index*S$scale], $dst */
2949 {
2950   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2951   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2952 #define FLD(f) abuf->fields.fmt_ldob_indirect_index_disp.f
2953   int UNUSED written = 0;
2954   IADDR UNUSED pc = abuf->addr;
2955   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
2956
2957   {
2958     SI opval = GETMEMUQI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
2959     * FLD (i_dst) = opval;
2960     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2961   }
2962
2963 #undef FLD
2964 }
2965   NEXT (vpc);
2966
2967   CASE (sem, INSN_LDOS_OFFSET) : /* ldos $offset, $dst */
2968 {
2969   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2970   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2971 #define FLD(f) abuf->fields.fmt_ldos_offset.f
2972   int UNUSED written = 0;
2973   IADDR UNUSED pc = abuf->addr;
2974   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2975
2976   {
2977     SI opval = GETMEMUHI (current_cpu, pc, FLD (f_offset));
2978     * FLD (i_dst) = opval;
2979     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2980   }
2981
2982 #undef FLD
2983 }
2984   NEXT (vpc);
2985
2986   CASE (sem, INSN_LDOS_INDIRECT_OFFSET) : /* ldos $offset($abase), $dst */
2987 {
2988   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
2989   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
2990 #define FLD(f) abuf->fields.fmt_ldos_indirect_offset.f
2991   int UNUSED written = 0;
2992   IADDR UNUSED pc = abuf->addr;
2993   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
2994
2995   {
2996     SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
2997     * FLD (i_dst) = opval;
2998     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
2999   }
3000
3001 #undef FLD
3002 }
3003   NEXT (vpc);
3004
3005   CASE (sem, INSN_LDOS_INDIRECT) : /* ldos ($abase), $dst */
3006 {
3007   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3008   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3009 #define FLD(f) abuf->fields.fmt_ldos_indirect.f
3010   int UNUSED written = 0;
3011   IADDR UNUSED pc = abuf->addr;
3012   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3013
3014   {
3015     SI opval = GETMEMUHI (current_cpu, pc, * FLD (i_abase));
3016     * FLD (i_dst) = opval;
3017     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3018   }
3019
3020 #undef FLD
3021 }
3022   NEXT (vpc);
3023
3024   CASE (sem, INSN_LDOS_INDIRECT_INDEX) : /* ldos ($abase)[$index*S$scale], $dst */
3025 {
3026   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3027   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3028 #define FLD(f) abuf->fields.fmt_ldos_indirect_index.f
3029   int UNUSED written = 0;
3030   IADDR UNUSED pc = abuf->addr;
3031   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3032
3033   {
3034     SI opval = GETMEMUHI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3035     * FLD (i_dst) = opval;
3036     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3037   }
3038
3039 #undef FLD
3040 }
3041   NEXT (vpc);
3042
3043   CASE (sem, INSN_LDOS_DISP) : /* ldos $optdisp, $dst */
3044 {
3045   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3046   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3047 #define FLD(f) abuf->fields.fmt_ldos_disp.f
3048   int UNUSED written = 0;
3049   IADDR UNUSED pc = abuf->addr;
3050   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3051
3052   {
3053     SI opval = GETMEMUHI (current_cpu, pc, FLD (f_optdisp));
3054     * FLD (i_dst) = opval;
3055     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3056   }
3057
3058 #undef FLD
3059 }
3060   NEXT (vpc);
3061
3062   CASE (sem, INSN_LDOS_INDIRECT_DISP) : /* ldos $optdisp($abase), $dst */
3063 {
3064   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3065   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3066 #define FLD(f) abuf->fields.fmt_ldos_indirect_disp.f
3067   int UNUSED written = 0;
3068   IADDR UNUSED pc = abuf->addr;
3069   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3070
3071   {
3072     SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
3073     * FLD (i_dst) = opval;
3074     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3075   }
3076
3077 #undef FLD
3078 }
3079   NEXT (vpc);
3080
3081   CASE (sem, INSN_LDOS_INDEX_DISP) : /* ldos $optdisp[$index*S$scale], $dst */
3082 {
3083   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3084   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3085 #define FLD(f) abuf->fields.fmt_ldos_index_disp.f
3086   int UNUSED written = 0;
3087   IADDR UNUSED pc = abuf->addr;
3088   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3089
3090   {
3091     SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3092     * FLD (i_dst) = opval;
3093     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3094   }
3095
3096 #undef FLD
3097 }
3098   NEXT (vpc);
3099
3100   CASE (sem, INSN_LDOS_INDIRECT_INDEX_DISP) : /* ldos $optdisp($abase)[$index*S$scale], $dst */
3101 {
3102   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3103   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3104 #define FLD(f) abuf->fields.fmt_ldos_indirect_index_disp.f
3105   int UNUSED written = 0;
3106   IADDR UNUSED pc = abuf->addr;
3107   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3108
3109   {
3110     SI opval = GETMEMUHI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
3111     * FLD (i_dst) = opval;
3112     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3113   }
3114
3115 #undef FLD
3116 }
3117   NEXT (vpc);
3118
3119   CASE (sem, INSN_LDIB_OFFSET) : /* ldib $offset, $dst */
3120 {
3121   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3122   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3123 #define FLD(f) abuf->fields.fmt_ldib_offset.f
3124   int UNUSED written = 0;
3125   IADDR UNUSED pc = abuf->addr;
3126   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3127
3128   {
3129     SI opval = GETMEMQI (current_cpu, pc, FLD (f_offset));
3130     * FLD (i_dst) = opval;
3131     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3132   }
3133
3134 #undef FLD
3135 }
3136   NEXT (vpc);
3137
3138   CASE (sem, INSN_LDIB_INDIRECT_OFFSET) : /* ldib $offset($abase), $dst */
3139 {
3140   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3141   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3142 #define FLD(f) abuf->fields.fmt_ldib_indirect_offset.f
3143   int UNUSED written = 0;
3144   IADDR UNUSED pc = abuf->addr;
3145   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3146
3147   {
3148     SI opval = GETMEMQI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
3149     * FLD (i_dst) = opval;
3150     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3151   }
3152
3153 #undef FLD
3154 }
3155   NEXT (vpc);
3156
3157   CASE (sem, INSN_LDIB_INDIRECT) : /* ldib ($abase), $dst */
3158 {
3159   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3160   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3161 #define FLD(f) abuf->fields.fmt_ldib_indirect.f
3162   int UNUSED written = 0;
3163   IADDR UNUSED pc = abuf->addr;
3164   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3165
3166   {
3167     SI opval = GETMEMQI (current_cpu, pc, * FLD (i_abase));
3168     * FLD (i_dst) = opval;
3169     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3170   }
3171
3172 #undef FLD
3173 }
3174   NEXT (vpc);
3175
3176   CASE (sem, INSN_LDIB_INDIRECT_INDEX) : /* ldib ($abase)[$index*S$scale], $dst */
3177 {
3178   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3179   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3180 #define FLD(f) abuf->fields.fmt_ldib_indirect_index.f
3181   int UNUSED written = 0;
3182   IADDR UNUSED pc = abuf->addr;
3183   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3184
3185   {
3186     SI opval = GETMEMQI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3187     * FLD (i_dst) = opval;
3188     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3189   }
3190
3191 #undef FLD
3192 }
3193   NEXT (vpc);
3194
3195   CASE (sem, INSN_LDIB_DISP) : /* ldib $optdisp, $dst */
3196 {
3197   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3198   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3199 #define FLD(f) abuf->fields.fmt_ldib_disp.f
3200   int UNUSED written = 0;
3201   IADDR UNUSED pc = abuf->addr;
3202   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3203
3204   {
3205     SI opval = GETMEMQI (current_cpu, pc, FLD (f_optdisp));
3206     * FLD (i_dst) = opval;
3207     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3208   }
3209
3210 #undef FLD
3211 }
3212   NEXT (vpc);
3213
3214   CASE (sem, INSN_LDIB_INDIRECT_DISP) : /* ldib $optdisp($abase), $dst */
3215 {
3216   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3217   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3218 #define FLD(f) abuf->fields.fmt_ldib_indirect_disp.f
3219   int UNUSED written = 0;
3220   IADDR UNUSED pc = abuf->addr;
3221   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3222
3223   {
3224     SI opval = GETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
3225     * FLD (i_dst) = opval;
3226     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3227   }
3228
3229 #undef FLD
3230 }
3231   NEXT (vpc);
3232
3233   CASE (sem, INSN_LDIB_INDEX_DISP) : /* ldib $optdisp[$index*S$scale], $dst */
3234 {
3235   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3236   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3237 #define FLD(f) abuf->fields.fmt_ldib_index_disp.f
3238   int UNUSED written = 0;
3239   IADDR UNUSED pc = abuf->addr;
3240   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3241
3242   {
3243     SI opval = GETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3244     * FLD (i_dst) = opval;
3245     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3246   }
3247
3248 #undef FLD
3249 }
3250   NEXT (vpc);
3251
3252   CASE (sem, INSN_LDIB_INDIRECT_INDEX_DISP) : /* ldib $optdisp($abase)[$index*S$scale], $dst */
3253 {
3254   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3255   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3256 #define FLD(f) abuf->fields.fmt_ldib_indirect_index_disp.f
3257   int UNUSED written = 0;
3258   IADDR UNUSED pc = abuf->addr;
3259   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3260
3261   {
3262     SI opval = GETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
3263     * FLD (i_dst) = opval;
3264     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3265   }
3266
3267 #undef FLD
3268 }
3269   NEXT (vpc);
3270
3271   CASE (sem, INSN_LDIS_OFFSET) : /* ldis $offset, $dst */
3272 {
3273   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3274   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3275 #define FLD(f) abuf->fields.fmt_ldis_offset.f
3276   int UNUSED written = 0;
3277   IADDR UNUSED pc = abuf->addr;
3278   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3279
3280   {
3281     SI opval = GETMEMHI (current_cpu, pc, FLD (f_offset));
3282     * FLD (i_dst) = opval;
3283     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3284   }
3285
3286 #undef FLD
3287 }
3288   NEXT (vpc);
3289
3290   CASE (sem, INSN_LDIS_INDIRECT_OFFSET) : /* ldis $offset($abase), $dst */
3291 {
3292   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3293   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3294 #define FLD(f) abuf->fields.fmt_ldis_indirect_offset.f
3295   int UNUSED written = 0;
3296   IADDR UNUSED pc = abuf->addr;
3297   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3298
3299   {
3300     SI opval = GETMEMHI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)));
3301     * FLD (i_dst) = opval;
3302     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3303   }
3304
3305 #undef FLD
3306 }
3307   NEXT (vpc);
3308
3309   CASE (sem, INSN_LDIS_INDIRECT) : /* ldis ($abase), $dst */
3310 {
3311   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3312   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3313 #define FLD(f) abuf->fields.fmt_ldis_indirect.f
3314   int UNUSED written = 0;
3315   IADDR UNUSED pc = abuf->addr;
3316   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3317
3318   {
3319     SI opval = GETMEMHI (current_cpu, pc, * FLD (i_abase));
3320     * FLD (i_dst) = opval;
3321     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3322   }
3323
3324 #undef FLD
3325 }
3326   NEXT (vpc);
3327
3328   CASE (sem, INSN_LDIS_INDIRECT_INDEX) : /* ldis ($abase)[$index*S$scale], $dst */
3329 {
3330   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3331   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3332 #define FLD(f) abuf->fields.fmt_ldis_indirect_index.f
3333   int UNUSED written = 0;
3334   IADDR UNUSED pc = abuf->addr;
3335   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3336
3337   {
3338     SI opval = GETMEMHI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3339     * FLD (i_dst) = opval;
3340     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3341   }
3342
3343 #undef FLD
3344 }
3345   NEXT (vpc);
3346
3347   CASE (sem, INSN_LDIS_DISP) : /* ldis $optdisp, $dst */
3348 {
3349   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3350   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3351 #define FLD(f) abuf->fields.fmt_ldis_disp.f
3352   int UNUSED written = 0;
3353   IADDR UNUSED pc = abuf->addr;
3354   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3355
3356   {
3357     SI opval = GETMEMHI (current_cpu, pc, FLD (f_optdisp));
3358     * FLD (i_dst) = opval;
3359     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3360   }
3361
3362 #undef FLD
3363 }
3364   NEXT (vpc);
3365
3366   CASE (sem, INSN_LDIS_INDIRECT_DISP) : /* ldis $optdisp($abase), $dst */
3367 {
3368   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3369   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3370 #define FLD(f) abuf->fields.fmt_ldis_indirect_disp.f
3371   int UNUSED written = 0;
3372   IADDR UNUSED pc = abuf->addr;
3373   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3374
3375   {
3376     SI opval = GETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)));
3377     * FLD (i_dst) = opval;
3378     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3379   }
3380
3381 #undef FLD
3382 }
3383   NEXT (vpc);
3384
3385   CASE (sem, INSN_LDIS_INDEX_DISP) : /* ldis $optdisp[$index*S$scale], $dst */
3386 {
3387   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3388   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3389 #define FLD(f) abuf->fields.fmt_ldis_index_disp.f
3390   int UNUSED written = 0;
3391   IADDR UNUSED pc = abuf->addr;
3392   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3393
3394   {
3395     SI opval = GETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3396     * FLD (i_dst) = opval;
3397     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3398   }
3399
3400 #undef FLD
3401 }
3402   NEXT (vpc);
3403
3404   CASE (sem, INSN_LDIS_INDIRECT_INDEX_DISP) : /* ldis $optdisp($abase)[$index*S$scale], $dst */
3405 {
3406   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3407   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3408 #define FLD(f) abuf->fields.fmt_ldis_indirect_index_disp.f
3409   int UNUSED written = 0;
3410   IADDR UNUSED pc = abuf->addr;
3411   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3412
3413   {
3414     SI opval = GETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))));
3415     * FLD (i_dst) = opval;
3416     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3417   }
3418
3419 #undef FLD
3420 }
3421   NEXT (vpc);
3422
3423   CASE (sem, INSN_LDL_OFFSET) : /* ldl $offset, $dst */
3424 {
3425   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3426   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3427 #define FLD(f) abuf->fields.fmt_ldl_offset.f
3428   int UNUSED written = 0;
3429   IADDR UNUSED pc = abuf->addr;
3430   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3431
3432 do {
3433   SI tmp_dregno;
3434   SI tmp_temp;
3435   tmp_dregno = FLD (f_srcdst);
3436   tmp_temp = FLD (f_offset);
3437   {
3438     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3439     * FLD (i_dst) = opval;
3440     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3441   }
3442   {
3443     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3444     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3445     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3446   }
3447 } while (0);
3448
3449 #undef FLD
3450 }
3451   NEXT (vpc);
3452
3453   CASE (sem, INSN_LDL_INDIRECT_OFFSET) : /* ldl $offset($abase), $dst */
3454 {
3455   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3456   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3457 #define FLD(f) abuf->fields.fmt_ldl_indirect_offset.f
3458   int UNUSED written = 0;
3459   IADDR UNUSED pc = abuf->addr;
3460   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3461
3462 do {
3463   SI tmp_dregno;
3464   SI tmp_temp;
3465   tmp_dregno = FLD (f_srcdst);
3466   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
3467   {
3468     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3469     * FLD (i_dst) = opval;
3470     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3471   }
3472   {
3473     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3474     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3475     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3476   }
3477 } while (0);
3478
3479 #undef FLD
3480 }
3481   NEXT (vpc);
3482
3483   CASE (sem, INSN_LDL_INDIRECT) : /* ldl ($abase), $dst */
3484 {
3485   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3486   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3487 #define FLD(f) abuf->fields.fmt_ldl_indirect.f
3488   int UNUSED written = 0;
3489   IADDR UNUSED pc = abuf->addr;
3490   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3491
3492 do {
3493   SI tmp_dregno;
3494   SI tmp_temp;
3495   tmp_dregno = FLD (f_srcdst);
3496   tmp_temp = * FLD (i_abase);
3497   {
3498     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3499     * FLD (i_dst) = opval;
3500     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3501   }
3502   {
3503     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3504     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3505     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3506   }
3507 } while (0);
3508
3509 #undef FLD
3510 }
3511   NEXT (vpc);
3512
3513   CASE (sem, INSN_LDL_INDIRECT_INDEX) : /* ldl ($abase)[$index*S$scale], $dst */
3514 {
3515   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3516   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3517 #define FLD(f) abuf->fields.fmt_ldl_indirect_index.f
3518   int UNUSED written = 0;
3519   IADDR UNUSED pc = abuf->addr;
3520   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3521
3522 do {
3523   SI tmp_dregno;
3524   SI tmp_temp;
3525   tmp_dregno = FLD (f_srcdst);
3526   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
3527   {
3528     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3529     * FLD (i_dst) = opval;
3530     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3531   }
3532   {
3533     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3534     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3535     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3536   }
3537 } while (0);
3538
3539 #undef FLD
3540 }
3541   NEXT (vpc);
3542
3543   CASE (sem, INSN_LDL_DISP) : /* ldl $optdisp, $dst */
3544 {
3545   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3546   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3547 #define FLD(f) abuf->fields.fmt_ldl_disp.f
3548   int UNUSED written = 0;
3549   IADDR UNUSED pc = abuf->addr;
3550   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3551
3552 do {
3553   SI tmp_dregno;
3554   SI tmp_temp;
3555   tmp_dregno = FLD (f_srcdst);
3556   tmp_temp = FLD (f_optdisp);
3557   {
3558     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3559     * FLD (i_dst) = opval;
3560     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3561   }
3562   {
3563     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3564     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3565     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3566   }
3567 } while (0);
3568
3569 #undef FLD
3570 }
3571   NEXT (vpc);
3572
3573   CASE (sem, INSN_LDL_INDIRECT_DISP) : /* ldl $optdisp($abase), $dst */
3574 {
3575   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3576   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3577 #define FLD(f) abuf->fields.fmt_ldl_indirect_disp.f
3578   int UNUSED written = 0;
3579   IADDR UNUSED pc = abuf->addr;
3580   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3581
3582 do {
3583   SI tmp_dregno;
3584   SI tmp_temp;
3585   tmp_dregno = FLD (f_srcdst);
3586   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
3587   {
3588     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3589     * FLD (i_dst) = opval;
3590     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3591   }
3592   {
3593     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3594     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3595     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3596   }
3597 } while (0);
3598
3599 #undef FLD
3600 }
3601   NEXT (vpc);
3602
3603   CASE (sem, INSN_LDL_INDEX_DISP) : /* ldl $optdisp[$index*S$scale], $dst */
3604 {
3605   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3606   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3607 #define FLD(f) abuf->fields.fmt_ldl_index_disp.f
3608   int UNUSED written = 0;
3609   IADDR UNUSED pc = abuf->addr;
3610   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3611
3612 do {
3613   SI tmp_dregno;
3614   SI tmp_temp;
3615   tmp_dregno = FLD (f_srcdst);
3616   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
3617   {
3618     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3619     * FLD (i_dst) = opval;
3620     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3621   }
3622   {
3623     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3624     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3625     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3626   }
3627 } while (0);
3628
3629 #undef FLD
3630 }
3631   NEXT (vpc);
3632
3633   CASE (sem, INSN_LDL_INDIRECT_INDEX_DISP) : /* ldl $optdisp($abase)[$index*S$scale], $dst */
3634 {
3635   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3636   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3637 #define FLD(f) abuf->fields.fmt_ldl_indirect_index_disp.f
3638   int UNUSED written = 0;
3639   IADDR UNUSED pc = abuf->addr;
3640   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3641
3642 do {
3643   SI tmp_dregno;
3644   SI tmp_temp;
3645   tmp_dregno = FLD (f_srcdst);
3646   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3647   {
3648     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3649     * FLD (i_dst) = opval;
3650     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3651   }
3652   {
3653     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3654     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3655     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3656   }
3657 } while (0);
3658
3659 #undef FLD
3660 }
3661   NEXT (vpc);
3662
3663   CASE (sem, INSN_LDT_OFFSET) : /* ldt $offset, $dst */
3664 {
3665   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3666   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3667 #define FLD(f) abuf->fields.fmt_ldt_offset.f
3668   int UNUSED written = 0;
3669   IADDR UNUSED pc = abuf->addr;
3670   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3671
3672 do {
3673   SI tmp_dregno;
3674   SI tmp_temp;
3675   tmp_dregno = FLD (f_srcdst);
3676   tmp_temp = FLD (f_offset);
3677   {
3678     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3679     * FLD (i_dst) = opval;
3680     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3681   }
3682   {
3683     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3684     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3685     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3686   }
3687   {
3688     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3689     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3690     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3691   }
3692 } while (0);
3693
3694 #undef FLD
3695 }
3696   NEXT (vpc);
3697
3698   CASE (sem, INSN_LDT_INDIRECT_OFFSET) : /* ldt $offset($abase), $dst */
3699 {
3700   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3701   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3702 #define FLD(f) abuf->fields.fmt_ldt_indirect_offset.f
3703   int UNUSED written = 0;
3704   IADDR UNUSED pc = abuf->addr;
3705   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3706
3707 do {
3708   SI tmp_dregno;
3709   SI tmp_temp;
3710   tmp_dregno = FLD (f_srcdst);
3711   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
3712   {
3713     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3714     * FLD (i_dst) = opval;
3715     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3716   }
3717   {
3718     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3719     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3720     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3721   }
3722   {
3723     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3724     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3725     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3726   }
3727 } while (0);
3728
3729 #undef FLD
3730 }
3731   NEXT (vpc);
3732
3733   CASE (sem, INSN_LDT_INDIRECT) : /* ldt ($abase), $dst */
3734 {
3735   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3736   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3737 #define FLD(f) abuf->fields.fmt_ldt_indirect.f
3738   int UNUSED written = 0;
3739   IADDR UNUSED pc = abuf->addr;
3740   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3741
3742 do {
3743   SI tmp_dregno;
3744   SI tmp_temp;
3745   tmp_dregno = FLD (f_srcdst);
3746   tmp_temp = * FLD (i_abase);
3747   {
3748     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3749     * FLD (i_dst) = opval;
3750     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3751   }
3752   {
3753     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3754     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3755     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3756   }
3757   {
3758     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3759     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3760     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3761   }
3762 } while (0);
3763
3764 #undef FLD
3765 }
3766   NEXT (vpc);
3767
3768   CASE (sem, INSN_LDT_INDIRECT_INDEX) : /* ldt ($abase)[$index*S$scale], $dst */
3769 {
3770   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3771   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3772 #define FLD(f) abuf->fields.fmt_ldt_indirect_index.f
3773   int UNUSED written = 0;
3774   IADDR UNUSED pc = abuf->addr;
3775   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3776
3777 do {
3778   SI tmp_dregno;
3779   SI tmp_temp;
3780   tmp_dregno = FLD (f_srcdst);
3781   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
3782   {
3783     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3784     * FLD (i_dst) = opval;
3785     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3786   }
3787   {
3788     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3789     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3790     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3791   }
3792   {
3793     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3794     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3795     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3796   }
3797 } while (0);
3798
3799 #undef FLD
3800 }
3801   NEXT (vpc);
3802
3803   CASE (sem, INSN_LDT_DISP) : /* ldt $optdisp, $dst */
3804 {
3805   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3806   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3807 #define FLD(f) abuf->fields.fmt_ldt_disp.f
3808   int UNUSED written = 0;
3809   IADDR UNUSED pc = abuf->addr;
3810   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3811
3812 do {
3813   SI tmp_dregno;
3814   SI tmp_temp;
3815   tmp_dregno = FLD (f_srcdst);
3816   tmp_temp = FLD (f_optdisp);
3817   {
3818     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3819     * FLD (i_dst) = opval;
3820     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3821   }
3822   {
3823     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3824     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3825     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3826   }
3827   {
3828     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3829     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3830     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3831   }
3832 } while (0);
3833
3834 #undef FLD
3835 }
3836   NEXT (vpc);
3837
3838   CASE (sem, INSN_LDT_INDIRECT_DISP) : /* ldt $optdisp($abase), $dst */
3839 {
3840   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3841   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3842 #define FLD(f) abuf->fields.fmt_ldt_indirect_disp.f
3843   int UNUSED written = 0;
3844   IADDR UNUSED pc = abuf->addr;
3845   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3846
3847 do {
3848   SI tmp_dregno;
3849   SI tmp_temp;
3850   tmp_dregno = FLD (f_srcdst);
3851   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
3852   {
3853     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3854     * FLD (i_dst) = opval;
3855     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3856   }
3857   {
3858     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3859     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3860     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3861   }
3862   {
3863     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3864     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3865     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3866   }
3867 } while (0);
3868
3869 #undef FLD
3870 }
3871   NEXT (vpc);
3872
3873   CASE (sem, INSN_LDT_INDEX_DISP) : /* ldt $optdisp[$index*S$scale], $dst */
3874 {
3875   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3876   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3877 #define FLD(f) abuf->fields.fmt_ldt_index_disp.f
3878   int UNUSED written = 0;
3879   IADDR UNUSED pc = abuf->addr;
3880   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3881
3882 do {
3883   SI tmp_dregno;
3884   SI tmp_temp;
3885   tmp_dregno = FLD (f_srcdst);
3886   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
3887   {
3888     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3889     * FLD (i_dst) = opval;
3890     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3891   }
3892   {
3893     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3894     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3895     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3896   }
3897   {
3898     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3899     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3900     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3901   }
3902 } while (0);
3903
3904 #undef FLD
3905 }
3906   NEXT (vpc);
3907
3908   CASE (sem, INSN_LDT_INDIRECT_INDEX_DISP) : /* ldt $optdisp($abase)[$index*S$scale], $dst */
3909 {
3910   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3911   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3912 #define FLD(f) abuf->fields.fmt_ldt_indirect_index_disp.f
3913   int UNUSED written = 0;
3914   IADDR UNUSED pc = abuf->addr;
3915   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
3916
3917 do {
3918   SI tmp_dregno;
3919   SI tmp_temp;
3920   tmp_dregno = FLD (f_srcdst);
3921   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
3922   {
3923     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3924     * FLD (i_dst) = opval;
3925     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3926   }
3927   {
3928     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3929     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3930     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3931   }
3932   {
3933     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3934     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3935     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3936   }
3937 } while (0);
3938
3939 #undef FLD
3940 }
3941   NEXT (vpc);
3942
3943   CASE (sem, INSN_LDQ_OFFSET) : /* ldq $offset, $dst */
3944 {
3945   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3946   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3947 #define FLD(f) abuf->fields.fmt_ldq_offset.f
3948   int UNUSED written = 0;
3949   IADDR UNUSED pc = abuf->addr;
3950   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3951
3952 do {
3953   SI tmp_dregno;
3954   SI tmp_temp;
3955   tmp_dregno = FLD (f_srcdst);
3956   tmp_temp = FLD (f_offset);
3957   {
3958     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3959     * FLD (i_dst) = opval;
3960     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
3961   }
3962   {
3963     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
3964     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
3965     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
3966   }
3967   {
3968     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
3969     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
3970     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
3971   }
3972   {
3973     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
3974     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
3975     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
3976   }
3977 } while (0);
3978
3979 #undef FLD
3980 }
3981   NEXT (vpc);
3982
3983   CASE (sem, INSN_LDQ_INDIRECT_OFFSET) : /* ldq $offset($abase), $dst */
3984 {
3985   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
3986   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
3987 #define FLD(f) abuf->fields.fmt_ldq_indirect_offset.f
3988   int UNUSED written = 0;
3989   IADDR UNUSED pc = abuf->addr;
3990   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
3991
3992 do {
3993   SI tmp_dregno;
3994   SI tmp_temp;
3995   tmp_dregno = FLD (f_srcdst);
3996   tmp_temp = ADDSI (FLD (f_offset), * FLD (i_abase));
3997   {
3998     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
3999     * FLD (i_dst) = opval;
4000     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4001   }
4002   {
4003     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4004     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4005     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
4006   }
4007   {
4008     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4009     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4010     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
4011   }
4012   {
4013     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4014     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4015     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
4016   }
4017 } while (0);
4018
4019 #undef FLD
4020 }
4021   NEXT (vpc);
4022
4023   CASE (sem, INSN_LDQ_INDIRECT) : /* ldq ($abase), $dst */
4024 {
4025   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4026   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4027 #define FLD(f) abuf->fields.fmt_ldq_indirect.f
4028   int UNUSED written = 0;
4029   IADDR UNUSED pc = abuf->addr;
4030   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4031
4032 do {
4033   SI tmp_dregno;
4034   SI tmp_temp;
4035   tmp_dregno = FLD (f_srcdst);
4036   tmp_temp = * FLD (i_abase);
4037   {
4038     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4039     * FLD (i_dst) = opval;
4040     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4041   }
4042   {
4043     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4044     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4045     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
4046   }
4047   {
4048     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4049     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4050     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
4051   }
4052   {
4053     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4054     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4055     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
4056   }
4057 } while (0);
4058
4059 #undef FLD
4060 }
4061   NEXT (vpc);
4062
4063   CASE (sem, INSN_LDQ_INDIRECT_INDEX) : /* ldq ($abase)[$index*S$scale], $dst */
4064 {
4065   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4066   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4067 #define FLD(f) abuf->fields.fmt_ldq_indirect_index.f
4068   int UNUSED written = 0;
4069   IADDR UNUSED pc = abuf->addr;
4070   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4071
4072 do {
4073   SI tmp_dregno;
4074   SI tmp_temp;
4075   tmp_dregno = FLD (f_srcdst);
4076   tmp_temp = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
4077   {
4078     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4079     * FLD (i_dst) = opval;
4080     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4081   }
4082   {
4083     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4084     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4085     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
4086   }
4087   {
4088     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4089     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4090     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
4091   }
4092   {
4093     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4094     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4095     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
4096   }
4097 } while (0);
4098
4099 #undef FLD
4100 }
4101   NEXT (vpc);
4102
4103   CASE (sem, INSN_LDQ_DISP) : /* ldq $optdisp, $dst */
4104 {
4105   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4106   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4107 #define FLD(f) abuf->fields.fmt_ldq_disp.f
4108   int UNUSED written = 0;
4109   IADDR UNUSED pc = abuf->addr;
4110   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4111
4112 do {
4113   SI tmp_dregno;
4114   SI tmp_temp;
4115   tmp_dregno = FLD (f_srcdst);
4116   tmp_temp = FLD (f_optdisp);
4117   {
4118     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4119     * FLD (i_dst) = opval;
4120     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4121   }
4122   {
4123     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4124     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4125     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
4126   }
4127   {
4128     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4129     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4130     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
4131   }
4132   {
4133     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4134     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4135     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
4136   }
4137 } while (0);
4138
4139 #undef FLD
4140 }
4141   NEXT (vpc);
4142
4143   CASE (sem, INSN_LDQ_INDIRECT_DISP) : /* ldq $optdisp($abase), $dst */
4144 {
4145   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4146   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4147 #define FLD(f) abuf->fields.fmt_ldq_indirect_disp.f
4148   int UNUSED written = 0;
4149   IADDR UNUSED pc = abuf->addr;
4150   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4151
4152 do {
4153   SI tmp_dregno;
4154   SI tmp_temp;
4155   tmp_dregno = FLD (f_srcdst);
4156   tmp_temp = ADDSI (FLD (f_optdisp), * FLD (i_abase));
4157   {
4158     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4159     * FLD (i_dst) = opval;
4160     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4161   }
4162   {
4163     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4164     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4165     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
4166   }
4167   {
4168     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4169     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4170     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
4171   }
4172   {
4173     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4174     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4175     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
4176   }
4177 } while (0);
4178
4179 #undef FLD
4180 }
4181   NEXT (vpc);
4182
4183   CASE (sem, INSN_LDQ_INDEX_DISP) : /* ldq $optdisp[$index*S$scale], $dst */
4184 {
4185   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4186   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4187 #define FLD(f) abuf->fields.fmt_ldq_index_disp.f
4188   int UNUSED written = 0;
4189   IADDR UNUSED pc = abuf->addr;
4190   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4191
4192 do {
4193   SI tmp_dregno;
4194   SI tmp_temp;
4195   tmp_dregno = FLD (f_srcdst);
4196   tmp_temp = ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
4197   {
4198     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4199     * FLD (i_dst) = opval;
4200     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4201   }
4202   {
4203     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4204     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4205     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
4206   }
4207   {
4208     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4209     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4210     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
4211   }
4212   {
4213     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4214     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4215     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
4216   }
4217 } while (0);
4218
4219 #undef FLD
4220 }
4221   NEXT (vpc);
4222
4223   CASE (sem, INSN_LDQ_INDIRECT_INDEX_DISP) : /* ldq $optdisp($abase)[$index*S$scale], $dst */
4224 {
4225   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4226   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4227 #define FLD(f) abuf->fields.fmt_ldq_indirect_index_disp.f
4228   int UNUSED written = 0;
4229   IADDR UNUSED pc = abuf->addr;
4230   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4231
4232 do {
4233   SI tmp_dregno;
4234   SI tmp_temp;
4235   tmp_dregno = FLD (f_srcdst);
4236   tmp_temp = ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))));
4237   {
4238     SI opval = GETMEMSI (current_cpu, pc, tmp_temp);
4239     * FLD (i_dst) = opval;
4240     TRACE_RESULT (current_cpu, abuf, "dst", 'x', opval);
4241   }
4242   {
4243     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 4));
4244     CPU (h_gr[((FLD (f_srcdst)) + (1))]) = opval;
4245     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-1", 'x', opval);
4246   }
4247   {
4248     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 8));
4249     CPU (h_gr[((FLD (f_srcdst)) + (2))]) = opval;
4250     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-2", 'x', opval);
4251   }
4252   {
4253     SI opval = GETMEMSI (current_cpu, pc, ADDSI (tmp_temp, 12));
4254     CPU (h_gr[((FLD (f_srcdst)) + (3))]) = opval;
4255     TRACE_RESULT (current_cpu, abuf, "gr-add:-VM-index-of-dst-const:-WI-3", 'x', opval);
4256   }
4257 } while (0);
4258
4259 #undef FLD
4260 }
4261   NEXT (vpc);
4262
4263   CASE (sem, INSN_ST_OFFSET) : /* st $st_src, $offset */
4264 {
4265   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4266   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4267 #define FLD(f) abuf->fields.fmt_st_offset.f
4268   int UNUSED written = 0;
4269   IADDR UNUSED pc = abuf->addr;
4270   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4271
4272   {
4273     SI opval = * FLD (i_st_src);
4274     SETMEMSI (current_cpu, pc, FLD (f_offset), opval);
4275     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4276   }
4277
4278 #undef FLD
4279 }
4280   NEXT (vpc);
4281
4282   CASE (sem, INSN_ST_INDIRECT_OFFSET) : /* st $st_src, $offset($abase) */
4283 {
4284   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4285   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4286 #define FLD(f) abuf->fields.fmt_st_indirect_offset.f
4287   int UNUSED written = 0;
4288   IADDR UNUSED pc = abuf->addr;
4289   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4290
4291   {
4292     SI opval = * FLD (i_st_src);
4293     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
4294     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4295   }
4296
4297 #undef FLD
4298 }
4299   NEXT (vpc);
4300
4301   CASE (sem, INSN_ST_INDIRECT) : /* st $st_src, ($abase) */
4302 {
4303   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4304   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4305 #define FLD(f) abuf->fields.fmt_st_indirect.f
4306   int UNUSED written = 0;
4307   IADDR UNUSED pc = abuf->addr;
4308   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4309
4310   {
4311     SI opval = * FLD (i_st_src);
4312     SETMEMSI (current_cpu, pc, * FLD (i_abase), opval);
4313     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4314   }
4315
4316 #undef FLD
4317 }
4318   NEXT (vpc);
4319
4320   CASE (sem, INSN_ST_INDIRECT_INDEX) : /* st $st_src, ($abase)[$index*S$scale] */
4321 {
4322   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4323   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4324 #define FLD(f) abuf->fields.fmt_st_indirect_index.f
4325   int UNUSED written = 0;
4326   IADDR UNUSED pc = abuf->addr;
4327   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4328
4329   {
4330     SI opval = * FLD (i_st_src);
4331     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4332     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4333   }
4334
4335 #undef FLD
4336 }
4337   NEXT (vpc);
4338
4339   CASE (sem, INSN_ST_DISP) : /* st $st_src, $optdisp */
4340 {
4341   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4342   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4343 #define FLD(f) abuf->fields.fmt_st_disp.f
4344   int UNUSED written = 0;
4345   IADDR UNUSED pc = abuf->addr;
4346   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4347
4348   {
4349     SI opval = * FLD (i_st_src);
4350     SETMEMSI (current_cpu, pc, FLD (f_optdisp), opval);
4351     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4352   }
4353
4354 #undef FLD
4355 }
4356   NEXT (vpc);
4357
4358   CASE (sem, INSN_ST_INDIRECT_DISP) : /* st $st_src, $optdisp($abase) */
4359 {
4360   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4361   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4362 #define FLD(f) abuf->fields.fmt_st_indirect_disp.f
4363   int UNUSED written = 0;
4364   IADDR UNUSED pc = abuf->addr;
4365   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4366
4367   {
4368     SI opval = * FLD (i_st_src);
4369     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
4370     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4371   }
4372
4373 #undef FLD
4374 }
4375   NEXT (vpc);
4376
4377   CASE (sem, INSN_ST_INDEX_DISP) : /* st $st_src, $optdisp[$index*S$scale */
4378 {
4379   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4380   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4381 #define FLD(f) abuf->fields.fmt_st_index_disp.f
4382   int UNUSED written = 0;
4383   IADDR UNUSED pc = abuf->addr;
4384   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4385
4386   {
4387     SI opval = * FLD (i_st_src);
4388     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4389     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4390   }
4391
4392 #undef FLD
4393 }
4394   NEXT (vpc);
4395
4396   CASE (sem, INSN_ST_INDIRECT_INDEX_DISP) : /* st $st_src, $optdisp($abase)[$index*S$scale] */
4397 {
4398   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4399   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4400 #define FLD(f) abuf->fields.fmt_st_indirect_index_disp.f
4401   int UNUSED written = 0;
4402   IADDR UNUSED pc = abuf->addr;
4403   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4404
4405   {
4406     SI opval = * FLD (i_st_src);
4407     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
4408     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4409   }
4410
4411 #undef FLD
4412 }
4413   NEXT (vpc);
4414
4415   CASE (sem, INSN_STOB_OFFSET) : /* stob $st_src, $offset */
4416 {
4417   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4418   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4419 #define FLD(f) abuf->fields.fmt_stob_offset.f
4420   int UNUSED written = 0;
4421   IADDR UNUSED pc = abuf->addr;
4422   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4423
4424   {
4425     QI opval = * FLD (i_st_src);
4426     SETMEMQI (current_cpu, pc, FLD (f_offset), opval);
4427     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4428   }
4429
4430 #undef FLD
4431 }
4432   NEXT (vpc);
4433
4434   CASE (sem, INSN_STOB_INDIRECT_OFFSET) : /* stob $st_src, $offset($abase) */
4435 {
4436   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4437   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4438 #define FLD(f) abuf->fields.fmt_stob_indirect_offset.f
4439   int UNUSED written = 0;
4440   IADDR UNUSED pc = abuf->addr;
4441   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4442
4443   {
4444     QI opval = * FLD (i_st_src);
4445     SETMEMQI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
4446     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4447   }
4448
4449 #undef FLD
4450 }
4451   NEXT (vpc);
4452
4453   CASE (sem, INSN_STOB_INDIRECT) : /* stob $st_src, ($abase) */
4454 {
4455   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4456   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4457 #define FLD(f) abuf->fields.fmt_stob_indirect.f
4458   int UNUSED written = 0;
4459   IADDR UNUSED pc = abuf->addr;
4460   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4461
4462   {
4463     QI opval = * FLD (i_st_src);
4464     SETMEMQI (current_cpu, pc, * FLD (i_abase), opval);
4465     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4466   }
4467
4468 #undef FLD
4469 }
4470   NEXT (vpc);
4471
4472   CASE (sem, INSN_STOB_INDIRECT_INDEX) : /* stob $st_src, ($abase)[$index*S$scale] */
4473 {
4474   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4475   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4476 #define FLD(f) abuf->fields.fmt_stob_indirect_index.f
4477   int UNUSED written = 0;
4478   IADDR UNUSED pc = abuf->addr;
4479   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4480
4481   {
4482     QI opval = * FLD (i_st_src);
4483     SETMEMQI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4484     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4485   }
4486
4487 #undef FLD
4488 }
4489   NEXT (vpc);
4490
4491   CASE (sem, INSN_STOB_DISP) : /* stob $st_src, $optdisp */
4492 {
4493   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4494   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4495 #define FLD(f) abuf->fields.fmt_stob_disp.f
4496   int UNUSED written = 0;
4497   IADDR UNUSED pc = abuf->addr;
4498   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4499
4500   {
4501     QI opval = * FLD (i_st_src);
4502     SETMEMQI (current_cpu, pc, FLD (f_optdisp), opval);
4503     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4504   }
4505
4506 #undef FLD
4507 }
4508   NEXT (vpc);
4509
4510   CASE (sem, INSN_STOB_INDIRECT_DISP) : /* stob $st_src, $optdisp($abase) */
4511 {
4512   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4513   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4514 #define FLD(f) abuf->fields.fmt_stob_indirect_disp.f
4515   int UNUSED written = 0;
4516   IADDR UNUSED pc = abuf->addr;
4517   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4518
4519   {
4520     QI opval = * FLD (i_st_src);
4521     SETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
4522     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4523   }
4524
4525 #undef FLD
4526 }
4527   NEXT (vpc);
4528
4529   CASE (sem, INSN_STOB_INDEX_DISP) : /* stob $st_src, $optdisp[$index*S$scale */
4530 {
4531   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4532   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4533 #define FLD(f) abuf->fields.fmt_stob_index_disp.f
4534   int UNUSED written = 0;
4535   IADDR UNUSED pc = abuf->addr;
4536   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4537
4538   {
4539     QI opval = * FLD (i_st_src);
4540     SETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4541     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4542   }
4543
4544 #undef FLD
4545 }
4546   NEXT (vpc);
4547
4548   CASE (sem, INSN_STOB_INDIRECT_INDEX_DISP) : /* stob $st_src, $optdisp($abase)[$index*S$scale] */
4549 {
4550   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4551   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4552 #define FLD(f) abuf->fields.fmt_stob_indirect_index_disp.f
4553   int UNUSED written = 0;
4554   IADDR UNUSED pc = abuf->addr;
4555   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4556
4557   {
4558     QI opval = * FLD (i_st_src);
4559     SETMEMQI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
4560     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4561   }
4562
4563 #undef FLD
4564 }
4565   NEXT (vpc);
4566
4567   CASE (sem, INSN_STOS_OFFSET) : /* stos $st_src, $offset */
4568 {
4569   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4570   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4571 #define FLD(f) abuf->fields.fmt_stos_offset.f
4572   int UNUSED written = 0;
4573   IADDR UNUSED pc = abuf->addr;
4574   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4575
4576   {
4577     HI opval = * FLD (i_st_src);
4578     SETMEMHI (current_cpu, pc, FLD (f_offset), opval);
4579     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4580   }
4581
4582 #undef FLD
4583 }
4584   NEXT (vpc);
4585
4586   CASE (sem, INSN_STOS_INDIRECT_OFFSET) : /* stos $st_src, $offset($abase) */
4587 {
4588   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4589   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4590 #define FLD(f) abuf->fields.fmt_stos_indirect_offset.f
4591   int UNUSED written = 0;
4592   IADDR UNUSED pc = abuf->addr;
4593   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4594
4595   {
4596     HI opval = * FLD (i_st_src);
4597     SETMEMHI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
4598     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4599   }
4600
4601 #undef FLD
4602 }
4603   NEXT (vpc);
4604
4605   CASE (sem, INSN_STOS_INDIRECT) : /* stos $st_src, ($abase) */
4606 {
4607   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4608   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4609 #define FLD(f) abuf->fields.fmt_stos_indirect.f
4610   int UNUSED written = 0;
4611   IADDR UNUSED pc = abuf->addr;
4612   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4613
4614   {
4615     HI opval = * FLD (i_st_src);
4616     SETMEMHI (current_cpu, pc, * FLD (i_abase), opval);
4617     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4618   }
4619
4620 #undef FLD
4621 }
4622   NEXT (vpc);
4623
4624   CASE (sem, INSN_STOS_INDIRECT_INDEX) : /* stos $st_src, ($abase)[$index*S$scale] */
4625 {
4626   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4627   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4628 #define FLD(f) abuf->fields.fmt_stos_indirect_index.f
4629   int UNUSED written = 0;
4630   IADDR UNUSED pc = abuf->addr;
4631   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4632
4633   {
4634     HI opval = * FLD (i_st_src);
4635     SETMEMHI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4636     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4637   }
4638
4639 #undef FLD
4640 }
4641   NEXT (vpc);
4642
4643   CASE (sem, INSN_STOS_DISP) : /* stos $st_src, $optdisp */
4644 {
4645   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4646   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4647 #define FLD(f) abuf->fields.fmt_stos_disp.f
4648   int UNUSED written = 0;
4649   IADDR UNUSED pc = abuf->addr;
4650   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4651
4652   {
4653     HI opval = * FLD (i_st_src);
4654     SETMEMHI (current_cpu, pc, FLD (f_optdisp), opval);
4655     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4656   }
4657
4658 #undef FLD
4659 }
4660   NEXT (vpc);
4661
4662   CASE (sem, INSN_STOS_INDIRECT_DISP) : /* stos $st_src, $optdisp($abase) */
4663 {
4664   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4665   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4666 #define FLD(f) abuf->fields.fmt_stos_indirect_disp.f
4667   int UNUSED written = 0;
4668   IADDR UNUSED pc = abuf->addr;
4669   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4670
4671   {
4672     HI opval = * FLD (i_st_src);
4673     SETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
4674     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4675   }
4676
4677 #undef FLD
4678 }
4679   NEXT (vpc);
4680
4681   CASE (sem, INSN_STOS_INDEX_DISP) : /* stos $st_src, $optdisp[$index*S$scale */
4682 {
4683   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4684   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4685 #define FLD(f) abuf->fields.fmt_stos_index_disp.f
4686   int UNUSED written = 0;
4687   IADDR UNUSED pc = abuf->addr;
4688   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4689
4690   {
4691     HI opval = * FLD (i_st_src);
4692     SETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4693     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4694   }
4695
4696 #undef FLD
4697 }
4698   NEXT (vpc);
4699
4700   CASE (sem, INSN_STOS_INDIRECT_INDEX_DISP) : /* stos $st_src, $optdisp($abase)[$index*S$scale] */
4701 {
4702   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4703   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4704 #define FLD(f) abuf->fields.fmt_stos_indirect_index_disp.f
4705   int UNUSED written = 0;
4706   IADDR UNUSED pc = abuf->addr;
4707   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4708
4709   {
4710     HI opval = * FLD (i_st_src);
4711     SETMEMHI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
4712     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4713   }
4714
4715 #undef FLD
4716 }
4717   NEXT (vpc);
4718
4719   CASE (sem, INSN_STL_OFFSET) : /* stl $st_src, $offset */
4720 {
4721   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4722   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4723 #define FLD(f) abuf->fields.fmt_stl_offset.f
4724   int UNUSED written = 0;
4725   IADDR UNUSED pc = abuf->addr;
4726   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4727
4728 do {
4729   SI tmp_sregno;
4730   tmp_sregno = FLD (f_srcdst);
4731   {
4732     SI opval = * FLD (i_st_src);
4733     SETMEMSI (current_cpu, pc, FLD (f_offset), opval);
4734     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4735   }
4736   {
4737     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4738     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 4), opval);
4739     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4740   }
4741 } while (0);
4742
4743 #undef FLD
4744 }
4745   NEXT (vpc);
4746
4747   CASE (sem, INSN_STL_INDIRECT_OFFSET) : /* stl $st_src, $offset($abase) */
4748 {
4749   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4750   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4751 #define FLD(f) abuf->fields.fmt_stl_indirect_offset.f
4752   int UNUSED written = 0;
4753   IADDR UNUSED pc = abuf->addr;
4754   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4755
4756 do {
4757   SI tmp_sregno;
4758   tmp_sregno = FLD (f_srcdst);
4759   {
4760     SI opval = * FLD (i_st_src);
4761     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
4762     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4763   }
4764   {
4765     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4766     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 4), opval);
4767     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4768   }
4769 } while (0);
4770
4771 #undef FLD
4772 }
4773   NEXT (vpc);
4774
4775   CASE (sem, INSN_STL_INDIRECT) : /* stl $st_src, ($abase) */
4776 {
4777   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4778   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4779 #define FLD(f) abuf->fields.fmt_stl_indirect.f
4780   int UNUSED written = 0;
4781   IADDR UNUSED pc = abuf->addr;
4782   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4783
4784 do {
4785   SI tmp_sregno;
4786   tmp_sregno = FLD (f_srcdst);
4787   {
4788     SI opval = * FLD (i_st_src);
4789     SETMEMSI (current_cpu, pc, * FLD (i_abase), opval);
4790     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4791   }
4792   {
4793     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4794     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 4), opval);
4795     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4796   }
4797 } while (0);
4798
4799 #undef FLD
4800 }
4801   NEXT (vpc);
4802
4803   CASE (sem, INSN_STL_INDIRECT_INDEX) : /* stl $st_src, ($abase)[$index*S$scale] */
4804 {
4805   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4806   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4807 #define FLD(f) abuf->fields.fmt_stl_indirect_index.f
4808   int UNUSED written = 0;
4809   IADDR UNUSED pc = abuf->addr;
4810   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4811
4812 do {
4813   SI tmp_sregno;
4814   tmp_sregno = FLD (f_srcdst);
4815   {
4816     SI opval = * FLD (i_st_src);
4817     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4818     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4819   }
4820   {
4821     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4822     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
4823     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4824   }
4825 } while (0);
4826
4827 #undef FLD
4828 }
4829   NEXT (vpc);
4830
4831   CASE (sem, INSN_STL_DISP) : /* stl $st_src, $optdisp */
4832 {
4833   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4834   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4835 #define FLD(f) abuf->fields.fmt_stl_disp.f
4836   int UNUSED written = 0;
4837   IADDR UNUSED pc = abuf->addr;
4838   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4839
4840 do {
4841   SI tmp_sregno;
4842   tmp_sregno = FLD (f_srcdst);
4843   {
4844     SI opval = * FLD (i_st_src);
4845     SETMEMSI (current_cpu, pc, FLD (f_optdisp), opval);
4846     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4847   }
4848   {
4849     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4850     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 4), opval);
4851     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4852   }
4853 } while (0);
4854
4855 #undef FLD
4856 }
4857   NEXT (vpc);
4858
4859   CASE (sem, INSN_STL_INDIRECT_DISP) : /* stl $st_src, $optdisp($abase) */
4860 {
4861   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4862   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4863 #define FLD(f) abuf->fields.fmt_stl_indirect_disp.f
4864   int UNUSED written = 0;
4865   IADDR UNUSED pc = abuf->addr;
4866   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4867
4868 do {
4869   SI tmp_sregno;
4870   tmp_sregno = FLD (f_srcdst);
4871   {
4872     SI opval = * FLD (i_st_src);
4873     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
4874     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4875   }
4876   {
4877     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4878     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 4), opval);
4879     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4880   }
4881 } while (0);
4882
4883 #undef FLD
4884 }
4885   NEXT (vpc);
4886
4887   CASE (sem, INSN_STL_INDEX_DISP) : /* stl $st_src, $optdisp[$index*S$scale */
4888 {
4889   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4890   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4891 #define FLD(f) abuf->fields.fmt_stl_index_disp.f
4892   int UNUSED written = 0;
4893   IADDR UNUSED pc = abuf->addr;
4894   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4895
4896 do {
4897   SI tmp_sregno;
4898   tmp_sregno = FLD (f_srcdst);
4899   {
4900     SI opval = * FLD (i_st_src);
4901     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
4902     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4903   }
4904   {
4905     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4906     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
4907     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4908   }
4909 } while (0);
4910
4911 #undef FLD
4912 }
4913   NEXT (vpc);
4914
4915   CASE (sem, INSN_STL_INDIRECT_INDEX_DISP) : /* stl $st_src, $optdisp($abase)[$index*S$scale] */
4916 {
4917   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4918   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4919 #define FLD(f) abuf->fields.fmt_stl_indirect_index_disp.f
4920   int UNUSED written = 0;
4921   IADDR UNUSED pc = abuf->addr;
4922   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
4923
4924 do {
4925   SI tmp_sregno;
4926   tmp_sregno = FLD (f_srcdst);
4927   {
4928     SI opval = * FLD (i_st_src);
4929     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
4930     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4931   }
4932   {
4933     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4934     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 4), opval);
4935     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4936   }
4937 } while (0);
4938
4939 #undef FLD
4940 }
4941   NEXT (vpc);
4942
4943   CASE (sem, INSN_STT_OFFSET) : /* stt $st_src, $offset */
4944 {
4945   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4946   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4947 #define FLD(f) abuf->fields.fmt_stt_offset.f
4948   int UNUSED written = 0;
4949   IADDR UNUSED pc = abuf->addr;
4950   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4951
4952 do {
4953   SI tmp_sregno;
4954   tmp_sregno = FLD (f_srcdst);
4955   {
4956     SI opval = * FLD (i_st_src);
4957     SETMEMSI (current_cpu, pc, FLD (f_offset), opval);
4958     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4959   }
4960   {
4961     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4962     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 4), opval);
4963     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4964   }
4965   {
4966     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
4967     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 8), opval);
4968     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4969   }
4970 } while (0);
4971
4972 #undef FLD
4973 }
4974   NEXT (vpc);
4975
4976   CASE (sem, INSN_STT_INDIRECT_OFFSET) : /* stt $st_src, $offset($abase) */
4977 {
4978   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
4979   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
4980 #define FLD(f) abuf->fields.fmt_stt_indirect_offset.f
4981   int UNUSED written = 0;
4982   IADDR UNUSED pc = abuf->addr;
4983   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
4984
4985 do {
4986   SI tmp_sregno;
4987   tmp_sregno = FLD (f_srcdst);
4988   {
4989     SI opval = * FLD (i_st_src);
4990     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
4991     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4992   }
4993   {
4994     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
4995     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 4), opval);
4996     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
4997   }
4998   {
4999     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5000     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 8), opval);
5001     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5002   }
5003 } while (0);
5004
5005 #undef FLD
5006 }
5007   NEXT (vpc);
5008
5009   CASE (sem, INSN_STT_INDIRECT) : /* stt $st_src, ($abase) */
5010 {
5011   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5012   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5013 #define FLD(f) abuf->fields.fmt_stt_indirect.f
5014   int UNUSED written = 0;
5015   IADDR UNUSED pc = abuf->addr;
5016   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5017
5018 do {
5019   SI tmp_sregno;
5020   tmp_sregno = FLD (f_srcdst);
5021   {
5022     SI opval = * FLD (i_st_src);
5023     SETMEMSI (current_cpu, pc, * FLD (i_abase), opval);
5024     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5025   }
5026   {
5027     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5028     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 4), opval);
5029     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5030   }
5031   {
5032     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5033     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 8), opval);
5034     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5035   }
5036 } while (0);
5037
5038 #undef FLD
5039 }
5040   NEXT (vpc);
5041
5042   CASE (sem, INSN_STT_INDIRECT_INDEX) : /* stt $st_src, ($abase)[$index*S$scale] */
5043 {
5044   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5045   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5046 #define FLD(f) abuf->fields.fmt_stt_indirect_index.f
5047   int UNUSED written = 0;
5048   IADDR UNUSED pc = abuf->addr;
5049   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5050
5051 do {
5052   SI tmp_sregno;
5053   tmp_sregno = FLD (f_srcdst);
5054   {
5055     SI opval = * FLD (i_st_src);
5056     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5057     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5058   }
5059   {
5060     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5061     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5062     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5063   }
5064   {
5065     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5066     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
5067     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5068   }
5069 } while (0);
5070
5071 #undef FLD
5072 }
5073   NEXT (vpc);
5074
5075   CASE (sem, INSN_STT_DISP) : /* stt $st_src, $optdisp */
5076 {
5077   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5078   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5079 #define FLD(f) abuf->fields.fmt_stt_disp.f
5080   int UNUSED written = 0;
5081   IADDR UNUSED pc = abuf->addr;
5082   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5083
5084 do {
5085   SI tmp_sregno;
5086   tmp_sregno = FLD (f_srcdst);
5087   {
5088     SI opval = * FLD (i_st_src);
5089     SETMEMSI (current_cpu, pc, FLD (f_optdisp), opval);
5090     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5091   }
5092   {
5093     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5094     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 4), opval);
5095     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5096   }
5097   {
5098     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5099     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 8), opval);
5100     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5101   }
5102 } while (0);
5103
5104 #undef FLD
5105 }
5106   NEXT (vpc);
5107
5108   CASE (sem, INSN_STT_INDIRECT_DISP) : /* stt $st_src, $optdisp($abase) */
5109 {
5110   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5111   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5112 #define FLD(f) abuf->fields.fmt_stt_indirect_disp.f
5113   int UNUSED written = 0;
5114   IADDR UNUSED pc = abuf->addr;
5115   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5116
5117 do {
5118   SI tmp_sregno;
5119   tmp_sregno = FLD (f_srcdst);
5120   {
5121     SI opval = * FLD (i_st_src);
5122     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
5123     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5124   }
5125   {
5126     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5127     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 4), opval);
5128     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5129   }
5130   {
5131     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5132     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 8), opval);
5133     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5134   }
5135 } while (0);
5136
5137 #undef FLD
5138 }
5139   NEXT (vpc);
5140
5141   CASE (sem, INSN_STT_INDEX_DISP) : /* stt $st_src, $optdisp[$index*S$scale */
5142 {
5143   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5144   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5145 #define FLD(f) abuf->fields.fmt_stt_index_disp.f
5146   int UNUSED written = 0;
5147   IADDR UNUSED pc = abuf->addr;
5148   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5149
5150 do {
5151   SI tmp_sregno;
5152   tmp_sregno = FLD (f_srcdst);
5153   {
5154     SI opval = * FLD (i_st_src);
5155     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5156     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5157   }
5158   {
5159     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5160     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5161     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5162   }
5163   {
5164     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5165     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
5166     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5167   }
5168 } while (0);
5169
5170 #undef FLD
5171 }
5172   NEXT (vpc);
5173
5174   CASE (sem, INSN_STT_INDIRECT_INDEX_DISP) : /* stt $st_src, $optdisp($abase)[$index*S$scale] */
5175 {
5176   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5177   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5178 #define FLD(f) abuf->fields.fmt_stt_indirect_index_disp.f
5179   int UNUSED written = 0;
5180   IADDR UNUSED pc = abuf->addr;
5181   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5182
5183 do {
5184   SI tmp_sregno;
5185   tmp_sregno = FLD (f_srcdst);
5186   {
5187     SI opval = * FLD (i_st_src);
5188     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
5189     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5190   }
5191   {
5192     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5193     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 4), opval);
5194     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5195   }
5196   {
5197     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5198     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 8), opval);
5199     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5200   }
5201 } while (0);
5202
5203 #undef FLD
5204 }
5205   NEXT (vpc);
5206
5207   CASE (sem, INSN_STQ_OFFSET) : /* stq $st_src, $offset */
5208 {
5209   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5210   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5211 #define FLD(f) abuf->fields.fmt_stq_offset.f
5212   int UNUSED written = 0;
5213   IADDR UNUSED pc = abuf->addr;
5214   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5215
5216 do {
5217   SI tmp_sregno;
5218   tmp_sregno = FLD (f_srcdst);
5219   {
5220     SI opval = * FLD (i_st_src);
5221     SETMEMSI (current_cpu, pc, FLD (f_offset), opval);
5222     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5223   }
5224   {
5225     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5226     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 4), opval);
5227     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5228   }
5229   {
5230     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5231     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 8), opval);
5232     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5233   }
5234   {
5235     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5236     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), 12), opval);
5237     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5238   }
5239 } while (0);
5240
5241 #undef FLD
5242 }
5243   NEXT (vpc);
5244
5245   CASE (sem, INSN_STQ_INDIRECT_OFFSET) : /* stq $st_src, $offset($abase) */
5246 {
5247   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5248   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5249 #define FLD(f) abuf->fields.fmt_stq_indirect_offset.f
5250   int UNUSED written = 0;
5251   IADDR UNUSED pc = abuf->addr;
5252   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5253
5254 do {
5255   SI tmp_sregno;
5256   tmp_sregno = FLD (f_srcdst);
5257   {
5258     SI opval = * FLD (i_st_src);
5259     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_offset), * FLD (i_abase)), opval);
5260     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5261   }
5262   {
5263     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5264     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 4), opval);
5265     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5266   }
5267   {
5268     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5269     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 8), opval);
5270     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5271   }
5272   {
5273     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5274     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_offset), * FLD (i_abase)), 12), opval);
5275     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5276   }
5277 } while (0);
5278
5279 #undef FLD
5280 }
5281   NEXT (vpc);
5282
5283   CASE (sem, INSN_STQ_INDIRECT) : /* stq $st_src, ($abase) */
5284 {
5285   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5286   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5287 #define FLD(f) abuf->fields.fmt_stq_indirect.f
5288   int UNUSED written = 0;
5289   IADDR UNUSED pc = abuf->addr;
5290   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5291
5292 do {
5293   SI tmp_sregno;
5294   tmp_sregno = FLD (f_srcdst);
5295   {
5296     SI opval = * FLD (i_st_src);
5297     SETMEMSI (current_cpu, pc, * FLD (i_abase), opval);
5298     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5299   }
5300   {
5301     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5302     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 4), opval);
5303     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5304   }
5305   {
5306     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5307     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 8), opval);
5308     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5309   }
5310   {
5311     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5312     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), 12), opval);
5313     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5314   }
5315 } while (0);
5316
5317 #undef FLD
5318 }
5319   NEXT (vpc);
5320
5321   CASE (sem, INSN_STQ_INDIRECT_INDEX) : /* stq $st_src, ($abase)[$index*S$scale] */
5322 {
5323   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5324   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5325 #define FLD(f) abuf->fields.fmt_stq_indirect_index.f
5326   int UNUSED written = 0;
5327   IADDR UNUSED pc = abuf->addr;
5328   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5329
5330 do {
5331   SI tmp_sregno;
5332   tmp_sregno = FLD (f_srcdst);
5333   {
5334     SI opval = * FLD (i_st_src);
5335     SETMEMSI (current_cpu, pc, ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5336     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5337   }
5338   {
5339     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5340     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5341     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5342   }
5343   {
5344     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5345     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
5346     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5347   }
5348   {
5349     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5350     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 12), opval);
5351     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5352   }
5353 } while (0);
5354
5355 #undef FLD
5356 }
5357   NEXT (vpc);
5358
5359   CASE (sem, INSN_STQ_DISP) : /* stq $st_src, $optdisp */
5360 {
5361   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5362   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5363 #define FLD(f) abuf->fields.fmt_stq_disp.f
5364   int UNUSED written = 0;
5365   IADDR UNUSED pc = abuf->addr;
5366   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5367
5368 do {
5369   SI tmp_sregno;
5370   tmp_sregno = FLD (f_srcdst);
5371   {
5372     SI opval = * FLD (i_st_src);
5373     SETMEMSI (current_cpu, pc, FLD (f_optdisp), opval);
5374     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5375   }
5376   {
5377     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5378     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 4), opval);
5379     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5380   }
5381   {
5382     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5383     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 8), opval);
5384     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5385   }
5386   {
5387     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5388     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), 12), opval);
5389     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5390   }
5391 } while (0);
5392
5393 #undef FLD
5394 }
5395   NEXT (vpc);
5396
5397   CASE (sem, INSN_STQ_INDIRECT_DISP) : /* stq $st_src, $optdisp($abase) */
5398 {
5399   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5400   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5401 #define FLD(f) abuf->fields.fmt_stq_indirect_disp.f
5402   int UNUSED written = 0;
5403   IADDR UNUSED pc = abuf->addr;
5404   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5405
5406 do {
5407   SI tmp_sregno;
5408   tmp_sregno = FLD (f_srcdst);
5409   {
5410     SI opval = * FLD (i_st_src);
5411     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), * FLD (i_abase)), opval);
5412     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5413   }
5414   {
5415     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5416     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 4), opval);
5417     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5418   }
5419   {
5420     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5421     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 8), opval);
5422     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5423   }
5424   {
5425     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5426     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), * FLD (i_abase)), 12), opval);
5427     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5428   }
5429 } while (0);
5430
5431 #undef FLD
5432 }
5433   NEXT (vpc);
5434
5435   CASE (sem, INSN_STQ_INDEX_DISP) : /* stq $st_src, $optdisp[$index*S$scale */
5436 {
5437   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5438   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5439 #define FLD(f) abuf->fields.fmt_stq_index_disp.f
5440   int UNUSED written = 0;
5441   IADDR UNUSED pc = abuf->addr;
5442   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5443
5444 do {
5445   SI tmp_sregno;
5446   tmp_sregno = FLD (f_srcdst);
5447   {
5448     SI opval = * FLD (i_st_src);
5449     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), opval);
5450     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5451   }
5452   {
5453     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5454     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 4), opval);
5455     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5456   }
5457   {
5458     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5459     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 8), opval);
5460     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5461   }
5462   {
5463     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5464     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale)))), 12), opval);
5465     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5466   }
5467 } while (0);
5468
5469 #undef FLD
5470 }
5471   NEXT (vpc);
5472
5473   CASE (sem, INSN_STQ_INDIRECT_INDEX_DISP) : /* stq $st_src, $optdisp($abase)[$index*S$scale] */
5474 {
5475   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5476   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5477 #define FLD(f) abuf->fields.fmt_stq_indirect_index_disp.f
5478   int UNUSED written = 0;
5479   IADDR UNUSED pc = abuf->addr;
5480   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
5481
5482 do {
5483   SI tmp_sregno;
5484   tmp_sregno = FLD (f_srcdst);
5485   {
5486     SI opval = * FLD (i_st_src);
5487     SETMEMSI (current_cpu, pc, ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), opval);
5488     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5489   }
5490   {
5491     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (1))]);
5492     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 4), opval);
5493     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5494   }
5495   {
5496     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (2))]);
5497     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 8), opval);
5498     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5499   }
5500   {
5501     SI opval = CPU (h_gr[((FLD (f_srcdst)) + (3))]);
5502     SETMEMSI (current_cpu, pc, ADDSI (ADDSI (FLD (f_optdisp), ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))))), 12), opval);
5503     TRACE_RESULT (current_cpu, abuf, "memory", 'x', opval);
5504   }
5505 } while (0);
5506
5507 #undef FLD
5508 }
5509   NEXT (vpc);
5510
5511   CASE (sem, INSN_CMPOBE_REG) : /* cmpobe $br_src1, $br_src2, $br_disp */
5512 {
5513   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5514   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5515 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
5516   int UNUSED written = 0;
5517   IADDR UNUSED pc = abuf->addr;
5518   SEM_BRANCH_INIT
5519   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5520
5521 if (EQSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5522   {
5523     USI opval = FLD (i_br_disp);
5524     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5525     written |= (1 << 3);
5526     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5527   }
5528 }
5529
5530   abuf->written = written;
5531   SEM_BRANCH_FINI (vpc);
5532 #undef FLD
5533 }
5534   NEXT (vpc);
5535
5536   CASE (sem, INSN_CMPOBE_LIT) : /* cmpobe $br_lit1, $br_src2, $br_disp */
5537 {
5538   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5539   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5540 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
5541   int UNUSED written = 0;
5542   IADDR UNUSED pc = abuf->addr;
5543   SEM_BRANCH_INIT
5544   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5545
5546 if (EQSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5547   {
5548     USI opval = FLD (i_br_disp);
5549     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5550     written |= (1 << 3);
5551     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5552   }
5553 }
5554
5555   abuf->written = written;
5556   SEM_BRANCH_FINI (vpc);
5557 #undef FLD
5558 }
5559   NEXT (vpc);
5560
5561   CASE (sem, INSN_CMPOBNE_REG) : /* cmpobne $br_src1, $br_src2, $br_disp */
5562 {
5563   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5564   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5565 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
5566   int UNUSED written = 0;
5567   IADDR UNUSED pc = abuf->addr;
5568   SEM_BRANCH_INIT
5569   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5570
5571 if (NESI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5572   {
5573     USI opval = FLD (i_br_disp);
5574     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5575     written |= (1 << 3);
5576     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5577   }
5578 }
5579
5580   abuf->written = written;
5581   SEM_BRANCH_FINI (vpc);
5582 #undef FLD
5583 }
5584   NEXT (vpc);
5585
5586   CASE (sem, INSN_CMPOBNE_LIT) : /* cmpobne $br_lit1, $br_src2, $br_disp */
5587 {
5588   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5589   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5590 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
5591   int UNUSED written = 0;
5592   IADDR UNUSED pc = abuf->addr;
5593   SEM_BRANCH_INIT
5594   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5595
5596 if (NESI (FLD (f_br_src1), * FLD (i_br_src2))) {
5597   {
5598     USI opval = FLD (i_br_disp);
5599     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5600     written |= (1 << 3);
5601     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5602   }
5603 }
5604
5605   abuf->written = written;
5606   SEM_BRANCH_FINI (vpc);
5607 #undef FLD
5608 }
5609   NEXT (vpc);
5610
5611   CASE (sem, INSN_CMPOBL_REG) : /* cmpobl $br_src1, $br_src2, $br_disp */
5612 {
5613   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5614   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5615 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_reg.f
5616   int UNUSED written = 0;
5617   IADDR UNUSED pc = abuf->addr;
5618   SEM_BRANCH_INIT
5619   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5620
5621 if (LTUSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5622   {
5623     USI opval = FLD (i_br_disp);
5624     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5625     written |= (1 << 3);
5626     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5627   }
5628 }
5629
5630   abuf->written = written;
5631   SEM_BRANCH_FINI (vpc);
5632 #undef FLD
5633 }
5634   NEXT (vpc);
5635
5636   CASE (sem, INSN_CMPOBL_LIT) : /* cmpobl $br_lit1, $br_src2, $br_disp */
5637 {
5638   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5639   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5640 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_lit.f
5641   int UNUSED written = 0;
5642   IADDR UNUSED pc = abuf->addr;
5643   SEM_BRANCH_INIT
5644   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5645
5646 if (LTUSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5647   {
5648     USI opval = FLD (i_br_disp);
5649     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5650     written |= (1 << 3);
5651     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5652   }
5653 }
5654
5655   abuf->written = written;
5656   SEM_BRANCH_FINI (vpc);
5657 #undef FLD
5658 }
5659   NEXT (vpc);
5660
5661   CASE (sem, INSN_CMPOBLE_REG) : /* cmpoble $br_src1, $br_src2, $br_disp */
5662 {
5663   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5664   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5665 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_reg.f
5666   int UNUSED written = 0;
5667   IADDR UNUSED pc = abuf->addr;
5668   SEM_BRANCH_INIT
5669   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5670
5671 if (LEUSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5672   {
5673     USI opval = FLD (i_br_disp);
5674     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5675     written |= (1 << 3);
5676     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5677   }
5678 }
5679
5680   abuf->written = written;
5681   SEM_BRANCH_FINI (vpc);
5682 #undef FLD
5683 }
5684   NEXT (vpc);
5685
5686   CASE (sem, INSN_CMPOBLE_LIT) : /* cmpoble $br_lit1, $br_src2, $br_disp */
5687 {
5688   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5689   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5690 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_lit.f
5691   int UNUSED written = 0;
5692   IADDR UNUSED pc = abuf->addr;
5693   SEM_BRANCH_INIT
5694   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5695
5696 if (LEUSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5697   {
5698     USI opval = FLD (i_br_disp);
5699     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5700     written |= (1 << 3);
5701     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5702   }
5703 }
5704
5705   abuf->written = written;
5706   SEM_BRANCH_FINI (vpc);
5707 #undef FLD
5708 }
5709   NEXT (vpc);
5710
5711   CASE (sem, INSN_CMPOBG_REG) : /* cmpobg $br_src1, $br_src2, $br_disp */
5712 {
5713   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5714   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5715 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_reg.f
5716   int UNUSED written = 0;
5717   IADDR UNUSED pc = abuf->addr;
5718   SEM_BRANCH_INIT
5719   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5720
5721 if (GTUSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5722   {
5723     USI opval = FLD (i_br_disp);
5724     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5725     written |= (1 << 3);
5726     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5727   }
5728 }
5729
5730   abuf->written = written;
5731   SEM_BRANCH_FINI (vpc);
5732 #undef FLD
5733 }
5734   NEXT (vpc);
5735
5736   CASE (sem, INSN_CMPOBG_LIT) : /* cmpobg $br_lit1, $br_src2, $br_disp */
5737 {
5738   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5739   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5740 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_lit.f
5741   int UNUSED written = 0;
5742   IADDR UNUSED pc = abuf->addr;
5743   SEM_BRANCH_INIT
5744   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5745
5746 if (GTUSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5747   {
5748     USI opval = FLD (i_br_disp);
5749     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5750     written |= (1 << 3);
5751     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5752   }
5753 }
5754
5755   abuf->written = written;
5756   SEM_BRANCH_FINI (vpc);
5757 #undef FLD
5758 }
5759   NEXT (vpc);
5760
5761   CASE (sem, INSN_CMPOBGE_REG) : /* cmpobge $br_src1, $br_src2, $br_disp */
5762 {
5763   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5764   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5765 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_reg.f
5766   int UNUSED written = 0;
5767   IADDR UNUSED pc = abuf->addr;
5768   SEM_BRANCH_INIT
5769   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5770
5771 if (GEUSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5772   {
5773     USI opval = FLD (i_br_disp);
5774     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5775     written |= (1 << 3);
5776     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5777   }
5778 }
5779
5780   abuf->written = written;
5781   SEM_BRANCH_FINI (vpc);
5782 #undef FLD
5783 }
5784   NEXT (vpc);
5785
5786   CASE (sem, INSN_CMPOBGE_LIT) : /* cmpobge $br_lit1, $br_src2, $br_disp */
5787 {
5788   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5789   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5790 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobl_lit.f
5791   int UNUSED written = 0;
5792   IADDR UNUSED pc = abuf->addr;
5793   SEM_BRANCH_INIT
5794   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5795
5796 if (GEUSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5797   {
5798     USI opval = FLD (i_br_disp);
5799     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5800     written |= (1 << 3);
5801     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5802   }
5803 }
5804
5805   abuf->written = written;
5806   SEM_BRANCH_FINI (vpc);
5807 #undef FLD
5808 }
5809   NEXT (vpc);
5810
5811   CASE (sem, INSN_CMPIBE_REG) : /* cmpibe $br_src1, $br_src2, $br_disp */
5812 {
5813   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5814   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5815 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
5816   int UNUSED written = 0;
5817   IADDR UNUSED pc = abuf->addr;
5818   SEM_BRANCH_INIT
5819   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5820
5821 if (EQSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5822   {
5823     USI opval = FLD (i_br_disp);
5824     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5825     written |= (1 << 3);
5826     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5827   }
5828 }
5829
5830   abuf->written = written;
5831   SEM_BRANCH_FINI (vpc);
5832 #undef FLD
5833 }
5834   NEXT (vpc);
5835
5836   CASE (sem, INSN_CMPIBE_LIT) : /* cmpibe $br_lit1, $br_src2, $br_disp */
5837 {
5838   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5839   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5840 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
5841   int UNUSED written = 0;
5842   IADDR UNUSED pc = abuf->addr;
5843   SEM_BRANCH_INIT
5844   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5845
5846 if (EQSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5847   {
5848     USI opval = FLD (i_br_disp);
5849     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5850     written |= (1 << 3);
5851     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5852   }
5853 }
5854
5855   abuf->written = written;
5856   SEM_BRANCH_FINI (vpc);
5857 #undef FLD
5858 }
5859   NEXT (vpc);
5860
5861   CASE (sem, INSN_CMPIBNE_REG) : /* cmpibne $br_src1, $br_src2, $br_disp */
5862 {
5863   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5864   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5865 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
5866   int UNUSED written = 0;
5867   IADDR UNUSED pc = abuf->addr;
5868   SEM_BRANCH_INIT
5869   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5870
5871 if (NESI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5872   {
5873     USI opval = FLD (i_br_disp);
5874     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5875     written |= (1 << 3);
5876     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5877   }
5878 }
5879
5880   abuf->written = written;
5881   SEM_BRANCH_FINI (vpc);
5882 #undef FLD
5883 }
5884   NEXT (vpc);
5885
5886   CASE (sem, INSN_CMPIBNE_LIT) : /* cmpibne $br_lit1, $br_src2, $br_disp */
5887 {
5888   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5889   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5890 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
5891   int UNUSED written = 0;
5892   IADDR UNUSED pc = abuf->addr;
5893   SEM_BRANCH_INIT
5894   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5895
5896 if (NESI (FLD (f_br_src1), * FLD (i_br_src2))) {
5897   {
5898     USI opval = FLD (i_br_disp);
5899     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5900     written |= (1 << 3);
5901     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5902   }
5903 }
5904
5905   abuf->written = written;
5906   SEM_BRANCH_FINI (vpc);
5907 #undef FLD
5908 }
5909   NEXT (vpc);
5910
5911   CASE (sem, INSN_CMPIBL_REG) : /* cmpibl $br_src1, $br_src2, $br_disp */
5912 {
5913   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5914   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5915 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
5916   int UNUSED written = 0;
5917   IADDR UNUSED pc = abuf->addr;
5918   SEM_BRANCH_INIT
5919   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5920
5921 if (LTSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5922   {
5923     USI opval = FLD (i_br_disp);
5924     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5925     written |= (1 << 3);
5926     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5927   }
5928 }
5929
5930   abuf->written = written;
5931   SEM_BRANCH_FINI (vpc);
5932 #undef FLD
5933 }
5934   NEXT (vpc);
5935
5936   CASE (sem, INSN_CMPIBL_LIT) : /* cmpibl $br_lit1, $br_src2, $br_disp */
5937 {
5938   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5939   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5940 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
5941   int UNUSED written = 0;
5942   IADDR UNUSED pc = abuf->addr;
5943   SEM_BRANCH_INIT
5944   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5945
5946 if (LTSI (FLD (f_br_src1), * FLD (i_br_src2))) {
5947   {
5948     USI opval = FLD (i_br_disp);
5949     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5950     written |= (1 << 3);
5951     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5952   }
5953 }
5954
5955   abuf->written = written;
5956   SEM_BRANCH_FINI (vpc);
5957 #undef FLD
5958 }
5959   NEXT (vpc);
5960
5961   CASE (sem, INSN_CMPIBLE_REG) : /* cmpible $br_src1, $br_src2, $br_disp */
5962 {
5963   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5964   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5965 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
5966   int UNUSED written = 0;
5967   IADDR UNUSED pc = abuf->addr;
5968   SEM_BRANCH_INIT
5969   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5970
5971 if (LESI (* FLD (i_br_src1), * FLD (i_br_src2))) {
5972   {
5973     USI opval = FLD (i_br_disp);
5974     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
5975     written |= (1 << 3);
5976     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
5977   }
5978 }
5979
5980   abuf->written = written;
5981   SEM_BRANCH_FINI (vpc);
5982 #undef FLD
5983 }
5984   NEXT (vpc);
5985
5986   CASE (sem, INSN_CMPIBLE_LIT) : /* cmpible $br_lit1, $br_src2, $br_disp */
5987 {
5988   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
5989   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
5990 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
5991   int UNUSED written = 0;
5992   IADDR UNUSED pc = abuf->addr;
5993   SEM_BRANCH_INIT
5994   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
5995
5996 if (LESI (FLD (f_br_src1), * FLD (i_br_src2))) {
5997   {
5998     USI opval = FLD (i_br_disp);
5999     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6000     written |= (1 << 3);
6001     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6002   }
6003 }
6004
6005   abuf->written = written;
6006   SEM_BRANCH_FINI (vpc);
6007 #undef FLD
6008 }
6009   NEXT (vpc);
6010
6011   CASE (sem, INSN_CMPIBG_REG) : /* cmpibg $br_src1, $br_src2, $br_disp */
6012 {
6013   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6014   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6015 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
6016   int UNUSED written = 0;
6017   IADDR UNUSED pc = abuf->addr;
6018   SEM_BRANCH_INIT
6019   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6020
6021 if (GTSI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6022   {
6023     USI opval = FLD (i_br_disp);
6024     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6025     written |= (1 << 3);
6026     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6027   }
6028 }
6029
6030   abuf->written = written;
6031   SEM_BRANCH_FINI (vpc);
6032 #undef FLD
6033 }
6034   NEXT (vpc);
6035
6036   CASE (sem, INSN_CMPIBG_LIT) : /* cmpibg $br_lit1, $br_src2, $br_disp */
6037 {
6038   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6039   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6040 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
6041   int UNUSED written = 0;
6042   IADDR UNUSED pc = abuf->addr;
6043   SEM_BRANCH_INIT
6044   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6045
6046 if (GTSI (FLD (f_br_src1), * FLD (i_br_src2))) {
6047   {
6048     USI opval = FLD (i_br_disp);
6049     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6050     written |= (1 << 3);
6051     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6052   }
6053 }
6054
6055   abuf->written = written;
6056   SEM_BRANCH_FINI (vpc);
6057 #undef FLD
6058 }
6059   NEXT (vpc);
6060
6061   CASE (sem, INSN_CMPIBGE_REG) : /* cmpibge $br_src1, $br_src2, $br_disp */
6062 {
6063   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6064   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6065 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_reg.f
6066   int UNUSED written = 0;
6067   IADDR UNUSED pc = abuf->addr;
6068   SEM_BRANCH_INIT
6069   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6070
6071 if (GESI (* FLD (i_br_src1), * FLD (i_br_src2))) {
6072   {
6073     USI opval = FLD (i_br_disp);
6074     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6075     written |= (1 << 3);
6076     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6077   }
6078 }
6079
6080   abuf->written = written;
6081   SEM_BRANCH_FINI (vpc);
6082 #undef FLD
6083 }
6084   NEXT (vpc);
6085
6086   CASE (sem, INSN_CMPIBGE_LIT) : /* cmpibge $br_lit1, $br_src2, $br_disp */
6087 {
6088   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6089   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6090 #define FLD(f) abuf->fields.cti.fields.fmt_cmpobe_lit.f
6091   int UNUSED written = 0;
6092   IADDR UNUSED pc = abuf->addr;
6093   SEM_BRANCH_INIT
6094   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6095
6096 if (GESI (FLD (f_br_src1), * FLD (i_br_src2))) {
6097   {
6098     USI opval = FLD (i_br_disp);
6099     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6100     written |= (1 << 3);
6101     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6102   }
6103 }
6104
6105   abuf->written = written;
6106   SEM_BRANCH_FINI (vpc);
6107 #undef FLD
6108 }
6109   NEXT (vpc);
6110
6111   CASE (sem, INSN_BBC_REG) : /* bbc $br_src1, $br_src2, $br_disp */
6112 {
6113   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6114   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6115 #define FLD(f) abuf->fields.cti.fields.fmt_bbc_reg.f
6116   int UNUSED written = 0;
6117   IADDR UNUSED pc = abuf->addr;
6118   SEM_BRANCH_INIT
6119   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6120
6121 if (EQSI (ANDSI (SLLSI (1, * FLD (i_br_src1)), * FLD (i_br_src2)), 0)) {
6122   {
6123     USI opval = FLD (i_br_disp);
6124     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6125     written |= (1 << 3);
6126     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6127   }
6128 }
6129
6130   abuf->written = written;
6131   SEM_BRANCH_FINI (vpc);
6132 #undef FLD
6133 }
6134   NEXT (vpc);
6135
6136   CASE (sem, INSN_BBC_LIT) : /* bbc $br_lit1, $br_src2, $br_disp */
6137 {
6138   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6139   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6140 #define FLD(f) abuf->fields.cti.fields.fmt_bbc_lit.f
6141   int UNUSED written = 0;
6142   IADDR UNUSED pc = abuf->addr;
6143   SEM_BRANCH_INIT
6144   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6145
6146 if (EQSI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
6147   {
6148     USI opval = FLD (i_br_disp);
6149     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6150     written |= (1 << 3);
6151     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6152   }
6153 }
6154
6155   abuf->written = written;
6156   SEM_BRANCH_FINI (vpc);
6157 #undef FLD
6158 }
6159   NEXT (vpc);
6160
6161   CASE (sem, INSN_BBS_REG) : /* bbs $br_src1, $br_src2, $br_disp */
6162 {
6163   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6164   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6165 #define FLD(f) abuf->fields.cti.fields.fmt_bbc_reg.f
6166   int UNUSED written = 0;
6167   IADDR UNUSED pc = abuf->addr;
6168   SEM_BRANCH_INIT
6169   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6170
6171 if (NESI (ANDSI (SLLSI (1, * FLD (i_br_src1)), * FLD (i_br_src2)), 0)) {
6172   {
6173     USI opval = FLD (i_br_disp);
6174     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6175     written |= (1 << 3);
6176     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6177   }
6178 }
6179
6180   abuf->written = written;
6181   SEM_BRANCH_FINI (vpc);
6182 #undef FLD
6183 }
6184   NEXT (vpc);
6185
6186   CASE (sem, INSN_BBS_LIT) : /* bbs $br_lit1, $br_src2, $br_disp */
6187 {
6188   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6189   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6190 #define FLD(f) abuf->fields.cti.fields.fmt_bbc_lit.f
6191   int UNUSED written = 0;
6192   IADDR UNUSED pc = abuf->addr;
6193   SEM_BRANCH_INIT
6194   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6195
6196 if (NESI (ANDSI (SLLSI (1, FLD (f_br_src1)), * FLD (i_br_src2)), 0)) {
6197   {
6198     USI opval = FLD (i_br_disp);
6199     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6200     written |= (1 << 3);
6201     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6202   }
6203 }
6204
6205   abuf->written = written;
6206   SEM_BRANCH_FINI (vpc);
6207 #undef FLD
6208 }
6209   NEXT (vpc);
6210
6211   CASE (sem, INSN_CMPI) : /* cmpi $src1, $src2 */
6212 {
6213   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6214   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6215 #define FLD(f) abuf->fields.fmt_cmpi.f
6216   int UNUSED written = 0;
6217   IADDR UNUSED pc = abuf->addr;
6218   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6219
6220   {
6221     SI opval = (LTSI (* FLD (i_src1), * FLD (i_src2))) ? (4) : (EQSI (* FLD (i_src1), * FLD (i_src2))) ? (2) : (1);
6222     CPU (h_cc) = opval;
6223     TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
6224   }
6225
6226 #undef FLD
6227 }
6228   NEXT (vpc);
6229
6230   CASE (sem, INSN_CMPI1) : /* cmpi $lit1, $src2 */
6231 {
6232   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6233   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6234 #define FLD(f) abuf->fields.fmt_cmpi1.f
6235   int UNUSED written = 0;
6236   IADDR UNUSED pc = abuf->addr;
6237   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6238
6239   {
6240     SI opval = (LTSI (FLD (f_src1), * FLD (i_src2))) ? (4) : (EQSI (FLD (f_src1), * FLD (i_src2))) ? (2) : (1);
6241     CPU (h_cc) = opval;
6242     TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
6243   }
6244
6245 #undef FLD
6246 }
6247   NEXT (vpc);
6248
6249   CASE (sem, INSN_CMPI2) : /* cmpi $src1, $lit2 */
6250 {
6251   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6252   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6253 #define FLD(f) abuf->fields.fmt_cmpi2.f
6254   int UNUSED written = 0;
6255   IADDR UNUSED pc = abuf->addr;
6256   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6257
6258   {
6259     SI opval = (LTSI (* FLD (i_src1), FLD (f_src2))) ? (4) : (EQSI (* FLD (i_src1), FLD (f_src2))) ? (2) : (1);
6260     CPU (h_cc) = opval;
6261     TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
6262   }
6263
6264 #undef FLD
6265 }
6266   NEXT (vpc);
6267
6268   CASE (sem, INSN_CMPI3) : /* cmpi $lit1, $lit2 */
6269 {
6270   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6271   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6272 #define FLD(f) abuf->fields.fmt_cmpi3.f
6273   int UNUSED written = 0;
6274   IADDR UNUSED pc = abuf->addr;
6275   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6276
6277   {
6278     SI opval = (LTSI (FLD (f_src1), FLD (f_src2))) ? (4) : (EQSI (FLD (f_src1), FLD (f_src2))) ? (2) : (1);
6279     CPU (h_cc) = opval;
6280     TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
6281   }
6282
6283 #undef FLD
6284 }
6285   NEXT (vpc);
6286
6287   CASE (sem, INSN_CMPO) : /* cmpo $src1, $src2 */
6288 {
6289   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6290   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6291 #define FLD(f) abuf->fields.fmt_cmpo.f
6292   int UNUSED written = 0;
6293   IADDR UNUSED pc = abuf->addr;
6294   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6295
6296   {
6297     SI opval = (LTUSI (* FLD (i_src1), * FLD (i_src2))) ? (4) : (EQSI (* FLD (i_src1), * FLD (i_src2))) ? (2) : (1);
6298     CPU (h_cc) = opval;
6299     TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
6300   }
6301
6302 #undef FLD
6303 }
6304   NEXT (vpc);
6305
6306   CASE (sem, INSN_CMPO1) : /* cmpo $lit1, $src2 */
6307 {
6308   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6309   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6310 #define FLD(f) abuf->fields.fmt_cmpo1.f
6311   int UNUSED written = 0;
6312   IADDR UNUSED pc = abuf->addr;
6313   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6314
6315   {
6316     SI opval = (LTUSI (FLD (f_src1), * FLD (i_src2))) ? (4) : (EQSI (FLD (f_src1), * FLD (i_src2))) ? (2) : (1);
6317     CPU (h_cc) = opval;
6318     TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
6319   }
6320
6321 #undef FLD
6322 }
6323   NEXT (vpc);
6324
6325   CASE (sem, INSN_CMPO2) : /* cmpo $src1, $lit2 */
6326 {
6327   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6328   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6329 #define FLD(f) abuf->fields.fmt_cmpo2.f
6330   int UNUSED written = 0;
6331   IADDR UNUSED pc = abuf->addr;
6332   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6333
6334   {
6335     SI opval = (LTUSI (* FLD (i_src1), FLD (f_src2))) ? (4) : (EQSI (* FLD (i_src1), FLD (f_src2))) ? (2) : (1);
6336     CPU (h_cc) = opval;
6337     TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
6338   }
6339
6340 #undef FLD
6341 }
6342   NEXT (vpc);
6343
6344   CASE (sem, INSN_CMPO3) : /* cmpo $lit1, $lit2 */
6345 {
6346   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6347   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6348 #define FLD(f) abuf->fields.fmt_cmpo3.f
6349   int UNUSED written = 0;
6350   IADDR UNUSED pc = abuf->addr;
6351   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6352
6353   {
6354     SI opval = (LTUSI (FLD (f_src1), FLD (f_src2))) ? (4) : (EQSI (FLD (f_src1), FLD (f_src2))) ? (2) : (1);
6355     CPU (h_cc) = opval;
6356     TRACE_RESULT (current_cpu, abuf, "cc-0", 'x', opval);
6357   }
6358
6359 #undef FLD
6360 }
6361   NEXT (vpc);
6362
6363   CASE (sem, INSN_TESTNO_REG) : /* testno $br_src1 */
6364 {
6365   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6366   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6367 #define FLD(f) abuf->fields.fmt_testno_reg.f
6368   int UNUSED written = 0;
6369   IADDR UNUSED pc = abuf->addr;
6370   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6371
6372   {
6373     SI opval = EQSI (CPU (h_cc), 0);
6374     * FLD (i_br_src1) = opval;
6375     TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6376   }
6377
6378 #undef FLD
6379 }
6380   NEXT (vpc);
6381
6382   CASE (sem, INSN_TESTG_REG) : /* testg $br_src1 */
6383 {
6384   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6385   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6386 #define FLD(f) abuf->fields.fmt_testno_reg.f
6387   int UNUSED written = 0;
6388   IADDR UNUSED pc = abuf->addr;
6389   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6390
6391   {
6392     SI opval = NESI (ANDSI (CPU (h_cc), 1), 0);
6393     * FLD (i_br_src1) = opval;
6394     TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6395   }
6396
6397 #undef FLD
6398 }
6399   NEXT (vpc);
6400
6401   CASE (sem, INSN_TESTE_REG) : /* teste $br_src1 */
6402 {
6403   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6404   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6405 #define FLD(f) abuf->fields.fmt_testno_reg.f
6406   int UNUSED written = 0;
6407   IADDR UNUSED pc = abuf->addr;
6408   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6409
6410   {
6411     SI opval = NESI (ANDSI (CPU (h_cc), 2), 0);
6412     * FLD (i_br_src1) = opval;
6413     TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6414   }
6415
6416 #undef FLD
6417 }
6418   NEXT (vpc);
6419
6420   CASE (sem, INSN_TESTGE_REG) : /* testge $br_src1 */
6421 {
6422   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6423   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6424 #define FLD(f) abuf->fields.fmt_testno_reg.f
6425   int UNUSED written = 0;
6426   IADDR UNUSED pc = abuf->addr;
6427   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6428
6429   {
6430     SI opval = NESI (ANDSI (CPU (h_cc), 3), 0);
6431     * FLD (i_br_src1) = opval;
6432     TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6433   }
6434
6435 #undef FLD
6436 }
6437   NEXT (vpc);
6438
6439   CASE (sem, INSN_TESTL_REG) : /* testl $br_src1 */
6440 {
6441   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6442   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6443 #define FLD(f) abuf->fields.fmt_testno_reg.f
6444   int UNUSED written = 0;
6445   IADDR UNUSED pc = abuf->addr;
6446   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6447
6448   {
6449     SI opval = NESI (ANDSI (CPU (h_cc), 4), 0);
6450     * FLD (i_br_src1) = opval;
6451     TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6452   }
6453
6454 #undef FLD
6455 }
6456   NEXT (vpc);
6457
6458   CASE (sem, INSN_TESTNE_REG) : /* testne $br_src1 */
6459 {
6460   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6461   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6462 #define FLD(f) abuf->fields.fmt_testno_reg.f
6463   int UNUSED written = 0;
6464   IADDR UNUSED pc = abuf->addr;
6465   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6466
6467   {
6468     SI opval = NESI (ANDSI (CPU (h_cc), 5), 0);
6469     * FLD (i_br_src1) = opval;
6470     TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6471   }
6472
6473 #undef FLD
6474 }
6475   NEXT (vpc);
6476
6477   CASE (sem, INSN_TESTLE_REG) : /* testle $br_src1 */
6478 {
6479   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6480   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6481 #define FLD(f) abuf->fields.fmt_testno_reg.f
6482   int UNUSED written = 0;
6483   IADDR UNUSED pc = abuf->addr;
6484   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6485
6486   {
6487     SI opval = NESI (ANDSI (CPU (h_cc), 6), 0);
6488     * FLD (i_br_src1) = opval;
6489     TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6490   }
6491
6492 #undef FLD
6493 }
6494   NEXT (vpc);
6495
6496   CASE (sem, INSN_TESTO_REG) : /* testo $br_src1 */
6497 {
6498   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6499   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6500 #define FLD(f) abuf->fields.fmt_testno_reg.f
6501   int UNUSED written = 0;
6502   IADDR UNUSED pc = abuf->addr;
6503   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6504
6505   {
6506     SI opval = NESI (ANDSI (CPU (h_cc), 7), 0);
6507     * FLD (i_br_src1) = opval;
6508     TRACE_RESULT (current_cpu, abuf, "br_src1", 'x', opval);
6509   }
6510
6511 #undef FLD
6512 }
6513   NEXT (vpc);
6514
6515   CASE (sem, INSN_BNO) : /* bno $ctrl_disp */
6516 {
6517   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6518   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6519 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
6520   int UNUSED written = 0;
6521   IADDR UNUSED pc = abuf->addr;
6522   SEM_BRANCH_INIT
6523   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6524
6525 if (EQSI (CPU (h_cc), 0)) {
6526   {
6527     USI opval = FLD (i_ctrl_disp);
6528     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6529     written |= (1 << 2);
6530     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6531   }
6532 }
6533
6534   abuf->written = written;
6535   SEM_BRANCH_FINI (vpc);
6536 #undef FLD
6537 }
6538   NEXT (vpc);
6539
6540   CASE (sem, INSN_BG) : /* bg $ctrl_disp */
6541 {
6542   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6543   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6544 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
6545   int UNUSED written = 0;
6546   IADDR UNUSED pc = abuf->addr;
6547   SEM_BRANCH_INIT
6548   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6549
6550 if (NESI (ANDSI (CPU (h_cc), 1), 0)) {
6551   {
6552     USI opval = FLD (i_ctrl_disp);
6553     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6554     written |= (1 << 2);
6555     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6556   }
6557 }
6558
6559   abuf->written = written;
6560   SEM_BRANCH_FINI (vpc);
6561 #undef FLD
6562 }
6563   NEXT (vpc);
6564
6565   CASE (sem, INSN_BE) : /* be $ctrl_disp */
6566 {
6567   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6568   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6569 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
6570   int UNUSED written = 0;
6571   IADDR UNUSED pc = abuf->addr;
6572   SEM_BRANCH_INIT
6573   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6574
6575 if (NESI (ANDSI (CPU (h_cc), 2), 0)) {
6576   {
6577     USI opval = FLD (i_ctrl_disp);
6578     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6579     written |= (1 << 2);
6580     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6581   }
6582 }
6583
6584   abuf->written = written;
6585   SEM_BRANCH_FINI (vpc);
6586 #undef FLD
6587 }
6588   NEXT (vpc);
6589
6590   CASE (sem, INSN_BGE) : /* bge $ctrl_disp */
6591 {
6592   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6593   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6594 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
6595   int UNUSED written = 0;
6596   IADDR UNUSED pc = abuf->addr;
6597   SEM_BRANCH_INIT
6598   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6599
6600 if (NESI (ANDSI (CPU (h_cc), 3), 0)) {
6601   {
6602     USI opval = FLD (i_ctrl_disp);
6603     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6604     written |= (1 << 2);
6605     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6606   }
6607 }
6608
6609   abuf->written = written;
6610   SEM_BRANCH_FINI (vpc);
6611 #undef FLD
6612 }
6613   NEXT (vpc);
6614
6615   CASE (sem, INSN_BL) : /* bl $ctrl_disp */
6616 {
6617   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6618   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6619 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
6620   int UNUSED written = 0;
6621   IADDR UNUSED pc = abuf->addr;
6622   SEM_BRANCH_INIT
6623   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6624
6625 if (NESI (ANDSI (CPU (h_cc), 4), 0)) {
6626   {
6627     USI opval = FLD (i_ctrl_disp);
6628     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6629     written |= (1 << 2);
6630     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6631   }
6632 }
6633
6634   abuf->written = written;
6635   SEM_BRANCH_FINI (vpc);
6636 #undef FLD
6637 }
6638   NEXT (vpc);
6639
6640   CASE (sem, INSN_BNE) : /* bne $ctrl_disp */
6641 {
6642   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6643   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6644 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
6645   int UNUSED written = 0;
6646   IADDR UNUSED pc = abuf->addr;
6647   SEM_BRANCH_INIT
6648   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6649
6650 if (NESI (ANDSI (CPU (h_cc), 5), 0)) {
6651   {
6652     USI opval = FLD (i_ctrl_disp);
6653     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6654     written |= (1 << 2);
6655     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6656   }
6657 }
6658
6659   abuf->written = written;
6660   SEM_BRANCH_FINI (vpc);
6661 #undef FLD
6662 }
6663   NEXT (vpc);
6664
6665   CASE (sem, INSN_BLE) : /* ble $ctrl_disp */
6666 {
6667   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6668   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6669 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
6670   int UNUSED written = 0;
6671   IADDR UNUSED pc = abuf->addr;
6672   SEM_BRANCH_INIT
6673   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6674
6675 if (NESI (ANDSI (CPU (h_cc), 6), 0)) {
6676   {
6677     USI opval = FLD (i_ctrl_disp);
6678     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6679     written |= (1 << 2);
6680     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6681   }
6682 }
6683
6684   abuf->written = written;
6685   SEM_BRANCH_FINI (vpc);
6686 #undef FLD
6687 }
6688   NEXT (vpc);
6689
6690   CASE (sem, INSN_BO) : /* bo $ctrl_disp */
6691 {
6692   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6693   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6694 #define FLD(f) abuf->fields.cti.fields.fmt_bno.f
6695   int UNUSED written = 0;
6696   IADDR UNUSED pc = abuf->addr;
6697   SEM_BRANCH_INIT
6698   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6699
6700 if (NESI (ANDSI (CPU (h_cc), 7), 0)) {
6701   {
6702     USI opval = FLD (i_ctrl_disp);
6703     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6704     written |= (1 << 2);
6705     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6706   }
6707 }
6708
6709   abuf->written = written;
6710   SEM_BRANCH_FINI (vpc);
6711 #undef FLD
6712 }
6713   NEXT (vpc);
6714
6715   CASE (sem, INSN_B) : /* b $ctrl_disp */
6716 {
6717   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6718   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6719 #define FLD(f) abuf->fields.cti.fields.fmt_b.f
6720   int UNUSED written = 0;
6721   IADDR UNUSED pc = abuf->addr;
6722   SEM_BRANCH_INIT
6723   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6724
6725   {
6726     USI opval = FLD (i_ctrl_disp);
6727     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6728     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6729   }
6730
6731   SEM_BRANCH_FINI (vpc);
6732 #undef FLD
6733 }
6734   NEXT (vpc);
6735
6736   CASE (sem, INSN_BX_INDIRECT_OFFSET) : /* bx $offset($abase) */
6737 {
6738   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6739   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6740 #define FLD(f) abuf->fields.cti.fields.fmt_bx_indirect_offset.f
6741   int UNUSED written = 0;
6742   IADDR UNUSED pc = abuf->addr;
6743   SEM_BRANCH_INIT
6744   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6745
6746   {
6747     USI opval = ADDSI (FLD (f_offset), * FLD (i_abase));
6748     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
6749     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6750   }
6751
6752   SEM_BRANCH_FINI (vpc);
6753 #undef FLD
6754 }
6755   NEXT (vpc);
6756
6757   CASE (sem, INSN_BX_INDIRECT) : /* bx ($abase) */
6758 {
6759   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6760   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6761 #define FLD(f) abuf->fields.cti.fields.fmt_bx_indirect.f
6762   int UNUSED written = 0;
6763   IADDR UNUSED pc = abuf->addr;
6764   SEM_BRANCH_INIT
6765   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6766
6767   {
6768     USI opval = * FLD (i_abase);
6769     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
6770     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6771   }
6772
6773   SEM_BRANCH_FINI (vpc);
6774 #undef FLD
6775 }
6776   NEXT (vpc);
6777
6778   CASE (sem, INSN_BX_INDIRECT_INDEX) : /* bx ($abase)[$index*S$scale] */
6779 {
6780   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6781   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6782 #define FLD(f) abuf->fields.cti.fields.fmt_bx_indirect_index.f
6783   int UNUSED written = 0;
6784   IADDR UNUSED pc = abuf->addr;
6785   SEM_BRANCH_INIT
6786   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6787
6788   {
6789     USI opval = ADDSI (* FLD (i_abase), MULSI (* FLD (i_index), SLLSI (1, FLD (f_scale))));
6790     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
6791     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6792   }
6793
6794   SEM_BRANCH_FINI (vpc);
6795 #undef FLD
6796 }
6797   NEXT (vpc);
6798
6799   CASE (sem, INSN_BX_DISP) : /* bx $optdisp */
6800 {
6801   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6802   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6803 #define FLD(f) abuf->fields.cti.fields.fmt_bx_disp.f
6804   int UNUSED written = 0;
6805   IADDR UNUSED pc = abuf->addr;
6806   SEM_BRANCH_INIT
6807   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
6808
6809   {
6810     USI opval = FLD (f_optdisp);
6811     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6812     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6813   }
6814
6815   SEM_BRANCH_FINI (vpc);
6816 #undef FLD
6817 }
6818   NEXT (vpc);
6819
6820   CASE (sem, INSN_BX_INDIRECT_DISP) : /* bx $optdisp($abase) */
6821 {
6822   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6823   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6824 #define FLD(f) abuf->fields.cti.fields.fmt_bx_indirect_disp.f
6825   int UNUSED written = 0;
6826   IADDR UNUSED pc = abuf->addr;
6827   SEM_BRANCH_INIT
6828   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
6829
6830   {
6831     USI opval = ADDSI (FLD (f_optdisp), * FLD (i_abase));
6832     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
6833     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6834   }
6835
6836   SEM_BRANCH_FINI (vpc);
6837 #undef FLD
6838 }
6839   NEXT (vpc);
6840
6841   CASE (sem, INSN_CALLX_DISP) : /* callx $optdisp */
6842 {
6843   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6844   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6845 #define FLD(f) abuf->fields.cti.fields.fmt_callx_disp.f
6846   int UNUSED written = 0;
6847   IADDR UNUSED pc = abuf->addr;
6848   SEM_BRANCH_INIT
6849   vpc = SEM_NEXT_VPC (sem_arg, pc, 8);
6850
6851 do {
6852   SI tmp_temp;
6853   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
6854   {
6855     SI opval = ADDSI (pc, 8);
6856     CPU (h_gr[((UINT) 2)]) = opval;
6857     TRACE_RESULT (current_cpu, abuf, "gr-2", 'x', opval);
6858   }
6859 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 0), CPU (h_gr[((UINT) 0)]));
6860 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 4), CPU (h_gr[((UINT) 1)]));
6861 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 8), CPU (h_gr[((UINT) 2)]));
6862 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 12), CPU (h_gr[((UINT) 3)]));
6863 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 16), CPU (h_gr[((UINT) 4)]));
6864 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 20), CPU (h_gr[((UINT) 5)]));
6865 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 24), CPU (h_gr[((UINT) 6)]));
6866 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 28), CPU (h_gr[((UINT) 7)]));
6867 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 32), CPU (h_gr[((UINT) 8)]));
6868 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 36), CPU (h_gr[((UINT) 9)]));
6869 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 40), CPU (h_gr[((UINT) 10)]));
6870 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 44), CPU (h_gr[((UINT) 11)]));
6871 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 48), CPU (h_gr[((UINT) 12)]));
6872 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 52), CPU (h_gr[((UINT) 13)]));
6873 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 56), CPU (h_gr[((UINT) 14)]));
6874 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 60), CPU (h_gr[((UINT) 15)]));
6875   {
6876     USI opval = FLD (f_optdisp);
6877     SEM_BRANCH_VIA_CACHE (current_cpu, sem_arg, opval, vpc, SEM_BRANCH_ADDR_CACHE (sem_arg));
6878     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6879   }
6880 CPU (h_gr[((UINT) 0)]) = 0xdeadbeef;
6881 CPU (h_gr[((UINT) 1)]) = 0xdeadbeef;
6882 CPU (h_gr[((UINT) 2)]) = 0xdeadbeef;
6883 CPU (h_gr[((UINT) 3)]) = 0xdeadbeef;
6884 CPU (h_gr[((UINT) 4)]) = 0xdeadbeef;
6885 CPU (h_gr[((UINT) 5)]) = 0xdeadbeef;
6886 CPU (h_gr[((UINT) 6)]) = 0xdeadbeef;
6887 CPU (h_gr[((UINT) 7)]) = 0xdeadbeef;
6888 CPU (h_gr[((UINT) 8)]) = 0xdeadbeef;
6889 CPU (h_gr[((UINT) 9)]) = 0xdeadbeef;
6890 CPU (h_gr[((UINT) 10)]) = 0xdeadbeef;
6891 CPU (h_gr[((UINT) 11)]) = 0xdeadbeef;
6892 CPU (h_gr[((UINT) 12)]) = 0xdeadbeef;
6893 CPU (h_gr[((UINT) 13)]) = 0xdeadbeef;
6894 CPU (h_gr[((UINT) 14)]) = 0xdeadbeef;
6895 CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
6896   {
6897     SI opval = CPU (h_gr[((UINT) 31)]);
6898     CPU (h_gr[((UINT) 0)]) = opval;
6899     TRACE_RESULT (current_cpu, abuf, "gr-0", 'x', opval);
6900   }
6901   {
6902     SI opval = tmp_temp;
6903     CPU (h_gr[((UINT) 31)]) = opval;
6904     TRACE_RESULT (current_cpu, abuf, "gr-31", 'x', opval);
6905   }
6906   {
6907     SI opval = ADDSI (tmp_temp, 64);
6908     CPU (h_gr[((UINT) 1)]) = opval;
6909     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
6910   }
6911 } while (0);
6912
6913   SEM_BRANCH_FINI (vpc);
6914 #undef FLD
6915 }
6916   NEXT (vpc);
6917
6918   CASE (sem, INSN_CALLX_INDIRECT) : /* callx ($abase) */
6919 {
6920   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6921   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6922 #define FLD(f) abuf->fields.cti.fields.fmt_callx_indirect.f
6923   int UNUSED written = 0;
6924   IADDR UNUSED pc = abuf->addr;
6925   SEM_BRANCH_INIT
6926   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
6927
6928 do {
6929   SI tmp_temp;
6930   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
6931   {
6932     SI opval = ADDSI (pc, 4);
6933     CPU (h_gr[((UINT) 2)]) = opval;
6934     TRACE_RESULT (current_cpu, abuf, "gr-2", 'x', opval);
6935   }
6936 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 0), CPU (h_gr[((UINT) 0)]));
6937 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 4), CPU (h_gr[((UINT) 1)]));
6938 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 8), CPU (h_gr[((UINT) 2)]));
6939 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 12), CPU (h_gr[((UINT) 3)]));
6940 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 16), CPU (h_gr[((UINT) 4)]));
6941 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 20), CPU (h_gr[((UINT) 5)]));
6942 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 24), CPU (h_gr[((UINT) 6)]));
6943 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 28), CPU (h_gr[((UINT) 7)]));
6944 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 32), CPU (h_gr[((UINT) 8)]));
6945 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 36), CPU (h_gr[((UINT) 9)]));
6946 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 40), CPU (h_gr[((UINT) 10)]));
6947 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 44), CPU (h_gr[((UINT) 11)]));
6948 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 48), CPU (h_gr[((UINT) 12)]));
6949 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 52), CPU (h_gr[((UINT) 13)]));
6950 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 56), CPU (h_gr[((UINT) 14)]));
6951 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 60), CPU (h_gr[((UINT) 15)]));
6952   {
6953     USI opval = * FLD (i_abase);
6954     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
6955     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
6956   }
6957 CPU (h_gr[((UINT) 0)]) = 0xdeadbeef;
6958 CPU (h_gr[((UINT) 1)]) = 0xdeadbeef;
6959 CPU (h_gr[((UINT) 2)]) = 0xdeadbeef;
6960 CPU (h_gr[((UINT) 3)]) = 0xdeadbeef;
6961 CPU (h_gr[((UINT) 4)]) = 0xdeadbeef;
6962 CPU (h_gr[((UINT) 5)]) = 0xdeadbeef;
6963 CPU (h_gr[((UINT) 6)]) = 0xdeadbeef;
6964 CPU (h_gr[((UINT) 7)]) = 0xdeadbeef;
6965 CPU (h_gr[((UINT) 8)]) = 0xdeadbeef;
6966 CPU (h_gr[((UINT) 9)]) = 0xdeadbeef;
6967 CPU (h_gr[((UINT) 10)]) = 0xdeadbeef;
6968 CPU (h_gr[((UINT) 11)]) = 0xdeadbeef;
6969 CPU (h_gr[((UINT) 12)]) = 0xdeadbeef;
6970 CPU (h_gr[((UINT) 13)]) = 0xdeadbeef;
6971 CPU (h_gr[((UINT) 14)]) = 0xdeadbeef;
6972 CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
6973   {
6974     SI opval = CPU (h_gr[((UINT) 31)]);
6975     CPU (h_gr[((UINT) 0)]) = opval;
6976     TRACE_RESULT (current_cpu, abuf, "gr-0", 'x', opval);
6977   }
6978   {
6979     SI opval = tmp_temp;
6980     CPU (h_gr[((UINT) 31)]) = opval;
6981     TRACE_RESULT (current_cpu, abuf, "gr-31", 'x', opval);
6982   }
6983   {
6984     SI opval = ADDSI (tmp_temp, 64);
6985     CPU (h_gr[((UINT) 1)]) = opval;
6986     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
6987   }
6988 } while (0);
6989
6990   SEM_BRANCH_FINI (vpc);
6991 #undef FLD
6992 }
6993   NEXT (vpc);
6994
6995   CASE (sem, INSN_CALLX_INDIRECT_OFFSET) : /* callx $offset($abase) */
6996 {
6997   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
6998   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
6999 #define FLD(f) abuf->fields.cti.fields.fmt_callx_indirect_offset.f
7000   int UNUSED written = 0;
7001   IADDR UNUSED pc = abuf->addr;
7002   SEM_BRANCH_INIT
7003   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7004
7005 do {
7006   SI tmp_temp;
7007   tmp_temp = ANDSI (ADDSI (CPU (h_gr[((UINT) 1)]), 63), INVSI (63));
7008   {
7009     SI opval = ADDSI (pc, 4);
7010     CPU (h_gr[((UINT) 2)]) = opval;
7011     TRACE_RESULT (current_cpu, abuf, "gr-2", 'x', opval);
7012   }
7013 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 0), CPU (h_gr[((UINT) 0)]));
7014 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 4), CPU (h_gr[((UINT) 1)]));
7015 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 8), CPU (h_gr[((UINT) 2)]));
7016 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 12), CPU (h_gr[((UINT) 3)]));
7017 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 16), CPU (h_gr[((UINT) 4)]));
7018 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 20), CPU (h_gr[((UINT) 5)]));
7019 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 24), CPU (h_gr[((UINT) 6)]));
7020 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 28), CPU (h_gr[((UINT) 7)]));
7021 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 32), CPU (h_gr[((UINT) 8)]));
7022 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 36), CPU (h_gr[((UINT) 9)]));
7023 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 40), CPU (h_gr[((UINT) 10)]));
7024 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 44), CPU (h_gr[((UINT) 11)]));
7025 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 48), CPU (h_gr[((UINT) 12)]));
7026 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 52), CPU (h_gr[((UINT) 13)]));
7027 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 56), CPU (h_gr[((UINT) 14)]));
7028 SETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 60), CPU (h_gr[((UINT) 15)]));
7029   {
7030     USI opval = ADDSI (FLD (f_offset), * FLD (i_abase));
7031     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7032     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7033   }
7034 CPU (h_gr[((UINT) 0)]) = 0xdeadbeef;
7035 CPU (h_gr[((UINT) 1)]) = 0xdeadbeef;
7036 CPU (h_gr[((UINT) 2)]) = 0xdeadbeef;
7037 CPU (h_gr[((UINT) 3)]) = 0xdeadbeef;
7038 CPU (h_gr[((UINT) 4)]) = 0xdeadbeef;
7039 CPU (h_gr[((UINT) 5)]) = 0xdeadbeef;
7040 CPU (h_gr[((UINT) 6)]) = 0xdeadbeef;
7041 CPU (h_gr[((UINT) 7)]) = 0xdeadbeef;
7042 CPU (h_gr[((UINT) 8)]) = 0xdeadbeef;
7043 CPU (h_gr[((UINT) 9)]) = 0xdeadbeef;
7044 CPU (h_gr[((UINT) 10)]) = 0xdeadbeef;
7045 CPU (h_gr[((UINT) 11)]) = 0xdeadbeef;
7046 CPU (h_gr[((UINT) 12)]) = 0xdeadbeef;
7047 CPU (h_gr[((UINT) 13)]) = 0xdeadbeef;
7048 CPU (h_gr[((UINT) 14)]) = 0xdeadbeef;
7049 CPU (h_gr[((UINT) 15)]) = 0xdeadbeef;
7050   {
7051     SI opval = CPU (h_gr[((UINT) 31)]);
7052     CPU (h_gr[((UINT) 0)]) = opval;
7053     TRACE_RESULT (current_cpu, abuf, "gr-0", 'x', opval);
7054   }
7055   {
7056     SI opval = tmp_temp;
7057     CPU (h_gr[((UINT) 31)]) = opval;
7058     TRACE_RESULT (current_cpu, abuf, "gr-31", 'x', opval);
7059   }
7060   {
7061     SI opval = ADDSI (tmp_temp, 64);
7062     CPU (h_gr[((UINT) 1)]) = opval;
7063     TRACE_RESULT (current_cpu, abuf, "gr-1", 'x', opval);
7064   }
7065 } while (0);
7066
7067   SEM_BRANCH_FINI (vpc);
7068 #undef FLD
7069 }
7070   NEXT (vpc);
7071
7072   CASE (sem, INSN_RET) : /* ret */
7073 {
7074   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
7075   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7076 #define FLD(f) abuf->fields.cti.fields.fmt_ret.f
7077   int UNUSED written = 0;
7078   IADDR UNUSED pc = abuf->addr;
7079   SEM_BRANCH_INIT
7080   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7081
7082 do {
7083   {
7084     SI opval = CPU (h_gr[((UINT) 0)]);
7085     CPU (h_gr[((UINT) 31)]) = opval;
7086     TRACE_RESULT (current_cpu, abuf, "gr-31", 'x', opval);
7087   }
7088 CPU (h_gr[((UINT) 0)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 0));
7089 CPU (h_gr[((UINT) 1)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 4));
7090 CPU (h_gr[((UINT) 2)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 8));
7091 CPU (h_gr[((UINT) 3)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 12));
7092 CPU (h_gr[((UINT) 4)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 16));
7093 CPU (h_gr[((UINT) 5)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 20));
7094 CPU (h_gr[((UINT) 6)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 24));
7095 CPU (h_gr[((UINT) 7)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 28));
7096 CPU (h_gr[((UINT) 8)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 32));
7097 CPU (h_gr[((UINT) 9)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 36));
7098 CPU (h_gr[((UINT) 10)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 40));
7099 CPU (h_gr[((UINT) 11)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 44));
7100 CPU (h_gr[((UINT) 12)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 48));
7101 CPU (h_gr[((UINT) 13)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 52));
7102 CPU (h_gr[((UINT) 14)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 56));
7103 CPU (h_gr[((UINT) 15)]) = GETMEMSI (current_cpu, pc, ADDSI (CPU (h_gr[((UINT) 31)]), 60));
7104   {
7105     USI opval = CPU (h_gr[((UINT) 2)]);
7106     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7107     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7108   }
7109 } while (0);
7110
7111   SEM_BRANCH_FINI (vpc);
7112 #undef FLD
7113 }
7114   NEXT (vpc);
7115
7116   CASE (sem, INSN_CALLS) : /* calls $src1 */
7117 {
7118   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
7119   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7120 #define FLD(f) abuf->fields.cti.fields.fmt_calls.f
7121   int UNUSED written = 0;
7122   IADDR UNUSED pc = abuf->addr;
7123   SEM_BRANCH_INIT
7124   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7125
7126   {
7127     SI opval = i960_trap (current_cpu, pc, * FLD (i_src1));
7128     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7129     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7130   }
7131
7132   SEM_BRANCH_FINI (vpc);
7133 #undef FLD
7134 }
7135   NEXT (vpc);
7136
7137   CASE (sem, INSN_FMARK) : /* fmark */
7138 {
7139   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
7140   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7141 #define FLD(f) abuf->fields.cti.fields.fmt_fmark.f
7142   int UNUSED written = 0;
7143   IADDR UNUSED pc = abuf->addr;
7144   SEM_BRANCH_INIT
7145   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7146
7147   {
7148     SI opval = i960_breakpoint (current_cpu, pc);
7149     SEM_BRANCH_VIA_ADDR (current_cpu, sem_arg, opval, vpc);
7150     TRACE_RESULT (current_cpu, abuf, "pc", 'x', opval);
7151   }
7152
7153   SEM_BRANCH_FINI (vpc);
7154 #undef FLD
7155 }
7156   NEXT (vpc);
7157
7158   CASE (sem, INSN_FLUSHREG) : /* flushreg */
7159 {
7160   SEM_ARG sem_arg = SEM_SEM_ARG (vpc, sc);
7161   ARGBUF *abuf = SEM_ARGBUF (sem_arg);
7162 #define FLD(f) abuf->fields.fmt_flushreg.f
7163   int UNUSED written = 0;
7164   IADDR UNUSED pc = abuf->addr;
7165   vpc = SEM_NEXT_VPC (sem_arg, pc, 4);
7166
7167 do { } while (0); /*nop*/
7168
7169 #undef FLD
7170 }
7171   NEXT (vpc);
7172
7173
7174     }
7175   ENDSWITCH (sem) /* End of semantic switch.  */
7176
7177   /* At this point `vpc' contains the next insn to execute.  */
7178 }
7179
7180 #undef DEFINE_SWITCH
7181 #endif /* DEFINE_SWITCH */