sid/component/cgen-cpu/arm7t/arm-semsw.cxx

   1 /* Simulator instruction semantics for arm.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright (C) 2000-2009 Red Hat, Inc.
   6
   7 This file is part of the Red Hat simulators.
   8
   9
  10 */
  11
  12
  13 #include "arm7f.h"
  14
  15 using namespace arm7f; // FIXME: namespace organization still wip
  16
  17 #define GET_ATTR(name) GET_ATTR_##name ()
  18
  19
  20 namespace arm7f {
  21
  22 /* Enum declaration for semantic fragments in cpu family arm.  */
  23 typedef enum arm_frag_type {
  24   ARM_FRAG_LIST_END, ARM_FRAG_MVN_REG_REG_SHIFT_HDR, ARM_FRAG_CMP_REG_REG_SHIFT_HDR, ARM_FRAG_TST_REG_REG_SHIFT_HDR
  25  , ARM_FRAG_ORR_REG_REG_SHIFT_HDR, ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, ARM_FRAG_CMP_REG_IMM_SHIFT_HDR, ARM_FRAG_TST_REG_IMM_SHIFT_HDR
  26  , ARM_FRAG_ORR_REG_IMM_SHIFT_HDR, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR
  27  , ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, ARM_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STMDA_WB_HDR, ARM_FRAG_STMIA_WB_HDR
  28  , ARM_FRAG_STMIB_WB_HDR, ARM_FRAG_STMDB_WB_HDR, ARM_FRAG_LDMIA_WB_HDR, ARM_FRAG_LDMIB_WB_HDR
  29  , ARM_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_X_HEADER
  30  , ARM_FRAG_TST_REG_REG_SHIFT_TRLR, ARM_FRAG_TEQ_REG_IMM_SHIFT_TRLR, ARM_FRAG_AND_IMM_TRLR, ARM_FRAG_AND_REG_REG_SHIFT_TRLR
  31  , ARM_FRAG_ORR_REG_IMM_SHIFT_TRLR, ARM_FRAG_UMULL_TRLR, ARM_FRAG_LDR_PRE_INC_IMM_OFFSET_TRLR, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR
  32  , ARM_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_STRH_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR
  33  , ARM_FRAG_LDR_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LDR_PRE_INC_REG_OFFSET_TRLR, ARM_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR
  34  , ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR
  35  , ARM_FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LDR_PRE_INC_WB_REG_OFFSET_TRLR, ARM_FRAG_STRB_POST_INC_REG_OFFSET_TRLR, ARM_FRAG_STR_POST_INC_REG_OFFSET_TRLR
  36  , ARM_FRAG_STR_POST_INC_IMM_OFFSET_TRLR, ARM_FRAG_LDRB_POST_INC_REG_OFFSET_TRLR, ARM_FRAG_STRB_POST_DEC_REG_OFFSET_TRLR, ARM_FRAG_STR_POST_DEC_REG_OFFSET_TRLR
  37  , ARM_FRAG_STR_POST_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LDRB_POST_DEC_REG_OFFSET_TRLR, ARM_FRAG_X_TRAILER, ARM_FRAG_X_COND_MID
  38  , ARM_FRAG_X_AFTER_MID, ARM_FRAG_X_BEFORE_MID, ARM_FRAG_X_CTI_CHAIN_MID, ARM_FRAG_X_CHAIN_MID
  39  , ARM_FRAG_X_BEGIN_MID, ARM_FRAG_X_INVALID_MID, ARM_FRAG_B_MID, ARM_FRAG_BL_MID
  40  , ARM_FRAG_BX_MID, ARM_FRAG_LDR_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LDR_POST_DEC_REG_OFFSET_MID, ARM_FRAG_LDR_POST_INC_IMM_OFFSET_MID
  41  , ARM_FRAG_LDR_POST_INC_REG_OFFSET_MID, ARM_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_MID, ARM_FRAG_LDR_POST_INC_NONPRIV_IMM_OFFSET_MID
  42  , ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_MID, ARM_FRAG_LDR_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_IMM_OFFSET_MID
  43  , ARM_FRAG_LDR_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_MID
  44  , ARM_FRAG_LDR_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRB_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_MID
  45  , ARM_FRAG_LDRB_POST_INC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_INC_IMM_OFFSET_MID
  46  , ARM_FRAG_LDRB_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_INC_WB_IMM_OFFSET_MID
  47  , ARM_FRAG_LDRB_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_STR_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_STR_POST_INC_IMM_OFFSET_MID, ARM_FRAG_STR_POST_DEC_NONPRIV_IMM_OFFSET_MID
  48  , ARM_FRAG_STR_POST_INC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_STR_PRE_INC_IMM_OFFSET_MID
  49  , ARM_FRAG_STR_PRE_INC_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_STR_PRE_INC_WB_IMM_OFFSET_MID
  50  , ARM_FRAG_STR_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_STRB_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_STRB_POST_INC_IMM_OFFSET_MID, ARM_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_MID
  51  , ARM_FRAG_STRB_POST_INC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_MID, ARM_FRAG_STRB_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_STRB_PRE_DEC_REG_OFFSET_MID
  52  , ARM_FRAG_STRB_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_STRB_PRE_INC_REG_OFFSET_MID, ARM_FRAG_STRB_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_STRB_PRE_DEC_WB_REG_OFFSET_MID
  53  , ARM_FRAG_STRB_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_STRB_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_STRH_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_STRH_PRE_DEC_REG_OFFSET_MID
  54  , ARM_FRAG_STRH_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_STRH_PRE_INC_REG_OFFSET_MID, ARM_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_STRH_PRE_DEC_WB_REG_OFFSET_MID
  55  , ARM_FRAG_STRH_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_STRH_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_STRH_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_STRH_POST_DEC_REG_OFFSET_MID
  56  , ARM_FRAG_STRH_POST_INC_IMM_OFFSET_MID, ARM_FRAG_STRH_POST_INC_REG_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_REG_OFFSET_MID
  57  , ARM_FRAG_LDRSB_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_WB_REG_OFFSET_MID
  58  , ARM_FRAG_LDRSB_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LDRSB_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_POST_DEC_REG_OFFSET_MID
  59  , ARM_FRAG_LDRSB_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_POST_INC_REG_OFFSET_MID, ARM_FRAG_LDRH_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRH_PRE_DEC_REG_OFFSET_MID
  60  , ARM_FRAG_LDRH_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_LDRH_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDRH_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRH_PRE_DEC_WB_REG_OFFSET_MID
  61  , ARM_FRAG_LDRH_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRH_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LDRH_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRH_POST_DEC_REG_OFFSET_MID
  62  , ARM_FRAG_LDRH_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LDRH_POST_INC_REG_OFFSET_MID, ARM_FRAG_LDRSH_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRSH_PRE_DEC_REG_OFFSET_MID
  63  , ARM_FRAG_LDRSH_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_LDRSH_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDRSH_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSH_PRE_DEC_WB_REG_OFFSET_MID
  64  , ARM_FRAG_LDRSH_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSH_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LDRSH_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRSH_POST_DEC_REG_OFFSET_MID
  65  , ARM_FRAG_LDRSH_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LDRSH_POST_INC_REG_OFFSET_MID, ARM_FRAG_MUL_MID, ARM_FRAG_MLA_MID
  66  , ARM_FRAG_UMULL_MID, ARM_FRAG_UMLAL_MID, ARM_FRAG_SMULL_MID, ARM_FRAG_SMLAL_MID
  67  , ARM_FRAG_SWP_MID, ARM_FRAG_SWPB_MID, ARM_FRAG_SWI_MID, ARM_FRAG_AND_REG_IMM_SHIFT_MID
  68  , ARM_FRAG_AND_REG_REG_SHIFT_MID, ARM_FRAG_AND_IMM_MID, ARM_FRAG_ORR_REG_IMM_SHIFT_MID, ARM_FRAG_ORR_REG_REG_SHIFT_MID
  69  , ARM_FRAG_ORR_IMM_MID, ARM_FRAG_EOR_REG_IMM_SHIFT_MID, ARM_FRAG_EOR_REG_REG_SHIFT_MID, ARM_FRAG_EOR_IMM_MID
  70  , ARM_FRAG_MOV_REG_IMM_SHIFT_MID, ARM_FRAG_MOV_REG_REG_SHIFT_MID, ARM_FRAG_MOV_IMM_MID, ARM_FRAG_BIC_REG_IMM_SHIFT_MID
  71  , ARM_FRAG_BIC_REG_REG_SHIFT_MID, ARM_FRAG_BIC_IMM_MID, ARM_FRAG_MVN_REG_IMM_SHIFT_MID, ARM_FRAG_MVN_REG_REG_SHIFT_MID
  72  , ARM_FRAG_MVN_IMM_MID, ARM_FRAG_ADD_REG_IMM_SHIFT_MID, ARM_FRAG_ADD_REG_REG_SHIFT_MID, ARM_FRAG_ADD_IMM_MID
  73  , ARM_FRAG_ADC_REG_IMM_SHIFT_MID, ARM_FRAG_ADC_REG_REG_SHIFT_MID, ARM_FRAG_ADC_IMM_MID, ARM_FRAG_SUB_REG_IMM_SHIFT_MID
  74  , ARM_FRAG_SUB_REG_REG_SHIFT_MID, ARM_FRAG_SUB_IMM_MID, ARM_FRAG_SBC_REG_IMM_SHIFT_MID, ARM_FRAG_SBC_REG_REG_SHIFT_MID
  75  , ARM_FRAG_SBC_IMM_MID, ARM_FRAG_RSB_REG_IMM_SHIFT_MID, ARM_FRAG_RSB_REG_REG_SHIFT_MID, ARM_FRAG_RSB_IMM_MID
  76  , ARM_FRAG_RSC_REG_IMM_SHIFT_MID, ARM_FRAG_RSC_REG_REG_SHIFT_MID, ARM_FRAG_RSC_IMM_MID, ARM_FRAG_TST_REG_IMM_SHIFT_MID
  77  , ARM_FRAG_TST_REG_REG_SHIFT_MID, ARM_FRAG_TST_IMM_MID, ARM_FRAG_TEQ_REG_IMM_SHIFT_MID, ARM_FRAG_TEQ_REG_REG_SHIFT_MID
  78  , ARM_FRAG_TEQ_IMM_MID, ARM_FRAG_CMP_REG_IMM_SHIFT_MID, ARM_FRAG_CMP_REG_REG_SHIFT_MID, ARM_FRAG_CMP_IMM_MID
  79  , ARM_FRAG_CMN_REG_IMM_SHIFT_MID, ARM_FRAG_CMN_REG_REG_SHIFT_MID, ARM_FRAG_CMN_IMM_MID, ARM_FRAG_LDMDA_MID
  80  , ARM_FRAG_LDMDA_SW_MID, ARM_FRAG_LDMDA_WB_MID, ARM_FRAG_LDMDA_SW_WB_MID, ARM_FRAG_LDMIB_MID
  81  , ARM_FRAG_LDMIB_SW_MID, ARM_FRAG_LDMIB_WB_MID, ARM_FRAG_LDMIB_SW_WB_MID, ARM_FRAG_LDMIA_MID
  82  , ARM_FRAG_LDMIA_SW_MID, ARM_FRAG_LDMIA_WB_MID, ARM_FRAG_LDMIA_SW_WB_MID, ARM_FRAG_LDMDB_MID
  83  , ARM_FRAG_LDMDB_SW_MID, ARM_FRAG_LDMDB_WB_MID, ARM_FRAG_LDMDB_SW_WB_MID, ARM_FRAG_STMDB_MID
  84  , ARM_FRAG_STMDB_SW_MID, ARM_FRAG_STMDB_WB_MID, ARM_FRAG_STMDB_SW_WB_MID, ARM_FRAG_STMIB_MID
  85  , ARM_FRAG_STMIB_SW_MID, ARM_FRAG_STMIB_WB_MID, ARM_FRAG_STMIB_SW_WB_MID, ARM_FRAG_STMIA_MID
  86  , ARM_FRAG_STMIA_SW_MID, ARM_FRAG_STMIA_WB_MID, ARM_FRAG_STMIA_SW_WB_MID, ARM_FRAG_STMDA_MID
  87  , ARM_FRAG_STMDA_SW_MID, ARM_FRAG_STMDA_WB_MID, ARM_FRAG_STMDA_SW_WB_MID, ARM_FRAG_MRS_C_MID
  88  , ARM_FRAG_MRS_S_MID, ARM_FRAG_MSR_C_MID, ARM_FRAG_MSR_S_MID, ARM_FRAG_MAX
  89 } ARM_FRAG_TYPE;
  90
  91 struct arm_insn_frag {
  92   ARM_INSN_TYPE itype;
  93   // 4: header+middle+trailer+delimiter
  94   ARM_FRAG_TYPE ftype[4];
  95 };
  96
  97 struct arm_pbb_label {
  98   ARM_FRAG_TYPE frag;
  99   void *label;
 100 };
 101
 102 } // end arm7f namespace
 103
 104 // Table of frags used by each insn.
 105
 106 const arm_insn_frag arm_frag_usage[] = {
 107   { ARM_INSN_X_COND, ARM_FRAG_X_COND_MID, ARM_FRAG_LIST_END },
 108   { ARM_INSN_X_AFTER, ARM_FRAG_X_AFTER_MID, ARM_FRAG_LIST_END },
 109   { ARM_INSN_X_BEFORE, ARM_FRAG_X_BEFORE_MID, ARM_FRAG_LIST_END },
 110   { ARM_INSN_X_CTI_CHAIN, ARM_FRAG_X_CTI_CHAIN_MID, ARM_FRAG_LIST_END },
 111   { ARM_INSN_X_CHAIN, ARM_FRAG_X_CHAIN_MID, ARM_FRAG_LIST_END },
 112   { ARM_INSN_X_BEGIN, ARM_FRAG_X_BEGIN_MID, ARM_FRAG_LIST_END },
 113   { ARM_INSN_X_INVALID, ARM_FRAG_X_INVALID_MID, ARM_FRAG_LIST_END },
 114   { ARM_INSN_B, ARM_FRAG_B_MID, ARM_FRAG_LIST_END },
 115   { ARM_INSN_BL, ARM_FRAG_BL_MID, ARM_FRAG_LIST_END },
 116   { ARM_INSN_BX, ARM_FRAG_BX_MID, ARM_FRAG_LIST_END },
 117   { ARM_INSN_LDR_POST_DEC_IMM_OFFSET, ARM_FRAG_LDR_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 118   { ARM_INSN_LDR_POST_DEC_REG_OFFSET, ARM_FRAG_LDR_POST_DEC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 119   { ARM_INSN_LDR_POST_INC_IMM_OFFSET, ARM_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_LDR_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 120   { ARM_INSN_LDR_POST_INC_REG_OFFSET, ARM_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_LDR_POST_INC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 121   { ARM_INSN_LDR_POST_DEC_NONPRIV_IMM_OFFSET, ARM_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 122   { ARM_INSN_LDR_POST_DEC_NONPRIV_REG_OFFSET, ARM_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 123   { ARM_INSN_LDR_POST_INC_NONPRIV_IMM_OFFSET, ARM_FRAG_LDR_POST_INC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 124   { ARM_INSN_LDR_POST_INC_NONPRIV_REG_OFFSET, ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 125   { ARM_INSN_LDR_PRE_DEC_IMM_OFFSET, ARM_FRAG_LDR_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 126   { ARM_INSN_LDR_PRE_DEC_REG_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDR_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 127   { ARM_INSN_LDR_PRE_INC_IMM_OFFSET, ARM_FRAG_LDR_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 128   { ARM_INSN_LDR_PRE_INC_REG_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDR_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 129   { ARM_INSN_LDR_PRE_DEC_WB_IMM_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 130   { ARM_INSN_LDR_PRE_DEC_WB_REG_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 131   { ARM_INSN_LDR_PRE_INC_WB_IMM_OFFSET, ARM_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 132   { ARM_INSN_LDR_PRE_INC_WB_REG_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDR_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 133   { ARM_INSN_LDRB_POST_DEC_IMM_OFFSET, ARM_FRAG_LDRB_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 134   { ARM_INSN_LDRB_POST_DEC_REG_OFFSET, ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_LDRB_POST_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 135   { ARM_INSN_LDRB_POST_INC_IMM_OFFSET, ARM_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_LDRB_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 136   { ARM_INSN_LDRB_POST_INC_REG_OFFSET, ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_LDRB_POST_INC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 137   { ARM_INSN_LDRB_POST_DEC_NONPRIV_IMM_OFFSET, ARM_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 138   { ARM_INSN_LDRB_POST_DEC_NONPRIV_REG_OFFSET, ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_LDRB_POST_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 139   { ARM_INSN_LDRB_POST_INC_NONPRIV_IMM_OFFSET, ARM_FRAG_LDRB_POST_INC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 140   { ARM_INSN_LDRB_POST_INC_NONPRIV_REG_OFFSET, ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_LDRB_POST_INC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 141   { ARM_INSN_LDRB_PRE_DEC_IMM_OFFSET, ARM_FRAG_LDRB_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 142   { ARM_INSN_LDRB_PRE_DEC_REG_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 143   { ARM_INSN_LDRB_PRE_INC_IMM_OFFSET, ARM_FRAG_LDRB_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 144   { ARM_INSN_LDRB_PRE_INC_REG_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDRB_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 145   { ARM_INSN_LDRB_PRE_DEC_WB_IMM_OFFSET, ARM_FRAG_LDRB_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 146   { ARM_INSN_LDRB_PRE_DEC_WB_REG_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 147   { ARM_INSN_LDRB_PRE_INC_WB_IMM_OFFSET, ARM_FRAG_LDRB_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 148   { ARM_INSN_LDRB_PRE_INC_WB_REG_OFFSET, ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, ARM_FRAG_LDRB_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 149   { ARM_INSN_STR_POST_DEC_IMM_OFFSET, ARM_FRAG_STR_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_STR_POST_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 150   { ARM_INSN_STR_POST_DEC_REG_OFFSET, ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, ARM_FRAG_STR_POST_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 151   { ARM_INSN_STR_POST_INC_IMM_OFFSET, ARM_FRAG_STR_POST_INC_IMM_OFFSET_MID, ARM_FRAG_STR_POST_INC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 152   { ARM_INSN_STR_POST_INC_REG_OFFSET, ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, ARM_FRAG_STR_POST_INC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 153   { ARM_INSN_STR_POST_DEC_NONPRIV_IMM_OFFSET, ARM_FRAG_STR_POST_DEC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 154   { ARM_INSN_STR_POST_DEC_NONPRIV_REG_OFFSET, ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, ARM_FRAG_STR_POST_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 155   { ARM_INSN_STR_POST_INC_NONPRIV_IMM_OFFSET, ARM_FRAG_STR_POST_INC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 156   { ARM_INSN_STR_POST_INC_NONPRIV_REG_OFFSET, ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, ARM_FRAG_STR_POST_INC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 157   { ARM_INSN_STR_PRE_DEC_IMM_OFFSET, ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 158   { ARM_INSN_STR_PRE_DEC_REG_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STR_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 159   { ARM_INSN_STR_PRE_INC_IMM_OFFSET, ARM_FRAG_STR_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 160   { ARM_INSN_STR_PRE_INC_REG_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STR_PRE_INC_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 161   { ARM_INSN_STR_PRE_DEC_WB_IMM_OFFSET, ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 162   { ARM_INSN_STR_PRE_DEC_WB_REG_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 163   { ARM_INSN_STR_PRE_INC_WB_IMM_OFFSET, ARM_FRAG_STR_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 164   { ARM_INSN_STR_PRE_INC_WB_REG_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STR_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 165   { ARM_INSN_STRB_POST_DEC_IMM_OFFSET, ARM_FRAG_STRB_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 166   { ARM_INSN_STRB_POST_DEC_REG_OFFSET, ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, ARM_FRAG_STRB_POST_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 167   { ARM_INSN_STRB_POST_INC_IMM_OFFSET, ARM_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_STRB_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 168   { ARM_INSN_STRB_POST_INC_REG_OFFSET, ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, ARM_FRAG_STRB_POST_INC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 169   { ARM_INSN_STRB_POST_DEC_NONPRIV_IMM_OFFSET, ARM_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR, ARM_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 170   { ARM_INSN_STRB_POST_DEC_NONPRIV_REG_OFFSET, ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, ARM_FRAG_STRB_POST_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 171   { ARM_INSN_STRB_POST_INC_NONPRIV_IMM_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 172   { ARM_INSN_STRB_POST_INC_NONPRIV_REG_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_MID, ARM_FRAG_STRB_POST_INC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 173   { ARM_INSN_STRB_PRE_DEC_IMM_OFFSET, ARM_FRAG_STRB_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 174   { ARM_INSN_STRB_PRE_DEC_REG_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STRB_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 175   { ARM_INSN_STRB_PRE_INC_IMM_OFFSET, ARM_FRAG_STRB_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 176   { ARM_INSN_STRB_PRE_INC_REG_OFFSET, ARM_FRAG_STRB_PRE_INC_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 177   { ARM_INSN_STRB_PRE_DEC_WB_IMM_OFFSET, ARM_FRAG_STRB_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 178   { ARM_INSN_STRB_PRE_DEC_WB_REG_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STRB_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 179   { ARM_INSN_STRB_PRE_INC_WB_IMM_OFFSET, ARM_FRAG_STRB_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 180   { ARM_INSN_STRB_PRE_INC_WB_REG_OFFSET, ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, ARM_FRAG_STRB_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 181   { ARM_INSN_STRH_PRE_DEC_IMM_OFFSET, ARM_FRAG_STRH_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_STRH_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 182   { ARM_INSN_STRH_PRE_DEC_REG_OFFSET, ARM_FRAG_STRH_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 183   { ARM_INSN_STRH_PRE_INC_IMM_OFFSET, ARM_FRAG_STRH_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_STRH_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 184   { ARM_INSN_STRH_PRE_INC_REG_OFFSET, ARM_FRAG_STRH_PRE_INC_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 185   { ARM_INSN_STRH_PRE_DEC_WB_IMM_OFFSET, ARM_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 186   { ARM_INSN_STRH_PRE_DEC_WB_REG_OFFSET, ARM_FRAG_STRH_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 187   { ARM_INSN_STRH_PRE_INC_WB_IMM_OFFSET, ARM_FRAG_STRH_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 188   { ARM_INSN_STRH_PRE_INC_WB_REG_OFFSET, ARM_FRAG_STRH_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 189   { ARM_INSN_STRH_POST_DEC_IMM_OFFSET, ARM_FRAG_STRH_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 190   { ARM_INSN_STRH_POST_DEC_REG_OFFSET, ARM_FRAG_STRH_POST_DEC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 191   { ARM_INSN_STRH_POST_INC_IMM_OFFSET, ARM_FRAG_STRH_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 192   { ARM_INSN_STRH_POST_INC_REG_OFFSET, ARM_FRAG_STRH_POST_INC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 193   { ARM_INSN_LDRSB_PRE_DEC_IMM_OFFSET, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 194   { ARM_INSN_LDRSB_PRE_DEC_REG_OFFSET, ARM_FRAG_LDRSB_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 195   { ARM_INSN_LDRSB_PRE_INC_IMM_OFFSET, ARM_FRAG_LDRSB_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 196   { ARM_INSN_LDRSB_PRE_INC_REG_OFFSET, ARM_FRAG_LDRSB_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 197   { ARM_INSN_LDRSB_PRE_DEC_WB_IMM_OFFSET, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 198   { ARM_INSN_LDRSB_PRE_DEC_WB_REG_OFFSET, ARM_FRAG_LDRSB_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 199   { ARM_INSN_LDRSB_PRE_INC_WB_IMM_OFFSET, ARM_FRAG_LDRSB_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 200   { ARM_INSN_LDRSB_PRE_INC_WB_REG_OFFSET, ARM_FRAG_LDRSB_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 201   { ARM_INSN_LDRSB_POST_DEC_IMM_OFFSET, ARM_FRAG_LDRSB_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 202   { ARM_INSN_LDRSB_POST_DEC_REG_OFFSET, ARM_FRAG_LDRSB_POST_DEC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 203   { ARM_INSN_LDRSB_POST_INC_IMM_OFFSET, ARM_FRAG_LDRSB_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 204   { ARM_INSN_LDRSB_POST_INC_REG_OFFSET, ARM_FRAG_LDRSB_POST_INC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 205   { ARM_INSN_LDRH_PRE_DEC_IMM_OFFSET, ARM_FRAG_LDRH_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 206   { ARM_INSN_LDRH_PRE_DEC_REG_OFFSET, ARM_FRAG_LDRH_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 207   { ARM_INSN_LDRH_PRE_INC_IMM_OFFSET, ARM_FRAG_LDRH_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 208   { ARM_INSN_LDRH_PRE_INC_REG_OFFSET, ARM_FRAG_LDRH_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 209   { ARM_INSN_LDRH_PRE_DEC_WB_IMM_OFFSET, ARM_FRAG_LDRH_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 210   { ARM_INSN_LDRH_PRE_DEC_WB_REG_OFFSET, ARM_FRAG_LDRH_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 211   { ARM_INSN_LDRH_PRE_INC_WB_IMM_OFFSET, ARM_FRAG_LDRH_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 212   { ARM_INSN_LDRH_PRE_INC_WB_REG_OFFSET, ARM_FRAG_LDRH_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 213   { ARM_INSN_LDRH_POST_DEC_IMM_OFFSET, ARM_FRAG_LDRH_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 214   { ARM_INSN_LDRH_POST_DEC_REG_OFFSET, ARM_FRAG_LDRH_POST_DEC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 215   { ARM_INSN_LDRH_POST_INC_IMM_OFFSET, ARM_FRAG_LDRH_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 216   { ARM_INSN_LDRH_POST_INC_REG_OFFSET, ARM_FRAG_LDRH_POST_INC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 217   { ARM_INSN_LDRSH_PRE_DEC_IMM_OFFSET, ARM_FRAG_LDRSH_PRE_DEC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 218   { ARM_INSN_LDRSH_PRE_DEC_REG_OFFSET, ARM_FRAG_LDRSH_PRE_DEC_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 219   { ARM_INSN_LDRSH_PRE_INC_IMM_OFFSET, ARM_FRAG_LDRSH_PRE_INC_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 220   { ARM_INSN_LDRSH_PRE_INC_REG_OFFSET, ARM_FRAG_LDRSH_PRE_INC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 221   { ARM_INSN_LDRSH_PRE_DEC_WB_IMM_OFFSET, ARM_FRAG_LDRSH_PRE_DEC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 222   { ARM_INSN_LDRSH_PRE_DEC_WB_REG_OFFSET, ARM_FRAG_LDRSH_PRE_DEC_WB_REG_OFFSET_MID, ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR, ARM_FRAG_LIST_END },
 223   { ARM_INSN_LDRSH_PRE_INC_WB_IMM_OFFSET, ARM_FRAG_LDRSH_PRE_INC_WB_IMM_OFFSET_MID, ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR, ARM_FRAG_LIST_END },
 224   { ARM_INSN_LDRSH_PRE_INC_WB_REG_OFFSET, ARM_FRAG_LDRSH_PRE_INC_WB_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 225   { ARM_INSN_LDRSH_POST_DEC_IMM_OFFSET, ARM_FRAG_LDRSH_POST_DEC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 226   { ARM_INSN_LDRSH_POST_DEC_REG_OFFSET, ARM_FRAG_LDRSH_POST_DEC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 227   { ARM_INSN_LDRSH_POST_INC_IMM_OFFSET, ARM_FRAG_LDRSH_POST_INC_IMM_OFFSET_MID, ARM_FRAG_LIST_END },
 228   { ARM_INSN_LDRSH_POST_INC_REG_OFFSET, ARM_FRAG_LDRSH_POST_INC_REG_OFFSET_MID, ARM_FRAG_LIST_END },
 229   { ARM_INSN_MUL, ARM_FRAG_MUL_MID, ARM_FRAG_LIST_END },
 230   { ARM_INSN_MLA, ARM_FRAG_MLA_MID, ARM_FRAG_LIST_END },
 231   { ARM_INSN_UMULL, ARM_FRAG_UMULL_MID, ARM_FRAG_UMULL_TRLR, ARM_FRAG_LIST_END },
 232   { ARM_INSN_UMLAL, ARM_FRAG_UMLAL_MID, ARM_FRAG_UMULL_TRLR, ARM_FRAG_LIST_END },
 233   { ARM_INSN_SMULL, ARM_FRAG_SMULL_MID, ARM_FRAG_UMULL_TRLR, ARM_FRAG_LIST_END },
 234   { ARM_INSN_SMLAL, ARM_FRAG_SMLAL_MID, ARM_FRAG_LIST_END },
 235   { ARM_INSN_SWP, ARM_FRAG_SWP_MID, ARM_FRAG_LIST_END },
 236   { ARM_INSN_SWPB, ARM_FRAG_SWPB_MID, ARM_FRAG_LIST_END },
 237   { ARM_INSN_SWI, ARM_FRAG_SWI_MID, ARM_FRAG_LIST_END },
 238   { ARM_INSN_AND_REG_IMM_SHIFT, ARM_FRAG_AND_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 239   { ARM_INSN_AND_REG_REG_SHIFT, ARM_FRAG_AND_REG_REG_SHIFT_MID, ARM_FRAG_AND_REG_REG_SHIFT_TRLR, ARM_FRAG_LIST_END },
 240   { ARM_INSN_AND_IMM, ARM_FRAG_AND_IMM_MID, ARM_FRAG_AND_IMM_TRLR, ARM_FRAG_LIST_END },
 241   { ARM_INSN_ORR_REG_IMM_SHIFT, ARM_FRAG_ORR_REG_IMM_SHIFT_HDR, ARM_FRAG_ORR_REG_IMM_SHIFT_MID, ARM_FRAG_ORR_REG_IMM_SHIFT_TRLR, ARM_FRAG_LIST_END },
 242   { ARM_INSN_ORR_REG_REG_SHIFT, ARM_FRAG_ORR_REG_REG_SHIFT_HDR, ARM_FRAG_ORR_REG_REG_SHIFT_MID, ARM_FRAG_AND_REG_REG_SHIFT_TRLR, ARM_FRAG_LIST_END },
 243   { ARM_INSN_ORR_IMM, ARM_FRAG_ORR_IMM_MID, ARM_FRAG_AND_IMM_TRLR, ARM_FRAG_LIST_END },
 244   { ARM_INSN_EOR_REG_IMM_SHIFT, ARM_FRAG_ORR_REG_IMM_SHIFT_HDR, ARM_FRAG_EOR_REG_IMM_SHIFT_MID, ARM_FRAG_ORR_REG_IMM_SHIFT_TRLR, ARM_FRAG_LIST_END },
 245   { ARM_INSN_EOR_REG_REG_SHIFT, ARM_FRAG_ORR_REG_REG_SHIFT_HDR, ARM_FRAG_EOR_REG_REG_SHIFT_MID, ARM_FRAG_AND_REG_REG_SHIFT_TRLR, ARM_FRAG_LIST_END },
 246   { ARM_INSN_EOR_IMM, ARM_FRAG_EOR_IMM_MID, ARM_FRAG_AND_IMM_TRLR, ARM_FRAG_LIST_END },
 247   { ARM_INSN_MOV_REG_IMM_SHIFT, ARM_FRAG_ORR_REG_IMM_SHIFT_HDR, ARM_FRAG_MOV_REG_IMM_SHIFT_MID, ARM_FRAG_ORR_REG_IMM_SHIFT_TRLR, ARM_FRAG_LIST_END },
 248   { ARM_INSN_MOV_REG_REG_SHIFT, ARM_FRAG_ORR_REG_REG_SHIFT_HDR, ARM_FRAG_MOV_REG_REG_SHIFT_MID, ARM_FRAG_AND_REG_REG_SHIFT_TRLR, ARM_FRAG_LIST_END },
 249   { ARM_INSN_MOV_IMM, ARM_FRAG_MOV_IMM_MID, ARM_FRAG_AND_IMM_TRLR, ARM_FRAG_LIST_END },
 250   { ARM_INSN_BIC_REG_IMM_SHIFT, ARM_FRAG_ORR_REG_IMM_SHIFT_HDR, ARM_FRAG_BIC_REG_IMM_SHIFT_MID, ARM_FRAG_ORR_REG_IMM_SHIFT_TRLR, ARM_FRAG_LIST_END },
 251   { ARM_INSN_BIC_REG_REG_SHIFT, ARM_FRAG_ORR_REG_REG_SHIFT_HDR, ARM_FRAG_BIC_REG_REG_SHIFT_MID, ARM_FRAG_AND_REG_REG_SHIFT_TRLR, ARM_FRAG_LIST_END },
 252   { ARM_INSN_BIC_IMM, ARM_FRAG_BIC_IMM_MID, ARM_FRAG_AND_IMM_TRLR, ARM_FRAG_LIST_END },
 253   { ARM_INSN_MVN_REG_IMM_SHIFT, ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, ARM_FRAG_MVN_REG_IMM_SHIFT_MID, ARM_FRAG_ORR_REG_IMM_SHIFT_TRLR, ARM_FRAG_LIST_END },
 254   { ARM_INSN_MVN_REG_REG_SHIFT, ARM_FRAG_MVN_REG_REG_SHIFT_HDR, ARM_FRAG_MVN_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 255   { ARM_INSN_MVN_IMM, ARM_FRAG_MVN_IMM_MID, ARM_FRAG_LIST_END },
 256   { ARM_INSN_ADD_REG_IMM_SHIFT, ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, ARM_FRAG_ADD_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 257   { ARM_INSN_ADD_REG_REG_SHIFT, ARM_FRAG_MVN_REG_REG_SHIFT_HDR, ARM_FRAG_ADD_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 258   { ARM_INSN_ADD_IMM, ARM_FRAG_ADD_IMM_MID, ARM_FRAG_LIST_END },
 259   { ARM_INSN_ADC_REG_IMM_SHIFT, ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, ARM_FRAG_ADC_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 260   { ARM_INSN_ADC_REG_REG_SHIFT, ARM_FRAG_MVN_REG_REG_SHIFT_HDR, ARM_FRAG_ADC_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 261   { ARM_INSN_ADC_IMM, ARM_FRAG_ADC_IMM_MID, ARM_FRAG_LIST_END },
 262   { ARM_INSN_SUB_REG_IMM_SHIFT, ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, ARM_FRAG_SUB_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 263   { ARM_INSN_SUB_REG_REG_SHIFT, ARM_FRAG_MVN_REG_REG_SHIFT_HDR, ARM_FRAG_SUB_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 264   { ARM_INSN_SUB_IMM, ARM_FRAG_SUB_IMM_MID, ARM_FRAG_LIST_END },
 265   { ARM_INSN_SBC_REG_IMM_SHIFT, ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, ARM_FRAG_SBC_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 266   { ARM_INSN_SBC_REG_REG_SHIFT, ARM_FRAG_MVN_REG_REG_SHIFT_HDR, ARM_FRAG_SBC_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 267   { ARM_INSN_SBC_IMM, ARM_FRAG_SBC_IMM_MID, ARM_FRAG_LIST_END },
 268   { ARM_INSN_RSB_REG_IMM_SHIFT, ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, ARM_FRAG_RSB_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 269   { ARM_INSN_RSB_REG_REG_SHIFT, ARM_FRAG_MVN_REG_REG_SHIFT_HDR, ARM_FRAG_RSB_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 270   { ARM_INSN_RSB_IMM, ARM_FRAG_RSB_IMM_MID, ARM_FRAG_LIST_END },
 271   { ARM_INSN_RSC_REG_IMM_SHIFT, ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, ARM_FRAG_RSC_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 272   { ARM_INSN_RSC_REG_REG_SHIFT, ARM_FRAG_MVN_REG_REG_SHIFT_HDR, ARM_FRAG_RSC_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 273   { ARM_INSN_RSC_IMM, ARM_FRAG_RSC_IMM_MID, ARM_FRAG_LIST_END },
 274   { ARM_INSN_TST_REG_IMM_SHIFT, ARM_FRAG_TST_REG_IMM_SHIFT_HDR, ARM_FRAG_TST_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 275   { ARM_INSN_TST_REG_REG_SHIFT, ARM_FRAG_TST_REG_REG_SHIFT_HDR, ARM_FRAG_TST_REG_REG_SHIFT_MID, ARM_FRAG_TST_REG_REG_SHIFT_TRLR, ARM_FRAG_LIST_END },
 276   { ARM_INSN_TST_IMM, ARM_FRAG_TST_IMM_MID, ARM_FRAG_LIST_END },
 277   { ARM_INSN_TEQ_REG_IMM_SHIFT, ARM_FRAG_TST_REG_IMM_SHIFT_HDR, ARM_FRAG_TEQ_REG_IMM_SHIFT_MID, ARM_FRAG_TEQ_REG_IMM_SHIFT_TRLR, ARM_FRAG_LIST_END },
 278   { ARM_INSN_TEQ_REG_REG_SHIFT, ARM_FRAG_TST_REG_REG_SHIFT_HDR, ARM_FRAG_TEQ_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 279   { ARM_INSN_TEQ_IMM, ARM_FRAG_TEQ_IMM_MID, ARM_FRAG_LIST_END },
 280   { ARM_INSN_CMP_REG_IMM_SHIFT, ARM_FRAG_CMP_REG_IMM_SHIFT_HDR, ARM_FRAG_CMP_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 281   { ARM_INSN_CMP_REG_REG_SHIFT, ARM_FRAG_CMP_REG_REG_SHIFT_HDR, ARM_FRAG_CMP_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 282   { ARM_INSN_CMP_IMM, ARM_FRAG_CMP_IMM_MID, ARM_FRAG_LIST_END },
 283   { ARM_INSN_CMN_REG_IMM_SHIFT, ARM_FRAG_CMN_REG_IMM_SHIFT_MID, ARM_FRAG_LIST_END },
 284   { ARM_INSN_CMN_REG_REG_SHIFT, ARM_FRAG_CMN_REG_REG_SHIFT_MID, ARM_FRAG_LIST_END },
 285   { ARM_INSN_CMN_IMM, ARM_FRAG_CMN_IMM_MID, ARM_FRAG_LIST_END },
 286   { ARM_INSN_LDMDA, ARM_FRAG_LDMDA_MID, ARM_FRAG_LIST_END },
 287   { ARM_INSN_LDMDA_SW, ARM_FRAG_LDMDA_SW_MID, ARM_FRAG_LIST_END },
 288   { ARM_INSN_LDMDA_WB, ARM_FRAG_LDMDA_WB_MID, ARM_FRAG_LIST_END },
 289   { ARM_INSN_LDMDA_SW_WB, ARM_FRAG_LDMDA_SW_WB_MID, ARM_FRAG_LIST_END },
 290   { ARM_INSN_LDMIB, ARM_FRAG_LDMIB_MID, ARM_FRAG_LIST_END },
 291   { ARM_INSN_LDMIB_SW, ARM_FRAG_LDMIB_WB_HDR, ARM_FRAG_LDMIB_SW_MID, ARM_FRAG_LIST_END },
 292   { ARM_INSN_LDMIB_WB, ARM_FRAG_LDMIB_WB_HDR, ARM_FRAG_LDMIB_WB_MID, ARM_FRAG_LIST_END },
 293   { ARM_INSN_LDMIB_SW_WB, ARM_FRAG_LDMIB_SW_WB_MID, ARM_FRAG_LIST_END },
 294   { ARM_INSN_LDMIA, ARM_FRAG_LDMIA_MID, ARM_FRAG_LIST_END },
 295   { ARM_INSN_LDMIA_SW, ARM_FRAG_LDMIA_WB_HDR, ARM_FRAG_LDMIA_SW_MID, ARM_FRAG_LIST_END },
 296   { ARM_INSN_LDMIA_WB, ARM_FRAG_LDMIA_WB_HDR, ARM_FRAG_LDMIA_WB_MID, ARM_FRAG_LIST_END },
 297   { ARM_INSN_LDMIA_SW_WB, ARM_FRAG_LDMIA_SW_WB_MID, ARM_FRAG_LIST_END },
 298   { ARM_INSN_LDMDB, ARM_FRAG_LDMDB_MID, ARM_FRAG_LIST_END },
 299   { ARM_INSN_LDMDB_SW, ARM_FRAG_LDMDB_SW_MID, ARM_FRAG_LIST_END },
 300   { ARM_INSN_LDMDB_WB, ARM_FRAG_LDMDB_WB_MID, ARM_FRAG_LIST_END },
 301   { ARM_INSN_LDMDB_SW_WB, ARM_FRAG_LDMDB_SW_WB_MID, ARM_FRAG_LIST_END },
 302   { ARM_INSN_STMDB, ARM_FRAG_STMDB_MID, ARM_FRAG_LIST_END },
 303   { ARM_INSN_STMDB_SW, ARM_FRAG_STMDB_WB_HDR, ARM_FRAG_STMDB_SW_MID, ARM_FRAG_LIST_END },
 304   { ARM_INSN_STMDB_WB, ARM_FRAG_STMDB_WB_HDR, ARM_FRAG_STMDB_WB_MID, ARM_FRAG_LIST_END },
 305   { ARM_INSN_STMDB_SW_WB, ARM_FRAG_STMDB_SW_WB_MID, ARM_FRAG_LIST_END },
 306   { ARM_INSN_STMIB, ARM_FRAG_STMIB_MID, ARM_FRAG_LIST_END },
 307   { ARM_INSN_STMIB_SW, ARM_FRAG_STMIB_WB_HDR, ARM_FRAG_STMIB_SW_MID, ARM_FRAG_LIST_END },
 308   { ARM_INSN_STMIB_WB, ARM_FRAG_STMIB_WB_HDR, ARM_FRAG_STMIB_WB_MID, ARM_FRAG_LIST_END },
 309   { ARM_INSN_STMIB_SW_WB, ARM_FRAG_STMIB_SW_WB_MID, ARM_FRAG_LIST_END },
 310   { ARM_INSN_STMIA, ARM_FRAG_STMIA_MID, ARM_FRAG_LIST_END },
 311   { ARM_INSN_STMIA_SW, ARM_FRAG_STMIA_WB_HDR, ARM_FRAG_STMIA_SW_MID, ARM_FRAG_LIST_END },
 312   { ARM_INSN_STMIA_WB, ARM_FRAG_STMIA_WB_HDR, ARM_FRAG_STMIA_WB_MID, ARM_FRAG_LIST_END },
 313   { ARM_INSN_STMIA_SW_WB, ARM_FRAG_STMIA_SW_WB_MID, ARM_FRAG_LIST_END },
 314   { ARM_INSN_STMDA, ARM_FRAG_STMDA_MID, ARM_FRAG_LIST_END },
 315   { ARM_INSN_STMDA_SW, ARM_FRAG_STMDA_WB_HDR, ARM_FRAG_STMDA_SW_MID, ARM_FRAG_LIST_END },
 316   { ARM_INSN_STMDA_WB, ARM_FRAG_STMDA_WB_HDR, ARM_FRAG_STMDA_WB_MID, ARM_FRAG_LIST_END },
 317   { ARM_INSN_STMDA_SW_WB, ARM_FRAG_STMDA_SW_WB_MID, ARM_FRAG_LIST_END },
 318   { ARM_INSN_MRS_C, ARM_FRAG_MRS_C_MID, ARM_FRAG_LIST_END },
 319   { ARM_INSN_MRS_S, ARM_FRAG_MRS_S_MID, ARM_FRAG_LIST_END },
 320   { ARM_INSN_MSR_C, ARM_FRAG_MSR_C_MID, ARM_FRAG_LIST_END },
 321   { ARM_INSN_MSR_S, ARM_FRAG_MSR_S_MID, ARM_FRAG_LIST_END },
 322 };
 323
 324 void
 325 arm7f_cpu::arm_pbb_run ()
 326 {
 327   arm7f_cpu* current_cpu = this;
 328   arm_scache* vpc;
 329   arm_scache* abuf;
 330 #ifdef __GNUC__
 331   void** fragpc;
 332 #else
 333   ARM_FRAG_TYPE* fragpc;
 334 #endif
 335
 336 #ifdef __GNUC__
 337 {
 338   static const arm_pbb_label labels[] =
 339     {
 340       { ARM_FRAG_LIST_END, 0 },
 341       { ARM_FRAG_MVN_REG_REG_SHIFT_HDR, && case_FRAG_MVN_REG_REG_SHIFT_HDR },
 342       { ARM_FRAG_CMP_REG_REG_SHIFT_HDR, && case_FRAG_CMP_REG_REG_SHIFT_HDR },
 343       { ARM_FRAG_TST_REG_REG_SHIFT_HDR, && case_FRAG_TST_REG_REG_SHIFT_HDR },
 344       { ARM_FRAG_ORR_REG_REG_SHIFT_HDR, && case_FRAG_ORR_REG_REG_SHIFT_HDR },
 345       { ARM_FRAG_MVN_REG_IMM_SHIFT_HDR, && case_FRAG_MVN_REG_IMM_SHIFT_HDR },
 346       { ARM_FRAG_CMP_REG_IMM_SHIFT_HDR, && case_FRAG_CMP_REG_IMM_SHIFT_HDR },
 347       { ARM_FRAG_TST_REG_IMM_SHIFT_HDR, && case_FRAG_TST_REG_IMM_SHIFT_HDR },
 348       { ARM_FRAG_ORR_REG_IMM_SHIFT_HDR, && case_FRAG_ORR_REG_IMM_SHIFT_HDR },
 349       { ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR, && case_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR },
 350       { ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR, && case_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR },
 351       { ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR, && case_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR },
 352       { ARM_FRAG_STR_POST_DEC_REG_OFFSET_HDR, && case_FRAG_STR_POST_DEC_REG_OFFSET_HDR },
 353       { ARM_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_HDR, && case_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_HDR },
 354       { ARM_FRAG_STMDA_WB_HDR, && case_FRAG_STMDA_WB_HDR },
 355       { ARM_FRAG_STMIA_WB_HDR, && case_FRAG_STMIA_WB_HDR },
 356       { ARM_FRAG_STMIB_WB_HDR, && case_FRAG_STMIB_WB_HDR },
 357       { ARM_FRAG_STMDB_WB_HDR, && case_FRAG_STMDB_WB_HDR },
 358       { ARM_FRAG_LDMIA_WB_HDR, && case_FRAG_LDMIA_WB_HDR },
 359       { ARM_FRAG_LDMIB_WB_HDR, && case_FRAG_LDMIB_WB_HDR },
 360       { ARM_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR, && case_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR },
 361       { ARM_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR, && case_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR },
 362       { ARM_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_HDR, && case_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_HDR },
 363       { ARM_FRAG_X_HEADER, && case_FRAG_X_HEADER },
 364       { ARM_FRAG_TST_REG_REG_SHIFT_TRLR, && case_FRAG_TST_REG_REG_SHIFT_TRLR },
 365       { ARM_FRAG_TEQ_REG_IMM_SHIFT_TRLR, && case_FRAG_TEQ_REG_IMM_SHIFT_TRLR },
 366       { ARM_FRAG_AND_IMM_TRLR, && case_FRAG_AND_IMM_TRLR },
 367       { ARM_FRAG_AND_REG_REG_SHIFT_TRLR, && case_FRAG_AND_REG_REG_SHIFT_TRLR },
 368       { ARM_FRAG_ORR_REG_IMM_SHIFT_TRLR, && case_FRAG_ORR_REG_IMM_SHIFT_TRLR },
 369       { ARM_FRAG_UMULL_TRLR, && case_FRAG_UMULL_TRLR },
 370       { ARM_FRAG_LDR_PRE_INC_IMM_OFFSET_TRLR, && case_FRAG_LDR_PRE_INC_IMM_OFFSET_TRLR },
 371       { ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR, && case_FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR },
 372       { ARM_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR, && case_FRAG_STR_PRE_DEC_REG_OFFSET_TRLR },
 373       { ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_TRLR, && case_FRAG_STR_PRE_DEC_IMM_OFFSET_TRLR },
 374       { ARM_FRAG_STRH_PRE_DEC_IMM_OFFSET_TRLR, && case_FRAG_STRH_PRE_DEC_IMM_OFFSET_TRLR },
 375       { ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR, && case_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR },
 376       { ARM_FRAG_LDR_PRE_DEC_IMM_OFFSET_TRLR, && case_FRAG_LDR_PRE_DEC_IMM_OFFSET_TRLR },
 377       { ARM_FRAG_LDR_PRE_INC_REG_OFFSET_TRLR, && case_FRAG_LDR_PRE_INC_REG_OFFSET_TRLR },
 378       { ARM_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_TRLR, && case_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_TRLR },
 379       { ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR, && case_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR },
 380       { ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR, && case_FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR },
 381       { ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_TRLR, && case_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_TRLR },
 382       { ARM_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_TRLR, && case_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_TRLR },
 383       { ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR, && case_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR },
 384       { ARM_FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_TRLR, && case_FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_TRLR },
 385       { ARM_FRAG_LDR_PRE_INC_WB_REG_OFFSET_TRLR, && case_FRAG_LDR_PRE_INC_WB_REG_OFFSET_TRLR },
 386       { ARM_FRAG_STRB_POST_INC_REG_OFFSET_TRLR, && case_FRAG_STRB_POST_INC_REG_OFFSET_TRLR },
 387       { ARM_FRAG_STR_POST_INC_REG_OFFSET_TRLR, && case_FRAG_STR_POST_INC_REG_OFFSET_TRLR },
 388       { ARM_FRAG_STR_POST_INC_IMM_OFFSET_TRLR, && case_FRAG_STR_POST_INC_IMM_OFFSET_TRLR },
 389       { ARM_FRAG_LDRB_POST_INC_REG_OFFSET_TRLR, && case_FRAG_LDRB_POST_INC_REG_OFFSET_TRLR },
 390       { ARM_FRAG_STRB_POST_DEC_REG_OFFSET_TRLR, && case_FRAG_STRB_POST_DEC_REG_OFFSET_TRLR },
 391       { ARM_FRAG_STR_POST_DEC_REG_OFFSET_TRLR, && case_FRAG_STR_POST_DEC_REG_OFFSET_TRLR },
 392       { ARM_FRAG_STR_POST_DEC_IMM_OFFSET_TRLR, && case_FRAG_STR_POST_DEC_IMM_OFFSET_TRLR },
 393       { ARM_FRAG_LDRB_POST_DEC_REG_OFFSET_TRLR, && case_FRAG_LDRB_POST_DEC_REG_OFFSET_TRLR },
 394       { ARM_FRAG_X_TRAILER, && case_FRAG_X_TRAILER },
 395       { ARM_FRAG_X_COND_MID, && case_FRAG_X_COND_MID },
 396       { ARM_FRAG_X_AFTER_MID, && case_FRAG_X_AFTER_MID },
 397       { ARM_FRAG_X_BEFORE_MID, && case_FRAG_X_BEFORE_MID },
 398       { ARM_FRAG_X_CTI_CHAIN_MID, && case_FRAG_X_CTI_CHAIN_MID },
 399       { ARM_FRAG_X_CHAIN_MID, && case_FRAG_X_CHAIN_MID },
 400       { ARM_FRAG_X_BEGIN_MID, && case_FRAG_X_BEGIN_MID },
 401       { ARM_FRAG_X_INVALID_MID, && case_FRAG_X_INVALID_MID },
 402       { ARM_FRAG_B_MID, && case_FRAG_B_MID },
 403       { ARM_FRAG_BL_MID, && case_FRAG_BL_MID },
 404       { ARM_FRAG_BX_MID, && case_FRAG_BX_MID },
 405       { ARM_FRAG_LDR_POST_DEC_IMM_OFFSET_MID, && case_FRAG_LDR_POST_DEC_IMM_OFFSET_MID },
 406       { ARM_FRAG_LDR_POST_DEC_REG_OFFSET_MID, && case_FRAG_LDR_POST_DEC_REG_OFFSET_MID },
 407       { ARM_FRAG_LDR_POST_INC_IMM_OFFSET_MID, && case_FRAG_LDR_POST_INC_IMM_OFFSET_MID },
 408       { ARM_FRAG_LDR_POST_INC_REG_OFFSET_MID, && case_FRAG_LDR_POST_INC_REG_OFFSET_MID },
 409       { ARM_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_MID, && case_FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_MID },
 410       { ARM_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_MID, && case_FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_MID },
 411       { ARM_FRAG_LDR_POST_INC_NONPRIV_IMM_OFFSET_MID, && case_FRAG_LDR_POST_INC_NONPRIV_IMM_OFFSET_MID },
 412       { ARM_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_MID, && case_FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_MID },
 413       { ARM_FRAG_LDR_PRE_DEC_IMM_OFFSET_MID, && case_FRAG_LDR_PRE_DEC_IMM_OFFSET_MID },
 414       { ARM_FRAG_LDR_PRE_DEC_REG_OFFSET_MID, && case_FRAG_LDR_PRE_DEC_REG_OFFSET_MID },
 415       { ARM_FRAG_LDR_PRE_INC_IMM_OFFSET_MID, && case_FRAG_LDR_PRE_INC_IMM_OFFSET_MID },
 416       { ARM_FRAG_LDR_PRE_INC_REG_OFFSET_MID, && case_FRAG_LDR_PRE_INC_REG_OFFSET_MID },
 417       { ARM_FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_MID, && case_FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_MID },
 418       { ARM_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_MID, && case_FRAG_LDR_PRE_DEC_WB_REG_OFFSET_MID },
 419       { ARM_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_MID, && case_FRAG_LDR_PRE_INC_WB_IMM_OFFSET_MID },
 420       { ARM_FRAG_LDR_PRE_INC_WB_REG_OFFSET_MID, && case_FRAG_LDR_PRE_INC_WB_REG_OFFSET_MID },
 421       { ARM_FRAG_LDRB_POST_DEC_IMM_OFFSET_MID, && case_FRAG_LDRB_POST_DEC_IMM_OFFSET_MID },
 422       { ARM_FRAG_LDRB_POST_INC_IMM_OFFSET_MID, && case_FRAG_LDRB_POST_INC_IMM_OFFSET_MID },
 423       { ARM_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_MID, && case_FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_MID },
 424       { ARM_FRAG_LDRB_POST_INC_NONPRIV_IMM_OFFSET_MID, && case_FRAG_LDRB_POST_INC_NONPRIV_IMM_OFFSET_MID },
 425       { ARM_FRAG_LDRB_PRE_DEC_IMM_OFFSET_MID, && case_FRAG_LDRB_PRE_DEC_IMM_OFFSET_MID },
 426       { ARM_FRAG_LDRB_PRE_DEC_REG_OFFSET_MID, && case_FRAG_LDRB_PRE_DEC_REG_OFFSET_MID },
 427       { ARM_FRAG_LDRB_PRE_INC_IMM_OFFSET_MID, && case_FRAG_LDRB_PRE_INC_IMM_OFFSET_MID },
 428       { ARM_FRAG_LDRB_PRE_INC_REG_OFFSET_MID, && case_FRAG_LDRB_PRE_INC_REG_OFFSET_MID },
 429       { ARM_FRAG_LDRB_PRE_DEC_WB_IMM_OFFSET_MID, && case_FRAG_LDRB_PRE_DEC_WB_IMM_OFFSET_MID },
 430       { ARM_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_MID, && case_FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_MID },
 431       { ARM_FRAG_LDRB_PRE_INC_WB_IMM_OFFSET_MID, && case_FRAG_LDRB_PRE_INC_WB_IMM_OFFSET_MID },
 432       { ARM_FRAG_LDRB_PRE_INC_WB_REG_OFFSET_MID, && case_FRAG_LDRB_PRE_INC_WB_REG_OFFSET_MID },
 433       { ARM_FRAG_STR_POST_DEC_IMM_OFFSET_MID, && case_FRAG_STR_POST_DEC_IMM_OFFSET_MID },
 434       { ARM_FRAG_STR_POST_INC_IMM_OFFSET_MID, && case_FRAG_STR_POST_INC_IMM_OFFSET_MID },
 435       { ARM_FRAG_STR_POST_DEC_NONPRIV_IMM_OFFSET_MID, && case_FRAG_STR_POST_DEC_NONPRIV_IMM_OFFSET_MID },
 436       { ARM_FRAG_STR_POST_INC_NONPRIV_IMM_OFFSET_MID, && case_FRAG_STR_POST_INC_NONPRIV_IMM_OFFSET_MID },
 437       { ARM_FRAG_STR_PRE_DEC_IMM_OFFSET_MID, && case_FRAG_STR_PRE_DEC_IMM_OFFSET_MID },
 438       { ARM_FRAG_STR_PRE_DEC_REG_OFFSET_MID, && case_FRAG_STR_PRE_DEC_REG_OFFSET_MID },
 439       { ARM_FRAG_STR_PRE_INC_IMM_OFFSET_MID, && case_FRAG_STR_PRE_INC_IMM_OFFSET_MID },
 440       { ARM_FRAG_STR_PRE_INC_REG_OFFSET_MID, && case_FRAG_STR_PRE_INC_REG_OFFSET_MID },
 441       { ARM_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_MID, && case_FRAG_STR_PRE_DEC_WB_IMM_OFFSET_MID },
 442       { ARM_FRAG_STR_PRE_DEC_WB_REG_OFFSET_MID, && case_FRAG_STR_PRE_DEC_WB_REG_OFFSET_MID },
 443       { ARM_FRAG_STR_PRE_INC_WB_IMM_OFFSET_MID, && case_FRAG_STR_PRE_INC_WB_IMM_OFFSET_MID },
 444       { ARM_FRAG_STR_PRE_INC_WB_REG_OFFSET_MID, && case_FRAG_STR_PRE_INC_WB_REG_OFFSET_MID },
 445       { ARM_FRAG_STRB_POST_DEC_IMM_OFFSET_MID, && case_FRAG_STRB_POST_DEC_IMM_OFFSET_MID },
 446       { ARM_FRAG_STRB_POST_INC_IMM_OFFSET_MID, && case_FRAG_STRB_POST_INC_IMM_OFFSET_MID },
 447       { ARM_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_MID, && case_FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_MID },
 448       { ARM_FRAG_STRB_POST_INC_NONPRIV_IMM_OFFSET_MID, && case_FRAG_STRB_POST_INC_NONPRIV_IMM_OFFSET_MID },
 449       { ARM_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_MID, && case_FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_MID },
 450       { ARM_FRAG_STRB_PRE_DEC_IMM_OFFSET_MID, && case_FRAG_STRB_PRE_DEC_IMM_OFFSET_MID },
 451       { ARM_FRAG_STRB_PRE_DEC_REG_OFFSET_MID, && case_FRAG_STRB_PRE_DEC_REG_OFFSET_MID },
 452       { ARM_FRAG_STRB_PRE_INC_IMM_OFFSET_MID, && case_FRAG_STRB_PRE_INC_IMM_OFFSET_MID },
 453       { ARM_FRAG_STRB_PRE_INC_REG_OFFSET_MID, && case_FRAG_STRB_PRE_INC_REG_OFFSET_MID },
 454       { ARM_FRAG_STRB_PRE_DEC_WB_IMM_OFFSET_MID, && case_FRAG_STRB_PRE_DEC_WB_IMM_OFFSET_MID },
 455       { ARM_FRAG_STRB_PRE_DEC_WB_REG_OFFSET_MID, && case_FRAG_STRB_PRE_DEC_WB_REG_OFFSET_MID },
 456       { ARM_FRAG_STRB_PRE_INC_WB_IMM_OFFSET_MID, && case_FRAG_STRB_PRE_INC_WB_IMM_OFFSET_MID },
 457       { ARM_FRAG_STRB_PRE_INC_WB_REG_OFFSET_MID, && case_FRAG_STRB_PRE_INC_WB_REG_OFFSET_MID },
 458       { ARM_FRAG_STRH_PRE_DEC_IMM_OFFSET_MID, && case_FRAG_STRH_PRE_DEC_IMM_OFFSET_MID },
 459       { ARM_FRAG_STRH_PRE_DEC_REG_OFFSET_MID, && case_FRAG_STRH_PRE_DEC_REG_OFFSET_MID },
 460       { ARM_FRAG_STRH_PRE_INC_IMM_OFFSET_MID, && case_FRAG_STRH_PRE_INC_IMM_OFFSET_MID },
 461       { ARM_FRAG_STRH_PRE_INC_REG_OFFSET_MID, && case_FRAG_STRH_PRE_INC_REG_OFFSET_MID },
 462       { ARM_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_MID, && case_FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_MID },
 463       { ARM_FRAG_STRH_PRE_DEC_WB_REG_OFFSET_MID, && case_FRAG_STRH_PRE_DEC_WB_REG_OFFSET_MID },
 464       { ARM_FRAG_STRH_PRE_INC_WB_IMM_OFFSET_MID, && case_FRAG_STRH_PRE_INC_WB_IMM_OFFSET_MID },
 465       { ARM_FRAG_STRH_PRE_INC_WB_REG_OFFSET_MID, && case_FRAG_STRH_PRE_INC_WB_REG_OFFSET_MID },
 466       { ARM_FRAG_STRH_POST_DEC_IMM_OFFSET_MID, && case_FRAG_STRH_POST_DEC_IMM_OFFSET_MID },
 467       { ARM_FRAG_STRH_POST_DEC_REG_OFFSET_MID, && case_FRAG_STRH_POST_DEC_REG_OFFSET_MID },
 468       { ARM_FRAG_STRH_POST_INC_IMM_OFFSET_MID, && case_FRAG_STRH_POST_INC_IMM_OFFSET_MID },
 469       { ARM_FRAG_STRH_POST_INC_REG_OFFSET_MID, && case_FRAG_STRH_POST_INC_REG_OFFSET_MID },
 470       { ARM_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_MID, && case_FRAG_LDRSB_PRE_DEC_IMM_OFFSET_MID },
 471       { ARM_FRAG_LDRSB_PRE_DEC_REG_OFFSET_MID, && case_FRAG_LDRSB_PRE_DEC_REG_OFFSET_MID },
 472       { ARM_FRAG_LDRSB_PRE_INC_IMM_OFFSET_MID, && case_FRAG_LDRSB_PRE_INC_IMM_OFFSET_MID },
 473       { ARM_FRAG_LDRSB_PRE_INC_REG_OFFSET_MID, && case_FRAG_LDRSB_PRE_INC_REG_OFFSET_MID },
 474       { ARM_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_MID, && case_FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_MID },
 475       { ARM_FRAG_LDRSB_PRE_DEC_WB_REG_OFFSET_MID, && case_FRAG_LDRSB_PRE_DEC_WB_REG_OFFSET_MID },
 476       { ARM_FRAG_LDRSB_PRE_INC_WB_IMM_OFFSET_MID, && case_FRAG_LDRSB_PRE_INC_WB_IMM_OFFSET_MID },
 477       { ARM_FRAG_LDRSB_PRE_INC_WB_REG_OFFSET_MID, && case_FRAG_LDRSB_PRE_INC_WB_REG_OFFSET_MID },
 478       { ARM_FRAG_LDRSB_POST_DEC_IMM_OFFSET_MID, && case_FRAG_LDRSB_POST_DEC_IMM_OFFSET_MID },
 479       { ARM_FRAG_LDRSB_POST_DEC_REG_OFFSET_MID, && case_FRAG_LDRSB_POST_DEC_REG_OFFSET_MID },
 480       { ARM_FRAG_LDRSB_POST_INC_IMM_OFFSET_MID, && case_FRAG_LDRSB_POST_INC_IMM_OFFSET_MID },
 481       { ARM_FRAG_LDRSB_POST_INC_REG_OFFSET_MID, && case_FRAG_LDRSB_POST_INC_REG_OFFSET_MID },
 482       { ARM_FRAG_LDRH_PRE_DEC_IMM_OFFSET_MID, && case_FRAG_LDRH_PRE_DEC_IMM_OFFSET_MID },
 483       { ARM_FRAG_LDRH_PRE_DEC_REG_OFFSET_MID, && case_FRAG_LDRH_PRE_DEC_REG_OFFSET_MID },
 484       { ARM_FRAG_LDRH_PRE_INC_IMM_OFFSET_MID, && case_FRAG_LDRH_PRE_INC_IMM_OFFSET_MID },
 485       { ARM_FRAG_LDRH_PRE_INC_REG_OFFSET_MID, && case_FRAG_LDRH_PRE_INC_REG_OFFSET_MID },
 486       { ARM_FRAG_LDRH_PRE_DEC_WB_IMM_OFFSET_MID, && case_FRAG_LDRH_PRE_DEC_WB_IMM_OFFSET_MID },
 487       { ARM_FRAG_LDRH_PRE_DEC_WB_REG_OFFSET_MID, && case_FRAG_LDRH_PRE_DEC_WB_REG_OFFSET_MID },
 488       { ARM_FRAG_LDRH_PRE_INC_WB_IMM_OFFSET_MID, && case_FRAG_LDRH_PRE_INC_WB_IMM_OFFSET_MID },
 489       { ARM_FRAG_LDRH_PRE_INC_WB_REG_OFFSET_MID, && case_FRAG_LDRH_PRE_INC_WB_REG_OFFSET_MID },
 490       { ARM_FRAG_LDRH_POST_DEC_IMM_OFFSET_MID, && case_FRAG_LDRH_POST_DEC_IMM_OFFSET_MID },
 491       { ARM_FRAG_LDRH_POST_DEC_REG_OFFSET_MID, && case_FRAG_LDRH_POST_DEC_REG_OFFSET_MID },
 492       { ARM_FRAG_LDRH_POST_INC_IMM_OFFSET_MID, && case_FRAG_LDRH_POST_INC_IMM_OFFSET_MID },
 493       { ARM_FRAG_LDRH_POST_INC_REG_OFFSET_MID, && case_FRAG_LDRH_POST_INC_REG_OFFSET_MID },
 494       { ARM_FRAG_LDRSH_PRE_DEC_IMM_OFFSET_MID, && case_FRAG_LDRSH_PRE_DEC_IMM_OFFSET_MID },
 495       { ARM_FRAG_LDRSH_PRE_DEC_REG_OFFSET_MID, && case_FRAG_LDRSH_PRE_DEC_REG_OFFSET_MID },
 496       { ARM_FRAG_LDRSH_PRE_INC_IMM_OFFSET_MID, && case_FRAG_LDRSH_PRE_INC_IMM_OFFSET_MID },
 497       { ARM_FRAG_LDRSH_PRE_INC_REG_OFFSET_MID, && case_FRAG_LDRSH_PRE_INC_REG_OFFSET_MID },
 498       { ARM_FRAG_LDRSH_PRE_DEC_WB_IMM_OFFSET_MID, && case_FRAG_LDRSH_PRE_DEC_WB_IMM_OFFSET_MID },
 499       { ARM_FRAG_LDRSH_PRE_DEC_WB_REG_OFFSET_MID, && case_FRAG_LDRSH_PRE_DEC_WB_REG_OFFSET_MID },
 500       { ARM_FRAG_LDRSH_PRE_INC_WB_IMM_OFFSET_MID, && case_FRAG_LDRSH_PRE_INC_WB_IMM_OFFSET_MID },
 501       { ARM_FRAG_LDRSH_PRE_INC_WB_REG_OFFSET_MID, && case_FRAG_LDRSH_PRE_INC_WB_REG_OFFSET_MID },
 502       { ARM_FRAG_LDRSH_POST_DEC_IMM_OFFSET_MID, && case_FRAG_LDRSH_POST_DEC_IMM_OFFSET_MID },
 503       { ARM_FRAG_LDRSH_POST_DEC_REG_OFFSET_MID, && case_FRAG_LDRSH_POST_DEC_REG_OFFSET_MID },
 504       { ARM_FRAG_LDRSH_POST_INC_IMM_OFFSET_MID, && case_FRAG_LDRSH_POST_INC_IMM_OFFSET_MID },
 505       { ARM_FRAG_LDRSH_POST_INC_REG_OFFSET_MID, && case_FRAG_LDRSH_POST_INC_REG_OFFSET_MID },
 506       { ARM_FRAG_MUL_MID, && case_FRAG_MUL_MID },
 507       { ARM_FRAG_MLA_MID, && case_FRAG_MLA_MID },
 508       { ARM_FRAG_UMULL_MID, && case_FRAG_UMULL_MID },
 509       { ARM_FRAG_UMLAL_MID, && case_FRAG_UMLAL_MID },
 510       { ARM_FRAG_SMULL_MID, && case_FRAG_SMULL_MID },
 511       { ARM_FRAG_SMLAL_MID, && case_FRAG_SMLAL_MID },
 512       { ARM_FRAG_SWP_MID, && case_FRAG_SWP_MID },
 513       { ARM_FRAG_SWPB_MID, && case_FRAG_SWPB_MID },
 514       { ARM_FRAG_SWI_MID, && case_FRAG_SWI_MID },
 515       { ARM_FRAG_AND_REG_IMM_SHIFT_MID, && case_FRAG_AND_REG_IMM_SHIFT_MID },
 516       { ARM_FRAG_AND_REG_REG_SHIFT_MID, && case_FRAG_AND_REG_REG_SHIFT_MID },
 517       { ARM_FRAG_AND_IMM_MID, && case_FRAG_AND_IMM_MID },
 518       { ARM_FRAG_ORR_REG_IMM_SHIFT_MID, && case_FRAG_ORR_REG_IMM_SHIFT_MID },
 519       { ARM_FRAG_ORR_REG_REG_SHIFT_MID, && case_FRAG_ORR_REG_REG_SHIFT_MID },
 520       { ARM_FRAG_ORR_IMM_MID, && case_FRAG_ORR_IMM_MID },
 521       { ARM_FRAG_EOR_REG_IMM_SHIFT_MID, && case_FRAG_EOR_REG_IMM_SHIFT_MID },
 522       { ARM_FRAG_EOR_REG_REG_SHIFT_MID, && case_FRAG_EOR_REG_REG_SHIFT_MID },
 523       { ARM_FRAG_EOR_IMM_MID, && case_FRAG_EOR_IMM_MID },
 524       { ARM_FRAG_MOV_REG_IMM_SHIFT_MID, && case_FRAG_MOV_REG_IMM_SHIFT_MID },
 525       { ARM_FRAG_MOV_REG_REG_SHIFT_MID, && case_FRAG_MOV_REG_REG_SHIFT_MID },
 526       { ARM_FRAG_MOV_IMM_MID, && case_FRAG_MOV_IMM_MID },
 527       { ARM_FRAG_BIC_REG_IMM_SHIFT_MID, && case_FRAG_BIC_REG_IMM_SHIFT_MID },
 528       { ARM_FRAG_BIC_REG_REG_SHIFT_MID, && case_FRAG_BIC_REG_REG_SHIFT_MID },
 529       { ARM_FRAG_BIC_IMM_MID, && case_FRAG_BIC_IMM_MID },
 530       { ARM_FRAG_MVN_REG_IMM_SHIFT_MID, && case_FRAG_MVN_REG_IMM_SHIFT_MID },
 531       { ARM_FRAG_MVN_REG_REG_SHIFT_MID, && case_FRAG_MVN_REG_REG_SHIFT_MID },
 532       { ARM_FRAG_MVN_IMM_MID, && case_FRAG_MVN_IMM_MID },
 533       { ARM_FRAG_ADD_REG_IMM_SHIFT_MID, && case_FRAG_ADD_REG_IMM_SHIFT_MID },
 534       { ARM_FRAG_ADD_REG_REG_SHIFT_MID, && case_FRAG_ADD_REG_REG_SHIFT_MID },
 535       { ARM_FRAG_ADD_IMM_MID, && case_FRAG_ADD_IMM_MID },
 536       { ARM_FRAG_ADC_REG_IMM_SHIFT_MID, && case_FRAG_ADC_REG_IMM_SHIFT_MID },
 537       { ARM_FRAG_ADC_REG_REG_SHIFT_MID, && case_FRAG_ADC_REG_REG_SHIFT_MID },
 538       { ARM_FRAG_ADC_IMM_MID, && case_FRAG_ADC_IMM_MID },
 539       { ARM_FRAG_SUB_REG_IMM_SHIFT_MID, && case_FRAG_SUB_REG_IMM_SHIFT_MID },
 540       { ARM_FRAG_SUB_REG_REG_SHIFT_MID, && case_FRAG_SUB_REG_REG_SHIFT_MID },
 541       { ARM_FRAG_SUB_IMM_MID, && case_FRAG_SUB_IMM_MID },
 542       { ARM_FRAG_SBC_REG_IMM_SHIFT_MID, && case_FRAG_SBC_REG_IMM_SHIFT_MID },
 543       { ARM_FRAG_SBC_REG_REG_SHIFT_MID, && case_FRAG_SBC_REG_REG_SHIFT_MID },
 544       { ARM_FRAG_SBC_IMM_MID, && case_FRAG_SBC_IMM_MID },
 545       { ARM_FRAG_RSB_REG_IMM_SHIFT_MID, && case_FRAG_RSB_REG_IMM_SHIFT_MID },
 546       { ARM_FRAG_RSB_REG_REG_SHIFT_MID, && case_FRAG_RSB_REG_REG_SHIFT_MID },
 547       { ARM_FRAG_RSB_IMM_MID, && case_FRAG_RSB_IMM_MID },
 548       { ARM_FRAG_RSC_REG_IMM_SHIFT_MID, && case_FRAG_RSC_REG_IMM_SHIFT_MID },
 549       { ARM_FRAG_RSC_REG_REG_SHIFT_MID, && case_FRAG_RSC_REG_REG_SHIFT_MID },
 550       { ARM_FRAG_RSC_IMM_MID, && case_FRAG_RSC_IMM_MID },
 551       { ARM_FRAG_TST_REG_IMM_SHIFT_MID, && case_FRAG_TST_REG_IMM_SHIFT_MID },
 552       { ARM_FRAG_TST_REG_REG_SHIFT_MID, && case_FRAG_TST_REG_REG_SHIFT_MID },
 553       { ARM_FRAG_TST_IMM_MID, && case_FRAG_TST_IMM_MID },
 554       { ARM_FRAG_TEQ_REG_IMM_SHIFT_MID, && case_FRAG_TEQ_REG_IMM_SHIFT_MID },
 555       { ARM_FRAG_TEQ_REG_REG_SHIFT_MID, && case_FRAG_TEQ_REG_REG_SHIFT_MID },
 556       { ARM_FRAG_TEQ_IMM_MID, && case_FRAG_TEQ_IMM_MID },
 557       { ARM_FRAG_CMP_REG_IMM_SHIFT_MID, && case_FRAG_CMP_REG_IMM_SHIFT_MID },
 558       { ARM_FRAG_CMP_REG_REG_SHIFT_MID, && case_FRAG_CMP_REG_REG_SHIFT_MID },
 559       { ARM_FRAG_CMP_IMM_MID, && case_FRAG_CMP_IMM_MID },
 560       { ARM_FRAG_CMN_REG_IMM_SHIFT_MID, && case_FRAG_CMN_REG_IMM_SHIFT_MID },
 561       { ARM_FRAG_CMN_REG_REG_SHIFT_MID, && case_FRAG_CMN_REG_REG_SHIFT_MID },
 562       { ARM_FRAG_CMN_IMM_MID, && case_FRAG_CMN_IMM_MID },
 563       { ARM_FRAG_LDMDA_MID, && case_FRAG_LDMDA_MID },
 564       { ARM_FRAG_LDMDA_SW_MID, && case_FRAG_LDMDA_SW_MID },
 565       { ARM_FRAG_LDMDA_WB_MID, && case_FRAG_LDMDA_WB_MID },
 566       { ARM_FRAG_LDMDA_SW_WB_MID, && case_FRAG_LDMDA_SW_WB_MID },
 567       { ARM_FRAG_LDMIB_MID, && case_FRAG_LDMIB_MID },
 568       { ARM_FRAG_LDMIB_SW_MID, && case_FRAG_LDMIB_SW_MID },
 569       { ARM_FRAG_LDMIB_WB_MID, && case_FRAG_LDMIB_WB_MID },
 570       { ARM_FRAG_LDMIB_SW_WB_MID, && case_FRAG_LDMIB_SW_WB_MID },
 571       { ARM_FRAG_LDMIA_MID, && case_FRAG_LDMIA_MID },
 572       { ARM_FRAG_LDMIA_SW_MID, && case_FRAG_LDMIA_SW_MID },
 573       { ARM_FRAG_LDMIA_WB_MID, && case_FRAG_LDMIA_WB_MID },
 574       { ARM_FRAG_LDMIA_SW_WB_MID, && case_FRAG_LDMIA_SW_WB_MID },
 575       { ARM_FRAG_LDMDB_MID, && case_FRAG_LDMDB_MID },
 576       { ARM_FRAG_LDMDB_SW_MID, && case_FRAG_LDMDB_SW_MID },
 577       { ARM_FRAG_LDMDB_WB_MID, && case_FRAG_LDMDB_WB_MID },
 578       { ARM_FRAG_LDMDB_SW_WB_MID, && case_FRAG_LDMDB_SW_WB_MID },
 579       { ARM_FRAG_STMDB_MID, && case_FRAG_STMDB_MID },
 580       { ARM_FRAG_STMDB_SW_MID, && case_FRAG_STMDB_SW_MID },
 581       { ARM_FRAG_STMDB_WB_MID, && case_FRAG_STMDB_WB_MID },
 582       { ARM_FRAG_STMDB_SW_WB_MID, && case_FRAG_STMDB_SW_WB_MID },
 583       { ARM_FRAG_STMIB_MID, && case_FRAG_STMIB_MID },
 584       { ARM_FRAG_STMIB_SW_MID, && case_FRAG_STMIB_SW_MID },
 585       { ARM_FRAG_STMIB_WB_MID, && case_FRAG_STMIB_WB_MID },
 586       { ARM_FRAG_STMIB_SW_WB_MID, && case_FRAG_STMIB_SW_WB_MID },
 587       { ARM_FRAG_STMIA_MID, && case_FRAG_STMIA_MID },
 588       { ARM_FRAG_STMIA_SW_MID, && case_FRAG_STMIA_SW_MID },
 589       { ARM_FRAG_STMIA_WB_MID, && case_FRAG_STMIA_WB_MID },
 590       { ARM_FRAG_STMIA_SW_WB_MID, && case_FRAG_STMIA_SW_WB_MID },
 591       { ARM_FRAG_STMDA_MID, && case_FRAG_STMDA_MID },
 592       { ARM_FRAG_STMDA_SW_MID, && case_FRAG_STMDA_SW_MID },
 593       { ARM_FRAG_STMDA_WB_MID, && case_FRAG_STMDA_WB_MID },
 594       { ARM_FRAG_STMDA_SW_WB_MID, && case_FRAG_STMDA_SW_WB_MID },
 595       { ARM_FRAG_MRS_C_MID, && case_FRAG_MRS_C_MID },
 596       { ARM_FRAG_MRS_S_MID, && case_FRAG_MRS_S_MID },
 597       { ARM_FRAG_MSR_C_MID, && case_FRAG_MSR_C_MID },
 598       { ARM_FRAG_MSR_S_MID, && case_FRAG_MSR_S_MID },
 599       { ARM_FRAG_MAX, 0 }
 600     };
 601
 602   if (! arm_idesc::idesc_table_initialized_p)
 603     {
 604       // Several tables are in play here:
 605       // idesc table: const table of misc things for each insn
 606       // frag usage table: const set of frags used by each insn
 607       // frag label table: same as frag usage table, but contains labels
 608       // selected insn frag table: table of pointers to either the frag usage
 609       // table (if !gnuc) or frag label table (if gnuc) for the currently
 610       // selected ISA.  Insns not in the ISA are redirected to the `invalid'
 611       // insn handler.  FIXME: This one isn't implemented yet.
 612
 613       // Allocate frag label table and point idesc table entries at it.
 614       // FIXME: Temporary hack, to be redone.
 615       static void** frag_label_table;
 616       int max_insns = ARM_INSN_MSR_S + 1;
 617       int tabsize = max_insns * 4;
 618       frag_label_table = new void* [tabsize];
 619       memset (frag_label_table, 0, sizeof (void*) * tabsize);
 620       int i;
 621       void** v;
 622       for (i = 0, v = frag_label_table; i < max_insns; ++i)
 623         {
 624           arm_idesc::idesc_table[arm_frag_usage[i].itype].cgoto.frags = v;
 625           for (int j = 0; arm_frag_usage[i].ftype[j] != ARM_FRAG_LIST_END; ++j)
 626             *v++ = labels[arm_frag_usage[i].ftype[j]].label;
 627         }
 628
 629       // Initialize the compiler virtual insn.
 630       // FIXME: Also needed if !gnuc.
 631       current_cpu->arm_engine.compile_begin_insn (current_cpu);
 632
 633       arm_idesc::idesc_table_initialized_p = true;
 634     }
 635 }
 636 #endif
 637
 638 #ifdef __GNUC__
 639 #define CASE(X) case_##X
 640 // Branch to next handler without going around main loop.
 641 #define NEXT_INSN(vpc, fragpc) fragpc = vpc->execute.cgoto.frags; goto * *fragpc
 642 #define NEXT_FRAG(fragpc) ++fragpc; goto * *fragpc
 643 // Break out of threaded interpreter and return to "main loop".
 644 #define BREAK(vpc) goto end_switch
 645 #else
 646 #define CASE(X) case ARM_##X
 647 #define NEXT_INSN(vpc, fragpc) fragpc = vpc->idesc->frags; goto restart
 648 #define NEXT_FRAG(fragpc) ++fragpc; goto restart
 649 #define BREAK(vpc) break
 650 #endif
 651
 652   // Get next insn to execute.
 653   vpc = current_cpu->arm_engine.get_next_vpc (current_cpu->h_pc_get ());
 654
 655   {
 656     // These two are used to pass data from cti insns to the cti-chain insn.
 657     PCADDR pbb_br_npc;
 658     branch_status pbb_br_status;
 659     // These two are used to build up values of the previous two.
 660     PCADDR npc;
 661     branch_status br_status;
 662     // Top level locals moved here so they're usable by multiple fragments.
 663     SI temp_op2;
 664     SI temp_op1;
 665     BI carry_out;
 666     SI operand2;
 667     SI temp;
 668     SI lo;
 669     SI hi;
 670     DI mul_result;
 671     SI result;
 672     SI offset;
 673     SI addr;
 674
 675 restart:
 676 #ifdef __GNUC__
 677   fragpc = vpc->execute.cgoto.frags;
 678   goto * *fragpc;
 679 #else
 680   fragpc = vpc->idesc->frags;
 681   switch (*fragpc)
 682 #endif
 683
 684     {
 685
 686 // ********** used by: mvn-reg/reg-shift, add-reg/reg-shift, adc-reg/reg-shift, sub-reg/reg-shift, sbc-reg/reg-shift, rsb-reg/reg-shift, rsc-reg/reg-shift
 687
 688   CASE (FRAG_MVN_REG_REG_SHIFT_HDR):
 689     {
 690       abuf = vpc;
 691       vpc = vpc + 1;
 692 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
 693       PCADDR pc = abuf->addr;
 694       br_status = BRANCH_UNTAKEN;
 695       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 696
 697 {
 698   operand2 = current_cpu->compute_operand2_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg));
 699 }
 700
 701 #undef FLD
 702     }
 703     NEXT_FRAG (fragpc);
 704
 705 // ********** used only by: cmp-reg/reg-shift
 706
 707   CASE (FRAG_CMP_REG_REG_SHIFT_HDR):
 708     {
 709       abuf = vpc;
 710       vpc = vpc + 1;
 711 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
 712       PCADDR pc = abuf->addr;
 713       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 714
 715 {
 716   operand2 = current_cpu->compute_operand2_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg));
 717 }
 718
 719 #undef FLD
 720     }
 721     NEXT_FRAG (fragpc);
 722
 723 // ********** used by: tst-reg/reg-shift, teq-reg/reg-shift
 724
 725   CASE (FRAG_TST_REG_REG_SHIFT_HDR):
 726     {
 727       abuf = vpc;
 728       vpc = vpc + 1;
 729 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
 730       PCADDR pc = abuf->addr;
 731       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 732
 733 {
 734   operand2 = current_cpu->compute_operand2_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg));
 735   carry_out = current_cpu->compute_carry_out_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg), current_cpu->hardware.h_cbit);
 736 }
 737
 738 #undef FLD
 739     }
 740     NEXT_FRAG (fragpc);
 741
 742 // ********** used by: orr-reg/reg-shift, eor-reg/reg-shift, mov-reg/reg-shift, bic-reg/reg-shift
 743
 744   CASE (FRAG_ORR_REG_REG_SHIFT_HDR):
 745     {
 746       abuf = vpc;
 747       vpc = vpc + 1;
 748 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
 749       PCADDR pc = abuf->addr;
 750       br_status = BRANCH_UNTAKEN;
 751       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 752
 753 {
 754   operand2 = current_cpu->compute_operand2_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg));
 755   carry_out = current_cpu->compute_carry_out_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg), current_cpu->hardware.h_cbit);
 756 }
 757
 758 #undef FLD
 759     }
 760     NEXT_FRAG (fragpc);
 761
 762 // ********** used by: mvn-reg/imm-shift, add-reg/imm-shift, adc-reg/imm-shift, sub-reg/imm-shift, sbc-reg/imm-shift, rsb-reg/imm-shift, rsc-reg/imm-shift
 763
 764   CASE (FRAG_MVN_REG_IMM_SHIFT_HDR):
 765     {
 766       abuf = vpc;
 767       vpc = vpc + 1;
 768 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 769       PCADDR pc = abuf->addr;
 770       br_status = BRANCH_UNTAKEN;
 771       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 772
 773 {
 774   operand2 = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 775 }
 776
 777 #undef FLD
 778     }
 779     NEXT_FRAG (fragpc);
 780
 781 // ********** used only by: cmp-reg/imm-shift
 782
 783   CASE (FRAG_CMP_REG_IMM_SHIFT_HDR):
 784     {
 785       abuf = vpc;
 786       vpc = vpc + 1;
 787 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 788       PCADDR pc = abuf->addr;
 789       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 790
 791 {
 792   operand2 = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 793 }
 794
 795 #undef FLD
 796     }
 797     NEXT_FRAG (fragpc);
 798
 799 // ********** used by: tst-reg/imm-shift, teq-reg/imm-shift
 800
 801   CASE (FRAG_TST_REG_IMM_SHIFT_HDR):
 802     {
 803       abuf = vpc;
 804       vpc = vpc + 1;
 805 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 806       PCADDR pc = abuf->addr;
 807       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 808
 809 {
 810   operand2 = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 811   carry_out = current_cpu->compute_carry_out_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm), current_cpu->hardware.h_cbit);
 812 }
 813
 814 #undef FLD
 815     }
 816     NEXT_FRAG (fragpc);
 817
 818 // ********** used by: orr-reg/imm-shift, eor-reg/imm-shift, mov-reg/imm-shift, bic-reg/imm-shift
 819
 820   CASE (FRAG_ORR_REG_IMM_SHIFT_HDR):
 821     {
 822       abuf = vpc;
 823       vpc = vpc + 1;
 824 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 825       PCADDR pc = abuf->addr;
 826       br_status = BRANCH_UNTAKEN;
 827       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 828
 829 {
 830   operand2 = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 831   carry_out = current_cpu->compute_carry_out_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm), current_cpu->hardware.h_cbit);
 832 }
 833
 834 #undef FLD
 835     }
 836     NEXT_FRAG (fragpc);
 837
 838 // ********** used by: strb-post-inc-nonpriv-reg-offset, str-pre-dec-wb-reg-offset, str-pre-dec-reg-offset, strb-pre-dec-wb-reg-offset, strb-pre-dec-reg-offset, str-pre-inc-wb-reg-offset, str-pre-inc-reg-offset, strb-pre-inc-wb-reg-offset
 839
 840   CASE (FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_HDR):
 841     {
 842       abuf = vpc;
 843       vpc = vpc + 1;
 844 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 845       PCADDR pc = abuf->addr;
 846       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 847
 848 {
 849   offset = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 850 }
 851
 852 #undef FLD
 853     }
 854     NEXT_FRAG (fragpc);
 855
 856 // ********** used by: ldr-pre-dec-wb-reg-offset, ldr-pre-dec-reg-offset, ldrb-pre-dec-wb-reg-offset, ldrb-pre-dec-reg-offset, ldr-pre-inc-wb-reg-offset, ldr-pre-inc-reg-offset, ldrb-pre-inc-wb-reg-offset, ldrb-pre-inc-reg-offset
 857
 858   CASE (FRAG_LDR_PRE_DEC_WB_REG_OFFSET_HDR):
 859     {
 860       abuf = vpc;
 861       vpc = vpc + 1;
 862 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 863       PCADDR pc = abuf->addr;
 864       br_status = BRANCH_UNTAKEN;
 865       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 866
 867 {
 868   offset = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 869 }
 870
 871 #undef FLD
 872     }
 873     NEXT_FRAG (fragpc);
 874
 875 // ********** used by: ldr-post-inc-nonpriv-reg-offset, ldrb-post-dec-reg-offset, ldrb-post-dec-nonpriv-reg-offset, ldrb-post-inc-reg-offset, ldrb-post-inc-nonpriv-reg-offset
 876
 877   CASE (FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_HDR):
 878     {
 879       abuf = vpc;
 880       vpc = vpc + 1;
 881 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 882       PCADDR pc = abuf->addr;
 883       br_status = BRANCH_UNTAKEN;
 884       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 885
 886 {
 887   offset = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 888   addr = * FLD (i_rn);
 889 }
 890
 891 #undef FLD
 892     }
 893     NEXT_FRAG (fragpc);
 894
 895 // ********** used by: str-post-dec-reg-offset, str-post-dec-nonpriv-reg-offset, str-post-inc-reg-offset, str-post-inc-nonpriv-reg-offset, strb-post-dec-reg-offset, strb-post-dec-nonpriv-reg-offset, strb-post-inc-reg-offset
 896
 897   CASE (FRAG_STR_POST_DEC_REG_OFFSET_HDR):
 898     {
 899       abuf = vpc;
 900       vpc = vpc + 1;
 901 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 902       PCADDR pc = abuf->addr;
 903       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 904
 905 {
 906   offset = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 907   addr = * FLD (i_rn);
 908 }
 909
 910 #undef FLD
 911     }
 912     NEXT_FRAG (fragpc);
 913
 914 // ********** used by: ldr-post-dec-nonpriv-reg-offset, ldr-post-inc-reg-offset
 915
 916   CASE (FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_HDR):
 917     {
 918       abuf = vpc;
 919       vpc = vpc + 1;
 920 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
 921       PCADDR pc = abuf->addr;
 922       br_status = BRANCH_UNTAKEN;
 923       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 924
 925 {
 926   offset = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
 927   addr = * FLD (i_rn);
 928 if (EQSI (FLD (f_rd), 15)) {
 929 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
 930 } else {
 931 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
 932 }
 933 }
 934
 935 #undef FLD
 936     }
 937     NEXT_FRAG (fragpc);
 938
 939 // ********** used by: stmda-wb, stmda-sw
 940
 941   CASE (FRAG_STMDA_WB_HDR):
 942     {
 943       abuf = vpc;
 944       vpc = vpc + 1;
 945 #define FLD(f) abuf->fields.sfmt_ldmda.f
 946       PCADDR pc = abuf->addr;
 947       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 948
 949 {
 950   addr = * FLD (i_rn);
 951 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
 952 {
 953 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
 954   addr = SUBSI (addr, 4);
 955 }
 956 }
 957 }
 958
 959 #undef FLD
 960     }
 961     NEXT_FRAG (fragpc);
 962
 963 // ********** used by: stmia-wb, stmia-sw
 964
 965   CASE (FRAG_STMIA_WB_HDR):
 966     {
 967       abuf = vpc;
 968       vpc = vpc + 1;
 969 #define FLD(f) abuf->fields.sfmt_ldmda.f
 970       PCADDR pc = abuf->addr;
 971       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
 972
 973 {
 974   addr = * FLD (i_rn);
 975 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
 976 {
 977 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
 978   addr = ADDSI (addr, 4);
 979 }
 980 }
 981 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
 982 {
 983 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
 984   addr = ADDSI (addr, 4);
 985 }
 986 }
 987 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
 988 {
 989 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
 990   addr = ADDSI (addr, 4);
 991 }
 992 }
 993 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
 994 {
 995 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
 996   addr = ADDSI (addr, 4);
 997 }
 998 }
 999 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
1000 {
1001 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
1002   addr = ADDSI (addr, 4);
1003 }
1004 }
1005 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
1006 {
1007 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
1008   addr = ADDSI (addr, 4);
1009 }
1010 }
1011 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
1012 {
1013 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
1014   addr = ADDSI (addr, 4);
1015 }
1016 }
1017 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
1018 {
1019 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
1020   addr = ADDSI (addr, 4);
1021 }
1022 }
1023 }
1024
1025 #undef FLD
1026     }
1027     NEXT_FRAG (fragpc);
1028
1029 // ********** used by: stmib-wb, stmib-sw
1030
1031   CASE (FRAG_STMIB_WB_HDR):
1032     {
1033       abuf = vpc;
1034       vpc = vpc + 1;
1035 #define FLD(f) abuf->fields.sfmt_ldmda.f
1036       PCADDR pc = abuf->addr;
1037       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
1038
1039 {
1040   addr = * FLD (i_rn);
1041 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
1042 {
1043   addr = ADDSI (addr, 4);
1044 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
1045 }
1046 }
1047 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
1048 {
1049   addr = ADDSI (addr, 4);
1050 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
1051 }
1052 }
1053 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
1054 {
1055   addr = ADDSI (addr, 4);
1056 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
1057 }
1058 }
1059 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
1060 {
1061   addr = ADDSI (addr, 4);
1062 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
1063 }
1064 }
1065 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
1066 {
1067   addr = ADDSI (addr, 4);
1068 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
1069 }
1070 }
1071 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
1072 {
1073   addr = ADDSI (addr, 4);
1074 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
1075 }
1076 }
1077 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
1078 {
1079   addr = ADDSI (addr, 4);
1080 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
1081 }
1082 }
1083 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
1084 {
1085   addr = ADDSI (addr, 4);
1086 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
1087 }
1088 }
1089 }
1090
1091 #undef FLD
1092     }
1093     NEXT_FRAG (fragpc);
1094
1095 // ********** used by: stmdb-wb, stmdb-sw
1096
1097   CASE (FRAG_STMDB_WB_HDR):
1098     {
1099       abuf = vpc;
1100       vpc = vpc + 1;
1101 #define FLD(f) abuf->fields.sfmt_ldmda.f
1102       PCADDR pc = abuf->addr;
1103       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
1104
1105 {
1106   addr = * FLD (i_rn);
1107 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
1108 {
1109   addr = SUBSI (addr, 4);
1110 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
1111 }
1112 }
1113 }
1114
1115 #undef FLD
1116     }
1117     NEXT_FRAG (fragpc);
1118
1119 // ********** used by: ldmia-wb, ldmia-sw
1120
1121   CASE (FRAG_LDMIA_WB_HDR):
1122     {
1123       abuf = vpc;
1124       vpc = vpc + 1;
1125 #define FLD(f) abuf->fields.sfmt_ldmda.f
1126       PCADDR pc = abuf->addr;
1127       br_status = BRANCH_UNTAKEN;
1128       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
1129
1130 {
1131   addr = * FLD (i_rn);
1132 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
1133 {
1134 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
1135   addr = ADDSI (addr, 4);
1136 }
1137 }
1138 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
1139 {
1140 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
1141   addr = ADDSI (addr, 4);
1142 }
1143 }
1144 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
1145 {
1146 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
1147   addr = ADDSI (addr, 4);
1148 }
1149 }
1150 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
1151 {
1152 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
1153   addr = ADDSI (addr, 4);
1154 }
1155 }
1156 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
1157 {
1158 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
1159   addr = ADDSI (addr, 4);
1160 }
1161 }
1162 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
1163 {
1164 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
1165   addr = ADDSI (addr, 4);
1166 }
1167 }
1168 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
1169 {
1170 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
1171   addr = ADDSI (addr, 4);
1172 }
1173 }
1174 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
1175 {
1176 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
1177   addr = ADDSI (addr, 4);
1178 }
1179 }
1180 }
1181
1182 #undef FLD
1183     }
1184     NEXT_FRAG (fragpc);
1185
1186 // ********** used by: ldmib-wb, ldmib-sw
1187
1188   CASE (FRAG_LDMIB_WB_HDR):
1189     {
1190       abuf = vpc;
1191       vpc = vpc + 1;
1192 #define FLD(f) abuf->fields.sfmt_ldmda.f
1193       PCADDR pc = abuf->addr;
1194       br_status = BRANCH_UNTAKEN;
1195       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
1196
1197 {
1198   addr = * FLD (i_rn);
1199 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
1200 {
1201   addr = ADDSI (addr, 4);
1202 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
1203 }
1204 }
1205 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
1206 {
1207   addr = ADDSI (addr, 4);
1208 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
1209 }
1210 }
1211 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
1212 {
1213   addr = ADDSI (addr, 4);
1214 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
1215 }
1216 }
1217 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
1218 {
1219   addr = ADDSI (addr, 4);
1220 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
1221 }
1222 }
1223 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
1224 {
1225   addr = ADDSI (addr, 4);
1226 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
1227 }
1228 }
1229 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
1230 {
1231   addr = ADDSI (addr, 4);
1232 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
1233 }
1234 }
1235 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
1236 {
1237   addr = ADDSI (addr, 4);
1238 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
1239 }
1240 }
1241 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
1242 {
1243   addr = ADDSI (addr, 4);
1244 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
1245 }
1246 }
1247 }
1248
1249 #undef FLD
1250     }
1251     NEXT_FRAG (fragpc);
1252
1253 // ********** used by: strb-post-dec-nonpriv-imm-offset, strb-post-inc-imm-offset
1254
1255   CASE (FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR):
1256     {
1257       abuf = vpc;
1258       vpc = vpc + 1;
1259 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1260       PCADDR pc = abuf->addr;
1261       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
1262
1263 {
1264   offset = FLD (f_uimm12);
1265   addr = * FLD (i_rn);
1266 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
1267 }
1268
1269 #undef FLD
1270     }
1271     NEXT_FRAG (fragpc);
1272
1273 // ********** used by: ldrb-post-dec-nonpriv-imm-offset, ldrb-post-inc-imm-offset
1274
1275   CASE (FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_HDR):
1276     {
1277       abuf = vpc;
1278       vpc = vpc + 1;
1279 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1280       PCADDR pc = abuf->addr;
1281       br_status = BRANCH_UNTAKEN;
1282       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
1283
1284 {
1285   offset = FLD (f_uimm12);
1286   addr = * FLD (i_rn);
1287 if (EQSI (FLD (f_rd), 15)) {
1288 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
1289 } else {
1290 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
1291 }
1292 }
1293
1294 #undef FLD
1295     }
1296     NEXT_FRAG (fragpc);
1297
1298 // ********** used by: ldr-post-dec-nonpriv-imm-offset, ldr-post-inc-imm-offset
1299
1300   CASE (FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_HDR):
1301     {
1302       abuf = vpc;
1303       vpc = vpc + 1;
1304 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1305       PCADDR pc = abuf->addr;
1306       br_status = BRANCH_UNTAKEN;
1307       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
1308
1309 {
1310   offset = FLD (f_uimm12);
1311   addr = * FLD (i_rn);
1312 if (EQSI (FLD (f_rd), 15)) {
1313 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
1314 } else {
1315 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
1316 }
1317 }
1318
1319 #undef FLD
1320     }
1321     NEXT_FRAG (fragpc);
1322
1323 // ********** used by:
1324
1325   CASE (FRAG_X_HEADER):
1326     {
1327       abuf = vpc;
1328       vpc = vpc + 1;
1329 #define FLD(f) abuf->fields.fmt_empty.f
1330       PCADDR pc = abuf->addr;
1331
1332 ((void) 0); /*nop*/
1333
1334 #undef FLD
1335     }
1336     NEXT_FRAG (fragpc);
1337
1338 // ********** used only by: tst-reg/reg-shift
1339
1340   CASE (FRAG_TST_REG_REG_SHIFT_TRLR):
1341     {
1342 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
1343       PCADDR pc = abuf->addr;
1344
1345 {
1346 if (EQSI (FLD (f_rd), 15)) {
1347 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
1348 } else {
1349 {
1350 {
1351 current_cpu->hardware.h_zbit = EQSI (result, 0);
1352 current_cpu->hardware.h_nbit = LTSI (result, 0);
1353 }
1354 current_cpu->hardware.h_cbit = carry_out;
1355 }
1356 }
1357 }
1358
1359 #undef FLD
1360     }
1361     NEXT_INSN (vpc, fragpc);
1362
1363 // ********** used only by: teq-reg/imm-shift
1364
1365   CASE (FRAG_TEQ_REG_IMM_SHIFT_TRLR):
1366     {
1367 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1368       PCADDR pc = abuf->addr;
1369
1370 {
1371 if (EQSI (FLD (f_rd), 15)) {
1372 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
1373 } else {
1374 {
1375 {
1376 current_cpu->hardware.h_zbit = EQSI (result, 0);
1377 current_cpu->hardware.h_nbit = LTSI (result, 0);
1378 }
1379 current_cpu->hardware.h_cbit = carry_out;
1380 }
1381 }
1382 }
1383
1384 #undef FLD
1385     }
1386     NEXT_INSN (vpc, fragpc);
1387
1388 // ********** used by: and-imm, orr-imm, eor-imm, mov-imm, bic-imm
1389
1390   CASE (FRAG_AND_IMM_TRLR):
1391     {
1392 #define FLD(f) abuf->fields.sfmt_and_imm.f
1393       PCADDR pc = abuf->addr;
1394
1395 {
1396 if (EQSI (FLD (f_rd), 15)) {
1397 {
1398 npc = result; br_status = BRANCH_UNCACHEABLE;
1399 if (FLD (f_set_cc_)) {
1400 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
1401 }
1402 }
1403 } else {
1404 {
1405 * FLD (i_rd) = result;
1406 if (FLD (f_set_cc_)) {
1407 {
1408 current_cpu->hardware.h_zbit = EQSI (result, 0);
1409 current_cpu->hardware.h_nbit = LTSI (result, 0);
1410 }
1411 }
1412 }
1413 }
1414 }
1415
1416       pbb_br_npc = npc;
1417       pbb_br_status = br_status;
1418 #undef FLD
1419     }
1420     NEXT_INSN (vpc, fragpc);
1421
1422 // ********** used by: and-reg/reg-shift, orr-reg/reg-shift, eor-reg/reg-shift, mov-reg/reg-shift, bic-reg/reg-shift
1423
1424   CASE (FRAG_AND_REG_REG_SHIFT_TRLR):
1425     {
1426 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
1427       PCADDR pc = abuf->addr;
1428
1429 {
1430 if (EQSI (FLD (f_rd), 15)) {
1431 {
1432 npc = result; br_status = BRANCH_UNCACHEABLE;
1433 if (FLD (f_set_cc_)) {
1434 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
1435 }
1436 }
1437 } else {
1438 {
1439 * FLD (i_rd) = result;
1440 if (FLD (f_set_cc_)) {
1441 {
1442 {
1443 current_cpu->hardware.h_zbit = EQSI (result, 0);
1444 current_cpu->hardware.h_nbit = LTSI (result, 0);
1445 }
1446 current_cpu->hardware.h_cbit = carry_out;
1447 }
1448 }
1449 }
1450 }
1451 }
1452
1453       pbb_br_npc = npc;
1454       pbb_br_status = br_status;
1455 #undef FLD
1456     }
1457     NEXT_INSN (vpc, fragpc);
1458
1459 // ********** used by: orr-reg/imm-shift, eor-reg/imm-shift, mov-reg/imm-shift, bic-reg/imm-shift, mvn-reg/imm-shift
1460
1461   CASE (FRAG_ORR_REG_IMM_SHIFT_TRLR):
1462     {
1463 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1464       PCADDR pc = abuf->addr;
1465
1466 {
1467 if (EQSI (FLD (f_rd), 15)) {
1468 {
1469 npc = result; br_status = BRANCH_UNCACHEABLE;
1470 if (FLD (f_set_cc_)) {
1471 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
1472 }
1473 }
1474 } else {
1475 {
1476 * FLD (i_rd) = result;
1477 if (FLD (f_set_cc_)) {
1478 {
1479 {
1480 current_cpu->hardware.h_zbit = EQSI (result, 0);
1481 current_cpu->hardware.h_nbit = LTSI (result, 0);
1482 }
1483 current_cpu->hardware.h_cbit = carry_out;
1484 }
1485 }
1486 }
1487 }
1488 }
1489
1490       pbb_br_npc = npc;
1491       pbb_br_status = br_status;
1492 #undef FLD
1493     }
1494     NEXT_INSN (vpc, fragpc);
1495
1496 // ********** used by: umull, umlal, smull
1497
1498   CASE (FRAG_UMULL_TRLR):
1499     {
1500 #define FLD(f) abuf->fields.sfmt_umull.f
1501       PCADDR pc = abuf->addr;
1502
1503 {
1504 * FLD (i_rdhi) = SUBWORDDISI (mul_result, 0);
1505 * FLD (i_rdlo) = SUBWORDDISI (mul_result, 1);
1506 if (FLD (f_set_cc_)) {
1507 {
1508 current_cpu->hardware.h_zbit = EQDI (mul_result, 0);
1509 current_cpu->hardware.h_nbit = LTDI (mul_result, 0);
1510 }
1511 }
1512 }
1513
1514 #undef FLD
1515     }
1516     NEXT_INSN (vpc, fragpc);
1517
1518 // ********** used by: ldr-pre-inc-imm-offset, ldrb-pre-dec-imm-offset, ldrb-pre-inc-imm-offset
1519
1520   CASE (FRAG_LDR_PRE_INC_IMM_OFFSET_TRLR):
1521     {
1522 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1523       PCADDR pc = abuf->addr;
1524
1525 {
1526 ((void) 0); /*nop*/
1527 ((void) 0); /*nop*/
1528 }
1529
1530       pbb_br_npc = npc;
1531       pbb_br_status = br_status;
1532 #undef FLD
1533     }
1534     NEXT_INSN (vpc, fragpc);
1535
1536 // ********** used by: ldrb-pre-dec-reg-offset, ldrb-pre-inc-reg-offset, ldrsb-pre-dec-reg-offset, ldrsb-pre-inc-reg-offset, ldrh-pre-dec-reg-offset, ldrh-pre-inc-reg-offset, ldrsh-pre-dec-reg-offset
1537
1538   CASE (FRAG_LDRB_PRE_DEC_REG_OFFSET_TRLR):
1539     {
1540 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1541       PCADDR pc = abuf->addr;
1542
1543 {
1544 ((void) 0); /*nop*/
1545 ((void) 0); /*nop*/
1546 }
1547
1548       pbb_br_npc = npc;
1549       pbb_br_status = br_status;
1550 #undef FLD
1551     }
1552     NEXT_INSN (vpc, fragpc);
1553
1554 // ********** used by: str-pre-dec-reg-offset, str-pre-inc-reg-offset, strb-pre-dec-reg-offset, strb-pre-inc-reg-offset, strh-pre-dec-reg-offset, strh-pre-inc-reg-offset
1555
1556   CASE (FRAG_STR_PRE_DEC_REG_OFFSET_TRLR):
1557     {
1558 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1559       PCADDR pc = abuf->addr;
1560
1561 {
1562 ((void) 0); /*nop*/
1563 ((void) 0); /*nop*/
1564 }
1565
1566 #undef FLD
1567     }
1568     NEXT_INSN (vpc, fragpc);
1569
1570 // ********** used by: str-pre-dec-imm-offset, str-pre-inc-imm-offset, strb-pre-dec-imm-offset, strb-pre-inc-imm-offset
1571
1572   CASE (FRAG_STR_PRE_DEC_IMM_OFFSET_TRLR):
1573     {
1574 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1575       PCADDR pc = abuf->addr;
1576
1577 {
1578 ((void) 0); /*nop*/
1579 ((void) 0); /*nop*/
1580 }
1581
1582 #undef FLD
1583     }
1584     NEXT_INSN (vpc, fragpc);
1585
1586 // ********** used by: strh-pre-dec-imm-offset, strh-pre-inc-imm-offset
1587
1588   CASE (FRAG_STRH_PRE_DEC_IMM_OFFSET_TRLR):
1589     {
1590 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
1591       PCADDR pc = abuf->addr;
1592
1593 {
1594 ((void) 0); /*nop*/
1595 ((void) 0); /*nop*/
1596 }
1597
1598 #undef FLD
1599     }
1600     NEXT_INSN (vpc, fragpc);
1601
1602 // ********** used by: ldrsb-pre-dec-imm-offset, ldrsb-pre-inc-imm-offset, ldrh-pre-dec-imm-offset, ldrh-pre-inc-imm-offset, ldrsh-pre-dec-imm-offset, ldrsh-pre-inc-imm-offset
1603
1604   CASE (FRAG_LDRSB_PRE_DEC_IMM_OFFSET_TRLR):
1605     {
1606 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
1607       PCADDR pc = abuf->addr;
1608
1609 {
1610 ((void) 0); /*nop*/
1611 ((void) 0); /*nop*/
1612 }
1613
1614       pbb_br_npc = npc;
1615       pbb_br_status = br_status;
1616 #undef FLD
1617     }
1618     NEXT_INSN (vpc, fragpc);
1619
1620 // ********** used only by: ldr-pre-dec-imm-offset
1621
1622   CASE (FRAG_LDR_PRE_DEC_IMM_OFFSET_TRLR):
1623     {
1624 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1625       PCADDR pc = abuf->addr;
1626
1627 {
1628 if (EQSI (FLD (f_rd), 15)) {
1629 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
1630 } else {
1631 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
1632 }
1633 ((void) 0); /*nop*/
1634 ((void) 0); /*nop*/
1635 }
1636
1637       pbb_br_npc = npc;
1638       pbb_br_status = br_status;
1639 #undef FLD
1640     }
1641     NEXT_INSN (vpc, fragpc);
1642
1643 // ********** used only by: ldr-pre-inc-reg-offset
1644
1645   CASE (FRAG_LDR_PRE_INC_REG_OFFSET_TRLR):
1646     {
1647 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1648       PCADDR pc = abuf->addr;
1649
1650 {
1651 if (EQSI (FLD (f_rd), 15)) {
1652 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
1653 } else {
1654 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
1655 }
1656 ((void) 0); /*nop*/
1657 ((void) 0); /*nop*/
1658 }
1659
1660       pbb_br_npc = npc;
1661       pbb_br_status = br_status;
1662 #undef FLD
1663     }
1664     NEXT_INSN (vpc, fragpc);
1665
1666 // ********** used by: ldr-pre-inc-wb-imm-offset, ldrb-pre-dec-wb-imm-offset, ldrb-pre-inc-wb-imm-offset
1667
1668   CASE (FRAG_LDR_PRE_INC_WB_IMM_OFFSET_TRLR):
1669     {
1670 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1671       PCADDR pc = abuf->addr;
1672
1673 {
1674 ((void) 0); /*nop*/
1675 * FLD (i_rn) = addr;
1676 }
1677
1678       pbb_br_npc = npc;
1679       pbb_br_status = br_status;
1680 #undef FLD
1681     }
1682     NEXT_INSN (vpc, fragpc);
1683
1684 // ********** used by: ldrb-pre-dec-wb-reg-offset, ldrb-pre-inc-wb-reg-offset, ldrsb-pre-dec-wb-reg-offset, ldrsb-pre-inc-wb-reg-offset, ldrh-pre-dec-wb-reg-offset, ldrh-pre-inc-wb-reg-offset, ldrsh-pre-dec-wb-reg-offset
1685
1686   CASE (FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_TRLR):
1687     {
1688 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1689       PCADDR pc = abuf->addr;
1690
1691 {
1692 ((void) 0); /*nop*/
1693 * FLD (i_rn) = addr;
1694 }
1695
1696       pbb_br_npc = npc;
1697       pbb_br_status = br_status;
1698 #undef FLD
1699     }
1700     NEXT_INSN (vpc, fragpc);
1701
1702 // ********** used by: str-pre-dec-wb-reg-offset, str-pre-inc-wb-reg-offset, strb-pre-dec-wb-reg-offset, strb-pre-inc-wb-reg-offset, strh-pre-dec-wb-reg-offset, strh-pre-inc-wb-reg-offset
1703
1704   CASE (FRAG_STR_PRE_DEC_WB_REG_OFFSET_TRLR):
1705     {
1706 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1707       PCADDR pc = abuf->addr;
1708
1709 {
1710 ((void) 0); /*nop*/
1711 * FLD (i_rn) = addr;
1712 }
1713
1714 #undef FLD
1715     }
1716     NEXT_INSN (vpc, fragpc);
1717
1718 // ********** used by: str-pre-dec-wb-imm-offset, str-pre-inc-wb-imm-offset, strb-pre-dec-wb-imm-offset, strb-pre-inc-wb-imm-offset
1719
1720   CASE (FRAG_STR_PRE_DEC_WB_IMM_OFFSET_TRLR):
1721     {
1722 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1723       PCADDR pc = abuf->addr;
1724
1725 {
1726 ((void) 0); /*nop*/
1727 * FLD (i_rn) = addr;
1728 }
1729
1730 #undef FLD
1731     }
1732     NEXT_INSN (vpc, fragpc);
1733
1734 // ********** used by: strh-pre-dec-wb-imm-offset, strh-pre-inc-wb-imm-offset
1735
1736   CASE (FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_TRLR):
1737     {
1738 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
1739       PCADDR pc = abuf->addr;
1740
1741 {
1742 ((void) 0); /*nop*/
1743 * FLD (i_rn) = addr;
1744 }
1745
1746 #undef FLD
1747     }
1748     NEXT_INSN (vpc, fragpc);
1749
1750 // ********** used by: ldrsb-pre-dec-wb-imm-offset, ldrsb-pre-inc-wb-imm-offset, ldrh-pre-dec-wb-imm-offset, ldrh-pre-inc-wb-imm-offset, ldrsh-pre-dec-wb-imm-offset, ldrsh-pre-inc-wb-imm-offset
1751
1752   CASE (FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_TRLR):
1753     {
1754 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
1755       PCADDR pc = abuf->addr;
1756
1757 {
1758 ((void) 0); /*nop*/
1759 * FLD (i_rn) = addr;
1760 }
1761
1762       pbb_br_npc = npc;
1763       pbb_br_status = br_status;
1764 #undef FLD
1765     }
1766     NEXT_INSN (vpc, fragpc);
1767
1768 // ********** used only by: ldr-pre-dec-wb-imm-offset
1769
1770   CASE (FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_TRLR):
1771     {
1772 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1773       PCADDR pc = abuf->addr;
1774
1775 {
1776 if (EQSI (FLD (f_rd), 15)) {
1777 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
1778 } else {
1779 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
1780 }
1781 ((void) 0); /*nop*/
1782 * FLD (i_rn) = addr;
1783 }
1784
1785       pbb_br_npc = npc;
1786       pbb_br_status = br_status;
1787 #undef FLD
1788     }
1789     NEXT_INSN (vpc, fragpc);
1790
1791 // ********** used only by: ldr-pre-inc-wb-reg-offset
1792
1793   CASE (FRAG_LDR_PRE_INC_WB_REG_OFFSET_TRLR):
1794     {
1795 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1796       PCADDR pc = abuf->addr;
1797
1798 {
1799 if (EQSI (FLD (f_rd), 15)) {
1800 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
1801 } else {
1802 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
1803 }
1804 ((void) 0); /*nop*/
1805 * FLD (i_rn) = addr;
1806 }
1807
1808       pbb_br_npc = npc;
1809       pbb_br_status = br_status;
1810 #undef FLD
1811     }
1812     NEXT_INSN (vpc, fragpc);
1813
1814 // ********** used by: strb-post-inc-reg-offset, strb-post-inc-nonpriv-reg-offset
1815
1816   CASE (FRAG_STRB_POST_INC_REG_OFFSET_TRLR):
1817     {
1818 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1819       PCADDR pc = abuf->addr;
1820
1821 {
1822 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
1823   addr = ADDSI (* FLD (i_rn), offset);
1824 * FLD (i_rn) = addr;
1825 }
1826
1827 #undef FLD
1828     }
1829     NEXT_INSN (vpc, fragpc);
1830
1831 // ********** used by: str-post-inc-reg-offset, str-post-inc-nonpriv-reg-offset
1832
1833   CASE (FRAG_STR_POST_INC_REG_OFFSET_TRLR):
1834     {
1835 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1836       PCADDR pc = abuf->addr;
1837
1838 {
1839 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
1840   addr = ADDSI (* FLD (i_rn), offset);
1841 * FLD (i_rn) = addr;
1842 }
1843
1844 #undef FLD
1845     }
1846     NEXT_INSN (vpc, fragpc);
1847
1848 // ********** used only by: str-post-inc-imm-offset
1849
1850   CASE (FRAG_STR_POST_INC_IMM_OFFSET_TRLR):
1851     {
1852 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1853       PCADDR pc = abuf->addr;
1854
1855 {
1856 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
1857   addr = ADDSI (* FLD (i_rn), offset);
1858 * FLD (i_rn) = addr;
1859 }
1860
1861 #undef FLD
1862     }
1863     NEXT_INSN (vpc, fragpc);
1864
1865 // ********** used by: ldrb-post-inc-reg-offset, ldrb-post-inc-nonpriv-reg-offset
1866
1867   CASE (FRAG_LDRB_POST_INC_REG_OFFSET_TRLR):
1868     {
1869 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1870       PCADDR pc = abuf->addr;
1871
1872 {
1873 if (EQSI (FLD (f_rd), 15)) {
1874 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
1875 } else {
1876 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
1877 }
1878   addr = ADDSI (* FLD (i_rn), offset);
1879 * FLD (i_rn) = addr;
1880 }
1881
1882       pbb_br_npc = npc;
1883       pbb_br_status = br_status;
1884 #undef FLD
1885     }
1886     NEXT_INSN (vpc, fragpc);
1887
1888 // ********** used by: strb-post-dec-reg-offset, strb-post-dec-nonpriv-reg-offset
1889
1890   CASE (FRAG_STRB_POST_DEC_REG_OFFSET_TRLR):
1891     {
1892 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1893       PCADDR pc = abuf->addr;
1894
1895 {
1896 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
1897   addr = SUBSI (* FLD (i_rn), offset);
1898 * FLD (i_rn) = addr;
1899 }
1900
1901 #undef FLD
1902     }
1903     NEXT_INSN (vpc, fragpc);
1904
1905 // ********** used by: str-post-dec-reg-offset, str-post-dec-nonpriv-reg-offset
1906
1907   CASE (FRAG_STR_POST_DEC_REG_OFFSET_TRLR):
1908     {
1909 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1910       PCADDR pc = abuf->addr;
1911
1912 {
1913 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
1914   addr = SUBSI (* FLD (i_rn), offset);
1915 * FLD (i_rn) = addr;
1916 }
1917
1918 #undef FLD
1919     }
1920     NEXT_INSN (vpc, fragpc);
1921
1922 // ********** used only by: str-post-dec-imm-offset
1923
1924   CASE (FRAG_STR_POST_DEC_IMM_OFFSET_TRLR):
1925     {
1926 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1927       PCADDR pc = abuf->addr;
1928
1929 {
1930 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
1931   addr = SUBSI (* FLD (i_rn), offset);
1932 * FLD (i_rn) = addr;
1933 }
1934
1935 #undef FLD
1936     }
1937     NEXT_INSN (vpc, fragpc);
1938
1939 // ********** used by: ldrb-post-dec-reg-offset, ldrb-post-dec-nonpriv-reg-offset
1940
1941   CASE (FRAG_LDRB_POST_DEC_REG_OFFSET_TRLR):
1942     {
1943 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1944       PCADDR pc = abuf->addr;
1945
1946 {
1947 if (EQSI (FLD (f_rd), 15)) {
1948 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
1949 } else {
1950 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
1951 }
1952   addr = SUBSI (* FLD (i_rn), offset);
1953 * FLD (i_rn) = addr;
1954 }
1955
1956       pbb_br_npc = npc;
1957       pbb_br_status = br_status;
1958 #undef FLD
1959     }
1960     NEXT_INSN (vpc, fragpc);
1961
1962 // ********** used by:
1963
1964   CASE (FRAG_X_TRAILER):
1965     {
1966 #define FLD(f) abuf->fields.fmt_empty.f
1967       PCADDR pc = abuf->addr;
1968
1969 ((void) 0); /*nop*/
1970
1971 #undef FLD
1972     }
1973     NEXT_INSN (vpc, fragpc);
1974
1975 // ********** used only by: x-cond
1976
1977   CASE (FRAG_X_COND_MID):
1978     {
1979       abuf = vpc;
1980       vpc = vpc + 1;
1981 #define FLD(f) abuf->fields.fmt_empty.f
1982       PCADDR pc = abuf->addr;
1983
1984 {
1985   {
1986     // Assume branch not taken.
1987     pbb_br_status = BRANCH_UNTAKEN;
1988     UINT cond_code = abuf->cond;
1989     BI exec_p = current_cpu->eval_cond (cond_code, pc);
1990     if (! exec_p)
1991       ++vpc;
1992   }
1993 }
1994
1995 #undef FLD
1996     }
1997     NEXT_INSN (vpc, fragpc);
1998
1999 // ********** used only by: x-after
2000
2001   CASE (FRAG_X_AFTER_MID):
2002     {
2003       abuf = vpc;
2004       vpc = vpc + 1;
2005 #define FLD(f) abuf->fields.fmt_empty.f
2006       PCADDR pc = abuf->addr;
2007
2008 {
2009   {
2010     current_cpu->arm_engine.pbb_after (current_cpu, abuf);
2011   }
2012 }
2013
2014 #undef FLD
2015     }
2016     NEXT_INSN (vpc, fragpc);
2017
2018 // ********** used only by: x-before
2019
2020   CASE (FRAG_X_BEFORE_MID):
2021     {
2022       abuf = vpc;
2023       vpc = vpc + 1;
2024 #define FLD(f) abuf->fields.fmt_empty.f
2025       PCADDR pc = abuf->addr;
2026
2027 {
2028   {
2029     current_cpu->arm_engine.pbb_before (current_cpu, abuf);
2030   }
2031 }
2032
2033 #undef FLD
2034     }
2035     NEXT_INSN (vpc, fragpc);
2036
2037 // ********** used only by: x-cti-chain
2038
2039   CASE (FRAG_X_CTI_CHAIN_MID):
2040     {
2041       abuf = vpc;
2042       vpc = vpc + 1;
2043 #define FLD(f) abuf->fields.fmt_empty.f
2044       PCADDR pc = abuf->addr;
2045
2046 {
2047   {
2048     vpc = current_cpu->arm_engine.pbb_cti_chain (current_cpu, abuf, pbb_br_status, pbb_br_npc);
2049     // If we don't have to give up control, don't.
2050     // Note that we may overrun step_insn_count since we do the test at the
2051     // end of the block.  This is defined to be ok.
2052     if (UNLIKELY(current_cpu->stop_after_insns_p (abuf->fields.chain.insn_count)))
2053       BREAK (vpc);
2054   }
2055 }
2056
2057 #undef FLD
2058     }
2059     NEXT_INSN (vpc, fragpc);
2060
2061 // ********** used only by: x-chain
2062
2063   CASE (FRAG_X_CHAIN_MID):
2064     {
2065       abuf = vpc;
2066       vpc = vpc + 1;
2067 #define FLD(f) abuf->fields.fmt_empty.f
2068       PCADDR pc = abuf->addr;
2069
2070 {
2071   {
2072     vpc = current_cpu->arm_engine.pbb_chain (current_cpu, abuf);
2073     // If we don't have to give up control, don't.
2074     // Note that we may overrun step_insn_count since we do the test at the
2075     // end of the block.  This is defined to be ok.
2076     if (UNLIKELY(current_cpu->stop_after_insns_p (abuf->fields.chain.insn_count)))
2077       BREAK (vpc);
2078   }
2079 }
2080
2081 #undef FLD
2082     }
2083     NEXT_INSN (vpc, fragpc);
2084
2085 // ********** used only by: x-begin
2086
2087   CASE (FRAG_X_BEGIN_MID):
2088     {
2089       abuf = vpc;
2090       vpc = vpc + 1;
2091 #define FLD(f) abuf->fields.fmt_empty.f
2092       PCADDR pc = abuf->addr;
2093
2094 {
2095   {
2096     vpc = current_cpu->arm_pbb_begin (current_cpu->h_pc_get ());
2097   }
2098 }
2099
2100 #undef FLD
2101     }
2102     NEXT_INSN (vpc, fragpc);
2103
2104 // ********** used only by: x-invalid
2105
2106   CASE (FRAG_X_INVALID_MID):
2107     {
2108       abuf = vpc;
2109       vpc = vpc + 1;
2110 #define FLD(f) abuf->fields.fmt_empty.f
2111       PCADDR pc = abuf->addr;
2112
2113 {
2114   {
2115     current_cpu->invalid_insn (pc);
2116     assert (0);
2117     /* NOTREACHED */
2118   }
2119 }
2120
2121 #undef FLD
2122     }
2123     NEXT_INSN (vpc, fragpc);
2124
2125 // ********** used only by: b
2126
2127   CASE (FRAG_B_MID):
2128     {
2129       abuf = vpc;
2130       vpc = vpc + 1;
2131 #define FLD(f) abuf->fields.sfmt_b.f
2132       PCADDR pc = abuf->addr;
2133       br_status = BRANCH_UNTAKEN;
2134       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2135
2136 {
2137 npc = FLD (i_offset24); br_status = BRANCH_CACHEABLE;
2138 }
2139
2140       pbb_br_npc = npc;
2141       pbb_br_status = br_status;
2142 #undef FLD
2143     }
2144     NEXT_INSN (vpc, fragpc);
2145
2146 // ********** used only by: bl
2147
2148   CASE (FRAG_BL_MID):
2149     {
2150       abuf = vpc;
2151       vpc = vpc + 1;
2152 #define FLD(f) abuf->fields.sfmt_b.f
2153       PCADDR pc = abuf->addr;
2154       br_status = BRANCH_UNTAKEN;
2155       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2156
2157 {
2158 current_cpu->hardware.h_gr[((UINT) 14)] = ANDSI (ADDSI (pc, 4), -4);
2159 npc = FLD (i_offset24); br_status = BRANCH_CACHEABLE;
2160 }
2161
2162       pbb_br_npc = npc;
2163       pbb_br_status = br_status;
2164 #undef FLD
2165     }
2166     NEXT_INSN (vpc, fragpc);
2167
2168 // ********** used only by: bx
2169
2170   CASE (FRAG_BX_MID):
2171     {
2172       abuf = vpc;
2173       vpc = vpc + 1;
2174 #define FLD(f) abuf->fields.sfmt_bx.f
2175       PCADDR pc = abuf->addr;
2176       br_status = BRANCH_UNTAKEN;
2177       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2178
2179 {
2180 npc = ANDSI (* FLD (i_bx_rn), 0xfffffffe); br_status = BRANCH_UNCACHEABLE;
2181 if (ANDSI (* FLD (i_bx_rn), 1)) {
2182 current_cpu->h_tbit_set (1);
2183 }
2184 }
2185
2186       pbb_br_npc = npc;
2187       pbb_br_status = br_status;
2188 #undef FLD
2189     }
2190     NEXT_INSN (vpc, fragpc);
2191
2192 // ********** used only by: ldr-post-dec-imm-offset
2193
2194   CASE (FRAG_LDR_POST_DEC_IMM_OFFSET_MID):
2195     {
2196       abuf = vpc;
2197       vpc = vpc + 1;
2198 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2199       PCADDR pc = abuf->addr;
2200       br_status = BRANCH_UNTAKEN;
2201       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2202
2203 {
2204   offset = FLD (f_uimm12);
2205   addr = * FLD (i_rn);
2206 if (EQSI (FLD (f_rd), 15)) {
2207 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
2208 } else {
2209 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
2210 }
2211   addr = SUBSI (* FLD (i_rn), offset);
2212 * FLD (i_rn) = addr;
2213 }
2214
2215       pbb_br_npc = npc;
2216       pbb_br_status = br_status;
2217 #undef FLD
2218     }
2219     NEXT_INSN (vpc, fragpc);
2220
2221 // ********** used only by: ldr-post-dec-reg-offset
2222
2223   CASE (FRAG_LDR_POST_DEC_REG_OFFSET_MID):
2224     {
2225       abuf = vpc;
2226       vpc = vpc + 1;
2227 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2228       PCADDR pc = abuf->addr;
2229       br_status = BRANCH_UNTAKEN;
2230       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2231
2232 {
2233   offset = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
2234   addr = * FLD (i_rn);
2235 if (EQSI (FLD (f_rd), 15)) {
2236 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
2237 } else {
2238 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
2239 }
2240   addr = SUBSI (* FLD (i_rn), offset);
2241 * FLD (i_rn) = addr;
2242 }
2243
2244       pbb_br_npc = npc;
2245       pbb_br_status = br_status;
2246 #undef FLD
2247     }
2248     NEXT_INSN (vpc, fragpc);
2249
2250 // ********** used only by: ldr-post-inc-imm-offset
2251
2252   CASE (FRAG_LDR_POST_INC_IMM_OFFSET_MID):
2253     {
2254 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2255       PCADDR pc = abuf->addr;
2256
2257 {
2258   addr = ADDSI (* FLD (i_rn), offset);
2259 * FLD (i_rn) = addr;
2260 }
2261
2262       pbb_br_npc = npc;
2263       pbb_br_status = br_status;
2264 #undef FLD
2265     }
2266     NEXT_INSN (vpc, fragpc);
2267
2268 // ********** used only by: ldr-post-inc-reg-offset
2269
2270   CASE (FRAG_LDR_POST_INC_REG_OFFSET_MID):
2271     {
2272 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2273       PCADDR pc = abuf->addr;
2274
2275 {
2276   addr = ADDSI (* FLD (i_rn), offset);
2277 * FLD (i_rn) = addr;
2278 }
2279
2280       pbb_br_npc = npc;
2281       pbb_br_status = br_status;
2282 #undef FLD
2283     }
2284     NEXT_INSN (vpc, fragpc);
2285
2286 // ********** used only by: ldr-post-dec-nonpriv-imm-offset
2287
2288   CASE (FRAG_LDR_POST_DEC_NONPRIV_IMM_OFFSET_MID):
2289     {
2290 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2291       PCADDR pc = abuf->addr;
2292
2293 {
2294   addr = SUBSI (* FLD (i_rn), offset);
2295 * FLD (i_rn) = addr;
2296 }
2297
2298       pbb_br_npc = npc;
2299       pbb_br_status = br_status;
2300 #undef FLD
2301     }
2302     NEXT_INSN (vpc, fragpc);
2303
2304 // ********** used only by: ldr-post-dec-nonpriv-reg-offset
2305
2306   CASE (FRAG_LDR_POST_DEC_NONPRIV_REG_OFFSET_MID):
2307     {
2308 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2309       PCADDR pc = abuf->addr;
2310
2311 {
2312   addr = SUBSI (* FLD (i_rn), offset);
2313 * FLD (i_rn) = addr;
2314 }
2315
2316       pbb_br_npc = npc;
2317       pbb_br_status = br_status;
2318 #undef FLD
2319     }
2320     NEXT_INSN (vpc, fragpc);
2321
2322 // ********** used only by: ldr-post-inc-nonpriv-imm-offset
2323
2324   CASE (FRAG_LDR_POST_INC_NONPRIV_IMM_OFFSET_MID):
2325     {
2326       abuf = vpc;
2327       vpc = vpc + 1;
2328 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2329       PCADDR pc = abuf->addr;
2330       br_status = BRANCH_UNTAKEN;
2331       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2332
2333 {
2334   offset = FLD (f_uimm12);
2335   addr = * FLD (i_rn);
2336 if (EQSI (FLD (f_rd), 15)) {
2337 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
2338 } else {
2339 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
2340 }
2341   addr = ADDSI (* FLD (i_rn), offset);
2342 * FLD (i_rn) = addr;
2343 }
2344
2345       pbb_br_npc = npc;
2346       pbb_br_status = br_status;
2347 #undef FLD
2348     }
2349     NEXT_INSN (vpc, fragpc);
2350
2351 // ********** used only by: ldr-post-inc-nonpriv-reg-offset
2352
2353   CASE (FRAG_LDR_POST_INC_NONPRIV_REG_OFFSET_MID):
2354     {
2355 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2356       PCADDR pc = abuf->addr;
2357
2358 {
2359 if (EQSI (FLD (f_rd), 15)) {
2360 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
2361 } else {
2362 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
2363 }
2364   addr = ADDSI (* FLD (i_rn), offset);
2365 * FLD (i_rn) = addr;
2366 }
2367
2368       pbb_br_npc = npc;
2369       pbb_br_status = br_status;
2370 #undef FLD
2371     }
2372     NEXT_INSN (vpc, fragpc);
2373
2374 // ********** used only by: ldr-pre-dec-imm-offset
2375
2376   CASE (FRAG_LDR_PRE_DEC_IMM_OFFSET_MID):
2377     {
2378       abuf = vpc;
2379       vpc = vpc + 1;
2380 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2381       PCADDR pc = abuf->addr;
2382       br_status = BRANCH_UNTAKEN;
2383       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2384
2385 {
2386   offset = FLD (f_uimm12);
2387   addr = SUBSI (* FLD (i_rn), offset);
2388 }
2389
2390 #undef FLD
2391     }
2392     NEXT_FRAG (fragpc);
2393
2394 // ********** used only by: ldr-pre-dec-reg-offset
2395
2396   CASE (FRAG_LDR_PRE_DEC_REG_OFFSET_MID):
2397     {
2398 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2399       PCADDR pc = abuf->addr;
2400
2401 {
2402   addr = SUBSI (* FLD (i_rn), offset);
2403 if (EQSI (FLD (f_rd), 15)) {
2404 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
2405 } else {
2406 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
2407 }
2408 ((void) 0); /*nop*/
2409 ((void) 0); /*nop*/
2410 }
2411
2412       pbb_br_npc = npc;
2413       pbb_br_status = br_status;
2414 #undef FLD
2415     }
2416     NEXT_INSN (vpc, fragpc);
2417
2418 // ********** used only by: ldr-pre-inc-imm-offset
2419
2420   CASE (FRAG_LDR_PRE_INC_IMM_OFFSET_MID):
2421     {
2422       abuf = vpc;
2423       vpc = vpc + 1;
2424 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2425       PCADDR pc = abuf->addr;
2426       br_status = BRANCH_UNTAKEN;
2427       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2428
2429 {
2430   offset = FLD (f_uimm12);
2431   addr = ADDSI (* FLD (i_rn), offset);
2432 if (EQSI (FLD (f_rd), 15)) {
2433 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
2434 } else {
2435 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
2436 }
2437 }
2438
2439 #undef FLD
2440     }
2441     NEXT_FRAG (fragpc);
2442
2443 // ********** used only by: ldr-pre-inc-reg-offset
2444
2445   CASE (FRAG_LDR_PRE_INC_REG_OFFSET_MID):
2446     {
2447 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2448       PCADDR pc = abuf->addr;
2449
2450 {
2451   addr = ADDSI (* FLD (i_rn), offset);
2452 }
2453
2454 #undef FLD
2455     }
2456     NEXT_FRAG (fragpc);
2457
2458 // ********** used only by: ldr-pre-dec-wb-imm-offset
2459
2460   CASE (FRAG_LDR_PRE_DEC_WB_IMM_OFFSET_MID):
2461     {
2462       abuf = vpc;
2463       vpc = vpc + 1;
2464 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2465       PCADDR pc = abuf->addr;
2466       br_status = BRANCH_UNTAKEN;
2467       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2468
2469 {
2470   offset = FLD (f_uimm12);
2471   addr = SUBSI (* FLD (i_rn), offset);
2472 }
2473
2474 #undef FLD
2475     }
2476     NEXT_FRAG (fragpc);
2477
2478 // ********** used only by: ldr-pre-dec-wb-reg-offset
2479
2480   CASE (FRAG_LDR_PRE_DEC_WB_REG_OFFSET_MID):
2481     {
2482 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2483       PCADDR pc = abuf->addr;
2484
2485 {
2486   addr = SUBSI (* FLD (i_rn), offset);
2487 if (EQSI (FLD (f_rd), 15)) {
2488 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
2489 } else {
2490 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
2491 }
2492 ((void) 0); /*nop*/
2493 * FLD (i_rn) = addr;
2494 }
2495
2496       pbb_br_npc = npc;
2497       pbb_br_status = br_status;
2498 #undef FLD
2499     }
2500     NEXT_INSN (vpc, fragpc);
2501
2502 // ********** used only by: ldr-pre-inc-wb-imm-offset
2503
2504   CASE (FRAG_LDR_PRE_INC_WB_IMM_OFFSET_MID):
2505     {
2506       abuf = vpc;
2507       vpc = vpc + 1;
2508 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2509       PCADDR pc = abuf->addr;
2510       br_status = BRANCH_UNTAKEN;
2511       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2512
2513 {
2514   offset = FLD (f_uimm12);
2515   addr = ADDSI (* FLD (i_rn), offset);
2516 if (EQSI (FLD (f_rd), 15)) {
2517 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
2518 } else {
2519 * FLD (i_rd) = current_cpu->GETMEMSI (pc, addr);
2520 }
2521 }
2522
2523 #undef FLD
2524     }
2525     NEXT_FRAG (fragpc);
2526
2527 // ********** used only by: ldr-pre-inc-wb-reg-offset
2528
2529   CASE (FRAG_LDR_PRE_INC_WB_REG_OFFSET_MID):
2530     {
2531 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2532       PCADDR pc = abuf->addr;
2533
2534 {
2535   addr = ADDSI (* FLD (i_rn), offset);
2536 }
2537
2538 #undef FLD
2539     }
2540     NEXT_FRAG (fragpc);
2541
2542 // ********** used only by: ldrb-post-dec-imm-offset
2543
2544   CASE (FRAG_LDRB_POST_DEC_IMM_OFFSET_MID):
2545     {
2546       abuf = vpc;
2547       vpc = vpc + 1;
2548 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2549       PCADDR pc = abuf->addr;
2550       br_status = BRANCH_UNTAKEN;
2551       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2552
2553 {
2554   offset = FLD (f_uimm12);
2555   addr = * FLD (i_rn);
2556 if (EQSI (FLD (f_rd), 15)) {
2557 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2558 } else {
2559 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2560 }
2561   addr = SUBSI (* FLD (i_rn), offset);
2562 * FLD (i_rn) = addr;
2563 }
2564
2565       pbb_br_npc = npc;
2566       pbb_br_status = br_status;
2567 #undef FLD
2568     }
2569     NEXT_INSN (vpc, fragpc);
2570
2571 // ********** used only by: ldrb-post-inc-imm-offset
2572
2573   CASE (FRAG_LDRB_POST_INC_IMM_OFFSET_MID):
2574     {
2575 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2576       PCADDR pc = abuf->addr;
2577
2578 {
2579   addr = ADDSI (* FLD (i_rn), offset);
2580 * FLD (i_rn) = addr;
2581 }
2582
2583       pbb_br_npc = npc;
2584       pbb_br_status = br_status;
2585 #undef FLD
2586     }
2587     NEXT_INSN (vpc, fragpc);
2588
2589 // ********** used only by: ldrb-post-dec-nonpriv-imm-offset
2590
2591   CASE (FRAG_LDRB_POST_DEC_NONPRIV_IMM_OFFSET_MID):
2592     {
2593 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2594       PCADDR pc = abuf->addr;
2595
2596 {
2597   addr = SUBSI (* FLD (i_rn), offset);
2598 * FLD (i_rn) = addr;
2599 }
2600
2601       pbb_br_npc = npc;
2602       pbb_br_status = br_status;
2603 #undef FLD
2604     }
2605     NEXT_INSN (vpc, fragpc);
2606
2607 // ********** used only by: ldrb-post-inc-nonpriv-imm-offset
2608
2609   CASE (FRAG_LDRB_POST_INC_NONPRIV_IMM_OFFSET_MID):
2610     {
2611       abuf = vpc;
2612       vpc = vpc + 1;
2613 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2614       PCADDR pc = abuf->addr;
2615       br_status = BRANCH_UNTAKEN;
2616       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2617
2618 {
2619   offset = FLD (f_uimm12);
2620   addr = * FLD (i_rn);
2621 if (EQSI (FLD (f_rd), 15)) {
2622 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2623 } else {
2624 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2625 }
2626   addr = ADDSI (* FLD (i_rn), offset);
2627 * FLD (i_rn) = addr;
2628 }
2629
2630       pbb_br_npc = npc;
2631       pbb_br_status = br_status;
2632 #undef FLD
2633     }
2634     NEXT_INSN (vpc, fragpc);
2635
2636 // ********** used only by: ldrb-pre-dec-imm-offset
2637
2638   CASE (FRAG_LDRB_PRE_DEC_IMM_OFFSET_MID):
2639     {
2640       abuf = vpc;
2641       vpc = vpc + 1;
2642 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2643       PCADDR pc = abuf->addr;
2644       br_status = BRANCH_UNTAKEN;
2645       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2646
2647 {
2648   offset = FLD (f_uimm12);
2649   addr = SUBSI (* FLD (i_rn), offset);
2650 if (EQSI (FLD (f_rd), 15)) {
2651 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2652 } else {
2653 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2654 }
2655 }
2656
2657 #undef FLD
2658     }
2659     NEXT_FRAG (fragpc);
2660
2661 // ********** used only by: ldrb-pre-dec-reg-offset
2662
2663   CASE (FRAG_LDRB_PRE_DEC_REG_OFFSET_MID):
2664     {
2665 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2666       PCADDR pc = abuf->addr;
2667
2668 {
2669   addr = SUBSI (* FLD (i_rn), offset);
2670 if (EQSI (FLD (f_rd), 15)) {
2671 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2672 } else {
2673 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2674 }
2675 }
2676
2677 #undef FLD
2678     }
2679     NEXT_FRAG (fragpc);
2680
2681 // ********** used only by: ldrb-pre-inc-imm-offset
2682
2683   CASE (FRAG_LDRB_PRE_INC_IMM_OFFSET_MID):
2684     {
2685       abuf = vpc;
2686       vpc = vpc + 1;
2687 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2688       PCADDR pc = abuf->addr;
2689       br_status = BRANCH_UNTAKEN;
2690       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2691
2692 {
2693   offset = FLD (f_uimm12);
2694   addr = ADDSI (* FLD (i_rn), offset);
2695 if (EQSI (FLD (f_rd), 15)) {
2696 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2697 } else {
2698 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2699 }
2700 }
2701
2702 #undef FLD
2703     }
2704     NEXT_FRAG (fragpc);
2705
2706 // ********** used only by: ldrb-pre-inc-reg-offset
2707
2708   CASE (FRAG_LDRB_PRE_INC_REG_OFFSET_MID):
2709     {
2710 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2711       PCADDR pc = abuf->addr;
2712
2713 {
2714   addr = ADDSI (* FLD (i_rn), offset);
2715 if (EQSI (FLD (f_rd), 15)) {
2716 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2717 } else {
2718 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2719 }
2720 }
2721
2722 #undef FLD
2723     }
2724     NEXT_FRAG (fragpc);
2725
2726 // ********** used only by: ldrb-pre-dec-wb-imm-offset
2727
2728   CASE (FRAG_LDRB_PRE_DEC_WB_IMM_OFFSET_MID):
2729     {
2730       abuf = vpc;
2731       vpc = vpc + 1;
2732 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2733       PCADDR pc = abuf->addr;
2734       br_status = BRANCH_UNTAKEN;
2735       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2736
2737 {
2738   offset = FLD (f_uimm12);
2739   addr = SUBSI (* FLD (i_rn), offset);
2740 if (EQSI (FLD (f_rd), 15)) {
2741 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2742 } else {
2743 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2744 }
2745 }
2746
2747 #undef FLD
2748     }
2749     NEXT_FRAG (fragpc);
2750
2751 // ********** used only by: ldrb-pre-dec-wb-reg-offset
2752
2753   CASE (FRAG_LDRB_PRE_DEC_WB_REG_OFFSET_MID):
2754     {
2755 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2756       PCADDR pc = abuf->addr;
2757
2758 {
2759   addr = SUBSI (* FLD (i_rn), offset);
2760 if (EQSI (FLD (f_rd), 15)) {
2761 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2762 } else {
2763 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2764 }
2765 }
2766
2767 #undef FLD
2768     }
2769     NEXT_FRAG (fragpc);
2770
2771 // ********** used only by: ldrb-pre-inc-wb-imm-offset
2772
2773   CASE (FRAG_LDRB_PRE_INC_WB_IMM_OFFSET_MID):
2774     {
2775       abuf = vpc;
2776       vpc = vpc + 1;
2777 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2778       PCADDR pc = abuf->addr;
2779       br_status = BRANCH_UNTAKEN;
2780       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2781
2782 {
2783   offset = FLD (f_uimm12);
2784   addr = ADDSI (* FLD (i_rn), offset);
2785 if (EQSI (FLD (f_rd), 15)) {
2786 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2787 } else {
2788 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2789 }
2790 }
2791
2792 #undef FLD
2793     }
2794     NEXT_FRAG (fragpc);
2795
2796 // ********** used only by: ldrb-pre-inc-wb-reg-offset
2797
2798   CASE (FRAG_LDRB_PRE_INC_WB_REG_OFFSET_MID):
2799     {
2800 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2801       PCADDR pc = abuf->addr;
2802
2803 {
2804   addr = ADDSI (* FLD (i_rn), offset);
2805 if (EQSI (FLD (f_rd), 15)) {
2806 npc = ZEXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
2807 } else {
2808 * FLD (i_rd) = ZEXTQISI (current_cpu->GETMEMQI (pc, addr));
2809 }
2810 }
2811
2812 #undef FLD
2813     }
2814     NEXT_FRAG (fragpc);
2815
2816 // ********** used only by: str-post-dec-imm-offset
2817
2818   CASE (FRAG_STR_POST_DEC_IMM_OFFSET_MID):
2819     {
2820       abuf = vpc;
2821       vpc = vpc + 1;
2822 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2823       PCADDR pc = abuf->addr;
2824       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2825
2826 {
2827   offset = FLD (f_uimm12);
2828   addr = * FLD (i_rn);
2829 }
2830
2831 #undef FLD
2832     }
2833     NEXT_FRAG (fragpc);
2834
2835 // ********** used only by: str-post-inc-imm-offset
2836
2837   CASE (FRAG_STR_POST_INC_IMM_OFFSET_MID):
2838     {
2839       abuf = vpc;
2840       vpc = vpc + 1;
2841 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2842       PCADDR pc = abuf->addr;
2843       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2844
2845 {
2846   offset = FLD (f_uimm12);
2847   addr = * FLD (i_rn);
2848 }
2849
2850 #undef FLD
2851     }
2852     NEXT_FRAG (fragpc);
2853
2854 // ********** used only by: str-post-dec-nonpriv-imm-offset
2855
2856   CASE (FRAG_STR_POST_DEC_NONPRIV_IMM_OFFSET_MID):
2857     {
2858       abuf = vpc;
2859       vpc = vpc + 1;
2860 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2861       PCADDR pc = abuf->addr;
2862       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2863
2864 {
2865   offset = FLD (f_uimm12);
2866   addr = * FLD (i_rn);
2867 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
2868   addr = SUBSI (* FLD (i_rn), offset);
2869 * FLD (i_rn) = addr;
2870 }
2871
2872 #undef FLD
2873     }
2874     NEXT_INSN (vpc, fragpc);
2875
2876 // ********** used only by: str-post-inc-nonpriv-imm-offset
2877
2878   CASE (FRAG_STR_POST_INC_NONPRIV_IMM_OFFSET_MID):
2879     {
2880       abuf = vpc;
2881       vpc = vpc + 1;
2882 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2883       PCADDR pc = abuf->addr;
2884       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2885
2886 {
2887   offset = FLD (f_uimm12);
2888   addr = * FLD (i_rn);
2889 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
2890   addr = ADDSI (* FLD (i_rn), offset);
2891 * FLD (i_rn) = addr;
2892 }
2893
2894 #undef FLD
2895     }
2896     NEXT_INSN (vpc, fragpc);
2897
2898 // ********** used only by: str-pre-dec-imm-offset
2899
2900   CASE (FRAG_STR_PRE_DEC_IMM_OFFSET_MID):
2901     {
2902       abuf = vpc;
2903       vpc = vpc + 1;
2904 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2905       PCADDR pc = abuf->addr;
2906       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2907
2908 {
2909   offset = FLD (f_uimm12);
2910   addr = SUBSI (* FLD (i_rn), offset);
2911 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
2912 }
2913
2914 #undef FLD
2915     }
2916     NEXT_FRAG (fragpc);
2917
2918 // ********** used only by: str-pre-dec-reg-offset
2919
2920   CASE (FRAG_STR_PRE_DEC_REG_OFFSET_MID):
2921     {
2922 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2923       PCADDR pc = abuf->addr;
2924
2925 {
2926   addr = SUBSI (* FLD (i_rn), offset);
2927 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
2928 }
2929
2930 #undef FLD
2931     }
2932     NEXT_FRAG (fragpc);
2933
2934 // ********** used only by: str-pre-inc-imm-offset
2935
2936   CASE (FRAG_STR_PRE_INC_IMM_OFFSET_MID):
2937     {
2938       abuf = vpc;
2939       vpc = vpc + 1;
2940 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2941       PCADDR pc = abuf->addr;
2942       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2943
2944 {
2945   offset = FLD (f_uimm12);
2946   addr = ADDSI (* FLD (i_rn), offset);
2947 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
2948 }
2949
2950 #undef FLD
2951     }
2952     NEXT_FRAG (fragpc);
2953
2954 // ********** used only by: str-pre-inc-reg-offset
2955
2956   CASE (FRAG_STR_PRE_INC_REG_OFFSET_MID):
2957     {
2958 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2959       PCADDR pc = abuf->addr;
2960
2961 {
2962   addr = ADDSI (* FLD (i_rn), offset);
2963 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
2964 }
2965
2966 #undef FLD
2967     }
2968     NEXT_FRAG (fragpc);
2969
2970 // ********** used only by: str-pre-dec-wb-imm-offset
2971
2972   CASE (FRAG_STR_PRE_DEC_WB_IMM_OFFSET_MID):
2973     {
2974       abuf = vpc;
2975       vpc = vpc + 1;
2976 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2977       PCADDR pc = abuf->addr;
2978       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
2979
2980 {
2981   offset = FLD (f_uimm12);
2982   addr = SUBSI (* FLD (i_rn), offset);
2983 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
2984 }
2985
2986 #undef FLD
2987     }
2988     NEXT_FRAG (fragpc);
2989
2990 // ********** used only by: str-pre-dec-wb-reg-offset
2991
2992   CASE (FRAG_STR_PRE_DEC_WB_REG_OFFSET_MID):
2993     {
2994 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2995       PCADDR pc = abuf->addr;
2996
2997 {
2998   addr = SUBSI (* FLD (i_rn), offset);
2999 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
3000 }
3001
3002 #undef FLD
3003     }
3004     NEXT_FRAG (fragpc);
3005
3006 // ********** used only by: str-pre-inc-wb-imm-offset
3007
3008   CASE (FRAG_STR_PRE_INC_WB_IMM_OFFSET_MID):
3009     {
3010       abuf = vpc;
3011       vpc = vpc + 1;
3012 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3013       PCADDR pc = abuf->addr;
3014       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3015
3016 {
3017   offset = FLD (f_uimm12);
3018   addr = ADDSI (* FLD (i_rn), offset);
3019 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
3020 }
3021
3022 #undef FLD
3023     }
3024     NEXT_FRAG (fragpc);
3025
3026 // ********** used only by: str-pre-inc-wb-reg-offset
3027
3028   CASE (FRAG_STR_PRE_INC_WB_REG_OFFSET_MID):
3029     {
3030 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3031       PCADDR pc = abuf->addr;
3032
3033 {
3034   addr = ADDSI (* FLD (i_rn), offset);
3035 current_cpu->SETMEMSI (pc, addr, * FLD (i_rd));
3036 }
3037
3038 #undef FLD
3039     }
3040     NEXT_FRAG (fragpc);
3041
3042 // ********** used only by: strb-post-dec-imm-offset
3043
3044   CASE (FRAG_STRB_POST_DEC_IMM_OFFSET_MID):
3045     {
3046       abuf = vpc;
3047       vpc = vpc + 1;
3048 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3049       PCADDR pc = abuf->addr;
3050       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3051
3052 {
3053   offset = FLD (f_uimm12);
3054   addr = * FLD (i_rn);
3055 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3056   addr = SUBSI (* FLD (i_rn), offset);
3057 * FLD (i_rn) = addr;
3058 }
3059
3060 #undef FLD
3061     }
3062     NEXT_INSN (vpc, fragpc);
3063
3064 // ********** used only by: strb-post-inc-imm-offset
3065
3066   CASE (FRAG_STRB_POST_INC_IMM_OFFSET_MID):
3067     {
3068 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3069       PCADDR pc = abuf->addr;
3070
3071 {
3072   addr = ADDSI (* FLD (i_rn), offset);
3073 * FLD (i_rn) = addr;
3074 }
3075
3076 #undef FLD
3077     }
3078     NEXT_INSN (vpc, fragpc);
3079
3080 // ********** used only by: strb-post-dec-nonpriv-imm-offset
3081
3082   CASE (FRAG_STRB_POST_DEC_NONPRIV_IMM_OFFSET_MID):
3083     {
3084 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3085       PCADDR pc = abuf->addr;
3086
3087 {
3088   addr = SUBSI (* FLD (i_rn), offset);
3089 * FLD (i_rn) = addr;
3090 }
3091
3092 #undef FLD
3093     }
3094     NEXT_INSN (vpc, fragpc);
3095
3096 // ********** used only by: strb-post-inc-nonpriv-imm-offset
3097
3098   CASE (FRAG_STRB_POST_INC_NONPRIV_IMM_OFFSET_MID):
3099     {
3100       abuf = vpc;
3101       vpc = vpc + 1;
3102 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3103       PCADDR pc = abuf->addr;
3104       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3105
3106 {
3107   offset = FLD (f_uimm12);
3108   addr = * FLD (i_rn);
3109 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3110   addr = ADDSI (* FLD (i_rn), offset);
3111 * FLD (i_rn) = addr;
3112 }
3113
3114 #undef FLD
3115     }
3116     NEXT_INSN (vpc, fragpc);
3117
3118 // ********** used only by: strb-post-inc-nonpriv-reg-offset
3119
3120   CASE (FRAG_STRB_POST_INC_NONPRIV_REG_OFFSET_MID):
3121     {
3122 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3123       PCADDR pc = abuf->addr;
3124
3125 {
3126   addr = * FLD (i_rn);
3127 }
3128
3129 #undef FLD
3130     }
3131     NEXT_FRAG (fragpc);
3132
3133 // ********** used only by: strb-pre-dec-imm-offset
3134
3135   CASE (FRAG_STRB_PRE_DEC_IMM_OFFSET_MID):
3136     {
3137       abuf = vpc;
3138       vpc = vpc + 1;
3139 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3140       PCADDR pc = abuf->addr;
3141       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3142
3143 {
3144   offset = FLD (f_uimm12);
3145   addr = SUBSI (* FLD (i_rn), offset);
3146 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3147 }
3148
3149 #undef FLD
3150     }
3151     NEXT_FRAG (fragpc);
3152
3153 // ********** used only by: strb-pre-dec-reg-offset
3154
3155   CASE (FRAG_STRB_PRE_DEC_REG_OFFSET_MID):
3156     {
3157 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3158       PCADDR pc = abuf->addr;
3159
3160 {
3161   addr = SUBSI (* FLD (i_rn), offset);
3162 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3163 }
3164
3165 #undef FLD
3166     }
3167     NEXT_FRAG (fragpc);
3168
3169 // ********** used only by: strb-pre-inc-imm-offset
3170
3171   CASE (FRAG_STRB_PRE_INC_IMM_OFFSET_MID):
3172     {
3173       abuf = vpc;
3174       vpc = vpc + 1;
3175 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3176       PCADDR pc = abuf->addr;
3177       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3178
3179 {
3180   offset = FLD (f_uimm12);
3181   addr = ADDSI (* FLD (i_rn), offset);
3182 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3183 }
3184
3185 #undef FLD
3186     }
3187     NEXT_FRAG (fragpc);
3188
3189 // ********** used only by: strb-pre-inc-reg-offset
3190
3191   CASE (FRAG_STRB_PRE_INC_REG_OFFSET_MID):
3192     {
3193       abuf = vpc;
3194       vpc = vpc + 1;
3195 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3196       PCADDR pc = abuf->addr;
3197       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3198
3199 {
3200   offset = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
3201   addr = ADDSI (* FLD (i_rn), offset);
3202 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3203 }
3204
3205 #undef FLD
3206     }
3207     NEXT_FRAG (fragpc);
3208
3209 // ********** used only by: strb-pre-dec-wb-imm-offset
3210
3211   CASE (FRAG_STRB_PRE_DEC_WB_IMM_OFFSET_MID):
3212     {
3213       abuf = vpc;
3214       vpc = vpc + 1;
3215 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3216       PCADDR pc = abuf->addr;
3217       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3218
3219 {
3220   offset = FLD (f_uimm12);
3221   addr = SUBSI (* FLD (i_rn), offset);
3222 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3223 }
3224
3225 #undef FLD
3226     }
3227     NEXT_FRAG (fragpc);
3228
3229 // ********** used only by: strb-pre-dec-wb-reg-offset
3230
3231   CASE (FRAG_STRB_PRE_DEC_WB_REG_OFFSET_MID):
3232     {
3233 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3234       PCADDR pc = abuf->addr;
3235
3236 {
3237   addr = SUBSI (* FLD (i_rn), offset);
3238 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3239 }
3240
3241 #undef FLD
3242     }
3243     NEXT_FRAG (fragpc);
3244
3245 // ********** used only by: strb-pre-inc-wb-imm-offset
3246
3247   CASE (FRAG_STRB_PRE_INC_WB_IMM_OFFSET_MID):
3248     {
3249       abuf = vpc;
3250       vpc = vpc + 1;
3251 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
3252       PCADDR pc = abuf->addr;
3253       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3254
3255 {
3256   offset = FLD (f_uimm12);
3257   addr = ADDSI (* FLD (i_rn), offset);
3258 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3259 }
3260
3261 #undef FLD
3262     }
3263     NEXT_FRAG (fragpc);
3264
3265 // ********** used only by: strb-pre-inc-wb-reg-offset
3266
3267   CASE (FRAG_STRB_PRE_INC_WB_REG_OFFSET_MID):
3268     {
3269 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3270       PCADDR pc = abuf->addr;
3271
3272 {
3273   addr = ADDSI (* FLD (i_rn), offset);
3274 current_cpu->SETMEMQI (pc, addr, TRUNCSIQI (* FLD (i_rd)));
3275 }
3276
3277 #undef FLD
3278     }
3279     NEXT_FRAG (fragpc);
3280
3281 // ********** used only by: strh-pre-dec-imm-offset
3282
3283   CASE (FRAG_STRH_PRE_DEC_IMM_OFFSET_MID):
3284     {
3285       abuf = vpc;
3286       vpc = vpc + 1;
3287 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3288       PCADDR pc = abuf->addr;
3289       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3290
3291 {
3292   offset = FLD (i_hdt_offset8);
3293   addr = SUBSI (* FLD (i_rn), offset);
3294 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3295 }
3296
3297 #undef FLD
3298     }
3299     NEXT_FRAG (fragpc);
3300
3301 // ********** used only by: strh-pre-dec-reg-offset
3302
3303   CASE (FRAG_STRH_PRE_DEC_REG_OFFSET_MID):
3304     {
3305       abuf = vpc;
3306       vpc = vpc + 1;
3307 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3308       PCADDR pc = abuf->addr;
3309       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3310
3311 {
3312   offset = * FLD (i_rm);
3313   addr = SUBSI (* FLD (i_rn), offset);
3314 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3315 }
3316
3317 #undef FLD
3318     }
3319     NEXT_FRAG (fragpc);
3320
3321 // ********** used only by: strh-pre-inc-imm-offset
3322
3323   CASE (FRAG_STRH_PRE_INC_IMM_OFFSET_MID):
3324     {
3325       abuf = vpc;
3326       vpc = vpc + 1;
3327 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3328       PCADDR pc = abuf->addr;
3329       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3330
3331 {
3332   offset = FLD (i_hdt_offset8);
3333   addr = ADDSI (* FLD (i_rn), offset);
3334 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3335 }
3336
3337 #undef FLD
3338     }
3339     NEXT_FRAG (fragpc);
3340
3341 // ********** used only by: strh-pre-inc-reg-offset
3342
3343   CASE (FRAG_STRH_PRE_INC_REG_OFFSET_MID):
3344     {
3345       abuf = vpc;
3346       vpc = vpc + 1;
3347 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3348       PCADDR pc = abuf->addr;
3349       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3350
3351 {
3352   offset = * FLD (i_rm);
3353   addr = ADDSI (* FLD (i_rn), offset);
3354 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3355 }
3356
3357 #undef FLD
3358     }
3359     NEXT_FRAG (fragpc);
3360
3361 // ********** used only by: strh-pre-dec-wb-imm-offset
3362
3363   CASE (FRAG_STRH_PRE_DEC_WB_IMM_OFFSET_MID):
3364     {
3365       abuf = vpc;
3366       vpc = vpc + 1;
3367 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3368       PCADDR pc = abuf->addr;
3369       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3370
3371 {
3372   offset = FLD (i_hdt_offset8);
3373   addr = SUBSI (* FLD (i_rn), offset);
3374 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3375 }
3376
3377 #undef FLD
3378     }
3379     NEXT_FRAG (fragpc);
3380
3381 // ********** used only by: strh-pre-dec-wb-reg-offset
3382
3383   CASE (FRAG_STRH_PRE_DEC_WB_REG_OFFSET_MID):
3384     {
3385       abuf = vpc;
3386       vpc = vpc + 1;
3387 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3388       PCADDR pc = abuf->addr;
3389       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3390
3391 {
3392   offset = * FLD (i_rm);
3393   addr = SUBSI (* FLD (i_rn), offset);
3394 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3395 }
3396
3397 #undef FLD
3398     }
3399     NEXT_FRAG (fragpc);
3400
3401 // ********** used only by: strh-pre-inc-wb-imm-offset
3402
3403   CASE (FRAG_STRH_PRE_INC_WB_IMM_OFFSET_MID):
3404     {
3405       abuf = vpc;
3406       vpc = vpc + 1;
3407 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3408       PCADDR pc = abuf->addr;
3409       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3410
3411 {
3412   offset = FLD (i_hdt_offset8);
3413   addr = ADDSI (* FLD (i_rn), offset);
3414 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3415 }
3416
3417 #undef FLD
3418     }
3419     NEXT_FRAG (fragpc);
3420
3421 // ********** used only by: strh-pre-inc-wb-reg-offset
3422
3423   CASE (FRAG_STRH_PRE_INC_WB_REG_OFFSET_MID):
3424     {
3425       abuf = vpc;
3426       vpc = vpc + 1;
3427 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3428       PCADDR pc = abuf->addr;
3429       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3430
3431 {
3432   offset = * FLD (i_rm);
3433   addr = ADDSI (* FLD (i_rn), offset);
3434 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3435 }
3436
3437 #undef FLD
3438     }
3439     NEXT_FRAG (fragpc);
3440
3441 // ********** used only by: strh-post-dec-imm-offset
3442
3443   CASE (FRAG_STRH_POST_DEC_IMM_OFFSET_MID):
3444     {
3445       abuf = vpc;
3446       vpc = vpc + 1;
3447 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3448       PCADDR pc = abuf->addr;
3449       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3450
3451 {
3452   offset = FLD (i_hdt_offset8);
3453   addr = * FLD (i_rn);
3454 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3455   addr = SUBSI (* FLD (i_rn), offset);
3456 * FLD (i_rn) = addr;
3457 }
3458
3459 #undef FLD
3460     }
3461     NEXT_INSN (vpc, fragpc);
3462
3463 // ********** used only by: strh-post-dec-reg-offset
3464
3465   CASE (FRAG_STRH_POST_DEC_REG_OFFSET_MID):
3466     {
3467       abuf = vpc;
3468       vpc = vpc + 1;
3469 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3470       PCADDR pc = abuf->addr;
3471       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3472
3473 {
3474   offset = * FLD (i_rm);
3475   addr = * FLD (i_rn);
3476 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3477   addr = SUBSI (* FLD (i_rn), offset);
3478 * FLD (i_rn) = addr;
3479 }
3480
3481 #undef FLD
3482     }
3483     NEXT_INSN (vpc, fragpc);
3484
3485 // ********** used only by: strh-post-inc-imm-offset
3486
3487   CASE (FRAG_STRH_POST_INC_IMM_OFFSET_MID):
3488     {
3489       abuf = vpc;
3490       vpc = vpc + 1;
3491 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3492       PCADDR pc = abuf->addr;
3493       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3494
3495 {
3496   offset = FLD (i_hdt_offset8);
3497   addr = * FLD (i_rn);
3498 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3499   addr = ADDSI (* FLD (i_rn), offset);
3500 * FLD (i_rn) = addr;
3501 }
3502
3503 #undef FLD
3504     }
3505     NEXT_INSN (vpc, fragpc);
3506
3507 // ********** used only by: strh-post-inc-reg-offset
3508
3509   CASE (FRAG_STRH_POST_INC_REG_OFFSET_MID):
3510     {
3511       abuf = vpc;
3512       vpc = vpc + 1;
3513 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3514       PCADDR pc = abuf->addr;
3515       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3516
3517 {
3518   offset = * FLD (i_rm);
3519   addr = * FLD (i_rn);
3520 current_cpu->SETMEMHI (pc, addr, TRUNCSIHI (* FLD (i_rd)));
3521   addr = ADDSI (* FLD (i_rn), offset);
3522 * FLD (i_rn) = addr;
3523 }
3524
3525 #undef FLD
3526     }
3527     NEXT_INSN (vpc, fragpc);
3528
3529 // ********** used only by: ldrsb-pre-dec-imm-offset
3530
3531   CASE (FRAG_LDRSB_PRE_DEC_IMM_OFFSET_MID):
3532     {
3533       abuf = vpc;
3534       vpc = vpc + 1;
3535 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3536       PCADDR pc = abuf->addr;
3537       br_status = BRANCH_UNTAKEN;
3538       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3539
3540 {
3541   offset = FLD (i_hdt_offset8);
3542   addr = SUBSI (* FLD (i_rn), offset);
3543 if (EQSI (FLD (f_rd), 15)) {
3544 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3545 } else {
3546 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3547 }
3548 }
3549
3550 #undef FLD
3551     }
3552     NEXT_FRAG (fragpc);
3553
3554 // ********** used only by: ldrsb-pre-dec-reg-offset
3555
3556   CASE (FRAG_LDRSB_PRE_DEC_REG_OFFSET_MID):
3557     {
3558       abuf = vpc;
3559       vpc = vpc + 1;
3560 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3561       PCADDR pc = abuf->addr;
3562       br_status = BRANCH_UNTAKEN;
3563       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3564
3565 {
3566   offset = * FLD (i_rm);
3567   addr = SUBSI (* FLD (i_rn), offset);
3568 if (EQSI (FLD (f_rd), 15)) {
3569 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3570 } else {
3571 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3572 }
3573 }
3574
3575 #undef FLD
3576     }
3577     NEXT_FRAG (fragpc);
3578
3579 // ********** used only by: ldrsb-pre-inc-imm-offset
3580
3581   CASE (FRAG_LDRSB_PRE_INC_IMM_OFFSET_MID):
3582     {
3583       abuf = vpc;
3584       vpc = vpc + 1;
3585 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3586       PCADDR pc = abuf->addr;
3587       br_status = BRANCH_UNTAKEN;
3588       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3589
3590 {
3591   offset = FLD (i_hdt_offset8);
3592   addr = ADDSI (* FLD (i_rn), offset);
3593 if (EQSI (FLD (f_rd), 15)) {
3594 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3595 } else {
3596 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3597 }
3598 }
3599
3600 #undef FLD
3601     }
3602     NEXT_FRAG (fragpc);
3603
3604 // ********** used only by: ldrsb-pre-inc-reg-offset
3605
3606   CASE (FRAG_LDRSB_PRE_INC_REG_OFFSET_MID):
3607     {
3608       abuf = vpc;
3609       vpc = vpc + 1;
3610 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3611       PCADDR pc = abuf->addr;
3612       br_status = BRANCH_UNTAKEN;
3613       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3614
3615 {
3616   offset = * FLD (i_rm);
3617   addr = ADDSI (* FLD (i_rn), offset);
3618 if (EQSI (FLD (f_rd), 15)) {
3619 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3620 } else {
3621 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3622 }
3623 }
3624
3625 #undef FLD
3626     }
3627     NEXT_FRAG (fragpc);
3628
3629 // ********** used only by: ldrsb-pre-dec-wb-imm-offset
3630
3631   CASE (FRAG_LDRSB_PRE_DEC_WB_IMM_OFFSET_MID):
3632     {
3633       abuf = vpc;
3634       vpc = vpc + 1;
3635 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3636       PCADDR pc = abuf->addr;
3637       br_status = BRANCH_UNTAKEN;
3638       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3639
3640 {
3641   offset = FLD (i_hdt_offset8);
3642   addr = SUBSI (* FLD (i_rn), offset);
3643 if (EQSI (FLD (f_rd), 15)) {
3644 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3645 } else {
3646 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3647 }
3648 }
3649
3650 #undef FLD
3651     }
3652     NEXT_FRAG (fragpc);
3653
3654 // ********** used only by: ldrsb-pre-dec-wb-reg-offset
3655
3656   CASE (FRAG_LDRSB_PRE_DEC_WB_REG_OFFSET_MID):
3657     {
3658       abuf = vpc;
3659       vpc = vpc + 1;
3660 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3661       PCADDR pc = abuf->addr;
3662       br_status = BRANCH_UNTAKEN;
3663       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3664
3665 {
3666   offset = * FLD (i_rm);
3667   addr = SUBSI (* FLD (i_rn), offset);
3668 if (EQSI (FLD (f_rd), 15)) {
3669 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3670 } else {
3671 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3672 }
3673 }
3674
3675 #undef FLD
3676     }
3677     NEXT_FRAG (fragpc);
3678
3679 // ********** used only by: ldrsb-pre-inc-wb-imm-offset
3680
3681   CASE (FRAG_LDRSB_PRE_INC_WB_IMM_OFFSET_MID):
3682     {
3683       abuf = vpc;
3684       vpc = vpc + 1;
3685 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3686       PCADDR pc = abuf->addr;
3687       br_status = BRANCH_UNTAKEN;
3688       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3689
3690 {
3691   offset = FLD (i_hdt_offset8);
3692   addr = ADDSI (* FLD (i_rn), offset);
3693 if (EQSI (FLD (f_rd), 15)) {
3694 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3695 } else {
3696 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3697 }
3698 }
3699
3700 #undef FLD
3701     }
3702     NEXT_FRAG (fragpc);
3703
3704 // ********** used only by: ldrsb-pre-inc-wb-reg-offset
3705
3706   CASE (FRAG_LDRSB_PRE_INC_WB_REG_OFFSET_MID):
3707     {
3708       abuf = vpc;
3709       vpc = vpc + 1;
3710 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3711       PCADDR pc = abuf->addr;
3712       br_status = BRANCH_UNTAKEN;
3713       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3714
3715 {
3716   offset = * FLD (i_rm);
3717   addr = ADDSI (* FLD (i_rn), offset);
3718 if (EQSI (FLD (f_rd), 15)) {
3719 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3720 } else {
3721 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3722 }
3723 }
3724
3725 #undef FLD
3726     }
3727     NEXT_FRAG (fragpc);
3728
3729 // ********** used only by: ldrsb-post-dec-imm-offset
3730
3731   CASE (FRAG_LDRSB_POST_DEC_IMM_OFFSET_MID):
3732     {
3733       abuf = vpc;
3734       vpc = vpc + 1;
3735 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3736       PCADDR pc = abuf->addr;
3737       br_status = BRANCH_UNTAKEN;
3738       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3739
3740 {
3741   offset = FLD (i_hdt_offset8);
3742   addr = * FLD (i_rn);
3743 if (EQSI (FLD (f_rd), 15)) {
3744 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3745 } else {
3746 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3747 }
3748   addr = SUBSI (* FLD (i_rn), offset);
3749 * FLD (i_rn) = addr;
3750 }
3751
3752       pbb_br_npc = npc;
3753       pbb_br_status = br_status;
3754 #undef FLD
3755     }
3756     NEXT_INSN (vpc, fragpc);
3757
3758 // ********** used only by: ldrsb-post-dec-reg-offset
3759
3760   CASE (FRAG_LDRSB_POST_DEC_REG_OFFSET_MID):
3761     {
3762       abuf = vpc;
3763       vpc = vpc + 1;
3764 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3765       PCADDR pc = abuf->addr;
3766       br_status = BRANCH_UNTAKEN;
3767       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3768
3769 {
3770   offset = * FLD (i_rm);
3771   addr = * FLD (i_rn);
3772 if (EQSI (FLD (f_rd), 15)) {
3773 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3774 } else {
3775 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3776 }
3777   addr = SUBSI (* FLD (i_rn), offset);
3778 * FLD (i_rn) = addr;
3779 }
3780
3781       pbb_br_npc = npc;
3782       pbb_br_status = br_status;
3783 #undef FLD
3784     }
3785     NEXT_INSN (vpc, fragpc);
3786
3787 // ********** used only by: ldrsb-post-inc-imm-offset
3788
3789   CASE (FRAG_LDRSB_POST_INC_IMM_OFFSET_MID):
3790     {
3791       abuf = vpc;
3792       vpc = vpc + 1;
3793 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3794       PCADDR pc = abuf->addr;
3795       br_status = BRANCH_UNTAKEN;
3796       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3797
3798 {
3799   offset = FLD (i_hdt_offset8);
3800   addr = * FLD (i_rn);
3801 if (EQSI (FLD (f_rd), 15)) {
3802 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3803 } else {
3804 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3805 }
3806   addr = ADDSI (* FLD (i_rn), offset);
3807 * FLD (i_rn) = addr;
3808 }
3809
3810       pbb_br_npc = npc;
3811       pbb_br_status = br_status;
3812 #undef FLD
3813     }
3814     NEXT_INSN (vpc, fragpc);
3815
3816 // ********** used only by: ldrsb-post-inc-reg-offset
3817
3818   CASE (FRAG_LDRSB_POST_INC_REG_OFFSET_MID):
3819     {
3820       abuf = vpc;
3821       vpc = vpc + 1;
3822 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3823       PCADDR pc = abuf->addr;
3824       br_status = BRANCH_UNTAKEN;
3825       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3826
3827 {
3828   offset = * FLD (i_rm);
3829   addr = * FLD (i_rn);
3830 if (EQSI (FLD (f_rd), 15)) {
3831 npc = EXTQISI (current_cpu->GETMEMQI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3832 } else {
3833 * FLD (i_rd) = EXTQISI (current_cpu->GETMEMQI (pc, addr));
3834 }
3835   addr = ADDSI (* FLD (i_rn), offset);
3836 * FLD (i_rn) = addr;
3837 }
3838
3839       pbb_br_npc = npc;
3840       pbb_br_status = br_status;
3841 #undef FLD
3842     }
3843     NEXT_INSN (vpc, fragpc);
3844
3845 // ********** used only by: ldrh-pre-dec-imm-offset
3846
3847   CASE (FRAG_LDRH_PRE_DEC_IMM_OFFSET_MID):
3848     {
3849       abuf = vpc;
3850       vpc = vpc + 1;
3851 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3852       PCADDR pc = abuf->addr;
3853       br_status = BRANCH_UNTAKEN;
3854       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3855
3856 {
3857   offset = FLD (i_hdt_offset8);
3858   addr = SUBSI (* FLD (i_rn), offset);
3859 if (EQSI (FLD (f_rd), 15)) {
3860 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3861 } else {
3862 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
3863 }
3864 }
3865
3866 #undef FLD
3867     }
3868     NEXT_FRAG (fragpc);
3869
3870 // ********** used only by: ldrh-pre-dec-reg-offset
3871
3872   CASE (FRAG_LDRH_PRE_DEC_REG_OFFSET_MID):
3873     {
3874       abuf = vpc;
3875       vpc = vpc + 1;
3876 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3877       PCADDR pc = abuf->addr;
3878       br_status = BRANCH_UNTAKEN;
3879       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3880
3881 {
3882   offset = * FLD (i_rm);
3883   addr = SUBSI (* FLD (i_rn), offset);
3884 if (EQSI (FLD (f_rd), 15)) {
3885 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3886 } else {
3887 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
3888 }
3889 }
3890
3891 #undef FLD
3892     }
3893     NEXT_FRAG (fragpc);
3894
3895 // ********** used only by: ldrh-pre-inc-imm-offset
3896
3897   CASE (FRAG_LDRH_PRE_INC_IMM_OFFSET_MID):
3898     {
3899       abuf = vpc;
3900       vpc = vpc + 1;
3901 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3902       PCADDR pc = abuf->addr;
3903       br_status = BRANCH_UNTAKEN;
3904       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3905
3906 {
3907   offset = FLD (i_hdt_offset8);
3908   addr = ADDSI (* FLD (i_rn), offset);
3909 if (EQSI (FLD (f_rd), 15)) {
3910 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3911 } else {
3912 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
3913 }
3914 }
3915
3916 #undef FLD
3917     }
3918     NEXT_FRAG (fragpc);
3919
3920 // ********** used only by: ldrh-pre-inc-reg-offset
3921
3922   CASE (FRAG_LDRH_PRE_INC_REG_OFFSET_MID):
3923     {
3924       abuf = vpc;
3925       vpc = vpc + 1;
3926 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3927       PCADDR pc = abuf->addr;
3928       br_status = BRANCH_UNTAKEN;
3929       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3930
3931 {
3932   offset = * FLD (i_rm);
3933   addr = ADDSI (* FLD (i_rn), offset);
3934 if (EQSI (FLD (f_rd), 15)) {
3935 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3936 } else {
3937 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
3938 }
3939 }
3940
3941 #undef FLD
3942     }
3943     NEXT_FRAG (fragpc);
3944
3945 // ********** used only by: ldrh-pre-dec-wb-imm-offset
3946
3947   CASE (FRAG_LDRH_PRE_DEC_WB_IMM_OFFSET_MID):
3948     {
3949       abuf = vpc;
3950       vpc = vpc + 1;
3951 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3952       PCADDR pc = abuf->addr;
3953       br_status = BRANCH_UNTAKEN;
3954       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3955
3956 {
3957   offset = FLD (i_hdt_offset8);
3958   addr = SUBSI (* FLD (i_rn), offset);
3959 if (EQSI (FLD (f_rd), 15)) {
3960 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3961 } else {
3962 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
3963 }
3964 }
3965
3966 #undef FLD
3967     }
3968     NEXT_FRAG (fragpc);
3969
3970 // ********** used only by: ldrh-pre-dec-wb-reg-offset
3971
3972   CASE (FRAG_LDRH_PRE_DEC_WB_REG_OFFSET_MID):
3973     {
3974       abuf = vpc;
3975       vpc = vpc + 1;
3976 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3977       PCADDR pc = abuf->addr;
3978       br_status = BRANCH_UNTAKEN;
3979       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
3980
3981 {
3982   offset = * FLD (i_rm);
3983   addr = SUBSI (* FLD (i_rn), offset);
3984 if (EQSI (FLD (f_rd), 15)) {
3985 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
3986 } else {
3987 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
3988 }
3989 }
3990
3991 #undef FLD
3992     }
3993     NEXT_FRAG (fragpc);
3994
3995 // ********** used only by: ldrh-pre-inc-wb-imm-offset
3996
3997   CASE (FRAG_LDRH_PRE_INC_WB_IMM_OFFSET_MID):
3998     {
3999       abuf = vpc;
4000       vpc = vpc + 1;
4001 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4002       PCADDR pc = abuf->addr;
4003       br_status = BRANCH_UNTAKEN;
4004       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4005
4006 {
4007   offset = FLD (i_hdt_offset8);
4008   addr = ADDSI (* FLD (i_rn), offset);
4009 if (EQSI (FLD (f_rd), 15)) {
4010 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4011 } else {
4012 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
4013 }
4014 }
4015
4016 #undef FLD
4017     }
4018     NEXT_FRAG (fragpc);
4019
4020 // ********** used only by: ldrh-pre-inc-wb-reg-offset
4021
4022   CASE (FRAG_LDRH_PRE_INC_WB_REG_OFFSET_MID):
4023     {
4024       abuf = vpc;
4025       vpc = vpc + 1;
4026 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4027       PCADDR pc = abuf->addr;
4028       br_status = BRANCH_UNTAKEN;
4029       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4030
4031 {
4032   offset = * FLD (i_rm);
4033   addr = ADDSI (* FLD (i_rn), offset);
4034 if (EQSI (FLD (f_rd), 15)) {
4035 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4036 } else {
4037 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
4038 }
4039 }
4040
4041 #undef FLD
4042     }
4043     NEXT_FRAG (fragpc);
4044
4045 // ********** used only by: ldrh-post-dec-imm-offset
4046
4047   CASE (FRAG_LDRH_POST_DEC_IMM_OFFSET_MID):
4048     {
4049       abuf = vpc;
4050       vpc = vpc + 1;
4051 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4052       PCADDR pc = abuf->addr;
4053       br_status = BRANCH_UNTAKEN;
4054       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4055
4056 {
4057   offset = FLD (i_hdt_offset8);
4058   addr = * FLD (i_rn);
4059 if (EQSI (FLD (f_rd), 15)) {
4060 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4061 } else {
4062 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
4063 }
4064   addr = SUBSI (* FLD (i_rn), offset);
4065 * FLD (i_rn) = addr;
4066 }
4067
4068       pbb_br_npc = npc;
4069       pbb_br_status = br_status;
4070 #undef FLD
4071     }
4072     NEXT_INSN (vpc, fragpc);
4073
4074 // ********** used only by: ldrh-post-dec-reg-offset
4075
4076   CASE (FRAG_LDRH_POST_DEC_REG_OFFSET_MID):
4077     {
4078       abuf = vpc;
4079       vpc = vpc + 1;
4080 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4081       PCADDR pc = abuf->addr;
4082       br_status = BRANCH_UNTAKEN;
4083       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4084
4085 {
4086   offset = * FLD (i_rm);
4087   addr = * FLD (i_rn);
4088 if (EQSI (FLD (f_rd), 15)) {
4089 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4090 } else {
4091 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
4092 }
4093   addr = SUBSI (* FLD (i_rn), offset);
4094 * FLD (i_rn) = addr;
4095 }
4096
4097       pbb_br_npc = npc;
4098       pbb_br_status = br_status;
4099 #undef FLD
4100     }
4101     NEXT_INSN (vpc, fragpc);
4102
4103 // ********** used only by: ldrh-post-inc-imm-offset
4104
4105   CASE (FRAG_LDRH_POST_INC_IMM_OFFSET_MID):
4106     {
4107       abuf = vpc;
4108       vpc = vpc + 1;
4109 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4110       PCADDR pc = abuf->addr;
4111       br_status = BRANCH_UNTAKEN;
4112       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4113
4114 {
4115   offset = FLD (i_hdt_offset8);
4116   addr = * FLD (i_rn);
4117 if (EQSI (FLD (f_rd), 15)) {
4118 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4119 } else {
4120 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
4121 }
4122   addr = ADDSI (* FLD (i_rn), offset);
4123 * FLD (i_rn) = addr;
4124 }
4125
4126       pbb_br_npc = npc;
4127       pbb_br_status = br_status;
4128 #undef FLD
4129     }
4130     NEXT_INSN (vpc, fragpc);
4131
4132 // ********** used only by: ldrh-post-inc-reg-offset
4133
4134   CASE (FRAG_LDRH_POST_INC_REG_OFFSET_MID):
4135     {
4136       abuf = vpc;
4137       vpc = vpc + 1;
4138 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4139       PCADDR pc = abuf->addr;
4140       br_status = BRANCH_UNTAKEN;
4141       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4142
4143 {
4144   offset = * FLD (i_rm);
4145   addr = * FLD (i_rn);
4146 if (EQSI (FLD (f_rd), 15)) {
4147 npc = ZEXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4148 } else {
4149 * FLD (i_rd) = ZEXTHISI (current_cpu->GETMEMHI (pc, addr));
4150 }
4151   addr = ADDSI (* FLD (i_rn), offset);
4152 * FLD (i_rn) = addr;
4153 }
4154
4155       pbb_br_npc = npc;
4156       pbb_br_status = br_status;
4157 #undef FLD
4158     }
4159     NEXT_INSN (vpc, fragpc);
4160
4161 // ********** used only by: ldrsh-pre-dec-imm-offset
4162
4163   CASE (FRAG_LDRSH_PRE_DEC_IMM_OFFSET_MID):
4164     {
4165       abuf = vpc;
4166       vpc = vpc + 1;
4167 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4168       PCADDR pc = abuf->addr;
4169       br_status = BRANCH_UNTAKEN;
4170       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4171
4172 {
4173   offset = FLD (i_hdt_offset8);
4174   addr = SUBSI (* FLD (i_rn), offset);
4175 if (EQSI (FLD (f_rd), 15)) {
4176 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4177 } else {
4178 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4179 }
4180 }
4181
4182 #undef FLD
4183     }
4184     NEXT_FRAG (fragpc);
4185
4186 // ********** used only by: ldrsh-pre-dec-reg-offset
4187
4188   CASE (FRAG_LDRSH_PRE_DEC_REG_OFFSET_MID):
4189     {
4190       abuf = vpc;
4191       vpc = vpc + 1;
4192 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4193       PCADDR pc = abuf->addr;
4194       br_status = BRANCH_UNTAKEN;
4195       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4196
4197 {
4198   offset = * FLD (i_rm);
4199   addr = SUBSI (* FLD (i_rn), offset);
4200 if (EQSI (FLD (f_rd), 15)) {
4201 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4202 } else {
4203 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4204 }
4205 }
4206
4207 #undef FLD
4208     }
4209     NEXT_FRAG (fragpc);
4210
4211 // ********** used only by: ldrsh-pre-inc-imm-offset
4212
4213   CASE (FRAG_LDRSH_PRE_INC_IMM_OFFSET_MID):
4214     {
4215       abuf = vpc;
4216       vpc = vpc + 1;
4217 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4218       PCADDR pc = abuf->addr;
4219       br_status = BRANCH_UNTAKEN;
4220       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4221
4222 {
4223   offset = FLD (i_hdt_offset8);
4224   addr = ADDSI (* FLD (i_rn), offset);
4225 if (EQSI (FLD (f_rd), 15)) {
4226 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4227 } else {
4228 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4229 }
4230 }
4231
4232 #undef FLD
4233     }
4234     NEXT_FRAG (fragpc);
4235
4236 // ********** used only by: ldrsh-pre-inc-reg-offset
4237
4238   CASE (FRAG_LDRSH_PRE_INC_REG_OFFSET_MID):
4239     {
4240       abuf = vpc;
4241       vpc = vpc + 1;
4242 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4243       PCADDR pc = abuf->addr;
4244       br_status = BRANCH_UNTAKEN;
4245       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4246
4247 {
4248   offset = * FLD (i_rm);
4249   addr = ADDSI (* FLD (i_rn), offset);
4250 if (EQSI (FLD (f_rd), 15)) {
4251 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4252 } else {
4253 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4254 }
4255 ((void) 0); /*nop*/
4256 ((void) 0); /*nop*/
4257 }
4258
4259       pbb_br_npc = npc;
4260       pbb_br_status = br_status;
4261 #undef FLD
4262     }
4263     NEXT_INSN (vpc, fragpc);
4264
4265 // ********** used only by: ldrsh-pre-dec-wb-imm-offset
4266
4267   CASE (FRAG_LDRSH_PRE_DEC_WB_IMM_OFFSET_MID):
4268     {
4269       abuf = vpc;
4270       vpc = vpc + 1;
4271 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4272       PCADDR pc = abuf->addr;
4273       br_status = BRANCH_UNTAKEN;
4274       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4275
4276 {
4277   offset = FLD (i_hdt_offset8);
4278   addr = SUBSI (* FLD (i_rn), offset);
4279 if (EQSI (FLD (f_rd), 15)) {
4280 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4281 } else {
4282 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4283 }
4284 }
4285
4286 #undef FLD
4287     }
4288     NEXT_FRAG (fragpc);
4289
4290 // ********** used only by: ldrsh-pre-dec-wb-reg-offset
4291
4292   CASE (FRAG_LDRSH_PRE_DEC_WB_REG_OFFSET_MID):
4293     {
4294       abuf = vpc;
4295       vpc = vpc + 1;
4296 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4297       PCADDR pc = abuf->addr;
4298       br_status = BRANCH_UNTAKEN;
4299       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4300
4301 {
4302   offset = * FLD (i_rm);
4303   addr = SUBSI (* FLD (i_rn), offset);
4304 if (EQSI (FLD (f_rd), 15)) {
4305 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4306 } else {
4307 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4308 }
4309 }
4310
4311 #undef FLD
4312     }
4313     NEXT_FRAG (fragpc);
4314
4315 // ********** used only by: ldrsh-pre-inc-wb-imm-offset
4316
4317   CASE (FRAG_LDRSH_PRE_INC_WB_IMM_OFFSET_MID):
4318     {
4319       abuf = vpc;
4320       vpc = vpc + 1;
4321 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4322       PCADDR pc = abuf->addr;
4323       br_status = BRANCH_UNTAKEN;
4324       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4325
4326 {
4327   offset = FLD (i_hdt_offset8);
4328   addr = ADDSI (* FLD (i_rn), offset);
4329 if (EQSI (FLD (f_rd), 15)) {
4330 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4331 } else {
4332 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4333 }
4334 }
4335
4336 #undef FLD
4337     }
4338     NEXT_FRAG (fragpc);
4339
4340 // ********** used only by: ldrsh-pre-inc-wb-reg-offset
4341
4342   CASE (FRAG_LDRSH_PRE_INC_WB_REG_OFFSET_MID):
4343     {
4344       abuf = vpc;
4345       vpc = vpc + 1;
4346 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4347       PCADDR pc = abuf->addr;
4348       br_status = BRANCH_UNTAKEN;
4349       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4350
4351 {
4352   offset = * FLD (i_rm);
4353   addr = ADDSI (* FLD (i_rn), offset);
4354 if (EQSI (FLD (f_rd), 15)) {
4355 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4356 } else {
4357 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4358 }
4359 ((void) 0); /*nop*/
4360 * FLD (i_rn) = addr;
4361 }
4362
4363       pbb_br_npc = npc;
4364       pbb_br_status = br_status;
4365 #undef FLD
4366     }
4367     NEXT_INSN (vpc, fragpc);
4368
4369 // ********** used only by: ldrsh-post-dec-imm-offset
4370
4371   CASE (FRAG_LDRSH_POST_DEC_IMM_OFFSET_MID):
4372     {
4373       abuf = vpc;
4374       vpc = vpc + 1;
4375 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4376       PCADDR pc = abuf->addr;
4377       br_status = BRANCH_UNTAKEN;
4378       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4379
4380 {
4381   offset = FLD (i_hdt_offset8);
4382   addr = * FLD (i_rn);
4383 if (EQSI (FLD (f_rd), 15)) {
4384 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4385 } else {
4386 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4387 }
4388   addr = SUBSI (* FLD (i_rn), offset);
4389 * FLD (i_rn) = addr;
4390 }
4391
4392       pbb_br_npc = npc;
4393       pbb_br_status = br_status;
4394 #undef FLD
4395     }
4396     NEXT_INSN (vpc, fragpc);
4397
4398 // ********** used only by: ldrsh-post-dec-reg-offset
4399
4400   CASE (FRAG_LDRSH_POST_DEC_REG_OFFSET_MID):
4401     {
4402       abuf = vpc;
4403       vpc = vpc + 1;
4404 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4405       PCADDR pc = abuf->addr;
4406       br_status = BRANCH_UNTAKEN;
4407       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4408
4409 {
4410   offset = * FLD (i_rm);
4411   addr = * FLD (i_rn);
4412 if (EQSI (FLD (f_rd), 15)) {
4413 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4414 } else {
4415 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4416 }
4417   addr = SUBSI (* FLD (i_rn), offset);
4418 * FLD (i_rn) = addr;
4419 }
4420
4421       pbb_br_npc = npc;
4422       pbb_br_status = br_status;
4423 #undef FLD
4424     }
4425     NEXT_INSN (vpc, fragpc);
4426
4427 // ********** used only by: ldrsh-post-inc-imm-offset
4428
4429   CASE (FRAG_LDRSH_POST_INC_IMM_OFFSET_MID):
4430     {
4431       abuf = vpc;
4432       vpc = vpc + 1;
4433 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
4434       PCADDR pc = abuf->addr;
4435       br_status = BRANCH_UNTAKEN;
4436       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4437
4438 {
4439   offset = FLD (i_hdt_offset8);
4440   addr = * FLD (i_rn);
4441 if (EQSI (FLD (f_rd), 15)) {
4442 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4443 } else {
4444 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4445 }
4446   addr = ADDSI (* FLD (i_rn), offset);
4447 * FLD (i_rn) = addr;
4448 }
4449
4450       pbb_br_npc = npc;
4451       pbb_br_status = br_status;
4452 #undef FLD
4453     }
4454     NEXT_INSN (vpc, fragpc);
4455
4456 // ********** used only by: ldrsh-post-inc-reg-offset
4457
4458   CASE (FRAG_LDRSH_POST_INC_REG_OFFSET_MID):
4459     {
4460       abuf = vpc;
4461       vpc = vpc + 1;
4462 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4463       PCADDR pc = abuf->addr;
4464       br_status = BRANCH_UNTAKEN;
4465       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4466
4467 {
4468   offset = * FLD (i_rm);
4469   addr = * FLD (i_rn);
4470 if (EQSI (FLD (f_rd), 15)) {
4471 npc = EXTHISI (current_cpu->GETMEMHI (pc, addr)); br_status = BRANCH_UNCACHEABLE;
4472 } else {
4473 * FLD (i_rd) = EXTHISI (current_cpu->GETMEMHI (pc, addr));
4474 }
4475   addr = ADDSI (* FLD (i_rn), offset);
4476 * FLD (i_rn) = addr;
4477 }
4478
4479       pbb_br_npc = npc;
4480       pbb_br_status = br_status;
4481 #undef FLD
4482     }
4483     NEXT_INSN (vpc, fragpc);
4484
4485 // ********** used only by: mul
4486
4487   CASE (FRAG_MUL_MID):
4488     {
4489       abuf = vpc;
4490       vpc = vpc + 1;
4491 #define FLD(f) abuf->fields.sfmt_mla.f
4492       PCADDR pc = abuf->addr;
4493       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4494
4495 {
4496   result = MULSI (* FLD (i_rm), * FLD (i_rs));
4497 * FLD (i_mul_rd) = result;
4498 if (FLD (f_set_cc_)) {
4499 {
4500 current_cpu->hardware.h_zbit = EQSI (result, 0);
4501 current_cpu->hardware.h_nbit = LTSI (result, 0);
4502 }
4503 }
4504 }
4505
4506 #undef FLD
4507     }
4508     NEXT_INSN (vpc, fragpc);
4509
4510 // ********** used only by: mla
4511
4512   CASE (FRAG_MLA_MID):
4513     {
4514       abuf = vpc;
4515       vpc = vpc + 1;
4516 #define FLD(f) abuf->fields.sfmt_mla.f
4517       PCADDR pc = abuf->addr;
4518       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4519
4520 {
4521 * FLD (i_mul_rd) = ADDSI (MULSI (* FLD (i_rm), * FLD (i_rs)), * FLD (i_mul_rn));
4522 if (FLD (f_set_cc_)) {
4523 {
4524 current_cpu->hardware.h_zbit = EQSI (result, 0);
4525 current_cpu->hardware.h_nbit = LTSI (result, 0);
4526 }
4527 }
4528 }
4529
4530 #undef FLD
4531     }
4532     NEXT_INSN (vpc, fragpc);
4533
4534 // ********** used only by: umull
4535
4536   CASE (FRAG_UMULL_MID):
4537     {
4538       abuf = vpc;
4539       vpc = vpc + 1;
4540 #define FLD(f) abuf->fields.sfmt_umull.f
4541       PCADDR pc = abuf->addr;
4542       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4543
4544 {
4545   mul_result = MULDI (ZEXTSIDI (* FLD (i_rs)), ZEXTSIDI (* FLD (i_rm)));
4546 }
4547
4548 #undef FLD
4549     }
4550     NEXT_FRAG (fragpc);
4551
4552 // ********** used only by: umlal
4553
4554   CASE (FRAG_UMLAL_MID):
4555     {
4556       abuf = vpc;
4557       vpc = vpc + 1;
4558 #define FLD(f) abuf->fields.sfmt_umull.f
4559       PCADDR pc = abuf->addr;
4560       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4561
4562 {
4563   mul_result = JOINSIDI (* FLD (i_rdhi), * FLD (i_rdlo));
4564   mul_result = ADDDI (MULDI (ZEXTSIDI (* FLD (i_rs)), ZEXTSIDI (* FLD (i_rm))), mul_result);
4565 }
4566
4567 #undef FLD
4568     }
4569     NEXT_FRAG (fragpc);
4570
4571 // ********** used only by: smull
4572
4573   CASE (FRAG_SMULL_MID):
4574     {
4575       abuf = vpc;
4576       vpc = vpc + 1;
4577 #define FLD(f) abuf->fields.sfmt_umull.f
4578       PCADDR pc = abuf->addr;
4579       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4580
4581 {
4582   mul_result = MULDI (EXTSIDI (* FLD (i_rs)), EXTSIDI (* FLD (i_rm)));
4583 }
4584
4585 #undef FLD
4586     }
4587     NEXT_FRAG (fragpc);
4588
4589 // ********** used only by: smlal
4590
4591   CASE (FRAG_SMLAL_MID):
4592     {
4593       abuf = vpc;
4594       vpc = vpc + 1;
4595 #define FLD(f) abuf->fields.sfmt_umull.f
4596       PCADDR pc = abuf->addr;
4597       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4598
4599 {
4600   mul_result = JOINSIDI (* FLD (i_rdhi), * FLD (i_rdlo));
4601   mul_result = ADDDI (MULDI (EXTSIDI (* FLD (i_rs)), EXTSIDI (* FLD (i_rm))), mul_result);
4602 * FLD (i_rdhi) = SUBWORDDISI (mul_result, 0);
4603 * FLD (i_rdlo) = SUBWORDDISI (mul_result, 1);
4604 if (FLD (f_set_cc_)) {
4605 {
4606 current_cpu->hardware.h_zbit = EQDI (mul_result, 0);
4607 current_cpu->hardware.h_nbit = LTDI (mul_result, 0);
4608 }
4609 }
4610 }
4611
4612 #undef FLD
4613     }
4614     NEXT_INSN (vpc, fragpc);
4615
4616 // ********** used only by: swp
4617
4618   CASE (FRAG_SWP_MID):
4619     {
4620       abuf = vpc;
4621       vpc = vpc + 1;
4622 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4623       PCADDR pc = abuf->addr;
4624       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4625
4626 {
4627   temp = current_cpu->GETMEMSI (pc, * FLD (i_rn));
4628 current_cpu->SETMEMSI (pc, * FLD (i_rn), * FLD (i_rm));
4629 * FLD (i_rd) = temp;
4630 }
4631
4632 #undef FLD
4633     }
4634     NEXT_INSN (vpc, fragpc);
4635
4636 // ********** used only by: swpb
4637
4638   CASE (FRAG_SWPB_MID):
4639     {
4640       abuf = vpc;
4641       vpc = vpc + 1;
4642 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4643       PCADDR pc = abuf->addr;
4644       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4645
4646 {
4647   temp = current_cpu->GETMEMQI (pc, * FLD (i_rn));
4648 current_cpu->SETMEMQI (pc, * FLD (i_rn), * FLD (i_rm));
4649 * FLD (i_rd) = temp;
4650 }
4651
4652 #undef FLD
4653     }
4654     NEXT_INSN (vpc, fragpc);
4655
4656 // ********** used only by: swi
4657
4658   CASE (FRAG_SWI_MID):
4659     {
4660       abuf = vpc;
4661       vpc = vpc + 1;
4662 #define FLD(f) abuf->fields.sfmt_swi.f
4663       PCADDR pc = abuf->addr;
4664       br_status = BRANCH_UNTAKEN;
4665       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4666
4667 {
4668 npc = current_cpu->arm_swi (pc, FLD (f_swi_comment)); br_status = BRANCH_UNCACHEABLE;
4669 }
4670
4671       pbb_br_npc = npc;
4672       pbb_br_status = br_status;
4673 #undef FLD
4674     }
4675     NEXT_INSN (vpc, fragpc);
4676
4677 // ********** used only by: and-reg/imm-shift
4678
4679   CASE (FRAG_AND_REG_IMM_SHIFT_MID):
4680     {
4681       abuf = vpc;
4682       vpc = vpc + 1;
4683 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4684       PCADDR pc = abuf->addr;
4685       br_status = BRANCH_UNTAKEN;
4686       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4687
4688 {
4689   operand2 = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
4690   carry_out = current_cpu->compute_carry_out_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm), current_cpu->hardware.h_cbit);
4691   result = ANDSI (* FLD (i_rn), operand2);
4692 if (EQSI (FLD (f_rd), 15)) {
4693 {
4694 npc = result; br_status = BRANCH_UNCACHEABLE;
4695 if (FLD (f_set_cc_)) {
4696 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
4697 }
4698 }
4699 } else {
4700 {
4701 * FLD (i_rd) = result;
4702 if (FLD (f_set_cc_)) {
4703 {
4704 {
4705 current_cpu->hardware.h_zbit = EQSI (result, 0);
4706 current_cpu->hardware.h_nbit = LTSI (result, 0);
4707 }
4708 current_cpu->hardware.h_cbit = carry_out;
4709 }
4710 }
4711 }
4712 }
4713 }
4714
4715       pbb_br_npc = npc;
4716       pbb_br_status = br_status;
4717 #undef FLD
4718     }
4719     NEXT_INSN (vpc, fragpc);
4720
4721 // ********** used only by: and-reg/reg-shift
4722
4723   CASE (FRAG_AND_REG_REG_SHIFT_MID):
4724     {
4725       abuf = vpc;
4726       vpc = vpc + 1;
4727 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
4728       PCADDR pc = abuf->addr;
4729       br_status = BRANCH_UNTAKEN;
4730       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4731
4732 {
4733   operand2 = current_cpu->compute_operand2_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg));
4734   carry_out = current_cpu->compute_carry_out_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg), current_cpu->hardware.h_cbit);
4735   result = ANDSI (* FLD (i_rn), operand2);
4736 }
4737
4738 #undef FLD
4739     }
4740     NEXT_FRAG (fragpc);
4741
4742 // ********** used only by: and-imm
4743
4744   CASE (FRAG_AND_IMM_MID):
4745     {
4746       abuf = vpc;
4747       vpc = vpc + 1;
4748 #define FLD(f) abuf->fields.sfmt_and_imm.f
4749       PCADDR pc = abuf->addr;
4750       br_status = BRANCH_UNTAKEN;
4751       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4752
4753 {
4754   result = ANDSI (* FLD (i_rn), FLD (f_imm12));
4755 }
4756
4757 #undef FLD
4758     }
4759     NEXT_FRAG (fragpc);
4760
4761 // ********** used only by: orr-reg/imm-shift
4762
4763   CASE (FRAG_ORR_REG_IMM_SHIFT_MID):
4764     {
4765 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4766       PCADDR pc = abuf->addr;
4767
4768 {
4769   result = ORSI (* FLD (i_rn), operand2);
4770 }
4771
4772 #undef FLD
4773     }
4774     NEXT_FRAG (fragpc);
4775
4776 // ********** used only by: orr-reg/reg-shift
4777
4778   CASE (FRAG_ORR_REG_REG_SHIFT_MID):
4779     {
4780 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
4781       PCADDR pc = abuf->addr;
4782
4783 {
4784   result = ORSI (* FLD (i_rn), operand2);
4785 }
4786
4787 #undef FLD
4788     }
4789     NEXT_FRAG (fragpc);
4790
4791 // ********** used only by: orr-imm
4792
4793   CASE (FRAG_ORR_IMM_MID):
4794     {
4795       abuf = vpc;
4796       vpc = vpc + 1;
4797 #define FLD(f) abuf->fields.sfmt_and_imm.f
4798       PCADDR pc = abuf->addr;
4799       br_status = BRANCH_UNTAKEN;
4800       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4801
4802 {
4803   result = ORSI (* FLD (i_rn), FLD (f_imm12));
4804 }
4805
4806 #undef FLD
4807     }
4808     NEXT_FRAG (fragpc);
4809
4810 // ********** used only by: eor-reg/imm-shift
4811
4812   CASE (FRAG_EOR_REG_IMM_SHIFT_MID):
4813     {
4814 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4815       PCADDR pc = abuf->addr;
4816
4817 {
4818   result = XORSI (* FLD (i_rn), operand2);
4819 }
4820
4821 #undef FLD
4822     }
4823     NEXT_FRAG (fragpc);
4824
4825 // ********** used only by: eor-reg/reg-shift
4826
4827   CASE (FRAG_EOR_REG_REG_SHIFT_MID):
4828     {
4829 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
4830       PCADDR pc = abuf->addr;
4831
4832 {
4833   result = XORSI (* FLD (i_rn), operand2);
4834 }
4835
4836 #undef FLD
4837     }
4838     NEXT_FRAG (fragpc);
4839
4840 // ********** used only by: eor-imm
4841
4842   CASE (FRAG_EOR_IMM_MID):
4843     {
4844       abuf = vpc;
4845       vpc = vpc + 1;
4846 #define FLD(f) abuf->fields.sfmt_and_imm.f
4847       PCADDR pc = abuf->addr;
4848       br_status = BRANCH_UNTAKEN;
4849       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4850
4851 {
4852   result = XORSI (* FLD (i_rn), FLD (f_imm12));
4853 }
4854
4855 #undef FLD
4856     }
4857     NEXT_FRAG (fragpc);
4858
4859 // ********** used only by: mov-reg/imm-shift
4860
4861   CASE (FRAG_MOV_REG_IMM_SHIFT_MID):
4862     {
4863 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4864       PCADDR pc = abuf->addr;
4865
4866 {
4867   result = operand2;
4868 }
4869
4870 #undef FLD
4871     }
4872     NEXT_FRAG (fragpc);
4873
4874 // ********** used only by: mov-reg/reg-shift
4875
4876   CASE (FRAG_MOV_REG_REG_SHIFT_MID):
4877     {
4878 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
4879       PCADDR pc = abuf->addr;
4880
4881 {
4882   result = operand2;
4883 }
4884
4885 #undef FLD
4886     }
4887     NEXT_FRAG (fragpc);
4888
4889 // ********** used only by: mov-imm
4890
4891   CASE (FRAG_MOV_IMM_MID):
4892     {
4893       abuf = vpc;
4894       vpc = vpc + 1;
4895 #define FLD(f) abuf->fields.sfmt_and_imm.f
4896       PCADDR pc = abuf->addr;
4897       br_status = BRANCH_UNTAKEN;
4898       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4899
4900 {
4901   result = FLD (f_imm12);
4902 }
4903
4904 #undef FLD
4905     }
4906     NEXT_FRAG (fragpc);
4907
4908 // ********** used only by: bic-reg/imm-shift
4909
4910   CASE (FRAG_BIC_REG_IMM_SHIFT_MID):
4911     {
4912 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4913       PCADDR pc = abuf->addr;
4914
4915 {
4916   result = ANDSI (* FLD (i_rn), INVSI (operand2));
4917 }
4918
4919 #undef FLD
4920     }
4921     NEXT_FRAG (fragpc);
4922
4923 // ********** used only by: bic-reg/reg-shift
4924
4925   CASE (FRAG_BIC_REG_REG_SHIFT_MID):
4926     {
4927 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
4928       PCADDR pc = abuf->addr;
4929
4930 {
4931   result = ANDSI (* FLD (i_rn), INVSI (operand2));
4932 }
4933
4934 #undef FLD
4935     }
4936     NEXT_FRAG (fragpc);
4937
4938 // ********** used only by: bic-imm
4939
4940   CASE (FRAG_BIC_IMM_MID):
4941     {
4942       abuf = vpc;
4943       vpc = vpc + 1;
4944 #define FLD(f) abuf->fields.sfmt_and_imm.f
4945       PCADDR pc = abuf->addr;
4946       br_status = BRANCH_UNTAKEN;
4947       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
4948
4949 {
4950   result = ANDSI (* FLD (i_rn), INVSI (FLD (f_imm12)));
4951 }
4952
4953 #undef FLD
4954     }
4955     NEXT_FRAG (fragpc);
4956
4957 // ********** used only by: mvn-reg/imm-shift
4958
4959   CASE (FRAG_MVN_REG_IMM_SHIFT_MID):
4960     {
4961 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
4962       PCADDR pc = abuf->addr;
4963
4964 {
4965   carry_out = current_cpu->compute_carry_out_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm), current_cpu->hardware.h_cbit);
4966   result = INVSI (operand2);
4967 }
4968
4969 #undef FLD
4970     }
4971     NEXT_FRAG (fragpc);
4972
4973 // ********** used only by: mvn-reg/reg-shift
4974
4975   CASE (FRAG_MVN_REG_REG_SHIFT_MID):
4976     {
4977 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
4978       PCADDR pc = abuf->addr;
4979
4980 {
4981   carry_out = current_cpu->compute_carry_out_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg), current_cpu->hardware.h_cbit);
4982   result = INVSI (operand2);
4983 if (EQSI (FLD (f_rd), 15)) {
4984 {
4985 npc = result; br_status = BRANCH_UNCACHEABLE;
4986 if (FLD (f_set_cc_)) {
4987 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
4988 }
4989 }
4990 } else {
4991 {
4992 * FLD (i_rd) = result;
4993 if (FLD (f_set_cc_)) {
4994 {
4995 {
4996 current_cpu->hardware.h_zbit = EQSI (result, 0);
4997 current_cpu->hardware.h_nbit = LTSI (result, 0);
4998 }
4999 current_cpu->hardware.h_cbit = carry_out;
5000 }
5001 }
5002 }
5003 }
5004 }
5005
5006       pbb_br_npc = npc;
5007       pbb_br_status = br_status;
5008 #undef FLD
5009     }
5010     NEXT_INSN (vpc, fragpc);
5011
5012 // ********** used only by: mvn-imm
5013
5014   CASE (FRAG_MVN_IMM_MID):
5015     {
5016       abuf = vpc;
5017       vpc = vpc + 1;
5018 #define FLD(f) abuf->fields.sfmt_and_imm.f
5019       PCADDR pc = abuf->addr;
5020       br_status = BRANCH_UNTAKEN;
5021       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5022
5023 {
5024   result = INVSI (FLD (f_imm12));
5025 if (EQSI (FLD (f_rd), 15)) {
5026 {
5027 npc = result; br_status = BRANCH_UNCACHEABLE;
5028 if (FLD (f_set_cc_)) {
5029 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5030 }
5031 }
5032 } else {
5033 {
5034 * FLD (i_rd) = result;
5035 if (FLD (f_set_cc_)) {
5036 {
5037 current_cpu->hardware.h_zbit = EQSI (result, 0);
5038 current_cpu->hardware.h_nbit = LTSI (result, 0);
5039 }
5040 }
5041 }
5042 }
5043 }
5044
5045       pbb_br_npc = npc;
5046       pbb_br_status = br_status;
5047 #undef FLD
5048     }
5049     NEXT_INSN (vpc, fragpc);
5050
5051 // ********** used only by: add-reg/imm-shift
5052
5053   CASE (FRAG_ADD_REG_IMM_SHIFT_MID):
5054     {
5055 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5056       PCADDR pc = abuf->addr;
5057
5058 {
5059   temp_op1 = * FLD (i_rn);
5060   temp_op2 = operand2;
5061   result = ADDSI (* FLD (i_rn), operand2);
5062 if (EQSI (FLD (f_rd), 15)) {
5063 {
5064 npc = result; br_status = BRANCH_UNCACHEABLE;
5065 if (FLD (f_set_cc_)) {
5066 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5067 }
5068 }
5069 } else {
5070 {
5071 * FLD (i_rd) = result;
5072 if (FLD (f_set_cc_)) {
5073 {
5074   SI tmp_result;
5075   tmp_result = ADDCSI (temp_op1, temp_op2, 0);
5076 {
5077 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5078 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5079 }
5080 current_cpu->hardware.h_cbit = ADDCFSI (temp_op1, temp_op2, 0);
5081 current_cpu->hardware.h_vbit = ADDOFSI (temp_op1, temp_op2, 0);
5082 }
5083 }
5084 }
5085 }
5086 }
5087
5088       pbb_br_npc = npc;
5089       pbb_br_status = br_status;
5090 #undef FLD
5091     }
5092     NEXT_INSN (vpc, fragpc);
5093
5094 // ********** used only by: add-reg/reg-shift
5095
5096   CASE (FRAG_ADD_REG_REG_SHIFT_MID):
5097     {
5098 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
5099       PCADDR pc = abuf->addr;
5100
5101 {
5102   temp_op1 = * FLD (i_rn);
5103   temp_op2 = operand2;
5104   result = ADDSI (* FLD (i_rn), operand2);
5105 if (EQSI (FLD (f_rd), 15)) {
5106 {
5107 npc = result; br_status = BRANCH_UNCACHEABLE;
5108 if (FLD (f_set_cc_)) {
5109 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5110 }
5111 }
5112 } else {
5113 {
5114 * FLD (i_rd) = result;
5115 if (FLD (f_set_cc_)) {
5116 {
5117   SI tmp_result;
5118   tmp_result = ADDCSI (temp_op1, temp_op2, 0);
5119 {
5120 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5121 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5122 }
5123 current_cpu->hardware.h_cbit = ADDCFSI (temp_op1, temp_op2, 0);
5124 current_cpu->hardware.h_vbit = ADDOFSI (temp_op1, temp_op2, 0);
5125 }
5126 }
5127 }
5128 }
5129 }
5130
5131       pbb_br_npc = npc;
5132       pbb_br_status = br_status;
5133 #undef FLD
5134     }
5135     NEXT_INSN (vpc, fragpc);
5136
5137 // ********** used only by: add-imm
5138
5139   CASE (FRAG_ADD_IMM_MID):
5140     {
5141       abuf = vpc;
5142       vpc = vpc + 1;
5143 #define FLD(f) abuf->fields.sfmt_and_imm.f
5144       PCADDR pc = abuf->addr;
5145       br_status = BRANCH_UNTAKEN;
5146       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5147
5148 {
5149   result = ADDSI (* FLD (i_rn), FLD (f_imm12));
5150 if (EQSI (FLD (f_rd), 15)) {
5151 {
5152 if (FLD (f_set_cc_)) {
5153 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5154 }
5155 npc = result; br_status = BRANCH_UNCACHEABLE;
5156 }
5157 } else {
5158 {
5159 if (FLD (f_set_cc_)) {
5160 {
5161   SI tmp_result;
5162   tmp_result = ADDCSI (* FLD (i_rn), FLD (f_imm12), 0);
5163 {
5164 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5165 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5166 }
5167 current_cpu->hardware.h_cbit = ADDCFSI (* FLD (i_rn), FLD (f_imm12), 0);
5168 current_cpu->hardware.h_vbit = ADDOFSI (* FLD (i_rn), FLD (f_imm12), 0);
5169 }
5170 }
5171 * FLD (i_rd) = result;
5172 }
5173 }
5174 }
5175
5176       pbb_br_npc = npc;
5177       pbb_br_status = br_status;
5178 #undef FLD
5179     }
5180     NEXT_INSN (vpc, fragpc);
5181
5182 // ********** used only by: adc-reg/imm-shift
5183
5184   CASE (FRAG_ADC_REG_IMM_SHIFT_MID):
5185     {
5186 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5187       PCADDR pc = abuf->addr;
5188
5189 {
5190   temp_op1 = * FLD (i_rn);
5191   temp_op2 = operand2;
5192   result = ADDCSI (* FLD (i_rn), operand2, current_cpu->hardware.h_cbit);
5193 if (EQSI (FLD (f_rd), 15)) {
5194 {
5195 npc = result; br_status = BRANCH_UNCACHEABLE;
5196 if (FLD (f_set_cc_)) {
5197 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5198 }
5199 }
5200 } else {
5201 {
5202 * FLD (i_rd) = result;
5203 if (FLD (f_set_cc_)) {
5204 {
5205   SI tmp_result;
5206   tmp_result = ADDCSI (temp_op1, temp_op2, current_cpu->hardware.h_cbit);
5207 {
5208 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5209 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5210 }
5211 current_cpu->hardware.h_cbit = ADDCFSI (temp_op1, temp_op2, current_cpu->hardware.h_cbit);
5212 current_cpu->hardware.h_vbit = ADDOFSI (temp_op1, temp_op2, current_cpu->hardware.h_cbit);
5213 }
5214 }
5215 }
5216 }
5217 }
5218
5219       pbb_br_npc = npc;
5220       pbb_br_status = br_status;
5221 #undef FLD
5222     }
5223     NEXT_INSN (vpc, fragpc);
5224
5225 // ********** used only by: adc-reg/reg-shift
5226
5227   CASE (FRAG_ADC_REG_REG_SHIFT_MID):
5228     {
5229 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
5230       PCADDR pc = abuf->addr;
5231
5232 {
5233   temp_op1 = * FLD (i_rn);
5234   temp_op2 = operand2;
5235   result = ADDCSI (* FLD (i_rn), operand2, current_cpu->hardware.h_cbit);
5236 if (EQSI (FLD (f_rd), 15)) {
5237 {
5238 npc = result; br_status = BRANCH_UNCACHEABLE;
5239 if (FLD (f_set_cc_)) {
5240 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5241 }
5242 }
5243 } else {
5244 {
5245 * FLD (i_rd) = result;
5246 if (FLD (f_set_cc_)) {
5247 {
5248   SI tmp_result;
5249   tmp_result = ADDCSI (temp_op1, temp_op2, current_cpu->hardware.h_cbit);
5250 {
5251 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5252 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5253 }
5254 current_cpu->hardware.h_cbit = ADDCFSI (temp_op1, temp_op2, current_cpu->hardware.h_cbit);
5255 current_cpu->hardware.h_vbit = ADDOFSI (temp_op1, temp_op2, current_cpu->hardware.h_cbit);
5256 }
5257 }
5258 }
5259 }
5260 }
5261
5262       pbb_br_npc = npc;
5263       pbb_br_status = br_status;
5264 #undef FLD
5265     }
5266     NEXT_INSN (vpc, fragpc);
5267
5268 // ********** used only by: adc-imm
5269
5270   CASE (FRAG_ADC_IMM_MID):
5271     {
5272       abuf = vpc;
5273       vpc = vpc + 1;
5274 #define FLD(f) abuf->fields.sfmt_and_imm.f
5275       PCADDR pc = abuf->addr;
5276       br_status = BRANCH_UNTAKEN;
5277       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5278
5279 {
5280   result = ADDCSI (* FLD (i_rn), FLD (f_imm12), current_cpu->hardware.h_cbit);
5281 if (EQSI (FLD (f_rd), 15)) {
5282 {
5283 if (FLD (f_set_cc_)) {
5284 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5285 }
5286 npc = result; br_status = BRANCH_UNCACHEABLE;
5287 }
5288 } else {
5289 {
5290 if (FLD (f_set_cc_)) {
5291 {
5292   SI tmp_result;
5293   tmp_result = ADDCSI (* FLD (i_rn), FLD (f_imm12), current_cpu->hardware.h_cbit);
5294 {
5295 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5296 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5297 }
5298 current_cpu->hardware.h_cbit = ADDCFSI (* FLD (i_rn), FLD (f_imm12), current_cpu->hardware.h_cbit);
5299 current_cpu->hardware.h_vbit = ADDOFSI (* FLD (i_rn), FLD (f_imm12), current_cpu->hardware.h_cbit);
5300 }
5301 }
5302 * FLD (i_rd) = result;
5303 }
5304 }
5305 }
5306
5307       pbb_br_npc = npc;
5308       pbb_br_status = br_status;
5309 #undef FLD
5310     }
5311     NEXT_INSN (vpc, fragpc);
5312
5313 // ********** used only by: sub-reg/imm-shift
5314
5315   CASE (FRAG_SUB_REG_IMM_SHIFT_MID):
5316     {
5317 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5318       PCADDR pc = abuf->addr;
5319
5320 {
5321   temp_op1 = * FLD (i_rn);
5322   temp_op2 = operand2;
5323   result = SUBSI (* FLD (i_rn), operand2);
5324 if (EQSI (FLD (f_rd), 15)) {
5325 {
5326 npc = result; br_status = BRANCH_UNCACHEABLE;
5327 if (FLD (f_set_cc_)) {
5328 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5329 }
5330 }
5331 } else {
5332 {
5333 * FLD (i_rd) = result;
5334 if (FLD (f_set_cc_)) {
5335 {
5336   SI tmp_result;
5337   tmp_result = SUBCSI (temp_op1, temp_op2, 0);
5338 {
5339 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5340 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5341 }
5342 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (temp_op1, temp_op2, 0));
5343 current_cpu->hardware.h_vbit = SUBOFSI (temp_op1, temp_op2, 0);
5344 }
5345 }
5346 }
5347 }
5348 }
5349
5350       pbb_br_npc = npc;
5351       pbb_br_status = br_status;
5352 #undef FLD
5353     }
5354     NEXT_INSN (vpc, fragpc);
5355
5356 // ********** used only by: sub-reg/reg-shift
5357
5358   CASE (FRAG_SUB_REG_REG_SHIFT_MID):
5359     {
5360 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
5361       PCADDR pc = abuf->addr;
5362
5363 {
5364   temp_op1 = * FLD (i_rn);
5365   temp_op2 = operand2;
5366   result = SUBSI (* FLD (i_rn), operand2);
5367 if (EQSI (FLD (f_rd), 15)) {
5368 {
5369 npc = result; br_status = BRANCH_UNCACHEABLE;
5370 if (FLD (f_set_cc_)) {
5371 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5372 }
5373 }
5374 } else {
5375 {
5376 * FLD (i_rd) = result;
5377 if (FLD (f_set_cc_)) {
5378 {
5379   SI tmp_result;
5380   tmp_result = SUBCSI (temp_op1, temp_op2, 0);
5381 {
5382 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5383 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5384 }
5385 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (temp_op1, temp_op2, 0));
5386 current_cpu->hardware.h_vbit = SUBOFSI (temp_op1, temp_op2, 0);
5387 }
5388 }
5389 }
5390 }
5391 }
5392
5393       pbb_br_npc = npc;
5394       pbb_br_status = br_status;
5395 #undef FLD
5396     }
5397     NEXT_INSN (vpc, fragpc);
5398
5399 // ********** used only by: sub-imm
5400
5401   CASE (FRAG_SUB_IMM_MID):
5402     {
5403       abuf = vpc;
5404       vpc = vpc + 1;
5405 #define FLD(f) abuf->fields.sfmt_and_imm.f
5406       PCADDR pc = abuf->addr;
5407       br_status = BRANCH_UNTAKEN;
5408       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5409
5410 {
5411   result = SUBSI (* FLD (i_rn), FLD (f_imm12));
5412 if (EQSI (FLD (f_rd), 15)) {
5413 {
5414 if (FLD (f_set_cc_)) {
5415 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5416 }
5417 npc = result; br_status = BRANCH_UNCACHEABLE;
5418 }
5419 } else {
5420 {
5421 if (FLD (f_set_cc_)) {
5422 {
5423   SI tmp_result;
5424   tmp_result = SUBCSI (* FLD (i_rn), FLD (f_imm12), 0);
5425 {
5426 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5427 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5428 }
5429 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (* FLD (i_rn), FLD (f_imm12), 0));
5430 current_cpu->hardware.h_vbit = SUBOFSI (* FLD (i_rn), FLD (f_imm12), 0);
5431 }
5432 }
5433 * FLD (i_rd) = result;
5434 }
5435 }
5436 }
5437
5438       pbb_br_npc = npc;
5439       pbb_br_status = br_status;
5440 #undef FLD
5441     }
5442     NEXT_INSN (vpc, fragpc);
5443
5444 // ********** used only by: sbc-reg/imm-shift
5445
5446   CASE (FRAG_SBC_REG_IMM_SHIFT_MID):
5447     {
5448 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5449       PCADDR pc = abuf->addr;
5450
5451 {
5452   temp_op1 = * FLD (i_rn);
5453   temp_op2 = operand2;
5454   result = SUBCSI (* FLD (i_rn), operand2, NOTBI (current_cpu->hardware.h_cbit));
5455 if (EQSI (FLD (f_rd), 15)) {
5456 {
5457 npc = result; br_status = BRANCH_UNCACHEABLE;
5458 if (FLD (f_set_cc_)) {
5459 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5460 }
5461 }
5462 } else {
5463 {
5464 * FLD (i_rd) = result;
5465 if (FLD (f_set_cc_)) {
5466 {
5467   SI tmp_result;
5468   tmp_result = SUBCSI (temp_op1, temp_op2, NOTBI (current_cpu->hardware.h_cbit));
5469 {
5470 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5471 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5472 }
5473 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (temp_op1, temp_op2, NOTBI (current_cpu->hardware.h_cbit)));
5474 current_cpu->hardware.h_vbit = SUBOFSI (temp_op1, temp_op2, NOTBI (current_cpu->hardware.h_cbit));
5475 }
5476 }
5477 }
5478 }
5479 }
5480
5481       pbb_br_npc = npc;
5482       pbb_br_status = br_status;
5483 #undef FLD
5484     }
5485     NEXT_INSN (vpc, fragpc);
5486
5487 // ********** used only by: sbc-reg/reg-shift
5488
5489   CASE (FRAG_SBC_REG_REG_SHIFT_MID):
5490     {
5491 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
5492       PCADDR pc = abuf->addr;
5493
5494 {
5495   temp_op1 = * FLD (i_rn);
5496   temp_op2 = operand2;
5497   result = SUBCSI (* FLD (i_rn), operand2, NOTBI (current_cpu->hardware.h_cbit));
5498 if (EQSI (FLD (f_rd), 15)) {
5499 {
5500 npc = result; br_status = BRANCH_UNCACHEABLE;
5501 if (FLD (f_set_cc_)) {
5502 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5503 }
5504 }
5505 } else {
5506 {
5507 * FLD (i_rd) = result;
5508 if (FLD (f_set_cc_)) {
5509 {
5510   SI tmp_result;
5511   tmp_result = SUBCSI (temp_op1, temp_op2, NOTBI (current_cpu->hardware.h_cbit));
5512 {
5513 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5514 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5515 }
5516 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (temp_op1, temp_op2, NOTBI (current_cpu->hardware.h_cbit)));
5517 current_cpu->hardware.h_vbit = SUBOFSI (temp_op1, temp_op2, NOTBI (current_cpu->hardware.h_cbit));
5518 }
5519 }
5520 }
5521 }
5522 }
5523
5524       pbb_br_npc = npc;
5525       pbb_br_status = br_status;
5526 #undef FLD
5527     }
5528     NEXT_INSN (vpc, fragpc);
5529
5530 // ********** used only by: sbc-imm
5531
5532   CASE (FRAG_SBC_IMM_MID):
5533     {
5534       abuf = vpc;
5535       vpc = vpc + 1;
5536 #define FLD(f) abuf->fields.sfmt_and_imm.f
5537       PCADDR pc = abuf->addr;
5538       br_status = BRANCH_UNTAKEN;
5539       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5540
5541 {
5542   result = SUBCSI (* FLD (i_rn), FLD (f_imm12), NOTBI (current_cpu->hardware.h_cbit));
5543 if (EQSI (FLD (f_rd), 15)) {
5544 {
5545 if (FLD (f_set_cc_)) {
5546 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5547 }
5548 npc = result; br_status = BRANCH_UNCACHEABLE;
5549 }
5550 } else {
5551 {
5552 if (FLD (f_set_cc_)) {
5553 {
5554   SI tmp_result;
5555   tmp_result = SUBCSI (* FLD (i_rn), FLD (f_imm12), NOTBI (current_cpu->hardware.h_cbit));
5556 {
5557 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5558 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5559 }
5560 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (* FLD (i_rn), FLD (f_imm12), NOTBI (current_cpu->hardware.h_cbit)));
5561 current_cpu->hardware.h_vbit = SUBOFSI (* FLD (i_rn), FLD (f_imm12), NOTBI (current_cpu->hardware.h_cbit));
5562 }
5563 }
5564 * FLD (i_rd) = result;
5565 }
5566 }
5567 }
5568
5569       pbb_br_npc = npc;
5570       pbb_br_status = br_status;
5571 #undef FLD
5572     }
5573     NEXT_INSN (vpc, fragpc);
5574
5575 // ********** used only by: rsb-reg/imm-shift
5576
5577   CASE (FRAG_RSB_REG_IMM_SHIFT_MID):
5578     {
5579 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5580       PCADDR pc = abuf->addr;
5581
5582 {
5583   temp_op1 = * FLD (i_rn);
5584   temp_op2 = operand2;
5585   result = SUBSI (operand2, * FLD (i_rn));
5586 if (EQSI (FLD (f_rd), 15)) {
5587 {
5588 npc = result; br_status = BRANCH_UNCACHEABLE;
5589 if (FLD (f_set_cc_)) {
5590 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5591 }
5592 }
5593 } else {
5594 {
5595 * FLD (i_rd) = result;
5596 if (FLD (f_set_cc_)) {
5597 {
5598   SI tmp_result;
5599   tmp_result = SUBCSI (temp_op2, temp_op1, 0);
5600 {
5601 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5602 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5603 }
5604 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (temp_op2, temp_op1, 0));
5605 current_cpu->hardware.h_vbit = SUBOFSI (temp_op2, temp_op1, 0);
5606 }
5607 }
5608 }
5609 }
5610 }
5611
5612       pbb_br_npc = npc;
5613       pbb_br_status = br_status;
5614 #undef FLD
5615     }
5616     NEXT_INSN (vpc, fragpc);
5617
5618 // ********** used only by: rsb-reg/reg-shift
5619
5620   CASE (FRAG_RSB_REG_REG_SHIFT_MID):
5621     {
5622 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
5623       PCADDR pc = abuf->addr;
5624
5625 {
5626   temp_op1 = * FLD (i_rn);
5627   temp_op2 = operand2;
5628   result = SUBSI (operand2, * FLD (i_rn));
5629 if (EQSI (FLD (f_rd), 15)) {
5630 {
5631 npc = result; br_status = BRANCH_UNCACHEABLE;
5632 if (FLD (f_set_cc_)) {
5633 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5634 }
5635 }
5636 } else {
5637 {
5638 * FLD (i_rd) = result;
5639 if (FLD (f_set_cc_)) {
5640 {
5641   SI tmp_result;
5642   tmp_result = SUBCSI (temp_op2, temp_op1, 0);
5643 {
5644 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5645 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5646 }
5647 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (temp_op2, temp_op1, 0));
5648 current_cpu->hardware.h_vbit = SUBOFSI (temp_op2, temp_op1, 0);
5649 }
5650 }
5651 }
5652 }
5653 }
5654
5655       pbb_br_npc = npc;
5656       pbb_br_status = br_status;
5657 #undef FLD
5658     }
5659     NEXT_INSN (vpc, fragpc);
5660
5661 // ********** used only by: rsb-imm
5662
5663   CASE (FRAG_RSB_IMM_MID):
5664     {
5665       abuf = vpc;
5666       vpc = vpc + 1;
5667 #define FLD(f) abuf->fields.sfmt_and_imm.f
5668       PCADDR pc = abuf->addr;
5669       br_status = BRANCH_UNTAKEN;
5670       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5671
5672 {
5673   result = SUBSI (FLD (f_imm12), * FLD (i_rn));
5674 if (EQSI (FLD (f_rd), 15)) {
5675 {
5676 if (FLD (f_set_cc_)) {
5677 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5678 }
5679 npc = result; br_status = BRANCH_UNCACHEABLE;
5680 }
5681 } else {
5682 {
5683 if (FLD (f_set_cc_)) {
5684 {
5685   SI tmp_result;
5686   tmp_result = SUBCSI (FLD (f_imm12), * FLD (i_rn), 0);
5687 {
5688 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5689 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5690 }
5691 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (FLD (f_imm12), * FLD (i_rn), 0));
5692 current_cpu->hardware.h_vbit = SUBOFSI (FLD (f_imm12), * FLD (i_rn), 0);
5693 }
5694 }
5695 * FLD (i_rd) = result;
5696 }
5697 }
5698 }
5699
5700       pbb_br_npc = npc;
5701       pbb_br_status = br_status;
5702 #undef FLD
5703     }
5704     NEXT_INSN (vpc, fragpc);
5705
5706 // ********** used only by: rsc-reg/imm-shift
5707
5708   CASE (FRAG_RSC_REG_IMM_SHIFT_MID):
5709     {
5710 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5711       PCADDR pc = abuf->addr;
5712
5713 {
5714   temp_op1 = * FLD (i_rn);
5715   temp_op2 = operand2;
5716   result = SUBCSI (operand2, * FLD (i_rn), NOTBI (current_cpu->hardware.h_cbit));
5717 if (EQSI (FLD (f_rd), 15)) {
5718 {
5719 npc = result; br_status = BRANCH_UNCACHEABLE;
5720 if (FLD (f_set_cc_)) {
5721 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5722 }
5723 }
5724 } else {
5725 {
5726 * FLD (i_rd) = result;
5727 if (FLD (f_set_cc_)) {
5728 {
5729   SI tmp_result;
5730   tmp_result = SUBCSI (temp_op2, temp_op1, NOTBI (current_cpu->hardware.h_cbit));
5731 {
5732 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5733 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5734 }
5735 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (temp_op2, temp_op1, NOTBI (current_cpu->hardware.h_cbit)));
5736 current_cpu->hardware.h_vbit = SUBOFSI (temp_op2, temp_op1, NOTBI (current_cpu->hardware.h_cbit));
5737 }
5738 }
5739 }
5740 }
5741 }
5742
5743       pbb_br_npc = npc;
5744       pbb_br_status = br_status;
5745 #undef FLD
5746     }
5747     NEXT_INSN (vpc, fragpc);
5748
5749 // ********** used only by: rsc-reg/reg-shift
5750
5751   CASE (FRAG_RSC_REG_REG_SHIFT_MID):
5752     {
5753 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
5754       PCADDR pc = abuf->addr;
5755
5756 {
5757   temp_op1 = * FLD (i_rn);
5758   temp_op2 = operand2;
5759   result = SUBCSI (operand2, * FLD (i_rn), NOTBI (current_cpu->hardware.h_cbit));
5760 if (EQSI (FLD (f_rd), 15)) {
5761 {
5762 npc = result; br_status = BRANCH_UNCACHEABLE;
5763 if (FLD (f_set_cc_)) {
5764 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5765 }
5766 }
5767 } else {
5768 {
5769 * FLD (i_rd) = result;
5770 if (FLD (f_set_cc_)) {
5771 {
5772   SI tmp_result;
5773   tmp_result = SUBCSI (temp_op2, temp_op1, NOTBI (current_cpu->hardware.h_cbit));
5774 {
5775 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5776 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5777 }
5778 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (temp_op2, temp_op1, NOTBI (current_cpu->hardware.h_cbit)));
5779 current_cpu->hardware.h_vbit = SUBOFSI (temp_op2, temp_op1, NOTBI (current_cpu->hardware.h_cbit));
5780 }
5781 }
5782 }
5783 }
5784 }
5785
5786       pbb_br_npc = npc;
5787       pbb_br_status = br_status;
5788 #undef FLD
5789     }
5790     NEXT_INSN (vpc, fragpc);
5791
5792 // ********** used only by: rsc-imm
5793
5794   CASE (FRAG_RSC_IMM_MID):
5795     {
5796       abuf = vpc;
5797       vpc = vpc + 1;
5798 #define FLD(f) abuf->fields.sfmt_and_imm.f
5799       PCADDR pc = abuf->addr;
5800       br_status = BRANCH_UNTAKEN;
5801       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5802
5803 {
5804   result = SUBCSI (FLD (f_imm12), * FLD (i_rn), NOTBI (current_cpu->hardware.h_cbit));
5805 if (EQSI (FLD (f_rd), 15)) {
5806 {
5807 if (FLD (f_set_cc_)) {
5808 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5809 }
5810 npc = result; br_status = BRANCH_UNCACHEABLE;
5811 }
5812 } else {
5813 {
5814 if (FLD (f_set_cc_)) {
5815 {
5816   SI tmp_result;
5817   tmp_result = SUBCSI (FLD (f_imm12), * FLD (i_rn), NOTBI (current_cpu->hardware.h_cbit));
5818 {
5819 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5820 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5821 }
5822 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (FLD (f_imm12), * FLD (i_rn), NOTBI (current_cpu->hardware.h_cbit)));
5823 current_cpu->hardware.h_vbit = SUBOFSI (FLD (f_imm12), * FLD (i_rn), NOTBI (current_cpu->hardware.h_cbit));
5824 }
5825 }
5826 * FLD (i_rd) = result;
5827 }
5828 }
5829 }
5830
5831       pbb_br_npc = npc;
5832       pbb_br_status = br_status;
5833 #undef FLD
5834     }
5835     NEXT_INSN (vpc, fragpc);
5836
5837 // ********** used only by: tst-reg/imm-shift
5838
5839   CASE (FRAG_TST_REG_IMM_SHIFT_MID):
5840     {
5841 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5842       PCADDR pc = abuf->addr;
5843
5844 {
5845   result = ANDSI (* FLD (i_rn), operand2);
5846 if (EQSI (FLD (f_rd), 15)) {
5847 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5848 } else {
5849 {
5850 {
5851 current_cpu->hardware.h_zbit = EQSI (result, 0);
5852 current_cpu->hardware.h_nbit = LTSI (result, 0);
5853 }
5854 current_cpu->hardware.h_cbit = carry_out;
5855 }
5856 }
5857 }
5858
5859 #undef FLD
5860     }
5861     NEXT_INSN (vpc, fragpc);
5862
5863 // ********** used only by: tst-reg/reg-shift
5864
5865   CASE (FRAG_TST_REG_REG_SHIFT_MID):
5866     {
5867 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
5868       PCADDR pc = abuf->addr;
5869
5870 {
5871   result = ANDSI (* FLD (i_rn), operand2);
5872 }
5873
5874 #undef FLD
5875     }
5876     NEXT_FRAG (fragpc);
5877
5878 // ********** used only by: tst-imm
5879
5880   CASE (FRAG_TST_IMM_MID):
5881     {
5882       abuf = vpc;
5883       vpc = vpc + 1;
5884 #define FLD(f) abuf->fields.sfmt_tst_imm.f
5885       PCADDR pc = abuf->addr;
5886       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5887
5888 {
5889 if (EQSI (FLD (f_ror_imm8_rotate), 0)) {
5890   carry_out = current_cpu->hardware.h_cbit;
5891 } else {
5892   carry_out = LTBI (FLD (f_ror_imm8), 0);
5893 }
5894 {
5895 {
5896 current_cpu->hardware.h_zbit = EQSI (ANDSI (* FLD (i_rn), FLD (f_ror_imm8)), 0);
5897 current_cpu->hardware.h_nbit = LTSI (ANDSI (* FLD (i_rn), FLD (f_ror_imm8)), 0);
5898 }
5899 current_cpu->hardware.h_cbit = carry_out;
5900 }
5901 }
5902
5903 #undef FLD
5904     }
5905     NEXT_INSN (vpc, fragpc);
5906
5907 // ********** used only by: teq-reg/imm-shift
5908
5909   CASE (FRAG_TEQ_REG_IMM_SHIFT_MID):
5910     {
5911 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5912       PCADDR pc = abuf->addr;
5913
5914 {
5915   result = XORSI (* FLD (i_rn), operand2);
5916 }
5917
5918 #undef FLD
5919     }
5920     NEXT_FRAG (fragpc);
5921
5922 // ********** used only by: teq-reg/reg-shift
5923
5924   CASE (FRAG_TEQ_REG_REG_SHIFT_MID):
5925     {
5926 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
5927       PCADDR pc = abuf->addr;
5928
5929 {
5930   result = XORSI (* FLD (i_rn), operand2);
5931 if (EQSI (FLD (f_rd), 15)) {
5932 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5933 } else {
5934 {
5935 {
5936 current_cpu->hardware.h_zbit = EQSI (result, 0);
5937 current_cpu->hardware.h_nbit = LTSI (result, 0);
5938 }
5939 current_cpu->hardware.h_cbit = carry_out;
5940 }
5941 }
5942 }
5943
5944 #undef FLD
5945     }
5946     NEXT_INSN (vpc, fragpc);
5947
5948 // ********** used only by: teq-imm
5949
5950   CASE (FRAG_TEQ_IMM_MID):
5951     {
5952       abuf = vpc;
5953       vpc = vpc + 1;
5954 #define FLD(f) abuf->fields.sfmt_tst_imm.f
5955       PCADDR pc = abuf->addr;
5956       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
5957
5958 {
5959 if (EQSI (FLD (f_ror_imm8_rotate), 0)) {
5960   carry_out = current_cpu->hardware.h_cbit;
5961 } else {
5962   carry_out = LTBI (FLD (f_ror_imm8), 0);
5963 }
5964 {
5965 {
5966 current_cpu->hardware.h_zbit = EQSI (XORSI (* FLD (i_rn), FLD (f_ror_imm8)), 0);
5967 current_cpu->hardware.h_nbit = LTSI (XORSI (* FLD (i_rn), FLD (f_ror_imm8)), 0);
5968 }
5969 current_cpu->hardware.h_cbit = carry_out;
5970 }
5971 }
5972
5973 #undef FLD
5974     }
5975     NEXT_INSN (vpc, fragpc);
5976
5977 // ********** used only by: cmp-reg/imm-shift
5978
5979   CASE (FRAG_CMP_REG_IMM_SHIFT_MID):
5980     {
5981 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
5982       PCADDR pc = abuf->addr;
5983
5984 {
5985 if (EQSI (FLD (f_rd), 15)) {
5986 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
5987 } else {
5988 {
5989   SI tmp_result;
5990   tmp_result = SUBCSI (* FLD (i_rn), operand2, 0);
5991 {
5992 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
5993 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
5994 }
5995 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (* FLD (i_rn), operand2, 0));
5996 current_cpu->hardware.h_vbit = SUBOFSI (* FLD (i_rn), operand2, 0);
5997 }
5998 }
5999 }
6000
6001 #undef FLD
6002     }
6003     NEXT_INSN (vpc, fragpc);
6004
6005 // ********** used only by: cmp-reg/reg-shift
6006
6007   CASE (FRAG_CMP_REG_REG_SHIFT_MID):
6008     {
6009 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
6010       PCADDR pc = abuf->addr;
6011
6012 {
6013 if (EQSI (FLD (f_rd), 15)) {
6014 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
6015 } else {
6016 {
6017   SI tmp_result;
6018   tmp_result = SUBCSI (* FLD (i_rn), operand2, 0);
6019 {
6020 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
6021 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
6022 }
6023 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (* FLD (i_rn), operand2, 0));
6024 current_cpu->hardware.h_vbit = SUBOFSI (* FLD (i_rn), operand2, 0);
6025 }
6026 }
6027 }
6028
6029 #undef FLD
6030     }
6031     NEXT_INSN (vpc, fragpc);
6032
6033 // ********** used only by: cmp-imm
6034
6035   CASE (FRAG_CMP_IMM_MID):
6036     {
6037       abuf = vpc;
6038       vpc = vpc + 1;
6039 #define FLD(f) abuf->fields.sfmt_and_imm.f
6040       PCADDR pc = abuf->addr;
6041       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6042
6043 {
6044   result = SUBCSI (* FLD (i_rn), FLD (f_imm12), 0);
6045 {
6046 current_cpu->hardware.h_zbit = EQSI (result, 0);
6047 current_cpu->hardware.h_nbit = LTSI (result, 0);
6048 }
6049 current_cpu->hardware.h_cbit = NOTBI (SUBCFSI (* FLD (i_rn), FLD (f_imm12), 0));
6050 current_cpu->hardware.h_vbit = SUBOFSI (* FLD (i_rn), FLD (f_imm12), 0);
6051 }
6052
6053 #undef FLD
6054     }
6055     NEXT_INSN (vpc, fragpc);
6056
6057 // ********** used only by: cmn-reg/imm-shift
6058
6059   CASE (FRAG_CMN_REG_IMM_SHIFT_MID):
6060     {
6061       abuf = vpc;
6062       vpc = vpc + 1;
6063 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
6064       PCADDR pc = abuf->addr;
6065       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6066
6067 {
6068   operand2 = current_cpu->compute_operand2_immshift (* FLD (i_rm), FLD (f_operand2_shifttype), FLD (f_operand2_shiftimm));
6069 if (EQSI (FLD (f_rd), 15)) {
6070 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
6071 } else {
6072 {
6073   SI tmp_result;
6074   tmp_result = ADDCSI (* FLD (i_rn), operand2, 0);
6075 {
6076 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
6077 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
6078 }
6079 current_cpu->hardware.h_cbit = ADDCFSI (* FLD (i_rn), operand2, 0);
6080 current_cpu->hardware.h_vbit = ADDOFSI (* FLD (i_rn), operand2, 0);
6081 }
6082 }
6083 }
6084
6085 #undef FLD
6086     }
6087     NEXT_INSN (vpc, fragpc);
6088
6089 // ********** used only by: cmn-reg/reg-shift
6090
6091   CASE (FRAG_CMN_REG_REG_SHIFT_MID):
6092     {
6093       abuf = vpc;
6094       vpc = vpc + 1;
6095 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
6096       PCADDR pc = abuf->addr;
6097       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6098
6099 {
6100   operand2 = current_cpu->compute_operand2_regshift (* FLD (i_rm), FLD (f_operand2_shifttype), * FLD (i_operand2_shiftreg));
6101 if (EQSI (FLD (f_rd), 15)) {
6102 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
6103 } else {
6104 {
6105   SI tmp_result;
6106   tmp_result = ADDCSI (* FLD (i_rn), operand2, 0);
6107 {
6108 current_cpu->hardware.h_zbit = EQSI (tmp_result, 0);
6109 current_cpu->hardware.h_nbit = LTSI (tmp_result, 0);
6110 }
6111 current_cpu->hardware.h_cbit = ADDCFSI (* FLD (i_rn), operand2, 0);
6112 current_cpu->hardware.h_vbit = ADDOFSI (* FLD (i_rn), operand2, 0);
6113 }
6114 }
6115 }
6116
6117 #undef FLD
6118     }
6119     NEXT_INSN (vpc, fragpc);
6120
6121 // ********** used only by: cmn-imm
6122
6123   CASE (FRAG_CMN_IMM_MID):
6124     {
6125       abuf = vpc;
6126       vpc = vpc + 1;
6127 #define FLD(f) abuf->fields.sfmt_and_imm.f
6128       PCADDR pc = abuf->addr;
6129       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6130
6131 {
6132   result = ADDCSI (* FLD (i_rn), FLD (f_imm12), 0);
6133 {
6134 current_cpu->hardware.h_zbit = EQSI (result, 0);
6135 current_cpu->hardware.h_nbit = LTSI (result, 0);
6136 }
6137 current_cpu->hardware.h_cbit = ADDCFSI (* FLD (i_rn), FLD (f_imm12), 0);
6138 current_cpu->hardware.h_vbit = ADDOFSI (* FLD (i_rn), FLD (f_imm12), 0);
6139 }
6140
6141 #undef FLD
6142     }
6143     NEXT_INSN (vpc, fragpc);
6144
6145 // ********** used only by: ldmda
6146
6147   CASE (FRAG_LDMDA_MID):
6148     {
6149       abuf = vpc;
6150       vpc = vpc + 1;
6151 #define FLD(f) abuf->fields.sfmt_ldmda.f
6152       PCADDR pc = abuf->addr;
6153       br_status = BRANCH_UNTAKEN;
6154       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6155
6156 {
6157   addr = * FLD (i_rn);
6158 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6159 {
6160 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
6161   addr = SUBSI (addr, 4);
6162 }
6163 }
6164 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
6165 {
6166 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
6167   addr = SUBSI (addr, 4);
6168 }
6169 }
6170 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
6171 {
6172 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
6173   addr = SUBSI (addr, 4);
6174 }
6175 }
6176 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
6177 {
6178 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
6179   addr = SUBSI (addr, 4);
6180 }
6181 }
6182 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
6183 {
6184 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
6185   addr = SUBSI (addr, 4);
6186 }
6187 }
6188 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
6189 {
6190 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
6191   addr = SUBSI (addr, 4);
6192 }
6193 }
6194 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
6195 {
6196 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
6197   addr = SUBSI (addr, 4);
6198 }
6199 }
6200 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
6201 {
6202 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
6203   addr = SUBSI (addr, 4);
6204 }
6205 }
6206 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
6207 {
6208 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
6209   addr = SUBSI (addr, 4);
6210 }
6211 }
6212 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
6213 {
6214 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
6215   addr = SUBSI (addr, 4);
6216 }
6217 }
6218 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
6219 {
6220 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
6221   addr = SUBSI (addr, 4);
6222 }
6223 }
6224 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
6225 {
6226 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
6227   addr = SUBSI (addr, 4);
6228 }
6229 }
6230 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
6231 {
6232 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
6233   addr = SUBSI (addr, 4);
6234 }
6235 }
6236 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
6237 {
6238 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
6239   addr = SUBSI (addr, 4);
6240 }
6241 }
6242 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
6243 {
6244 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
6245   addr = SUBSI (addr, 4);
6246 }
6247 }
6248 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
6249 {
6250 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
6251   addr = SUBSI (addr, 4);
6252 }
6253 }
6254 }
6255
6256       pbb_br_npc = npc;
6257       pbb_br_status = br_status;
6258 #undef FLD
6259     }
6260     NEXT_INSN (vpc, fragpc);
6261
6262 // ********** used only by: ldmda-sw
6263
6264   CASE (FRAG_LDMDA_SW_MID):
6265     {
6266       abuf = vpc;
6267       vpc = vpc + 1;
6268 #define FLD(f) abuf->fields.sfmt_ldmda.f
6269       PCADDR pc = abuf->addr;
6270       br_status = BRANCH_UNTAKEN;
6271       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6272
6273 {
6274   addr = * FLD (i_rn);
6275 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6276 {
6277 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
6278   addr = SUBSI (addr, 4);
6279 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
6280 }
6281 }
6282 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
6283 {
6284 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6285 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
6286 } else {
6287 current_cpu->hardware.h_gr_usr[SUBSI (14, 8)] = current_cpu->GETMEMSI (pc, addr);
6288 }
6289   addr = SUBSI (addr, 4);
6290 }
6291 }
6292 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
6293 {
6294 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6295 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
6296 } else {
6297 current_cpu->hardware.h_gr_usr[SUBSI (13, 8)] = current_cpu->GETMEMSI (pc, addr);
6298 }
6299   addr = SUBSI (addr, 4);
6300 }
6301 }
6302 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
6303 {
6304 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6305 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
6306 } else {
6307 current_cpu->hardware.h_gr_usr[SUBSI (12, 8)] = current_cpu->GETMEMSI (pc, addr);
6308 }
6309   addr = SUBSI (addr, 4);
6310 }
6311 }
6312 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
6313 {
6314 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6315 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
6316 } else {
6317 current_cpu->hardware.h_gr_usr[SUBSI (11, 8)] = current_cpu->GETMEMSI (pc, addr);
6318 }
6319   addr = SUBSI (addr, 4);
6320 }
6321 }
6322 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
6323 {
6324 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6325 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
6326 } else {
6327 current_cpu->hardware.h_gr_usr[SUBSI (10, 8)] = current_cpu->GETMEMSI (pc, addr);
6328 }
6329   addr = SUBSI (addr, 4);
6330 }
6331 }
6332 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
6333 {
6334 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6335 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
6336 } else {
6337 current_cpu->hardware.h_gr_usr[SUBSI (9, 8)] = current_cpu->GETMEMSI (pc, addr);
6338 }
6339   addr = SUBSI (addr, 4);
6340 }
6341 }
6342 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
6343 {
6344 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6345 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
6346 } else {
6347 current_cpu->hardware.h_gr_usr[SUBSI (8, 8)] = current_cpu->GETMEMSI (pc, addr);
6348 }
6349   addr = SUBSI (addr, 4);
6350 }
6351 }
6352 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
6353 {
6354 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
6355   addr = SUBSI (addr, 4);
6356 }
6357 }
6358 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
6359 {
6360 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
6361   addr = SUBSI (addr, 4);
6362 }
6363 }
6364 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
6365 {
6366 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
6367   addr = SUBSI (addr, 4);
6368 }
6369 }
6370 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
6371 {
6372 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
6373   addr = SUBSI (addr, 4);
6374 }
6375 }
6376 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
6377 {
6378 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
6379   addr = SUBSI (addr, 4);
6380 }
6381 }
6382 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
6383 {
6384 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
6385   addr = SUBSI (addr, 4);
6386 }
6387 }
6388 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
6389 {
6390 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
6391   addr = SUBSI (addr, 4);
6392 }
6393 }
6394 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
6395 {
6396 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
6397   addr = SUBSI (addr, 4);
6398 }
6399 }
6400 }
6401
6402       pbb_br_npc = npc;
6403       pbb_br_status = br_status;
6404 #undef FLD
6405     }
6406     NEXT_INSN (vpc, fragpc);
6407
6408 // ********** used only by: ldmda-wb
6409
6410   CASE (FRAG_LDMDA_WB_MID):
6411     {
6412       abuf = vpc;
6413       vpc = vpc + 1;
6414 #define FLD(f) abuf->fields.sfmt_ldmda.f
6415       PCADDR pc = abuf->addr;
6416       br_status = BRANCH_UNTAKEN;
6417       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6418
6419 {
6420   addr = * FLD (i_rn);
6421 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6422 {
6423 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
6424   addr = SUBSI (addr, 4);
6425 }
6426 }
6427 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
6428 {
6429 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
6430   addr = SUBSI (addr, 4);
6431 }
6432 }
6433 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
6434 {
6435 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
6436   addr = SUBSI (addr, 4);
6437 }
6438 }
6439 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
6440 {
6441 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
6442   addr = SUBSI (addr, 4);
6443 }
6444 }
6445 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
6446 {
6447 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
6448   addr = SUBSI (addr, 4);
6449 }
6450 }
6451 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
6452 {
6453 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
6454   addr = SUBSI (addr, 4);
6455 }
6456 }
6457 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
6458 {
6459 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
6460   addr = SUBSI (addr, 4);
6461 }
6462 }
6463 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
6464 {
6465 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
6466   addr = SUBSI (addr, 4);
6467 }
6468 }
6469 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
6470 {
6471 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
6472   addr = SUBSI (addr, 4);
6473 }
6474 }
6475 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
6476 {
6477 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
6478   addr = SUBSI (addr, 4);
6479 }
6480 }
6481 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
6482 {
6483 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
6484   addr = SUBSI (addr, 4);
6485 }
6486 }
6487 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
6488 {
6489 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
6490   addr = SUBSI (addr, 4);
6491 }
6492 }
6493 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
6494 {
6495 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
6496   addr = SUBSI (addr, 4);
6497 }
6498 }
6499 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
6500 {
6501 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
6502   addr = SUBSI (addr, 4);
6503 }
6504 }
6505 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
6506 {
6507 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
6508   addr = SUBSI (addr, 4);
6509 }
6510 }
6511 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
6512 {
6513 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
6514   addr = SUBSI (addr, 4);
6515 }
6516 }
6517 * FLD (i_rn) = addr;
6518 }
6519
6520       pbb_br_npc = npc;
6521       pbb_br_status = br_status;
6522 #undef FLD
6523     }
6524     NEXT_INSN (vpc, fragpc);
6525
6526 // ********** used only by: ldmda-sw-wb
6527
6528   CASE (FRAG_LDMDA_SW_WB_MID):
6529     {
6530       abuf = vpc;
6531       vpc = vpc + 1;
6532 #define FLD(f) abuf->fields.sfmt_ldmda.f
6533       PCADDR pc = abuf->addr;
6534       br_status = BRANCH_UNTAKEN;
6535       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6536
6537 {
6538   addr = * FLD (i_rn);
6539 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6540 {
6541 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
6542   addr = SUBSI (addr, 4);
6543 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
6544 }
6545 }
6546 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
6547 {
6548 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6549 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
6550 } else {
6551 current_cpu->hardware.h_gr_usr[SUBSI (14, 8)] = current_cpu->GETMEMSI (pc, addr);
6552 }
6553   addr = SUBSI (addr, 4);
6554 }
6555 }
6556 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
6557 {
6558 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6559 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
6560 } else {
6561 current_cpu->hardware.h_gr_usr[SUBSI (13, 8)] = current_cpu->GETMEMSI (pc, addr);
6562 }
6563   addr = SUBSI (addr, 4);
6564 }
6565 }
6566 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
6567 {
6568 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6569 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
6570 } else {
6571 current_cpu->hardware.h_gr_usr[SUBSI (12, 8)] = current_cpu->GETMEMSI (pc, addr);
6572 }
6573   addr = SUBSI (addr, 4);
6574 }
6575 }
6576 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
6577 {
6578 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6579 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
6580 } else {
6581 current_cpu->hardware.h_gr_usr[SUBSI (11, 8)] = current_cpu->GETMEMSI (pc, addr);
6582 }
6583   addr = SUBSI (addr, 4);
6584 }
6585 }
6586 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
6587 {
6588 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6589 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
6590 } else {
6591 current_cpu->hardware.h_gr_usr[SUBSI (10, 8)] = current_cpu->GETMEMSI (pc, addr);
6592 }
6593   addr = SUBSI (addr, 4);
6594 }
6595 }
6596 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
6597 {
6598 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6599 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
6600 } else {
6601 current_cpu->hardware.h_gr_usr[SUBSI (9, 8)] = current_cpu->GETMEMSI (pc, addr);
6602 }
6603   addr = SUBSI (addr, 4);
6604 }
6605 }
6606 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
6607 {
6608 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6609 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
6610 } else {
6611 current_cpu->hardware.h_gr_usr[SUBSI (8, 8)] = current_cpu->GETMEMSI (pc, addr);
6612 }
6613   addr = SUBSI (addr, 4);
6614 }
6615 }
6616 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
6617 {
6618 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
6619   addr = SUBSI (addr, 4);
6620 }
6621 }
6622 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
6623 {
6624 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
6625   addr = SUBSI (addr, 4);
6626 }
6627 }
6628 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
6629 {
6630 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
6631   addr = SUBSI (addr, 4);
6632 }
6633 }
6634 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
6635 {
6636 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
6637   addr = SUBSI (addr, 4);
6638 }
6639 }
6640 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
6641 {
6642 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
6643   addr = SUBSI (addr, 4);
6644 }
6645 }
6646 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
6647 {
6648 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
6649   addr = SUBSI (addr, 4);
6650 }
6651 }
6652 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
6653 {
6654 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
6655   addr = SUBSI (addr, 4);
6656 }
6657 }
6658 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
6659 {
6660 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
6661   addr = SUBSI (addr, 4);
6662 }
6663 }
6664 * FLD (i_rn) = addr;
6665 }
6666
6667       pbb_br_npc = npc;
6668       pbb_br_status = br_status;
6669 #undef FLD
6670     }
6671     NEXT_INSN (vpc, fragpc);
6672
6673 // ********** used only by: ldmib
6674
6675   CASE (FRAG_LDMIB_MID):
6676     {
6677       abuf = vpc;
6678       vpc = vpc + 1;
6679 #define FLD(f) abuf->fields.sfmt_ldmda.f
6680       PCADDR pc = abuf->addr;
6681       br_status = BRANCH_UNTAKEN;
6682       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6683
6684 {
6685   addr = * FLD (i_rn);
6686 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
6687 {
6688   addr = ADDSI (addr, 4);
6689 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
6690 }
6691 }
6692 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
6693 {
6694   addr = ADDSI (addr, 4);
6695 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
6696 }
6697 }
6698 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
6699 {
6700   addr = ADDSI (addr, 4);
6701 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
6702 }
6703 }
6704 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
6705 {
6706   addr = ADDSI (addr, 4);
6707 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
6708 }
6709 }
6710 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
6711 {
6712   addr = ADDSI (addr, 4);
6713 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
6714 }
6715 }
6716 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
6717 {
6718   addr = ADDSI (addr, 4);
6719 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
6720 }
6721 }
6722 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
6723 {
6724   addr = ADDSI (addr, 4);
6725 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
6726 }
6727 }
6728 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
6729 {
6730   addr = ADDSI (addr, 4);
6731 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
6732 }
6733 }
6734 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
6735 {
6736   addr = ADDSI (addr, 4);
6737 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
6738 }
6739 }
6740 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
6741 {
6742   addr = ADDSI (addr, 4);
6743 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
6744 }
6745 }
6746 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
6747 {
6748   addr = ADDSI (addr, 4);
6749 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
6750 }
6751 }
6752 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
6753 {
6754   addr = ADDSI (addr, 4);
6755 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
6756 }
6757 }
6758 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
6759 {
6760   addr = ADDSI (addr, 4);
6761 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
6762 }
6763 }
6764 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
6765 {
6766   addr = ADDSI (addr, 4);
6767 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
6768 }
6769 }
6770 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
6771 {
6772   addr = ADDSI (addr, 4);
6773 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
6774 }
6775 }
6776 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6777 {
6778   addr = ADDSI (addr, 4);
6779 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
6780 }
6781 }
6782 }
6783
6784       pbb_br_npc = npc;
6785       pbb_br_status = br_status;
6786 #undef FLD
6787     }
6788     NEXT_INSN (vpc, fragpc);
6789
6790 // ********** used only by: ldmib-sw
6791
6792   CASE (FRAG_LDMIB_SW_MID):
6793     {
6794 #define FLD(f) abuf->fields.sfmt_ldmda.f
6795       PCADDR pc = abuf->addr;
6796
6797 {
6798 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
6799 {
6800   addr = ADDSI (addr, 4);
6801 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6802 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
6803 } else {
6804 current_cpu->hardware.h_gr_usr[SUBSI (8, 8)] = current_cpu->GETMEMSI (pc, addr);
6805 }
6806 }
6807 }
6808 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
6809 {
6810   addr = ADDSI (addr, 4);
6811 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6812 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
6813 } else {
6814 current_cpu->hardware.h_gr_usr[SUBSI (9, 8)] = current_cpu->GETMEMSI (pc, addr);
6815 }
6816 }
6817 }
6818 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
6819 {
6820   addr = ADDSI (addr, 4);
6821 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6822 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
6823 } else {
6824 current_cpu->hardware.h_gr_usr[SUBSI (10, 8)] = current_cpu->GETMEMSI (pc, addr);
6825 }
6826 }
6827 }
6828 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
6829 {
6830   addr = ADDSI (addr, 4);
6831 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6832 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
6833 } else {
6834 current_cpu->hardware.h_gr_usr[SUBSI (11, 8)] = current_cpu->GETMEMSI (pc, addr);
6835 }
6836 }
6837 }
6838 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
6839 {
6840   addr = ADDSI (addr, 4);
6841 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6842 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
6843 } else {
6844 current_cpu->hardware.h_gr_usr[SUBSI (12, 8)] = current_cpu->GETMEMSI (pc, addr);
6845 }
6846 }
6847 }
6848 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
6849 {
6850   addr = ADDSI (addr, 4);
6851 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6852 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
6853 } else {
6854 current_cpu->hardware.h_gr_usr[SUBSI (13, 8)] = current_cpu->GETMEMSI (pc, addr);
6855 }
6856 }
6857 }
6858 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
6859 {
6860   addr = ADDSI (addr, 4);
6861 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6862 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
6863 } else {
6864 current_cpu->hardware.h_gr_usr[SUBSI (14, 8)] = current_cpu->GETMEMSI (pc, addr);
6865 }
6866 }
6867 }
6868 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6869 {
6870   addr = ADDSI (addr, 4);
6871 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
6872 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
6873 }
6874 }
6875 }
6876
6877       pbb_br_npc = npc;
6878       pbb_br_status = br_status;
6879 #undef FLD
6880     }
6881     NEXT_INSN (vpc, fragpc);
6882
6883 // ********** used only by: ldmib-wb
6884
6885   CASE (FRAG_LDMIB_WB_MID):
6886     {
6887 #define FLD(f) abuf->fields.sfmt_ldmda.f
6888       PCADDR pc = abuf->addr;
6889
6890 {
6891 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
6892 {
6893   addr = ADDSI (addr, 4);
6894 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
6895 }
6896 }
6897 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
6898 {
6899   addr = ADDSI (addr, 4);
6900 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
6901 }
6902 }
6903 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
6904 {
6905   addr = ADDSI (addr, 4);
6906 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
6907 }
6908 }
6909 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
6910 {
6911   addr = ADDSI (addr, 4);
6912 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
6913 }
6914 }
6915 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
6916 {
6917   addr = ADDSI (addr, 4);
6918 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
6919 }
6920 }
6921 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
6922 {
6923   addr = ADDSI (addr, 4);
6924 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
6925 }
6926 }
6927 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
6928 {
6929   addr = ADDSI (addr, 4);
6930 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
6931 }
6932 }
6933 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
6934 {
6935   addr = ADDSI (addr, 4);
6936 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
6937 }
6938 }
6939 * FLD (i_rn) = addr;
6940 }
6941
6942       pbb_br_npc = npc;
6943       pbb_br_status = br_status;
6944 #undef FLD
6945     }
6946     NEXT_INSN (vpc, fragpc);
6947
6948 // ********** used only by: ldmib-sw-wb
6949
6950   CASE (FRAG_LDMIB_SW_WB_MID):
6951     {
6952       abuf = vpc;
6953       vpc = vpc + 1;
6954 #define FLD(f) abuf->fields.sfmt_ldmda.f
6955       PCADDR pc = abuf->addr;
6956       br_status = BRANCH_UNTAKEN;
6957       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
6958
6959 {
6960   addr = * FLD (i_rn);
6961 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
6962 {
6963   addr = ADDSI (addr, 4);
6964 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
6965 }
6966 }
6967 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
6968 {
6969   addr = ADDSI (addr, 4);
6970 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
6971 }
6972 }
6973 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
6974 {
6975   addr = ADDSI (addr, 4);
6976 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
6977 }
6978 }
6979 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
6980 {
6981   addr = ADDSI (addr, 4);
6982 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
6983 }
6984 }
6985 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
6986 {
6987   addr = ADDSI (addr, 4);
6988 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
6989 }
6990 }
6991 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
6992 {
6993   addr = ADDSI (addr, 4);
6994 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
6995 }
6996 }
6997 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
6998 {
6999   addr = ADDSI (addr, 4);
7000 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
7001 }
7002 }
7003 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
7004 {
7005   addr = ADDSI (addr, 4);
7006 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
7007 }
7008 }
7009 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7010 {
7011   addr = ADDSI (addr, 4);
7012 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7013 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7014 } else {
7015 current_cpu->hardware.h_gr_usr[SUBSI (8, 8)] = current_cpu->GETMEMSI (pc, addr);
7016 }
7017 }
7018 }
7019 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7020 {
7021   addr = ADDSI (addr, 4);
7022 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7023 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7024 } else {
7025 current_cpu->hardware.h_gr_usr[SUBSI (9, 8)] = current_cpu->GETMEMSI (pc, addr);
7026 }
7027 }
7028 }
7029 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7030 {
7031   addr = ADDSI (addr, 4);
7032 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7033 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7034 } else {
7035 current_cpu->hardware.h_gr_usr[SUBSI (10, 8)] = current_cpu->GETMEMSI (pc, addr);
7036 }
7037 }
7038 }
7039 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7040 {
7041   addr = ADDSI (addr, 4);
7042 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7043 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7044 } else {
7045 current_cpu->hardware.h_gr_usr[SUBSI (11, 8)] = current_cpu->GETMEMSI (pc, addr);
7046 }
7047 }
7048 }
7049 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7050 {
7051   addr = ADDSI (addr, 4);
7052 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7053 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7054 } else {
7055 current_cpu->hardware.h_gr_usr[SUBSI (12, 8)] = current_cpu->GETMEMSI (pc, addr);
7056 }
7057 }
7058 }
7059 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7060 {
7061   addr = ADDSI (addr, 4);
7062 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7063 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7064 } else {
7065 current_cpu->hardware.h_gr_usr[SUBSI (13, 8)] = current_cpu->GETMEMSI (pc, addr);
7066 }
7067 }
7068 }
7069 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7070 {
7071   addr = ADDSI (addr, 4);
7072 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7073 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7074 } else {
7075 current_cpu->hardware.h_gr_usr[SUBSI (14, 8)] = current_cpu->GETMEMSI (pc, addr);
7076 }
7077 }
7078 }
7079 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7080 {
7081   addr = ADDSI (addr, 4);
7082 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7083 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
7084 }
7085 }
7086 * FLD (i_rn) = addr;
7087 }
7088
7089       pbb_br_npc = npc;
7090       pbb_br_status = br_status;
7091 #undef FLD
7092     }
7093     NEXT_INSN (vpc, fragpc);
7094
7095 // ********** used only by: ldmia
7096
7097   CASE (FRAG_LDMIA_MID):
7098     {
7099       abuf = vpc;
7100       vpc = vpc + 1;
7101 #define FLD(f) abuf->fields.sfmt_ldmda.f
7102       PCADDR pc = abuf->addr;
7103       br_status = BRANCH_UNTAKEN;
7104       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
7105
7106 {
7107   addr = * FLD (i_rn);
7108 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
7109 {
7110 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
7111   addr = ADDSI (addr, 4);
7112 }
7113 }
7114 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
7115 {
7116 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
7117   addr = ADDSI (addr, 4);
7118 }
7119 }
7120 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
7121 {
7122 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
7123   addr = ADDSI (addr, 4);
7124 }
7125 }
7126 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
7127 {
7128 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
7129   addr = ADDSI (addr, 4);
7130 }
7131 }
7132 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
7133 {
7134 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
7135   addr = ADDSI (addr, 4);
7136 }
7137 }
7138 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
7139 {
7140 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
7141   addr = ADDSI (addr, 4);
7142 }
7143 }
7144 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
7145 {
7146 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
7147   addr = ADDSI (addr, 4);
7148 }
7149 }
7150 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
7151 {
7152 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
7153   addr = ADDSI (addr, 4);
7154 }
7155 }
7156 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7157 {
7158 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7159   addr = ADDSI (addr, 4);
7160 }
7161 }
7162 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7163 {
7164 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7165   addr = ADDSI (addr, 4);
7166 }
7167 }
7168 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7169 {
7170 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7171   addr = ADDSI (addr, 4);
7172 }
7173 }
7174 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7175 {
7176 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7177   addr = ADDSI (addr, 4);
7178 }
7179 }
7180 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7181 {
7182 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7183   addr = ADDSI (addr, 4);
7184 }
7185 }
7186 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7187 {
7188 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7189   addr = ADDSI (addr, 4);
7190 }
7191 }
7192 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7193 {
7194 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7195   addr = ADDSI (addr, 4);
7196 }
7197 }
7198 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7199 {
7200 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7201   addr = ADDSI (addr, 4);
7202 }
7203 }
7204 }
7205
7206       pbb_br_npc = npc;
7207       pbb_br_status = br_status;
7208 #undef FLD
7209     }
7210     NEXT_INSN (vpc, fragpc);
7211
7212 // ********** used only by: ldmia-sw
7213
7214   CASE (FRAG_LDMIA_SW_MID):
7215     {
7216 #define FLD(f) abuf->fields.sfmt_ldmda.f
7217       PCADDR pc = abuf->addr;
7218
7219 {
7220 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7221 {
7222 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7223 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7224 } else {
7225 current_cpu->hardware.h_gr_usr[SUBSI (8, 8)] = current_cpu->GETMEMSI (pc, addr);
7226 }
7227   addr = ADDSI (addr, 4);
7228 }
7229 }
7230 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7231 {
7232 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7233 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7234 } else {
7235 current_cpu->hardware.h_gr_usr[SUBSI (9, 8)] = current_cpu->GETMEMSI (pc, addr);
7236 }
7237   addr = ADDSI (addr, 4);
7238 }
7239 }
7240 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7241 {
7242 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7243 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7244 } else {
7245 current_cpu->hardware.h_gr_usr[SUBSI (10, 8)] = current_cpu->GETMEMSI (pc, addr);
7246 }
7247   addr = ADDSI (addr, 4);
7248 }
7249 }
7250 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7251 {
7252 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7253 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7254 } else {
7255 current_cpu->hardware.h_gr_usr[SUBSI (11, 8)] = current_cpu->GETMEMSI (pc, addr);
7256 }
7257   addr = ADDSI (addr, 4);
7258 }
7259 }
7260 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7261 {
7262 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7263 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7264 } else {
7265 current_cpu->hardware.h_gr_usr[SUBSI (12, 8)] = current_cpu->GETMEMSI (pc, addr);
7266 }
7267   addr = ADDSI (addr, 4);
7268 }
7269 }
7270 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7271 {
7272 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7273 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7274 } else {
7275 current_cpu->hardware.h_gr_usr[SUBSI (13, 8)] = current_cpu->GETMEMSI (pc, addr);
7276 }
7277   addr = ADDSI (addr, 4);
7278 }
7279 }
7280 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7281 {
7282 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7283 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7284 } else {
7285 current_cpu->hardware.h_gr_usr[SUBSI (14, 8)] = current_cpu->GETMEMSI (pc, addr);
7286 }
7287   addr = ADDSI (addr, 4);
7288 }
7289 }
7290 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7291 {
7292 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7293   addr = ADDSI (addr, 4);
7294 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
7295 }
7296 }
7297 }
7298
7299       pbb_br_npc = npc;
7300       pbb_br_status = br_status;
7301 #undef FLD
7302     }
7303     NEXT_INSN (vpc, fragpc);
7304
7305 // ********** used only by: ldmia-wb
7306
7307   CASE (FRAG_LDMIA_WB_MID):
7308     {
7309 #define FLD(f) abuf->fields.sfmt_ldmda.f
7310       PCADDR pc = abuf->addr;
7311
7312 {
7313 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7314 {
7315 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7316   addr = ADDSI (addr, 4);
7317 }
7318 }
7319 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7320 {
7321 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7322   addr = ADDSI (addr, 4);
7323 }
7324 }
7325 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7326 {
7327 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7328   addr = ADDSI (addr, 4);
7329 }
7330 }
7331 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7332 {
7333 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7334   addr = ADDSI (addr, 4);
7335 }
7336 }
7337 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7338 {
7339 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7340   addr = ADDSI (addr, 4);
7341 }
7342 }
7343 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7344 {
7345 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7346   addr = ADDSI (addr, 4);
7347 }
7348 }
7349 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7350 {
7351 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7352   addr = ADDSI (addr, 4);
7353 }
7354 }
7355 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7356 {
7357 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7358   addr = ADDSI (addr, 4);
7359 }
7360 }
7361 * FLD (i_rn) = addr;
7362 }
7363
7364       pbb_br_npc = npc;
7365       pbb_br_status = br_status;
7366 #undef FLD
7367     }
7368     NEXT_INSN (vpc, fragpc);
7369
7370 // ********** used only by: ldmia-sw-wb
7371
7372   CASE (FRAG_LDMIA_SW_WB_MID):
7373     {
7374       abuf = vpc;
7375       vpc = vpc + 1;
7376 #define FLD(f) abuf->fields.sfmt_ldmda.f
7377       PCADDR pc = abuf->addr;
7378       br_status = BRANCH_UNTAKEN;
7379       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
7380
7381 {
7382   addr = * FLD (i_rn);
7383 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
7384 {
7385 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
7386   addr = ADDSI (addr, 4);
7387 }
7388 }
7389 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
7390 {
7391 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
7392   addr = ADDSI (addr, 4);
7393 }
7394 }
7395 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
7396 {
7397 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
7398   addr = ADDSI (addr, 4);
7399 }
7400 }
7401 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
7402 {
7403 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
7404   addr = ADDSI (addr, 4);
7405 }
7406 }
7407 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
7408 {
7409 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
7410   addr = ADDSI (addr, 4);
7411 }
7412 }
7413 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
7414 {
7415 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
7416   addr = ADDSI (addr, 4);
7417 }
7418 }
7419 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
7420 {
7421 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
7422   addr = ADDSI (addr, 4);
7423 }
7424 }
7425 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
7426 {
7427 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
7428   addr = ADDSI (addr, 4);
7429 }
7430 }
7431 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7432 {
7433 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7434 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7435 } else {
7436 current_cpu->hardware.h_gr_usr[SUBSI (8, 8)] = current_cpu->GETMEMSI (pc, addr);
7437 }
7438   addr = ADDSI (addr, 4);
7439 }
7440 }
7441 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7442 {
7443 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7444 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7445 } else {
7446 current_cpu->hardware.h_gr_usr[SUBSI (9, 8)] = current_cpu->GETMEMSI (pc, addr);
7447 }
7448   addr = ADDSI (addr, 4);
7449 }
7450 }
7451 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7452 {
7453 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7454 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7455 } else {
7456 current_cpu->hardware.h_gr_usr[SUBSI (10, 8)] = current_cpu->GETMEMSI (pc, addr);
7457 }
7458   addr = ADDSI (addr, 4);
7459 }
7460 }
7461 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7462 {
7463 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7464 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7465 } else {
7466 current_cpu->hardware.h_gr_usr[SUBSI (11, 8)] = current_cpu->GETMEMSI (pc, addr);
7467 }
7468   addr = ADDSI (addr, 4);
7469 }
7470 }
7471 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7472 {
7473 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7474 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7475 } else {
7476 current_cpu->hardware.h_gr_usr[SUBSI (12, 8)] = current_cpu->GETMEMSI (pc, addr);
7477 }
7478   addr = ADDSI (addr, 4);
7479 }
7480 }
7481 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7482 {
7483 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7484 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7485 } else {
7486 current_cpu->hardware.h_gr_usr[SUBSI (13, 8)] = current_cpu->GETMEMSI (pc, addr);
7487 }
7488   addr = ADDSI (addr, 4);
7489 }
7490 }
7491 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7492 {
7493 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7494 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7495 } else {
7496 current_cpu->hardware.h_gr_usr[SUBSI (14, 8)] = current_cpu->GETMEMSI (pc, addr);
7497 }
7498   addr = ADDSI (addr, 4);
7499 }
7500 }
7501 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7502 {
7503 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7504   addr = ADDSI (addr, 4);
7505 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
7506 }
7507 }
7508 * FLD (i_rn) = addr;
7509 }
7510
7511       pbb_br_npc = npc;
7512       pbb_br_status = br_status;
7513 #undef FLD
7514     }
7515     NEXT_INSN (vpc, fragpc);
7516
7517 // ********** used only by: ldmdb
7518
7519   CASE (FRAG_LDMDB_MID):
7520     {
7521       abuf = vpc;
7522       vpc = vpc + 1;
7523 #define FLD(f) abuf->fields.sfmt_ldmda.f
7524       PCADDR pc = abuf->addr;
7525       br_status = BRANCH_UNTAKEN;
7526       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
7527
7528 {
7529   addr = * FLD (i_rn);
7530 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7531 {
7532   addr = SUBSI (addr, 4);
7533 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7534 }
7535 }
7536 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7537 {
7538   addr = SUBSI (addr, 4);
7539 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7540 }
7541 }
7542 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7543 {
7544   addr = SUBSI (addr, 4);
7545 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7546 }
7547 }
7548 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7549 {
7550   addr = SUBSI (addr, 4);
7551 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7552 }
7553 }
7554 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7555 {
7556   addr = SUBSI (addr, 4);
7557 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7558 }
7559 }
7560 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7561 {
7562   addr = SUBSI (addr, 4);
7563 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7564 }
7565 }
7566 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7567 {
7568   addr = SUBSI (addr, 4);
7569 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7570 }
7571 }
7572 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7573 {
7574   addr = SUBSI (addr, 4);
7575 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7576 }
7577 }
7578 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
7579 {
7580   addr = SUBSI (addr, 4);
7581 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
7582 }
7583 }
7584 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
7585 {
7586   addr = SUBSI (addr, 4);
7587 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
7588 }
7589 }
7590 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
7591 {
7592   addr = SUBSI (addr, 4);
7593 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
7594 }
7595 }
7596 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
7597 {
7598   addr = SUBSI (addr, 4);
7599 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
7600 }
7601 }
7602 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
7603 {
7604   addr = SUBSI (addr, 4);
7605 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
7606 }
7607 }
7608 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
7609 {
7610   addr = SUBSI (addr, 4);
7611 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
7612 }
7613 }
7614 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
7615 {
7616   addr = SUBSI (addr, 4);
7617 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
7618 }
7619 }
7620 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
7621 {
7622   addr = SUBSI (addr, 4);
7623 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
7624 }
7625 }
7626 }
7627
7628       pbb_br_npc = npc;
7629       pbb_br_status = br_status;
7630 #undef FLD
7631     }
7632     NEXT_INSN (vpc, fragpc);
7633
7634 // ********** used only by: ldmdb-sw
7635
7636   CASE (FRAG_LDMDB_SW_MID):
7637     {
7638       abuf = vpc;
7639       vpc = vpc + 1;
7640 #define FLD(f) abuf->fields.sfmt_ldmda.f
7641       PCADDR pc = abuf->addr;
7642       br_status = BRANCH_UNTAKEN;
7643       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
7644
7645 {
7646   addr = * FLD (i_rn);
7647 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7648 {
7649   addr = SUBSI (addr, 4);
7650 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7651 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
7652 }
7653 }
7654 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7655 {
7656   addr = SUBSI (addr, 4);
7657 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7658 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7659 } else {
7660 current_cpu->hardware.h_gr_usr[SUBSI (14, 8)] = current_cpu->GETMEMSI (pc, addr);
7661 }
7662 }
7663 }
7664 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7665 {
7666   addr = SUBSI (addr, 4);
7667 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7668 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7669 } else {
7670 current_cpu->hardware.h_gr_usr[SUBSI (13, 8)] = current_cpu->GETMEMSI (pc, addr);
7671 }
7672 }
7673 }
7674 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7675 {
7676   addr = SUBSI (addr, 4);
7677 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7678 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7679 } else {
7680 current_cpu->hardware.h_gr_usr[SUBSI (12, 8)] = current_cpu->GETMEMSI (pc, addr);
7681 }
7682 }
7683 }
7684 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7685 {
7686   addr = SUBSI (addr, 4);
7687 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7688 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7689 } else {
7690 current_cpu->hardware.h_gr_usr[SUBSI (11, 8)] = current_cpu->GETMEMSI (pc, addr);
7691 }
7692 }
7693 }
7694 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7695 {
7696   addr = SUBSI (addr, 4);
7697 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7698 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7699 } else {
7700 current_cpu->hardware.h_gr_usr[SUBSI (10, 8)] = current_cpu->GETMEMSI (pc, addr);
7701 }
7702 }
7703 }
7704 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7705 {
7706   addr = SUBSI (addr, 4);
7707 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7708 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7709 } else {
7710 current_cpu->hardware.h_gr_usr[SUBSI (9, 8)] = current_cpu->GETMEMSI (pc, addr);
7711 }
7712 }
7713 }
7714 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7715 {
7716   addr = SUBSI (addr, 4);
7717 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7718 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7719 } else {
7720 current_cpu->hardware.h_gr_usr[SUBSI (8, 8)] = current_cpu->GETMEMSI (pc, addr);
7721 }
7722 }
7723 }
7724 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
7725 {
7726   addr = SUBSI (addr, 4);
7727 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
7728 }
7729 }
7730 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
7731 {
7732   addr = SUBSI (addr, 4);
7733 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
7734 }
7735 }
7736 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
7737 {
7738   addr = SUBSI (addr, 4);
7739 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
7740 }
7741 }
7742 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
7743 {
7744   addr = SUBSI (addr, 4);
7745 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
7746 }
7747 }
7748 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
7749 {
7750   addr = SUBSI (addr, 4);
7751 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
7752 }
7753 }
7754 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
7755 {
7756   addr = SUBSI (addr, 4);
7757 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
7758 }
7759 }
7760 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
7761 {
7762   addr = SUBSI (addr, 4);
7763 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
7764 }
7765 }
7766 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
7767 {
7768   addr = SUBSI (addr, 4);
7769 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
7770 }
7771 }
7772 }
7773
7774       pbb_br_npc = npc;
7775       pbb_br_status = br_status;
7776 #undef FLD
7777     }
7778     NEXT_INSN (vpc, fragpc);
7779
7780 // ********** used only by: ldmdb-wb
7781
7782   CASE (FRAG_LDMDB_WB_MID):
7783     {
7784       abuf = vpc;
7785       vpc = vpc + 1;
7786 #define FLD(f) abuf->fields.sfmt_ldmda.f
7787       PCADDR pc = abuf->addr;
7788       br_status = BRANCH_UNTAKEN;
7789       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
7790
7791 {
7792   addr = * FLD (i_rn);
7793 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7794 {
7795   addr = SUBSI (addr, 4);
7796 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7797 }
7798 }
7799 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7800 {
7801   addr = SUBSI (addr, 4);
7802 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7803 }
7804 }
7805 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7806 {
7807   addr = SUBSI (addr, 4);
7808 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7809 }
7810 }
7811 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7812 {
7813   addr = SUBSI (addr, 4);
7814 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7815 }
7816 }
7817 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7818 {
7819   addr = SUBSI (addr, 4);
7820 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7821 }
7822 }
7823 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7824 {
7825   addr = SUBSI (addr, 4);
7826 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7827 }
7828 }
7829 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7830 {
7831   addr = SUBSI (addr, 4);
7832 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7833 }
7834 }
7835 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7836 {
7837   addr = SUBSI (addr, 4);
7838 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7839 }
7840 }
7841 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
7842 {
7843   addr = SUBSI (addr, 4);
7844 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
7845 }
7846 }
7847 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
7848 {
7849   addr = SUBSI (addr, 4);
7850 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
7851 }
7852 }
7853 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
7854 {
7855   addr = SUBSI (addr, 4);
7856 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
7857 }
7858 }
7859 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
7860 {
7861   addr = SUBSI (addr, 4);
7862 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
7863 }
7864 }
7865 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
7866 {
7867   addr = SUBSI (addr, 4);
7868 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
7869 }
7870 }
7871 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
7872 {
7873   addr = SUBSI (addr, 4);
7874 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
7875 }
7876 }
7877 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
7878 {
7879   addr = SUBSI (addr, 4);
7880 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
7881 }
7882 }
7883 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
7884 {
7885   addr = SUBSI (addr, 4);
7886 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
7887 }
7888 }
7889 * FLD (i_rn) = addr;
7890 }
7891
7892       pbb_br_npc = npc;
7893       pbb_br_status = br_status;
7894 #undef FLD
7895     }
7896     NEXT_INSN (vpc, fragpc);
7897
7898 // ********** used only by: ldmdb-sw-wb
7899
7900   CASE (FRAG_LDMDB_SW_WB_MID):
7901     {
7902       abuf = vpc;
7903       vpc = vpc + 1;
7904 #define FLD(f) abuf->fields.sfmt_ldmda.f
7905       PCADDR pc = abuf->addr;
7906       br_status = BRANCH_UNTAKEN;
7907       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
7908
7909 {
7910   addr = * FLD (i_rn);
7911 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7912 {
7913   addr = SUBSI (addr, 4);
7914 npc = current_cpu->GETMEMSI (pc, addr); br_status = BRANCH_UNCACHEABLE;
7915 current_cpu->h_cpsr_set (current_cpu->h_spsr_get ());
7916 }
7917 }
7918 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
7919 {
7920   addr = SUBSI (addr, 4);
7921 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7922 current_cpu->hardware.h_gr[((UINT) 14)] = current_cpu->GETMEMSI (pc, addr);
7923 } else {
7924 current_cpu->hardware.h_gr_usr[SUBSI (14, 8)] = current_cpu->GETMEMSI (pc, addr);
7925 }
7926 }
7927 }
7928 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
7929 {
7930   addr = SUBSI (addr, 4);
7931 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7932 current_cpu->hardware.h_gr[((UINT) 13)] = current_cpu->GETMEMSI (pc, addr);
7933 } else {
7934 current_cpu->hardware.h_gr_usr[SUBSI (13, 8)] = current_cpu->GETMEMSI (pc, addr);
7935 }
7936 }
7937 }
7938 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
7939 {
7940   addr = SUBSI (addr, 4);
7941 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7942 current_cpu->hardware.h_gr[((UINT) 12)] = current_cpu->GETMEMSI (pc, addr);
7943 } else {
7944 current_cpu->hardware.h_gr_usr[SUBSI (12, 8)] = current_cpu->GETMEMSI (pc, addr);
7945 }
7946 }
7947 }
7948 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
7949 {
7950   addr = SUBSI (addr, 4);
7951 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7952 current_cpu->hardware.h_gr[((UINT) 11)] = current_cpu->GETMEMSI (pc, addr);
7953 } else {
7954 current_cpu->hardware.h_gr_usr[SUBSI (11, 8)] = current_cpu->GETMEMSI (pc, addr);
7955 }
7956 }
7957 }
7958 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
7959 {
7960   addr = SUBSI (addr, 4);
7961 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7962 current_cpu->hardware.h_gr[((UINT) 10)] = current_cpu->GETMEMSI (pc, addr);
7963 } else {
7964 current_cpu->hardware.h_gr_usr[SUBSI (10, 8)] = current_cpu->GETMEMSI (pc, addr);
7965 }
7966 }
7967 }
7968 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
7969 {
7970   addr = SUBSI (addr, 4);
7971 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7972 current_cpu->hardware.h_gr[((UINT) 9)] = current_cpu->GETMEMSI (pc, addr);
7973 } else {
7974 current_cpu->hardware.h_gr_usr[SUBSI (9, 8)] = current_cpu->GETMEMSI (pc, addr);
7975 }
7976 }
7977 }
7978 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
7979 {
7980   addr = SUBSI (addr, 4);
7981 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
7982 current_cpu->hardware.h_gr[((UINT) 8)] = current_cpu->GETMEMSI (pc, addr);
7983 } else {
7984 current_cpu->hardware.h_gr_usr[SUBSI (8, 8)] = current_cpu->GETMEMSI (pc, addr);
7985 }
7986 }
7987 }
7988 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
7989 {
7990   addr = SUBSI (addr, 4);
7991 current_cpu->hardware.h_gr[((UINT) 7)] = current_cpu->GETMEMSI (pc, addr);
7992 }
7993 }
7994 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
7995 {
7996   addr = SUBSI (addr, 4);
7997 current_cpu->hardware.h_gr[((UINT) 6)] = current_cpu->GETMEMSI (pc, addr);
7998 }
7999 }
8000 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
8001 {
8002   addr = SUBSI (addr, 4);
8003 current_cpu->hardware.h_gr[((UINT) 5)] = current_cpu->GETMEMSI (pc, addr);
8004 }
8005 }
8006 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
8007 {
8008   addr = SUBSI (addr, 4);
8009 current_cpu->hardware.h_gr[((UINT) 4)] = current_cpu->GETMEMSI (pc, addr);
8010 }
8011 }
8012 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
8013 {
8014   addr = SUBSI (addr, 4);
8015 current_cpu->hardware.h_gr[((UINT) 3)] = current_cpu->GETMEMSI (pc, addr);
8016 }
8017 }
8018 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
8019 {
8020   addr = SUBSI (addr, 4);
8021 current_cpu->hardware.h_gr[((UINT) 2)] = current_cpu->GETMEMSI (pc, addr);
8022 }
8023 }
8024 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
8025 {
8026   addr = SUBSI (addr, 4);
8027 current_cpu->hardware.h_gr[((UINT) 1)] = current_cpu->GETMEMSI (pc, addr);
8028 }
8029 }
8030 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
8031 {
8032   addr = SUBSI (addr, 4);
8033 current_cpu->hardware.h_gr[((UINT) 0)] = current_cpu->GETMEMSI (pc, addr);
8034 }
8035 }
8036 * FLD (i_rn) = addr;
8037 }
8038
8039       pbb_br_npc = npc;
8040       pbb_br_status = br_status;
8041 #undef FLD
8042     }
8043     NEXT_INSN (vpc, fragpc);
8044
8045 // ********** used only by: stmdb
8046
8047   CASE (FRAG_STMDB_MID):
8048     {
8049       abuf = vpc;
8050       vpc = vpc + 1;
8051 #define FLD(f) abuf->fields.sfmt_ldmda.f
8052       PCADDR pc = abuf->addr;
8053       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
8054
8055 {
8056   addr = * FLD (i_rn);
8057 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8058 {
8059   addr = SUBSI (addr, 4);
8060 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
8061 }
8062 }
8063 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
8064 {
8065   addr = SUBSI (addr, 4);
8066 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
8067 }
8068 }
8069 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
8070 {
8071   addr = SUBSI (addr, 4);
8072 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
8073 }
8074 }
8075 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
8076 {
8077   addr = SUBSI (addr, 4);
8078 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
8079 }
8080 }
8081 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
8082 {
8083   addr = SUBSI (addr, 4);
8084 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
8085 }
8086 }
8087 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
8088 {
8089   addr = SUBSI (addr, 4);
8090 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
8091 }
8092 }
8093 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
8094 {
8095   addr = SUBSI (addr, 4);
8096 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
8097 }
8098 }
8099 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
8100 {
8101   addr = SUBSI (addr, 4);
8102 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
8103 }
8104 }
8105 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
8106 {
8107   addr = SUBSI (addr, 4);
8108 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
8109 }
8110 }
8111 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
8112 {
8113   addr = SUBSI (addr, 4);
8114 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
8115 }
8116 }
8117 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
8118 {
8119   addr = SUBSI (addr, 4);
8120 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
8121 }
8122 }
8123 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
8124 {
8125   addr = SUBSI (addr, 4);
8126 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
8127 }
8128 }
8129 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
8130 {
8131   addr = SUBSI (addr, 4);
8132 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
8133 }
8134 }
8135 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
8136 {
8137   addr = SUBSI (addr, 4);
8138 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
8139 }
8140 }
8141 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
8142 {
8143   addr = SUBSI (addr, 4);
8144 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
8145 }
8146 }
8147 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
8148 {
8149   addr = SUBSI (addr, 4);
8150 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
8151 }
8152 }
8153 }
8154
8155 #undef FLD
8156     }
8157     NEXT_INSN (vpc, fragpc);
8158
8159 // ********** used only by: stmdb-sw
8160
8161   CASE (FRAG_STMDB_SW_MID):
8162     {
8163 #define FLD(f) abuf->fields.sfmt_ldmda.f
8164       PCADDR pc = abuf->addr;
8165
8166 {
8167 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
8168 {
8169   addr = SUBSI (addr, 4);
8170 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8171 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
8172 } else {
8173 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (14, 8)]);
8174 }
8175 }
8176 }
8177 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
8178 {
8179   addr = SUBSI (addr, 4);
8180 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8181 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
8182 } else {
8183 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (13, 8)]);
8184 }
8185 }
8186 }
8187 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
8188 {
8189   addr = SUBSI (addr, 4);
8190 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8191 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
8192 } else {
8193 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (12, 8)]);
8194 }
8195 }
8196 }
8197 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
8198 {
8199   addr = SUBSI (addr, 4);
8200 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8201 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
8202 } else {
8203 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (11, 8)]);
8204 }
8205 }
8206 }
8207 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
8208 {
8209   addr = SUBSI (addr, 4);
8210 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8211 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
8212 } else {
8213 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (10, 8)]);
8214 }
8215 }
8216 }
8217 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
8218 {
8219   addr = SUBSI (addr, 4);
8220 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8221 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
8222 } else {
8223 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (9, 8)]);
8224 }
8225 }
8226 }
8227 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
8228 {
8229   addr = SUBSI (addr, 4);
8230 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8231 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
8232 } else {
8233 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (8, 8)]);
8234 }
8235 }
8236 }
8237 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
8238 {
8239   addr = SUBSI (addr, 4);
8240 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
8241 }
8242 }
8243 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
8244 {
8245   addr = SUBSI (addr, 4);
8246 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
8247 }
8248 }
8249 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
8250 {
8251   addr = SUBSI (addr, 4);
8252 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
8253 }
8254 }
8255 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
8256 {
8257   addr = SUBSI (addr, 4);
8258 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
8259 }
8260 }
8261 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
8262 {
8263   addr = SUBSI (addr, 4);
8264 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
8265 }
8266 }
8267 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
8268 {
8269   addr = SUBSI (addr, 4);
8270 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
8271 }
8272 }
8273 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
8274 {
8275   addr = SUBSI (addr, 4);
8276 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
8277 }
8278 }
8279 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
8280 {
8281   addr = SUBSI (addr, 4);
8282 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
8283 }
8284 }
8285 }
8286
8287 #undef FLD
8288     }
8289     NEXT_INSN (vpc, fragpc);
8290
8291 // ********** used only by: stmdb-wb
8292
8293   CASE (FRAG_STMDB_WB_MID):
8294     {
8295 #define FLD(f) abuf->fields.sfmt_ldmda.f
8296       PCADDR pc = abuf->addr;
8297
8298 {
8299 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
8300 {
8301   addr = SUBSI (addr, 4);
8302 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
8303 }
8304 }
8305 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
8306 {
8307   addr = SUBSI (addr, 4);
8308 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
8309 }
8310 }
8311 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
8312 {
8313   addr = SUBSI (addr, 4);
8314 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
8315 }
8316 }
8317 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
8318 {
8319   addr = SUBSI (addr, 4);
8320 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
8321 }
8322 }
8323 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
8324 {
8325   addr = SUBSI (addr, 4);
8326 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
8327 }
8328 }
8329 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
8330 {
8331   addr = SUBSI (addr, 4);
8332 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
8333 }
8334 }
8335 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
8336 {
8337   addr = SUBSI (addr, 4);
8338 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
8339 }
8340 }
8341 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
8342 {
8343   addr = SUBSI (addr, 4);
8344 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
8345 }
8346 }
8347 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
8348 {
8349   addr = SUBSI (addr, 4);
8350 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
8351 }
8352 }
8353 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
8354 {
8355   addr = SUBSI (addr, 4);
8356 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
8357 }
8358 }
8359 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
8360 {
8361   addr = SUBSI (addr, 4);
8362 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
8363 }
8364 }
8365 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
8366 {
8367   addr = SUBSI (addr, 4);
8368 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
8369 }
8370 }
8371 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
8372 {
8373   addr = SUBSI (addr, 4);
8374 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
8375 }
8376 }
8377 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
8378 {
8379   addr = SUBSI (addr, 4);
8380 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
8381 }
8382 }
8383 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
8384 {
8385   addr = SUBSI (addr, 4);
8386 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
8387 }
8388 }
8389 * FLD (i_rn) = addr;
8390 }
8391
8392 #undef FLD
8393     }
8394     NEXT_INSN (vpc, fragpc);
8395
8396 // ********** used only by: stmdb-sw-wb
8397
8398   CASE (FRAG_STMDB_SW_WB_MID):
8399     {
8400       abuf = vpc;
8401       vpc = vpc + 1;
8402 #define FLD(f) abuf->fields.sfmt_ldmda.f
8403       PCADDR pc = abuf->addr;
8404       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
8405
8406 {
8407   addr = * FLD (i_rn);
8408 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8409 {
8410   addr = SUBSI (addr, 4);
8411 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
8412 }
8413 }
8414 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
8415 {
8416   addr = SUBSI (addr, 4);
8417 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8418 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
8419 } else {
8420 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (14, 8)]);
8421 }
8422 }
8423 }
8424 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
8425 {
8426   addr = SUBSI (addr, 4);
8427 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8428 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
8429 } else {
8430 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (13, 8)]);
8431 }
8432 }
8433 }
8434 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
8435 {
8436   addr = SUBSI (addr, 4);
8437 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8438 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
8439 } else {
8440 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (12, 8)]);
8441 }
8442 }
8443 }
8444 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
8445 {
8446   addr = SUBSI (addr, 4);
8447 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8448 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
8449 } else {
8450 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (11, 8)]);
8451 }
8452 }
8453 }
8454 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
8455 {
8456   addr = SUBSI (addr, 4);
8457 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8458 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
8459 } else {
8460 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (10, 8)]);
8461 }
8462 }
8463 }
8464 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
8465 {
8466   addr = SUBSI (addr, 4);
8467 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8468 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
8469 } else {
8470 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (9, 8)]);
8471 }
8472 }
8473 }
8474 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
8475 {
8476   addr = SUBSI (addr, 4);
8477 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8478 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
8479 } else {
8480 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (8, 8)]);
8481 }
8482 }
8483 }
8484 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
8485 {
8486   addr = SUBSI (addr, 4);
8487 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
8488 }
8489 }
8490 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
8491 {
8492   addr = SUBSI (addr, 4);
8493 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
8494 }
8495 }
8496 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
8497 {
8498   addr = SUBSI (addr, 4);
8499 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
8500 }
8501 }
8502 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
8503 {
8504   addr = SUBSI (addr, 4);
8505 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
8506 }
8507 }
8508 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
8509 {
8510   addr = SUBSI (addr, 4);
8511 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
8512 }
8513 }
8514 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
8515 {
8516   addr = SUBSI (addr, 4);
8517 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
8518 }
8519 }
8520 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
8521 {
8522   addr = SUBSI (addr, 4);
8523 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
8524 }
8525 }
8526 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
8527 {
8528   addr = SUBSI (addr, 4);
8529 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
8530 }
8531 }
8532 * FLD (i_rn) = addr;
8533 }
8534
8535 #undef FLD
8536     }
8537     NEXT_INSN (vpc, fragpc);
8538
8539 // ********** used only by: stmib
8540
8541   CASE (FRAG_STMIB_MID):
8542     {
8543       abuf = vpc;
8544       vpc = vpc + 1;
8545 #define FLD(f) abuf->fields.sfmt_ldmda.f
8546       PCADDR pc = abuf->addr;
8547       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
8548
8549 {
8550   addr = * FLD (i_rn);
8551 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
8552 {
8553   addr = ADDSI (addr, 4);
8554 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
8555 }
8556 }
8557 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
8558 {
8559   addr = ADDSI (addr, 4);
8560 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
8561 }
8562 }
8563 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
8564 {
8565   addr = ADDSI (addr, 4);
8566 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
8567 }
8568 }
8569 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
8570 {
8571   addr = ADDSI (addr, 4);
8572 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
8573 }
8574 }
8575 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
8576 {
8577   addr = ADDSI (addr, 4);
8578 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
8579 }
8580 }
8581 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
8582 {
8583   addr = ADDSI (addr, 4);
8584 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
8585 }
8586 }
8587 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
8588 {
8589   addr = ADDSI (addr, 4);
8590 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
8591 }
8592 }
8593 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
8594 {
8595   addr = ADDSI (addr, 4);
8596 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
8597 }
8598 }
8599 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
8600 {
8601   addr = ADDSI (addr, 4);
8602 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
8603 }
8604 }
8605 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
8606 {
8607   addr = ADDSI (addr, 4);
8608 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
8609 }
8610 }
8611 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
8612 {
8613   addr = ADDSI (addr, 4);
8614 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
8615 }
8616 }
8617 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
8618 {
8619   addr = ADDSI (addr, 4);
8620 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
8621 }
8622 }
8623 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
8624 {
8625   addr = ADDSI (addr, 4);
8626 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
8627 }
8628 }
8629 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
8630 {
8631   addr = ADDSI (addr, 4);
8632 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
8633 }
8634 }
8635 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
8636 {
8637   addr = ADDSI (addr, 4);
8638 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
8639 }
8640 }
8641 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8642 {
8643   addr = ADDSI (addr, 4);
8644 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
8645 }
8646 }
8647 }
8648
8649 #undef FLD
8650     }
8651     NEXT_INSN (vpc, fragpc);
8652
8653 // ********** used only by: stmib-sw
8654
8655   CASE (FRAG_STMIB_SW_MID):
8656     {
8657 #define FLD(f) abuf->fields.sfmt_ldmda.f
8658       PCADDR pc = abuf->addr;
8659
8660 {
8661 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
8662 {
8663   addr = ADDSI (addr, 4);
8664 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8665 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
8666 } else {
8667 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (8, 8)]);
8668 }
8669 }
8670 }
8671 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
8672 {
8673   addr = ADDSI (addr, 4);
8674 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8675 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
8676 } else {
8677 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (9, 8)]);
8678 }
8679 }
8680 }
8681 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
8682 {
8683   addr = ADDSI (addr, 4);
8684 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8685 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
8686 } else {
8687 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (10, 8)]);
8688 }
8689 }
8690 }
8691 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
8692 {
8693   addr = ADDSI (addr, 4);
8694 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8695 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
8696 } else {
8697 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (11, 8)]);
8698 }
8699 }
8700 }
8701 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
8702 {
8703   addr = ADDSI (addr, 4);
8704 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8705 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
8706 } else {
8707 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (12, 8)]);
8708 }
8709 }
8710 }
8711 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
8712 {
8713   addr = ADDSI (addr, 4);
8714 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8715 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
8716 } else {
8717 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (13, 8)]);
8718 }
8719 }
8720 }
8721 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
8722 {
8723   addr = ADDSI (addr, 4);
8724 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8725 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
8726 } else {
8727 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (14, 8)]);
8728 }
8729 }
8730 }
8731 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8732 {
8733   addr = ADDSI (addr, 4);
8734 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
8735 }
8736 }
8737 }
8738
8739 #undef FLD
8740     }
8741     NEXT_INSN (vpc, fragpc);
8742
8743 // ********** used only by: stmib-wb
8744
8745   CASE (FRAG_STMIB_WB_MID):
8746     {
8747 #define FLD(f) abuf->fields.sfmt_ldmda.f
8748       PCADDR pc = abuf->addr;
8749
8750 {
8751 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
8752 {
8753   addr = ADDSI (addr, 4);
8754 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
8755 }
8756 }
8757 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
8758 {
8759   addr = ADDSI (addr, 4);
8760 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
8761 }
8762 }
8763 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
8764 {
8765   addr = ADDSI (addr, 4);
8766 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
8767 }
8768 }
8769 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
8770 {
8771   addr = ADDSI (addr, 4);
8772 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
8773 }
8774 }
8775 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
8776 {
8777   addr = ADDSI (addr, 4);
8778 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
8779 }
8780 }
8781 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
8782 {
8783   addr = ADDSI (addr, 4);
8784 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
8785 }
8786 }
8787 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
8788 {
8789   addr = ADDSI (addr, 4);
8790 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
8791 }
8792 }
8793 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8794 {
8795   addr = ADDSI (addr, 4);
8796 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
8797 }
8798 }
8799 * FLD (i_rn) = addr;
8800 }
8801
8802 #undef FLD
8803     }
8804     NEXT_INSN (vpc, fragpc);
8805
8806 // ********** used only by: stmib-sw-wb
8807
8808   CASE (FRAG_STMIB_SW_WB_MID):
8809     {
8810       abuf = vpc;
8811       vpc = vpc + 1;
8812 #define FLD(f) abuf->fields.sfmt_ldmda.f
8813       PCADDR pc = abuf->addr;
8814       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
8815
8816 {
8817   addr = * FLD (i_rn);
8818 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
8819 {
8820   addr = ADDSI (addr, 4);
8821 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
8822 }
8823 }
8824 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
8825 {
8826   addr = ADDSI (addr, 4);
8827 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
8828 }
8829 }
8830 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
8831 {
8832   addr = ADDSI (addr, 4);
8833 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
8834 }
8835 }
8836 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
8837 {
8838   addr = ADDSI (addr, 4);
8839 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
8840 }
8841 }
8842 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
8843 {
8844   addr = ADDSI (addr, 4);
8845 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
8846 }
8847 }
8848 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
8849 {
8850   addr = ADDSI (addr, 4);
8851 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
8852 }
8853 }
8854 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
8855 {
8856   addr = ADDSI (addr, 4);
8857 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
8858 }
8859 }
8860 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
8861 {
8862   addr = ADDSI (addr, 4);
8863 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
8864 }
8865 }
8866 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
8867 {
8868   addr = ADDSI (addr, 4);
8869 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8870 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
8871 } else {
8872 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (8, 8)]);
8873 }
8874 }
8875 }
8876 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
8877 {
8878   addr = ADDSI (addr, 4);
8879 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8880 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
8881 } else {
8882 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (9, 8)]);
8883 }
8884 }
8885 }
8886 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
8887 {
8888   addr = ADDSI (addr, 4);
8889 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8890 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
8891 } else {
8892 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (10, 8)]);
8893 }
8894 }
8895 }
8896 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
8897 {
8898   addr = ADDSI (addr, 4);
8899 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8900 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
8901 } else {
8902 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (11, 8)]);
8903 }
8904 }
8905 }
8906 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
8907 {
8908   addr = ADDSI (addr, 4);
8909 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8910 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
8911 } else {
8912 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (12, 8)]);
8913 }
8914 }
8915 }
8916 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
8917 {
8918   addr = ADDSI (addr, 4);
8919 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8920 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
8921 } else {
8922 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (13, 8)]);
8923 }
8924 }
8925 }
8926 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
8927 {
8928   addr = ADDSI (addr, 4);
8929 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8930 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
8931 } else {
8932 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (14, 8)]);
8933 }
8934 }
8935 }
8936 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
8937 {
8938   addr = ADDSI (addr, 4);
8939 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
8940 }
8941 }
8942 * FLD (i_rn) = addr;
8943 }
8944
8945 #undef FLD
8946     }
8947     NEXT_INSN (vpc, fragpc);
8948
8949 // ********** used only by: stmia
8950
8951   CASE (FRAG_STMIA_MID):
8952     {
8953       abuf = vpc;
8954       vpc = vpc + 1;
8955 #define FLD(f) abuf->fields.sfmt_ldmda.f
8956       PCADDR pc = abuf->addr;
8957       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
8958
8959 {
8960   addr = * FLD (i_rn);
8961 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
8962 {
8963 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
8964   addr = ADDSI (addr, 4);
8965 }
8966 }
8967 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
8968 {
8969 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
8970   addr = ADDSI (addr, 4);
8971 }
8972 }
8973 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
8974 {
8975 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
8976   addr = ADDSI (addr, 4);
8977 }
8978 }
8979 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
8980 {
8981 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
8982   addr = ADDSI (addr, 4);
8983 }
8984 }
8985 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
8986 {
8987 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
8988   addr = ADDSI (addr, 4);
8989 }
8990 }
8991 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
8992 {
8993 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
8994   addr = ADDSI (addr, 4);
8995 }
8996 }
8997 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
8998 {
8999 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
9000   addr = ADDSI (addr, 4);
9001 }
9002 }
9003 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
9004 {
9005 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
9006   addr = ADDSI (addr, 4);
9007 }
9008 }
9009 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
9010 {
9011 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
9012   addr = ADDSI (addr, 4);
9013 }
9014 }
9015 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
9016 {
9017 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
9018   addr = ADDSI (addr, 4);
9019 }
9020 }
9021 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
9022 {
9023 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
9024   addr = ADDSI (addr, 4);
9025 }
9026 }
9027 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
9028 {
9029 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
9030   addr = ADDSI (addr, 4);
9031 }
9032 }
9033 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
9034 {
9035 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
9036   addr = ADDSI (addr, 4);
9037 }
9038 }
9039 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
9040 {
9041 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
9042   addr = ADDSI (addr, 4);
9043 }
9044 }
9045 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
9046 {
9047 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
9048   addr = ADDSI (addr, 4);
9049 }
9050 }
9051 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9052 {
9053 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
9054   addr = ADDSI (addr, 4);
9055 }
9056 }
9057 }
9058
9059 #undef FLD
9060     }
9061     NEXT_INSN (vpc, fragpc);
9062
9063 // ********** used only by: stmia-sw
9064
9065   CASE (FRAG_STMIA_SW_MID):
9066     {
9067 #define FLD(f) abuf->fields.sfmt_ldmda.f
9068       PCADDR pc = abuf->addr;
9069
9070 {
9071 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
9072 {
9073 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9074 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
9075 } else {
9076 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (8, 8)]);
9077 }
9078   addr = ADDSI (addr, 4);
9079 }
9080 }
9081 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
9082 {
9083 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9084 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
9085 } else {
9086 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (9, 8)]);
9087 }
9088   addr = ADDSI (addr, 4);
9089 }
9090 }
9091 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
9092 {
9093 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9094 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
9095 } else {
9096 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (10, 8)]);
9097 }
9098   addr = ADDSI (addr, 4);
9099 }
9100 }
9101 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
9102 {
9103 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9104 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
9105 } else {
9106 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (11, 8)]);
9107 }
9108   addr = ADDSI (addr, 4);
9109 }
9110 }
9111 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
9112 {
9113 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9114 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
9115 } else {
9116 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (12, 8)]);
9117 }
9118   addr = ADDSI (addr, 4);
9119 }
9120 }
9121 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
9122 {
9123 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9124 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
9125 } else {
9126 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (13, 8)]);
9127 }
9128   addr = ADDSI (addr, 4);
9129 }
9130 }
9131 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
9132 {
9133 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9134 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
9135 } else {
9136 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (14, 8)]);
9137 }
9138   addr = ADDSI (addr, 4);
9139 }
9140 }
9141 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9142 {
9143 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
9144   addr = ADDSI (addr, 4);
9145 }
9146 }
9147 }
9148
9149 #undef FLD
9150     }
9151     NEXT_INSN (vpc, fragpc);
9152
9153 // ********** used only by: stmia-wb
9154
9155   CASE (FRAG_STMIA_WB_MID):
9156     {
9157 #define FLD(f) abuf->fields.sfmt_ldmda.f
9158       PCADDR pc = abuf->addr;
9159
9160 {
9161 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
9162 {
9163 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
9164   addr = ADDSI (addr, 4);
9165 }
9166 }
9167 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
9168 {
9169 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
9170   addr = ADDSI (addr, 4);
9171 }
9172 }
9173 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
9174 {
9175 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
9176   addr = ADDSI (addr, 4);
9177 }
9178 }
9179 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
9180 {
9181 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
9182   addr = ADDSI (addr, 4);
9183 }
9184 }
9185 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
9186 {
9187 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
9188   addr = ADDSI (addr, 4);
9189 }
9190 }
9191 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
9192 {
9193 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
9194   addr = ADDSI (addr, 4);
9195 }
9196 }
9197 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
9198 {
9199 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
9200   addr = ADDSI (addr, 4);
9201 }
9202 }
9203 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9204 {
9205 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
9206   addr = ADDSI (addr, 4);
9207 }
9208 }
9209 * FLD (i_rn) = addr;
9210 }
9211
9212 #undef FLD
9213     }
9214     NEXT_INSN (vpc, fragpc);
9215
9216 // ********** used only by: stmia-sw-wb
9217
9218   CASE (FRAG_STMIA_SW_WB_MID):
9219     {
9220       abuf = vpc;
9221       vpc = vpc + 1;
9222 #define FLD(f) abuf->fields.sfmt_ldmda.f
9223       PCADDR pc = abuf->addr;
9224       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
9225
9226 {
9227   addr = * FLD (i_rn);
9228 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
9229 {
9230 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
9231   addr = ADDSI (addr, 4);
9232 }
9233 }
9234 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
9235 {
9236 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
9237   addr = ADDSI (addr, 4);
9238 }
9239 }
9240 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
9241 {
9242 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
9243   addr = ADDSI (addr, 4);
9244 }
9245 }
9246 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
9247 {
9248 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
9249   addr = ADDSI (addr, 4);
9250 }
9251 }
9252 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
9253 {
9254 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
9255   addr = ADDSI (addr, 4);
9256 }
9257 }
9258 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
9259 {
9260 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
9261   addr = ADDSI (addr, 4);
9262 }
9263 }
9264 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
9265 {
9266 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
9267   addr = ADDSI (addr, 4);
9268 }
9269 }
9270 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
9271 {
9272 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
9273   addr = ADDSI (addr, 4);
9274 }
9275 }
9276 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
9277 {
9278 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9279 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
9280 } else {
9281 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (8, 8)]);
9282 }
9283   addr = ADDSI (addr, 4);
9284 }
9285 }
9286 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
9287 {
9288 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9289 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
9290 } else {
9291 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (9, 8)]);
9292 }
9293   addr = ADDSI (addr, 4);
9294 }
9295 }
9296 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
9297 {
9298 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9299 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
9300 } else {
9301 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (10, 8)]);
9302 }
9303   addr = ADDSI (addr, 4);
9304 }
9305 }
9306 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
9307 {
9308 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9309 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
9310 } else {
9311 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (11, 8)]);
9312 }
9313   addr = ADDSI (addr, 4);
9314 }
9315 }
9316 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
9317 {
9318 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9319 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
9320 } else {
9321 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (12, 8)]);
9322 }
9323   addr = ADDSI (addr, 4);
9324 }
9325 }
9326 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
9327 {
9328 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9329 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
9330 } else {
9331 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (13, 8)]);
9332 }
9333   addr = ADDSI (addr, 4);
9334 }
9335 }
9336 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
9337 {
9338 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9339 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
9340 } else {
9341 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (14, 8)]);
9342 }
9343   addr = ADDSI (addr, 4);
9344 }
9345 }
9346 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9347 {
9348 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
9349   addr = ADDSI (addr, 4);
9350 }
9351 }
9352 * FLD (i_rn) = addr;
9353 }
9354
9355 #undef FLD
9356     }
9357     NEXT_INSN (vpc, fragpc);
9358
9359 // ********** used only by: stmda
9360
9361   CASE (FRAG_STMDA_MID):
9362     {
9363       abuf = vpc;
9364       vpc = vpc + 1;
9365 #define FLD(f) abuf->fields.sfmt_ldmda.f
9366       PCADDR pc = abuf->addr;
9367       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
9368
9369 {
9370   addr = * FLD (i_rn);
9371 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9372 {
9373 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
9374   addr = SUBSI (addr, 4);
9375 }
9376 }
9377 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
9378 {
9379 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
9380   addr = SUBSI (addr, 4);
9381 }
9382 }
9383 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
9384 {
9385 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
9386   addr = SUBSI (addr, 4);
9387 }
9388 }
9389 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
9390 {
9391 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
9392   addr = SUBSI (addr, 4);
9393 }
9394 }
9395 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
9396 {
9397 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
9398   addr = SUBSI (addr, 4);
9399 }
9400 }
9401 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
9402 {
9403 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
9404   addr = SUBSI (addr, 4);
9405 }
9406 }
9407 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
9408 {
9409 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
9410   addr = SUBSI (addr, 4);
9411 }
9412 }
9413 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
9414 {
9415 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
9416   addr = SUBSI (addr, 4);
9417 }
9418 }
9419 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
9420 {
9421 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
9422   addr = SUBSI (addr, 4);
9423 }
9424 }
9425 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
9426 {
9427 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
9428   addr = SUBSI (addr, 4);
9429 }
9430 }
9431 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
9432 {
9433 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
9434   addr = SUBSI (addr, 4);
9435 }
9436 }
9437 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
9438 {
9439 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
9440   addr = SUBSI (addr, 4);
9441 }
9442 }
9443 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
9444 {
9445 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
9446   addr = SUBSI (addr, 4);
9447 }
9448 }
9449 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
9450 {
9451 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
9452   addr = SUBSI (addr, 4);
9453 }
9454 }
9455 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
9456 {
9457 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
9458   addr = SUBSI (addr, 4);
9459 }
9460 }
9461 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
9462 {
9463 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
9464   addr = SUBSI (addr, 4);
9465 }
9466 }
9467 }
9468
9469 #undef FLD
9470     }
9471     NEXT_INSN (vpc, fragpc);
9472
9473 // ********** used only by: stmda-sw
9474
9475   CASE (FRAG_STMDA_SW_MID):
9476     {
9477 #define FLD(f) abuf->fields.sfmt_ldmda.f
9478       PCADDR pc = abuf->addr;
9479
9480 {
9481 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
9482 {
9483 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9484 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
9485 } else {
9486 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (14, 8)]);
9487 }
9488   addr = SUBSI (addr, 4);
9489 }
9490 }
9491 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
9492 {
9493 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9494 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
9495 } else {
9496 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (13, 8)]);
9497 }
9498   addr = SUBSI (addr, 4);
9499 }
9500 }
9501 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
9502 {
9503 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9504 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
9505 } else {
9506 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (12, 8)]);
9507 }
9508   addr = SUBSI (addr, 4);
9509 }
9510 }
9511 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
9512 {
9513 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9514 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
9515 } else {
9516 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (11, 8)]);
9517 }
9518   addr = SUBSI (addr, 4);
9519 }
9520 }
9521 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
9522 {
9523 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9524 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
9525 } else {
9526 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (10, 8)]);
9527 }
9528   addr = SUBSI (addr, 4);
9529 }
9530 }
9531 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
9532 {
9533 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9534 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
9535 } else {
9536 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (9, 8)]);
9537 }
9538   addr = SUBSI (addr, 4);
9539 }
9540 }
9541 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
9542 {
9543 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9544 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
9545 } else {
9546 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (8, 8)]);
9547 }
9548   addr = SUBSI (addr, 4);
9549 }
9550 }
9551 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
9552 {
9553 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
9554   addr = SUBSI (addr, 4);
9555 }
9556 }
9557 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
9558 {
9559 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
9560   addr = SUBSI (addr, 4);
9561 }
9562 }
9563 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
9564 {
9565 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
9566   addr = SUBSI (addr, 4);
9567 }
9568 }
9569 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
9570 {
9571 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
9572   addr = SUBSI (addr, 4);
9573 }
9574 }
9575 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
9576 {
9577 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
9578   addr = SUBSI (addr, 4);
9579 }
9580 }
9581 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
9582 {
9583 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
9584   addr = SUBSI (addr, 4);
9585 }
9586 }
9587 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
9588 {
9589 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
9590   addr = SUBSI (addr, 4);
9591 }
9592 }
9593 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
9594 {
9595 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
9596   addr = SUBSI (addr, 4);
9597 }
9598 }
9599 }
9600
9601 #undef FLD
9602     }
9603     NEXT_INSN (vpc, fragpc);
9604
9605 // ********** used only by: stmda-wb
9606
9607   CASE (FRAG_STMDA_WB_MID):
9608     {
9609 #define FLD(f) abuf->fields.sfmt_ldmda.f
9610       PCADDR pc = abuf->addr;
9611
9612 {
9613 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
9614 {
9615 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
9616   addr = SUBSI (addr, 4);
9617 }
9618 }
9619 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
9620 {
9621 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
9622   addr = SUBSI (addr, 4);
9623 }
9624 }
9625 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
9626 {
9627 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
9628   addr = SUBSI (addr, 4);
9629 }
9630 }
9631 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
9632 {
9633 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
9634   addr = SUBSI (addr, 4);
9635 }
9636 }
9637 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
9638 {
9639 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
9640   addr = SUBSI (addr, 4);
9641 }
9642 }
9643 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
9644 {
9645 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
9646   addr = SUBSI (addr, 4);
9647 }
9648 }
9649 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
9650 {
9651 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
9652   addr = SUBSI (addr, 4);
9653 }
9654 }
9655 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
9656 {
9657 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
9658   addr = SUBSI (addr, 4);
9659 }
9660 }
9661 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
9662 {
9663 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
9664   addr = SUBSI (addr, 4);
9665 }
9666 }
9667 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
9668 {
9669 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
9670   addr = SUBSI (addr, 4);
9671 }
9672 }
9673 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
9674 {
9675 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
9676   addr = SUBSI (addr, 4);
9677 }
9678 }
9679 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
9680 {
9681 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
9682   addr = SUBSI (addr, 4);
9683 }
9684 }
9685 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
9686 {
9687 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
9688   addr = SUBSI (addr, 4);
9689 }
9690 }
9691 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
9692 {
9693 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
9694   addr = SUBSI (addr, 4);
9695 }
9696 }
9697 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
9698 {
9699 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
9700   addr = SUBSI (addr, 4);
9701 }
9702 }
9703 * FLD (i_rn) = addr;
9704 }
9705
9706 #undef FLD
9707     }
9708     NEXT_INSN (vpc, fragpc);
9709
9710 // ********** used only by: stmda-sw-wb
9711
9712   CASE (FRAG_STMDA_SW_WB_MID):
9713     {
9714       abuf = vpc;
9715       vpc = vpc + 1;
9716 #define FLD(f) abuf->fields.sfmt_ldmda.f
9717       PCADDR pc = abuf->addr;
9718       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
9719
9720 {
9721   addr = * FLD (i_rn);
9722 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9723 {
9724 current_cpu->SETMEMSI (pc, addr, ADDSI (current_cpu->hardware.h_gr[((UINT) 15)], 4));
9725   addr = SUBSI (addr, 4);
9726 }
9727 }
9728 if (ANDSI (FLD (f_reg_list), SLLSI (1, 14))) {
9729 {
9730 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9731 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 14)]);
9732 } else {
9733 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (14, 8)]);
9734 }
9735   addr = SUBSI (addr, 4);
9736 }
9737 }
9738 if (ANDSI (FLD (f_reg_list), SLLSI (1, 13))) {
9739 {
9740 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9741 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 13)]);
9742 } else {
9743 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (13, 8)]);
9744 }
9745   addr = SUBSI (addr, 4);
9746 }
9747 }
9748 if (ANDSI (FLD (f_reg_list), SLLSI (1, 12))) {
9749 {
9750 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9751 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 12)]);
9752 } else {
9753 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (12, 8)]);
9754 }
9755   addr = SUBSI (addr, 4);
9756 }
9757 }
9758 if (ANDSI (FLD (f_reg_list), SLLSI (1, 11))) {
9759 {
9760 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9761 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 11)]);
9762 } else {
9763 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (11, 8)]);
9764 }
9765   addr = SUBSI (addr, 4);
9766 }
9767 }
9768 if (ANDSI (FLD (f_reg_list), SLLSI (1, 10))) {
9769 {
9770 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9771 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 10)]);
9772 } else {
9773 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (10, 8)]);
9774 }
9775   addr = SUBSI (addr, 4);
9776 }
9777 }
9778 if (ANDSI (FLD (f_reg_list), SLLSI (1, 9))) {
9779 {
9780 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9781 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 9)]);
9782 } else {
9783 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (9, 8)]);
9784 }
9785   addr = SUBSI (addr, 4);
9786 }
9787 }
9788 if (ANDSI (FLD (f_reg_list), SLLSI (1, 8))) {
9789 {
9790 if (ANDSI (FLD (f_reg_list), SLLSI (1, 15))) {
9791 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 8)]);
9792 } else {
9793 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr_usr[SUBSI (8, 8)]);
9794 }
9795   addr = SUBSI (addr, 4);
9796 }
9797 }
9798 if (ANDSI (FLD (f_reg_list), SLLSI (1, 7))) {
9799 {
9800 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 7)]);
9801   addr = SUBSI (addr, 4);
9802 }
9803 }
9804 if (ANDSI (FLD (f_reg_list), SLLSI (1, 6))) {
9805 {
9806 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 6)]);
9807   addr = SUBSI (addr, 4);
9808 }
9809 }
9810 if (ANDSI (FLD (f_reg_list), SLLSI (1, 5))) {
9811 {
9812 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 5)]);
9813   addr = SUBSI (addr, 4);
9814 }
9815 }
9816 if (ANDSI (FLD (f_reg_list), SLLSI (1, 4))) {
9817 {
9818 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 4)]);
9819   addr = SUBSI (addr, 4);
9820 }
9821 }
9822 if (ANDSI (FLD (f_reg_list), SLLSI (1, 3))) {
9823 {
9824 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 3)]);
9825   addr = SUBSI (addr, 4);
9826 }
9827 }
9828 if (ANDSI (FLD (f_reg_list), SLLSI (1, 2))) {
9829 {
9830 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 2)]);
9831   addr = SUBSI (addr, 4);
9832 }
9833 }
9834 if (ANDSI (FLD (f_reg_list), SLLSI (1, 1))) {
9835 {
9836 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 1)]);
9837   addr = SUBSI (addr, 4);
9838 }
9839 }
9840 if (ANDSI (FLD (f_reg_list), SLLSI (1, 0))) {
9841 {
9842 current_cpu->SETMEMSI (pc, addr, current_cpu->hardware.h_gr[((UINT) 0)]);
9843   addr = SUBSI (addr, 4);
9844 }
9845 }
9846 * FLD (i_rn) = addr;
9847 }
9848
9849 #undef FLD
9850     }
9851     NEXT_INSN (vpc, fragpc);
9852
9853 // ********** used only by: mrs-c
9854
9855   CASE (FRAG_MRS_C_MID):
9856     {
9857       abuf = vpc;
9858       vpc = vpc + 1;
9859 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
9860       PCADDR pc = abuf->addr;
9861       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
9862
9863 {
9864 * FLD (i_rd) = current_cpu->h_cpsr_get ();
9865 }
9866
9867 #undef FLD
9868     }
9869     NEXT_INSN (vpc, fragpc);
9870
9871 // ********** used only by: mrs-s
9872
9873   CASE (FRAG_MRS_S_MID):
9874     {
9875       abuf = vpc;
9876       vpc = vpc + 1;
9877 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
9878       PCADDR pc = abuf->addr;
9879       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
9880
9881 {
9882 * FLD (i_rd) = current_cpu->h_spsr_get ();
9883 }
9884
9885 #undef FLD
9886     }
9887     NEXT_INSN (vpc, fragpc);
9888
9889 // ********** used only by: msr-c
9890
9891   CASE (FRAG_MSR_C_MID):
9892     {
9893       abuf = vpc;
9894       vpc = vpc + 1;
9895 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
9896       PCADDR pc = abuf->addr;
9897       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
9898
9899 {
9900 current_cpu->h_cpsr_set (* FLD (i_rm));
9901 }
9902
9903 #undef FLD
9904     }
9905     NEXT_INSN (vpc, fragpc);
9906
9907 // ********** used only by: msr-s
9908
9909   CASE (FRAG_MSR_S_MID):
9910     {
9911       abuf = vpc;
9912       vpc = vpc + 1;
9913 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
9914       PCADDR pc = abuf->addr;
9915       current_cpu->hardware.h_gr[((UINT) 15)] = ADDSI (pc, GET_ATTR (R15_OFFSET));
9916
9917 {
9918 current_cpu->h_spsr_set (* FLD (i_rm));
9919 }
9920
9921 #undef FLD
9922     }
9923     NEXT_INSN (vpc, fragpc);
9924
9925
9926 #ifdef __GNUC__
9927     end_switch: ;
9928 #else
9929     default: abort ();
9930 #endif
9931     }
9932   }
9933
9934   // Save vpc for next time.
9935   current_cpu->arm_engine.set_next_vpc (vpc);
9936 }
9937