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

   1 /* Simulator instruction decoder for arm.
   2
   3 THIS FILE IS MACHINE GENERATED WITH CGEN.
   4
   5 Copyright (C) 2000-2010 Red Hat, Inc.
   6
   7 This file is part of the Red Hat simulators.
   8
   9
  10 */
  11
  12
  13 #if HAVE_CONFIG_H
  14 #include "config.h"
  15 #endif
  16 #include "arm7f.h"
  17
  18 using namespace arm7f; // FIXME: namespace organization still wip
  19
  20
  21 // The instruction descriptor array.
  22
  23 // Have label pointers been initialized?
  24 // XXX: Note that this is also needed by when semantics are implemented as
  25 // functions to handle machine variants.
  26 bool arm_idesc::idesc_table_initialized_p = false;
  27
  28 arm_idesc arm_idesc::idesc_table[ARM_INSN_MSR_S + 1] =
  29 {
  30   { 0, 0, "X_COND", ARM_INSN_X_COND, { 0|(1<<CGEN_INSN_PBB)|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  31   { 0, 0, "X_AFTER", ARM_INSN_X_AFTER, { 0|(1<<CGEN_INSN_PBB)|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  32   { 0, 0, "X_BEFORE", ARM_INSN_X_BEFORE, { 0|(1<<CGEN_INSN_PBB)|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  33   { 0, 0, "X_CTI_CHAIN", ARM_INSN_X_CTI_CHAIN, { 0|(1<<CGEN_INSN_PBB)|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  34   { 0, 0, "X_CHAIN", ARM_INSN_X_CHAIN, { 0|(1<<CGEN_INSN_PBB)|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  35   { 0, 0, "X_BEGIN", ARM_INSN_X_BEGIN, { 0|(1<<CGEN_INSN_PBB)|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  36   { 0, arm_sem_x_invalid, "X_INVALID", ARM_INSN_X_INVALID, { 0|(1<<CGEN_INSN_VIRTUAL), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  37   { 0, arm_sem_b, "B", ARM_INSN_B, { 0|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  38   { 0, arm_sem_bl, "BL", ARM_INSN_BL, { 0|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  39   { 0, arm_sem_bx, "BX", ARM_INSN_BX, { 0|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  40   { 0, arm_sem_ldr_post_dec_imm_offset, "LDR_POST_DEC_IMM_OFFSET", ARM_INSN_LDR_POST_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  41   { 0, arm_sem_ldr_post_dec_reg_offset, "LDR_POST_DEC_REG_OFFSET", ARM_INSN_LDR_POST_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  42   { 0, arm_sem_ldr_post_inc_imm_offset, "LDR_POST_INC_IMM_OFFSET", ARM_INSN_LDR_POST_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  43   { 0, arm_sem_ldr_post_inc_reg_offset, "LDR_POST_INC_REG_OFFSET", ARM_INSN_LDR_POST_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  44   { 0, arm_sem_ldr_post_dec_nonpriv_imm_offset, "LDR_POST_DEC_NONPRIV_IMM_OFFSET", ARM_INSN_LDR_POST_DEC_NONPRIV_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  45   { 0, arm_sem_ldr_post_dec_nonpriv_reg_offset, "LDR_POST_DEC_NONPRIV_REG_OFFSET", ARM_INSN_LDR_POST_DEC_NONPRIV_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  46   { 0, arm_sem_ldr_post_inc_nonpriv_imm_offset, "LDR_POST_INC_NONPRIV_IMM_OFFSET", ARM_INSN_LDR_POST_INC_NONPRIV_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  47   { 0, arm_sem_ldr_post_inc_nonpriv_reg_offset, "LDR_POST_INC_NONPRIV_REG_OFFSET", ARM_INSN_LDR_POST_INC_NONPRIV_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  48   { 0, arm_sem_ldr_pre_dec_imm_offset, "LDR_PRE_DEC_IMM_OFFSET", ARM_INSN_LDR_PRE_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  49   { 0, arm_sem_ldr_pre_dec_reg_offset, "LDR_PRE_DEC_REG_OFFSET", ARM_INSN_LDR_PRE_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  50   { 0, arm_sem_ldr_pre_inc_imm_offset, "LDR_PRE_INC_IMM_OFFSET", ARM_INSN_LDR_PRE_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  51   { 0, arm_sem_ldr_pre_inc_reg_offset, "LDR_PRE_INC_REG_OFFSET", ARM_INSN_LDR_PRE_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  52   { 0, arm_sem_ldr_pre_dec_wb_imm_offset, "LDR_PRE_DEC_WB_IMM_OFFSET", ARM_INSN_LDR_PRE_DEC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  53   { 0, arm_sem_ldr_pre_dec_wb_reg_offset, "LDR_PRE_DEC_WB_REG_OFFSET", ARM_INSN_LDR_PRE_DEC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  54   { 0, arm_sem_ldr_pre_inc_wb_imm_offset, "LDR_PRE_INC_WB_IMM_OFFSET", ARM_INSN_LDR_PRE_INC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  55   { 0, arm_sem_ldr_pre_inc_wb_reg_offset, "LDR_PRE_INC_WB_REG_OFFSET", ARM_INSN_LDR_PRE_INC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  56   { 0, arm_sem_ldrb_post_dec_imm_offset, "LDRB_POST_DEC_IMM_OFFSET", ARM_INSN_LDRB_POST_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  57   { 0, arm_sem_ldrb_post_dec_reg_offset, "LDRB_POST_DEC_REG_OFFSET", ARM_INSN_LDRB_POST_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  58   { 0, arm_sem_ldrb_post_inc_imm_offset, "LDRB_POST_INC_IMM_OFFSET", ARM_INSN_LDRB_POST_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  59   { 0, arm_sem_ldrb_post_inc_reg_offset, "LDRB_POST_INC_REG_OFFSET", ARM_INSN_LDRB_POST_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  60   { 0, arm_sem_ldrb_post_dec_nonpriv_imm_offset, "LDRB_POST_DEC_NONPRIV_IMM_OFFSET", ARM_INSN_LDRB_POST_DEC_NONPRIV_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  61   { 0, arm_sem_ldrb_post_dec_nonpriv_reg_offset, "LDRB_POST_DEC_NONPRIV_REG_OFFSET", ARM_INSN_LDRB_POST_DEC_NONPRIV_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  62   { 0, arm_sem_ldrb_post_inc_nonpriv_imm_offset, "LDRB_POST_INC_NONPRIV_IMM_OFFSET", ARM_INSN_LDRB_POST_INC_NONPRIV_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  63   { 0, arm_sem_ldrb_post_inc_nonpriv_reg_offset, "LDRB_POST_INC_NONPRIV_REG_OFFSET", ARM_INSN_LDRB_POST_INC_NONPRIV_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  64   { 0, arm_sem_ldrb_pre_dec_imm_offset, "LDRB_PRE_DEC_IMM_OFFSET", ARM_INSN_LDRB_PRE_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  65   { 0, arm_sem_ldrb_pre_dec_reg_offset, "LDRB_PRE_DEC_REG_OFFSET", ARM_INSN_LDRB_PRE_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  66   { 0, arm_sem_ldrb_pre_inc_imm_offset, "LDRB_PRE_INC_IMM_OFFSET", ARM_INSN_LDRB_PRE_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  67   { 0, arm_sem_ldrb_pre_inc_reg_offset, "LDRB_PRE_INC_REG_OFFSET", ARM_INSN_LDRB_PRE_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  68   { 0, arm_sem_ldrb_pre_dec_wb_imm_offset, "LDRB_PRE_DEC_WB_IMM_OFFSET", ARM_INSN_LDRB_PRE_DEC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  69   { 0, arm_sem_ldrb_pre_dec_wb_reg_offset, "LDRB_PRE_DEC_WB_REG_OFFSET", ARM_INSN_LDRB_PRE_DEC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  70   { 0, arm_sem_ldrb_pre_inc_wb_imm_offset, "LDRB_PRE_INC_WB_IMM_OFFSET", ARM_INSN_LDRB_PRE_INC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  71   { 0, arm_sem_ldrb_pre_inc_wb_reg_offset, "LDRB_PRE_INC_WB_REG_OFFSET", ARM_INSN_LDRB_PRE_INC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  72   { 0, arm_sem_str_post_dec_imm_offset, "STR_POST_DEC_IMM_OFFSET", ARM_INSN_STR_POST_DEC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  73   { 0, arm_sem_str_post_dec_reg_offset, "STR_POST_DEC_REG_OFFSET", ARM_INSN_STR_POST_DEC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  74   { 0, arm_sem_str_post_inc_imm_offset, "STR_POST_INC_IMM_OFFSET", ARM_INSN_STR_POST_INC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  75   { 0, arm_sem_str_post_inc_reg_offset, "STR_POST_INC_REG_OFFSET", ARM_INSN_STR_POST_INC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  76   { 0, arm_sem_str_post_dec_nonpriv_imm_offset, "STR_POST_DEC_NONPRIV_IMM_OFFSET", ARM_INSN_STR_POST_DEC_NONPRIV_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  77   { 0, arm_sem_str_post_dec_nonpriv_reg_offset, "STR_POST_DEC_NONPRIV_REG_OFFSET", ARM_INSN_STR_POST_DEC_NONPRIV_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  78   { 0, arm_sem_str_post_inc_nonpriv_imm_offset, "STR_POST_INC_NONPRIV_IMM_OFFSET", ARM_INSN_STR_POST_INC_NONPRIV_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  79   { 0, arm_sem_str_post_inc_nonpriv_reg_offset, "STR_POST_INC_NONPRIV_REG_OFFSET", ARM_INSN_STR_POST_INC_NONPRIV_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  80   { 0, arm_sem_str_pre_dec_imm_offset, "STR_PRE_DEC_IMM_OFFSET", ARM_INSN_STR_PRE_DEC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  81   { 0, arm_sem_str_pre_dec_reg_offset, "STR_PRE_DEC_REG_OFFSET", ARM_INSN_STR_PRE_DEC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  82   { 0, arm_sem_str_pre_inc_imm_offset, "STR_PRE_INC_IMM_OFFSET", ARM_INSN_STR_PRE_INC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  83   { 0, arm_sem_str_pre_inc_reg_offset, "STR_PRE_INC_REG_OFFSET", ARM_INSN_STR_PRE_INC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  84   { 0, arm_sem_str_pre_dec_wb_imm_offset, "STR_PRE_DEC_WB_IMM_OFFSET", ARM_INSN_STR_PRE_DEC_WB_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  85   { 0, arm_sem_str_pre_dec_wb_reg_offset, "STR_PRE_DEC_WB_REG_OFFSET", ARM_INSN_STR_PRE_DEC_WB_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  86   { 0, arm_sem_str_pre_inc_wb_imm_offset, "STR_PRE_INC_WB_IMM_OFFSET", ARM_INSN_STR_PRE_INC_WB_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  87   { 0, arm_sem_str_pre_inc_wb_reg_offset, "STR_PRE_INC_WB_REG_OFFSET", ARM_INSN_STR_PRE_INC_WB_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  88   { 0, arm_sem_strb_post_dec_imm_offset, "STRB_POST_DEC_IMM_OFFSET", ARM_INSN_STRB_POST_DEC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  89   { 0, arm_sem_strb_post_dec_reg_offset, "STRB_POST_DEC_REG_OFFSET", ARM_INSN_STRB_POST_DEC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  90   { 0, arm_sem_strb_post_inc_imm_offset, "STRB_POST_INC_IMM_OFFSET", ARM_INSN_STRB_POST_INC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  91   { 0, arm_sem_strb_post_inc_reg_offset, "STRB_POST_INC_REG_OFFSET", ARM_INSN_STRB_POST_INC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  92   { 0, arm_sem_strb_post_dec_nonpriv_imm_offset, "STRB_POST_DEC_NONPRIV_IMM_OFFSET", ARM_INSN_STRB_POST_DEC_NONPRIV_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  93   { 0, arm_sem_strb_post_dec_nonpriv_reg_offset, "STRB_POST_DEC_NONPRIV_REG_OFFSET", ARM_INSN_STRB_POST_DEC_NONPRIV_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  94   { 0, arm_sem_strb_post_inc_nonpriv_imm_offset, "STRB_POST_INC_NONPRIV_IMM_OFFSET", ARM_INSN_STRB_POST_INC_NONPRIV_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  95   { 0, arm_sem_strb_post_inc_nonpriv_reg_offset, "STRB_POST_INC_NONPRIV_REG_OFFSET", ARM_INSN_STRB_POST_INC_NONPRIV_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  96   { 0, arm_sem_strb_pre_dec_imm_offset, "STRB_PRE_DEC_IMM_OFFSET", ARM_INSN_STRB_PRE_DEC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  97   { 0, arm_sem_strb_pre_dec_reg_offset, "STRB_PRE_DEC_REG_OFFSET", ARM_INSN_STRB_PRE_DEC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  98   { 0, arm_sem_strb_pre_inc_imm_offset, "STRB_PRE_INC_IMM_OFFSET", ARM_INSN_STRB_PRE_INC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
  99   { 0, arm_sem_strb_pre_inc_reg_offset, "STRB_PRE_INC_REG_OFFSET", ARM_INSN_STRB_PRE_INC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 100   { 0, arm_sem_strb_pre_dec_wb_imm_offset, "STRB_PRE_DEC_WB_IMM_OFFSET", ARM_INSN_STRB_PRE_DEC_WB_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 101   { 0, arm_sem_strb_pre_dec_wb_reg_offset, "STRB_PRE_DEC_WB_REG_OFFSET", ARM_INSN_STRB_PRE_DEC_WB_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 102   { 0, arm_sem_strb_pre_inc_wb_imm_offset, "STRB_PRE_INC_WB_IMM_OFFSET", ARM_INSN_STRB_PRE_INC_WB_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 103   { 0, arm_sem_strb_pre_inc_wb_reg_offset, "STRB_PRE_INC_WB_REG_OFFSET", ARM_INSN_STRB_PRE_INC_WB_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 104   { 0, arm_sem_strh_pre_dec_imm_offset, "STRH_PRE_DEC_IMM_OFFSET", ARM_INSN_STRH_PRE_DEC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 105   { 0, arm_sem_strh_pre_dec_reg_offset, "STRH_PRE_DEC_REG_OFFSET", ARM_INSN_STRH_PRE_DEC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 106   { 0, arm_sem_strh_pre_inc_imm_offset, "STRH_PRE_INC_IMM_OFFSET", ARM_INSN_STRH_PRE_INC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 107   { 0, arm_sem_strh_pre_inc_reg_offset, "STRH_PRE_INC_REG_OFFSET", ARM_INSN_STRH_PRE_INC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 108   { 0, arm_sem_strh_pre_dec_wb_imm_offset, "STRH_PRE_DEC_WB_IMM_OFFSET", ARM_INSN_STRH_PRE_DEC_WB_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 109   { 0, arm_sem_strh_pre_dec_wb_reg_offset, "STRH_PRE_DEC_WB_REG_OFFSET", ARM_INSN_STRH_PRE_DEC_WB_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 110   { 0, arm_sem_strh_pre_inc_wb_imm_offset, "STRH_PRE_INC_WB_IMM_OFFSET", ARM_INSN_STRH_PRE_INC_WB_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 111   { 0, arm_sem_strh_pre_inc_wb_reg_offset, "STRH_PRE_INC_WB_REG_OFFSET", ARM_INSN_STRH_PRE_INC_WB_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 112   { 0, arm_sem_strh_post_dec_imm_offset, "STRH_POST_DEC_IMM_OFFSET", ARM_INSN_STRH_POST_DEC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 113   { 0, arm_sem_strh_post_dec_reg_offset, "STRH_POST_DEC_REG_OFFSET", ARM_INSN_STRH_POST_DEC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 114   { 0, arm_sem_strh_post_inc_imm_offset, "STRH_POST_INC_IMM_OFFSET", ARM_INSN_STRH_POST_INC_IMM_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 115   { 0, arm_sem_strh_post_inc_reg_offset, "STRH_POST_INC_REG_OFFSET", ARM_INSN_STRH_POST_INC_REG_OFFSET, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 116   { 0, arm_sem_ldrsb_pre_dec_imm_offset, "LDRSB_PRE_DEC_IMM_OFFSET", ARM_INSN_LDRSB_PRE_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 117   { 0, arm_sem_ldrsb_pre_dec_reg_offset, "LDRSB_PRE_DEC_REG_OFFSET", ARM_INSN_LDRSB_PRE_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 118   { 0, arm_sem_ldrsb_pre_inc_imm_offset, "LDRSB_PRE_INC_IMM_OFFSET", ARM_INSN_LDRSB_PRE_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 119   { 0, arm_sem_ldrsb_pre_inc_reg_offset, "LDRSB_PRE_INC_REG_OFFSET", ARM_INSN_LDRSB_PRE_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 120   { 0, arm_sem_ldrsb_pre_dec_wb_imm_offset, "LDRSB_PRE_DEC_WB_IMM_OFFSET", ARM_INSN_LDRSB_PRE_DEC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 121   { 0, arm_sem_ldrsb_pre_dec_wb_reg_offset, "LDRSB_PRE_DEC_WB_REG_OFFSET", ARM_INSN_LDRSB_PRE_DEC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 122   { 0, arm_sem_ldrsb_pre_inc_wb_imm_offset, "LDRSB_PRE_INC_WB_IMM_OFFSET", ARM_INSN_LDRSB_PRE_INC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 123   { 0, arm_sem_ldrsb_pre_inc_wb_reg_offset, "LDRSB_PRE_INC_WB_REG_OFFSET", ARM_INSN_LDRSB_PRE_INC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 124   { 0, arm_sem_ldrsb_post_dec_imm_offset, "LDRSB_POST_DEC_IMM_OFFSET", ARM_INSN_LDRSB_POST_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 125   { 0, arm_sem_ldrsb_post_dec_reg_offset, "LDRSB_POST_DEC_REG_OFFSET", ARM_INSN_LDRSB_POST_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 126   { 0, arm_sem_ldrsb_post_inc_imm_offset, "LDRSB_POST_INC_IMM_OFFSET", ARM_INSN_LDRSB_POST_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 127   { 0, arm_sem_ldrsb_post_inc_reg_offset, "LDRSB_POST_INC_REG_OFFSET", ARM_INSN_LDRSB_POST_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 128   { 0, arm_sem_ldrh_pre_dec_imm_offset, "LDRH_PRE_DEC_IMM_OFFSET", ARM_INSN_LDRH_PRE_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 129   { 0, arm_sem_ldrh_pre_dec_reg_offset, "LDRH_PRE_DEC_REG_OFFSET", ARM_INSN_LDRH_PRE_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 130   { 0, arm_sem_ldrh_pre_inc_imm_offset, "LDRH_PRE_INC_IMM_OFFSET", ARM_INSN_LDRH_PRE_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 131   { 0, arm_sem_ldrh_pre_inc_reg_offset, "LDRH_PRE_INC_REG_OFFSET", ARM_INSN_LDRH_PRE_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 132   { 0, arm_sem_ldrh_pre_dec_wb_imm_offset, "LDRH_PRE_DEC_WB_IMM_OFFSET", ARM_INSN_LDRH_PRE_DEC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 133   { 0, arm_sem_ldrh_pre_dec_wb_reg_offset, "LDRH_PRE_DEC_WB_REG_OFFSET", ARM_INSN_LDRH_PRE_DEC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 134   { 0, arm_sem_ldrh_pre_inc_wb_imm_offset, "LDRH_PRE_INC_WB_IMM_OFFSET", ARM_INSN_LDRH_PRE_INC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 135   { 0, arm_sem_ldrh_pre_inc_wb_reg_offset, "LDRH_PRE_INC_WB_REG_OFFSET", ARM_INSN_LDRH_PRE_INC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 136   { 0, arm_sem_ldrh_post_dec_imm_offset, "LDRH_POST_DEC_IMM_OFFSET", ARM_INSN_LDRH_POST_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 137   { 0, arm_sem_ldrh_post_dec_reg_offset, "LDRH_POST_DEC_REG_OFFSET", ARM_INSN_LDRH_POST_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 138   { 0, arm_sem_ldrh_post_inc_imm_offset, "LDRH_POST_INC_IMM_OFFSET", ARM_INSN_LDRH_POST_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 139   { 0, arm_sem_ldrh_post_inc_reg_offset, "LDRH_POST_INC_REG_OFFSET", ARM_INSN_LDRH_POST_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 140   { 0, arm_sem_ldrsh_pre_dec_imm_offset, "LDRSH_PRE_DEC_IMM_OFFSET", ARM_INSN_LDRSH_PRE_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 141   { 0, arm_sem_ldrsh_pre_dec_reg_offset, "LDRSH_PRE_DEC_REG_OFFSET", ARM_INSN_LDRSH_PRE_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 142   { 0, arm_sem_ldrsh_pre_inc_imm_offset, "LDRSH_PRE_INC_IMM_OFFSET", ARM_INSN_LDRSH_PRE_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 143   { 0, arm_sem_ldrsh_pre_inc_reg_offset, "LDRSH_PRE_INC_REG_OFFSET", ARM_INSN_LDRSH_PRE_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 144   { 0, arm_sem_ldrsh_pre_dec_wb_imm_offset, "LDRSH_PRE_DEC_WB_IMM_OFFSET", ARM_INSN_LDRSH_PRE_DEC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 145   { 0, arm_sem_ldrsh_pre_dec_wb_reg_offset, "LDRSH_PRE_DEC_WB_REG_OFFSET", ARM_INSN_LDRSH_PRE_DEC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 146   { 0, arm_sem_ldrsh_pre_inc_wb_imm_offset, "LDRSH_PRE_INC_WB_IMM_OFFSET", ARM_INSN_LDRSH_PRE_INC_WB_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 147   { 0, arm_sem_ldrsh_pre_inc_wb_reg_offset, "LDRSH_PRE_INC_WB_REG_OFFSET", ARM_INSN_LDRSH_PRE_INC_WB_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 148   { 0, arm_sem_ldrsh_post_dec_imm_offset, "LDRSH_POST_DEC_IMM_OFFSET", ARM_INSN_LDRSH_POST_DEC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 149   { 0, arm_sem_ldrsh_post_dec_reg_offset, "LDRSH_POST_DEC_REG_OFFSET", ARM_INSN_LDRSH_POST_DEC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 150   { 0, arm_sem_ldrsh_post_inc_imm_offset, "LDRSH_POST_INC_IMM_OFFSET", ARM_INSN_LDRSH_POST_INC_IMM_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 151   { 0, arm_sem_ldrsh_post_inc_reg_offset, "LDRSH_POST_INC_REG_OFFSET", ARM_INSN_LDRSH_POST_INC_REG_OFFSET, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 152   { 0, arm_sem_mul, "MUL", ARM_INSN_MUL, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 153   { 0, arm_sem_mla, "MLA", ARM_INSN_MLA, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 154   { 0, arm_sem_umull, "UMULL", ARM_INSN_UMULL, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 155   { 0, arm_sem_umlal, "UMLAL", ARM_INSN_UMLAL, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 156   { 0, arm_sem_smull, "SMULL", ARM_INSN_SMULL, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 157   { 0, arm_sem_smlal, "SMLAL", ARM_INSN_SMLAL, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 158   { 0, arm_sem_swp, "SWP", ARM_INSN_SWP, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 159   { 0, arm_sem_swpb, "SWPB", ARM_INSN_SWPB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 160   { 0, arm_sem_swi, "SWI", ARM_INSN_SWI, { 0|(1<<CGEN_INSN_UNCOND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 161   { 0, arm_sem_and_reg_imm_shift, "AND_REG_IMM_SHIFT", ARM_INSN_AND_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 162   { 0, arm_sem_and_reg_reg_shift, "AND_REG_REG_SHIFT", ARM_INSN_AND_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 163   { 0, arm_sem_and_imm, "AND_IMM", ARM_INSN_AND_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 164   { 0, arm_sem_orr_reg_imm_shift, "ORR_REG_IMM_SHIFT", ARM_INSN_ORR_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 165   { 0, arm_sem_orr_reg_reg_shift, "ORR_REG_REG_SHIFT", ARM_INSN_ORR_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 166   { 0, arm_sem_orr_imm, "ORR_IMM", ARM_INSN_ORR_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 167   { 0, arm_sem_eor_reg_imm_shift, "EOR_REG_IMM_SHIFT", ARM_INSN_EOR_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 168   { 0, arm_sem_eor_reg_reg_shift, "EOR_REG_REG_SHIFT", ARM_INSN_EOR_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 169   { 0, arm_sem_eor_imm, "EOR_IMM", ARM_INSN_EOR_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 170   { 0, arm_sem_mov_reg_imm_shift, "MOV_REG_IMM_SHIFT", ARM_INSN_MOV_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 171   { 0, arm_sem_mov_reg_reg_shift, "MOV_REG_REG_SHIFT", ARM_INSN_MOV_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 172   { 0, arm_sem_mov_imm, "MOV_IMM", ARM_INSN_MOV_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 173   { 0, arm_sem_bic_reg_imm_shift, "BIC_REG_IMM_SHIFT", ARM_INSN_BIC_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 174   { 0, arm_sem_bic_reg_reg_shift, "BIC_REG_REG_SHIFT", ARM_INSN_BIC_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 175   { 0, arm_sem_bic_imm, "BIC_IMM", ARM_INSN_BIC_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 176   { 0, arm_sem_mvn_reg_imm_shift, "MVN_REG_IMM_SHIFT", ARM_INSN_MVN_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 177   { 0, arm_sem_mvn_reg_reg_shift, "MVN_REG_REG_SHIFT", ARM_INSN_MVN_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 178   { 0, arm_sem_mvn_imm, "MVN_IMM", ARM_INSN_MVN_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 179   { 0, arm_sem_add_reg_imm_shift, "ADD_REG_IMM_SHIFT", ARM_INSN_ADD_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 180   { 0, arm_sem_add_reg_reg_shift, "ADD_REG_REG_SHIFT", ARM_INSN_ADD_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 181   { 0, arm_sem_add_imm, "ADD_IMM", ARM_INSN_ADD_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 182   { 0, arm_sem_adc_reg_imm_shift, "ADC_REG_IMM_SHIFT", ARM_INSN_ADC_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 183   { 0, arm_sem_adc_reg_reg_shift, "ADC_REG_REG_SHIFT", ARM_INSN_ADC_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 184   { 0, arm_sem_adc_imm, "ADC_IMM", ARM_INSN_ADC_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 185   { 0, arm_sem_sub_reg_imm_shift, "SUB_REG_IMM_SHIFT", ARM_INSN_SUB_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 186   { 0, arm_sem_sub_reg_reg_shift, "SUB_REG_REG_SHIFT", ARM_INSN_SUB_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 187   { 0, arm_sem_sub_imm, "SUB_IMM", ARM_INSN_SUB_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 188   { 0, arm_sem_sbc_reg_imm_shift, "SBC_REG_IMM_SHIFT", ARM_INSN_SBC_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 189   { 0, arm_sem_sbc_reg_reg_shift, "SBC_REG_REG_SHIFT", ARM_INSN_SBC_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 190   { 0, arm_sem_sbc_imm, "SBC_IMM", ARM_INSN_SBC_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 191   { 0, arm_sem_rsb_reg_imm_shift, "RSB_REG_IMM_SHIFT", ARM_INSN_RSB_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 192   { 0, arm_sem_rsb_reg_reg_shift, "RSB_REG_REG_SHIFT", ARM_INSN_RSB_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 193   { 0, arm_sem_rsb_imm, "RSB_IMM", ARM_INSN_RSB_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 194   { 0, arm_sem_rsc_reg_imm_shift, "RSC_REG_IMM_SHIFT", ARM_INSN_RSC_REG_IMM_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 195   { 0, arm_sem_rsc_reg_reg_shift, "RSC_REG_REG_SHIFT", ARM_INSN_RSC_REG_REG_SHIFT, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 196   { 0, arm_sem_rsc_imm, "RSC_IMM", ARM_INSN_RSC_IMM, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 197   { 0, arm_sem_tst_reg_imm_shift, "TST_REG_IMM_SHIFT", ARM_INSN_TST_REG_IMM_SHIFT, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 198   { 0, arm_sem_tst_reg_reg_shift, "TST_REG_REG_SHIFT", ARM_INSN_TST_REG_REG_SHIFT, { 0, (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 199   { 0, arm_sem_tst_imm, "TST_IMM", ARM_INSN_TST_IMM, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 200   { 0, arm_sem_teq_reg_imm_shift, "TEQ_REG_IMM_SHIFT", ARM_INSN_TEQ_REG_IMM_SHIFT, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 201   { 0, arm_sem_teq_reg_reg_shift, "TEQ_REG_REG_SHIFT", ARM_INSN_TEQ_REG_REG_SHIFT, { 0, (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 202   { 0, arm_sem_teq_imm, "TEQ_IMM", ARM_INSN_TEQ_IMM, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 203   { 0, arm_sem_cmp_reg_imm_shift, "CMP_REG_IMM_SHIFT", ARM_INSN_CMP_REG_IMM_SHIFT, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 204   { 0, arm_sem_cmp_reg_reg_shift, "CMP_REG_REG_SHIFT", ARM_INSN_CMP_REG_REG_SHIFT, { 0, (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 205   { 0, arm_sem_cmp_imm, "CMP_IMM", ARM_INSN_CMP_IMM, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 206   { 0, arm_sem_cmn_reg_imm_shift, "CMN_REG_IMM_SHIFT", ARM_INSN_CMN_REG_IMM_SHIFT, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 207   { 0, arm_sem_cmn_reg_reg_shift, "CMN_REG_REG_SHIFT", ARM_INSN_CMN_REG_REG_SHIFT, { 0, (1<<MACH_BASE), { 1, "\x80" }, 12 } },
 208   { 0, arm_sem_cmn_imm, "CMN_IMM", ARM_INSN_CMN_IMM, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 209   { 0, arm_sem_ldmda, "LDMDA", ARM_INSN_LDMDA, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 210   { 0, arm_sem_ldmda_sw, "LDMDA_SW", ARM_INSN_LDMDA_SW, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 211   { 0, arm_sem_ldmda_wb, "LDMDA_WB", ARM_INSN_LDMDA_WB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 212   { 0, arm_sem_ldmda_sw_wb, "LDMDA_SW_WB", ARM_INSN_LDMDA_SW_WB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 213   { 0, arm_sem_ldmib, "LDMIB", ARM_INSN_LDMIB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 214   { 0, arm_sem_ldmib_sw, "LDMIB_SW", ARM_INSN_LDMIB_SW, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 215   { 0, arm_sem_ldmib_wb, "LDMIB_WB", ARM_INSN_LDMIB_WB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 216   { 0, arm_sem_ldmib_sw_wb, "LDMIB_SW_WB", ARM_INSN_LDMIB_SW_WB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 217   { 0, arm_sem_ldmia, "LDMIA", ARM_INSN_LDMIA, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 218   { 0, arm_sem_ldmia_sw, "LDMIA_SW", ARM_INSN_LDMIA_SW, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 219   { 0, arm_sem_ldmia_wb, "LDMIA_WB", ARM_INSN_LDMIA_WB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 220   { 0, arm_sem_ldmia_sw_wb, "LDMIA_SW_WB", ARM_INSN_LDMIA_SW_WB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 221   { 0, arm_sem_ldmdb, "LDMDB", ARM_INSN_LDMDB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 222   { 0, arm_sem_ldmdb_sw, "LDMDB_SW", ARM_INSN_LDMDB_SW, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 223   { 0, arm_sem_ldmdb_wb, "LDMDB_WB", ARM_INSN_LDMDB_WB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 224   { 0, arm_sem_ldmdb_sw_wb, "LDMDB_SW_WB", ARM_INSN_LDMDB_SW_WB, { 0|(1<<CGEN_INSN_COND_CTI), (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 225   { 0, arm_sem_stmdb, "STMDB", ARM_INSN_STMDB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 226   { 0, arm_sem_stmdb_sw, "STMDB_SW", ARM_INSN_STMDB_SW, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 227   { 0, arm_sem_stmdb_wb, "STMDB_WB", ARM_INSN_STMDB_WB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 228   { 0, arm_sem_stmdb_sw_wb, "STMDB_SW_WB", ARM_INSN_STMDB_SW_WB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 229   { 0, arm_sem_stmib, "STMIB", ARM_INSN_STMIB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 230   { 0, arm_sem_stmib_sw, "STMIB_SW", ARM_INSN_STMIB_SW, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 231   { 0, arm_sem_stmib_wb, "STMIB_WB", ARM_INSN_STMIB_WB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 232   { 0, arm_sem_stmib_sw_wb, "STMIB_SW_WB", ARM_INSN_STMIB_SW_WB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 233   { 0, arm_sem_stmia, "STMIA", ARM_INSN_STMIA, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 234   { 0, arm_sem_stmia_sw, "STMIA_SW", ARM_INSN_STMIA_SW, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 235   { 0, arm_sem_stmia_wb, "STMIA_WB", ARM_INSN_STMIA_WB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 236   { 0, arm_sem_stmia_sw_wb, "STMIA_SW_WB", ARM_INSN_STMIA_SW_WB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 237   { 0, arm_sem_stmda, "STMDA", ARM_INSN_STMDA, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 238   { 0, arm_sem_stmda_sw, "STMDA_SW", ARM_INSN_STMDA_SW, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 239   { 0, arm_sem_stmda_wb, "STMDA_WB", ARM_INSN_STMDA_WB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 240   { 0, arm_sem_stmda_sw_wb, "STMDA_SW_WB", ARM_INSN_STMDA_SW_WB, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 241   { 0, arm_sem_mrs_c, "MRS_C", ARM_INSN_MRS_C, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 242   { 0, arm_sem_mrs_s, "MRS_S", ARM_INSN_MRS_S, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 243   { 0, arm_sem_msr_c, "MSR_C", ARM_INSN_MSR_C, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 244   { 0, arm_sem_msr_s, "MSR_S", ARM_INSN_MSR_S, { 0, (1<<MACH_BASE), { 1, "\x80" }, 8 } },
 245
 246 };
 247
 248 // Given a canonical virtual insn id, return the target specific one.
 249
 250 arm_insn_type
 251 arm_idesc::lookup_virtual (virtual_insn_type vit)
 252 {
 253   switch (vit)
 254     {
 255       case VIRTUAL_INSN_INVALID: return ARM_INSN_X_INVALID;
 256       case VIRTUAL_INSN_BEGIN: return ARM_INSN_X_BEGIN;
 257       case VIRTUAL_INSN_CHAIN: return ARM_INSN_X_CHAIN;
 258       case VIRTUAL_INSN_CTI_CHAIN: return ARM_INSN_X_CTI_CHAIN;
 259       case VIRTUAL_INSN_BEFORE: return ARM_INSN_X_BEFORE;
 260       case VIRTUAL_INSN_AFTER: return ARM_INSN_X_AFTER;
 261       case VIRTUAL_INSN_COND: return ARM_INSN_X_COND;
 262     }
 263   abort ();
 264 }
 265
 266
 267 // Declare extractor functions
 268
 269 static void
 270 arm_extract_sfmt_empty (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 271 static void
 272 arm_extract_sfmt_b (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 273 static void
 274 arm_extract_sfmt_bl (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 275 static void
 276 arm_extract_sfmt_bx (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 277 static void
 278 arm_extract_sfmt_ldr_post_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 279 static void
 280 arm_extract_sfmt_ldr_post_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 281 static void
 282 arm_extract_sfmt_ldr_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 283 static void
 284 arm_extract_sfmt_ldr_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 285 static void
 286 arm_extract_sfmt_ldrb_post_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 287 static void
 288 arm_extract_sfmt_ldrb_post_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 289 static void
 290 arm_extract_sfmt_ldrb_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 291 static void
 292 arm_extract_sfmt_ldrb_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 293 static void
 294 arm_extract_sfmt_str_post_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 295 static void
 296 arm_extract_sfmt_str_post_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 297 static void
 298 arm_extract_sfmt_str_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 299 static void
 300 arm_extract_sfmt_str_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 301 static void
 302 arm_extract_sfmt_strb_post_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 303 static void
 304 arm_extract_sfmt_strb_post_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 305 static void
 306 arm_extract_sfmt_strb_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 307 static void
 308 arm_extract_sfmt_strb_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 309 static void
 310 arm_extract_sfmt_strh_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 311 static void
 312 arm_extract_sfmt_strh_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 313 static void
 314 arm_extract_sfmt_strh_pre_dec_wb_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 315 static void
 316 arm_extract_sfmt_strh_pre_dec_wb_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 317 static void
 318 arm_extract_sfmt_ldrsb_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 319 static void
 320 arm_extract_sfmt_ldrsb_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 321 static void
 322 arm_extract_sfmt_ldrsb_pre_dec_wb_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 323 static void
 324 arm_extract_sfmt_ldrsb_pre_dec_wb_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 325 static void
 326 arm_extract_sfmt_ldrh_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 327 static void
 328 arm_extract_sfmt_ldrh_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 329 static void
 330 arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 331 static void
 332 arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 333 static void
 334 arm_extract_sfmt_mul (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 335 static void
 336 arm_extract_sfmt_mla (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 337 static void
 338 arm_extract_sfmt_umull (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 339 static void
 340 arm_extract_sfmt_umlal (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 341 static void
 342 arm_extract_sfmt_swp (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 343 static void
 344 arm_extract_sfmt_swpb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 345 static void
 346 arm_extract_sfmt_swi (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 347 static void
 348 arm_extract_sfmt_and_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 349 static void
 350 arm_extract_sfmt_and_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 351 static void
 352 arm_extract_sfmt_and_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 353 static void
 354 arm_extract_sfmt_mov_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 355 static void
 356 arm_extract_sfmt_mov_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 357 static void
 358 arm_extract_sfmt_mov_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 359 static void
 360 arm_extract_sfmt_add_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 361 static void
 362 arm_extract_sfmt_add_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 363 static void
 364 arm_extract_sfmt_add_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 365 static void
 366 arm_extract_sfmt_adc_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 367 static void
 368 arm_extract_sfmt_adc_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 369 static void
 370 arm_extract_sfmt_adc_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 371 static void
 372 arm_extract_sfmt_tst_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 373 static void
 374 arm_extract_sfmt_tst_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 375 static void
 376 arm_extract_sfmt_tst_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 377 static void
 378 arm_extract_sfmt_cmp_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 379 static void
 380 arm_extract_sfmt_cmp_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 381 static void
 382 arm_extract_sfmt_cmp_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 383 static void
 384 arm_extract_sfmt_ldmda (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 385 static void
 386 arm_extract_sfmt_ldmda_sw (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 387 static void
 388 arm_extract_sfmt_ldmda_wb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 389 static void
 390 arm_extract_sfmt_ldmda_sw_wb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 391 static void
 392 arm_extract_sfmt_stmdb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 393 static void
 394 arm_extract_sfmt_stmdb_sw (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 395 static void
 396 arm_extract_sfmt_stmdb_wb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 397 static void
 398 arm_extract_sfmt_stmdb_sw_wb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 399 static void
 400 arm_extract_sfmt_mrs_c (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 401 static void
 402 arm_extract_sfmt_mrs_s (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 403 static void
 404 arm_extract_sfmt_msr_c (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 405 static void
 406 arm_extract_sfmt_msr_s (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn);
 407
 408 // Fetch & decode instruction
 409 void
 410 arm_scache::decode (arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn)
 411 {
 412   /* Result of decoder.  */
 413   ARM_INSN_TYPE itype;
 414
 415   {
 416     arm_insn_word insn = base_insn;
 417
 418     {
 419       unsigned int val = (((insn >> 21) & (127 << 0)));
 420       switch (val)
 421       {
 422       case 0 :
 423         {
 424           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 425           switch (val)
 426           {
 427           case 0 : /* fall through */
 428           case 2 : /* fall through */
 429           case 4 : /* fall through */
 430           case 6 : /* fall through */
 431           case 8 : /* fall through */
 432           case 10 : /* fall through */
 433           case 12 : /* fall through */
 434           case 14 : /* fall through */
 435           case 16 : /* fall through */
 436           case 18 : /* fall through */
 437           case 20 : /* fall through */
 438           case 22 : /* fall through */
 439           case 24 : /* fall through */
 440           case 26 : /* fall through */
 441           case 28 : /* fall through */
 442           case 30 : itype = ARM_INSN_AND_REG_IMM_SHIFT; arm_extract_sfmt_and_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 443           case 1 : /* fall through */
 444           case 3 : /* fall through */
 445           case 5 : /* fall through */
 446           case 7 : /* fall through */
 447           case 17 : /* fall through */
 448           case 19 : /* fall through */
 449           case 21 : /* fall through */
 450           case 23 : itype = ARM_INSN_AND_REG_REG_SHIFT; arm_extract_sfmt_and_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 451           case 9 : /* fall through */
 452           case 25 : itype = ARM_INSN_MUL; arm_extract_sfmt_mul (this, current_cpu, pc, base_insn, entire_insn); goto done;
 453           case 11 :
 454             if ((entire_insn & 0xff00ff0) == 0xb0)
 455               { itype = ARM_INSN_STRH_POST_DEC_REG_OFFSET; arm_extract_sfmt_strh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 456             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 457           case 27 :
 458             if ((entire_insn & 0xff00ff0) == 0x1000b0)
 459               { itype = ARM_INSN_LDRH_POST_DEC_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 460             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 461           case 29 :
 462             if ((entire_insn & 0xff00ff0) == 0x1000d0)
 463               { itype = ARM_INSN_LDRSB_POST_DEC_REG_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 464             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 465           case 31 :
 466             if ((entire_insn & 0xff00ff0) == 0x1000f0)
 467               { itype = ARM_INSN_LDRSH_POST_DEC_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 468             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 469           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 470           }
 471         }
 472       case 1 :
 473         {
 474           unsigned int val = (((insn >> 6) & (1 << 1)) | ((insn >> 4) & (1 << 0)));
 475           switch (val)
 476           {
 477           case 0 : /* fall through */
 478           case 2 : itype = ARM_INSN_EOR_REG_IMM_SHIFT; arm_extract_sfmt_and_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 479           case 1 : itype = ARM_INSN_EOR_REG_REG_SHIFT; arm_extract_sfmt_and_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 480           case 3 :
 481             if ((entire_insn & 0xfe000f0) == 0x200090)
 482               { itype = ARM_INSN_MLA; arm_extract_sfmt_mla (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 483             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 484           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 485           }
 486         }
 487       case 2 :
 488         {
 489           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 490           switch (val)
 491           {
 492           case 0 : /* fall through */
 493           case 2 : /* fall through */
 494           case 4 : /* fall through */
 495           case 6 : /* fall through */
 496           case 8 : /* fall through */
 497           case 10 : /* fall through */
 498           case 12 : /* fall through */
 499           case 14 : /* fall through */
 500           case 16 : /* fall through */
 501           case 18 : /* fall through */
 502           case 20 : /* fall through */
 503           case 22 : /* fall through */
 504           case 24 : /* fall through */
 505           case 26 : /* fall through */
 506           case 28 : /* fall through */
 507           case 30 : itype = ARM_INSN_SUB_REG_IMM_SHIFT; arm_extract_sfmt_add_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 508           case 1 : /* fall through */
 509           case 3 : /* fall through */
 510           case 5 : /* fall through */
 511           case 7 : /* fall through */
 512           case 17 : /* fall through */
 513           case 19 : /* fall through */
 514           case 21 : /* fall through */
 515           case 23 : itype = ARM_INSN_SUB_REG_REG_SHIFT; arm_extract_sfmt_add_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 516           case 11 : itype = ARM_INSN_STRH_POST_DEC_IMM_OFFSET; arm_extract_sfmt_strh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 517           case 27 : itype = ARM_INSN_LDRH_POST_DEC_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 518           case 29 : itype = ARM_INSN_LDRSB_POST_DEC_IMM_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 519           case 31 : itype = ARM_INSN_LDRSH_POST_DEC_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 520           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 521           }
 522         }
 523       case 3 :
 524         {
 525           unsigned int val = (((insn >> 4) & (1 << 0)));
 526           switch (val)
 527           {
 528           case 0 : itype = ARM_INSN_RSB_REG_IMM_SHIFT; arm_extract_sfmt_add_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 529           case 1 :
 530             if ((entire_insn & 0xfe00090) == 0x600010)
 531               { itype = ARM_INSN_RSB_REG_REG_SHIFT; arm_extract_sfmt_add_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 532             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 533           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 534           }
 535         }
 536       case 4 :
 537         {
 538           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 539           switch (val)
 540           {
 541           case 0 : /* fall through */
 542           case 2 : /* fall through */
 543           case 4 : /* fall through */
 544           case 6 : /* fall through */
 545           case 8 : /* fall through */
 546           case 10 : /* fall through */
 547           case 12 : /* fall through */
 548           case 14 : /* fall through */
 549           case 16 : /* fall through */
 550           case 18 : /* fall through */
 551           case 20 : /* fall through */
 552           case 22 : /* fall through */
 553           case 24 : /* fall through */
 554           case 26 : /* fall through */
 555           case 28 : /* fall through */
 556           case 30 : itype = ARM_INSN_ADD_REG_IMM_SHIFT; arm_extract_sfmt_add_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 557           case 1 : /* fall through */
 558           case 3 : /* fall through */
 559           case 5 : /* fall through */
 560           case 7 : /* fall through */
 561           case 17 : /* fall through */
 562           case 19 : /* fall through */
 563           case 21 : /* fall through */
 564           case 23 : itype = ARM_INSN_ADD_REG_REG_SHIFT; arm_extract_sfmt_add_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 565           case 9 : /* fall through */
 566           case 25 : itype = ARM_INSN_UMULL; arm_extract_sfmt_umull (this, current_cpu, pc, base_insn, entire_insn); goto done;
 567           case 11 :
 568             if ((entire_insn & 0xff00ff0) == 0x8000b0)
 569               { itype = ARM_INSN_STRH_POST_INC_REG_OFFSET; arm_extract_sfmt_strh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 570             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 571           case 27 :
 572             if ((entire_insn & 0xff00ff0) == 0x9000b0)
 573               { itype = ARM_INSN_LDRH_POST_INC_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 574             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 575           case 29 :
 576             if ((entire_insn & 0xff00ff0) == 0x9000d0)
 577               { itype = ARM_INSN_LDRSB_POST_INC_REG_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 578             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 579           case 31 :
 580             if ((entire_insn & 0xff00ff0) == 0x9000f0)
 581               { itype = ARM_INSN_LDRSH_POST_INC_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 582             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 583           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 584           }
 585         }
 586       case 5 :
 587         {
 588           unsigned int val = (((insn >> 6) & (1 << 1)) | ((insn >> 4) & (1 << 0)));
 589           switch (val)
 590           {
 591           case 0 : /* fall through */
 592           case 2 : itype = ARM_INSN_ADC_REG_IMM_SHIFT; arm_extract_sfmt_adc_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 593           case 1 : itype = ARM_INSN_ADC_REG_REG_SHIFT; arm_extract_sfmt_adc_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 594           case 3 :
 595             if ((entire_insn & 0xfe000f0) == 0xa00090)
 596               { itype = ARM_INSN_UMLAL; arm_extract_sfmt_umlal (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 597             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 598           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 599           }
 600         }
 601       case 6 :
 602         {
 603           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 604           switch (val)
 605           {
 606           case 0 : /* fall through */
 607           case 2 : /* fall through */
 608           case 4 : /* fall through */
 609           case 6 : /* fall through */
 610           case 8 : /* fall through */
 611           case 10 : /* fall through */
 612           case 12 : /* fall through */
 613           case 14 : /* fall through */
 614           case 16 : /* fall through */
 615           case 18 : /* fall through */
 616           case 20 : /* fall through */
 617           case 22 : /* fall through */
 618           case 24 : /* fall through */
 619           case 26 : /* fall through */
 620           case 28 : /* fall through */
 621           case 30 : itype = ARM_INSN_SBC_REG_IMM_SHIFT; arm_extract_sfmt_adc_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 622           case 1 : /* fall through */
 623           case 3 : /* fall through */
 624           case 5 : /* fall through */
 625           case 7 : /* fall through */
 626           case 17 : /* fall through */
 627           case 19 : /* fall through */
 628           case 21 : /* fall through */
 629           case 23 : itype = ARM_INSN_SBC_REG_REG_SHIFT; arm_extract_sfmt_adc_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 630           case 9 : /* fall through */
 631           case 25 : itype = ARM_INSN_SMULL; arm_extract_sfmt_umull (this, current_cpu, pc, base_insn, entire_insn); goto done;
 632           case 11 : itype = ARM_INSN_STRH_POST_INC_IMM_OFFSET; arm_extract_sfmt_strh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 633           case 27 : itype = ARM_INSN_LDRH_POST_INC_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 634           case 29 : itype = ARM_INSN_LDRSB_POST_INC_IMM_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 635           case 31 : itype = ARM_INSN_LDRSH_POST_INC_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 636           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 637           }
 638         }
 639       case 7 :
 640         {
 641           unsigned int val = (((insn >> 6) & (1 << 1)) | ((insn >> 4) & (1 << 0)));
 642           switch (val)
 643           {
 644           case 0 : /* fall through */
 645           case 2 : itype = ARM_INSN_RSC_REG_IMM_SHIFT; arm_extract_sfmt_adc_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 646           case 1 : itype = ARM_INSN_RSC_REG_REG_SHIFT; arm_extract_sfmt_adc_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 647           case 3 :
 648             if ((entire_insn & 0xfe000f0) == 0xe00090)
 649               { itype = ARM_INSN_SMLAL; arm_extract_sfmt_umlal (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 650             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 651           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 652           }
 653         }
 654       case 8 :
 655         {
 656           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 657           switch (val)
 658           {
 659           case 0 :
 660             if ((entire_insn & 0xfff0fff) == 0x10f0000)
 661               { itype = ARM_INSN_MRS_C; arm_extract_sfmt_mrs_c (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 662             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 663           case 9 :
 664             if ((entire_insn & 0xff00ff0) == 0x1000090)
 665               { itype = ARM_INSN_SWP; arm_extract_sfmt_swp (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 666             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 667           case 11 :
 668             if ((entire_insn & 0xff00ff0) == 0x10000b0)
 669               { itype = ARM_INSN_STRH_PRE_DEC_REG_OFFSET; arm_extract_sfmt_strh_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 670             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 671           case 16 : /* fall through */
 672           case 18 : /* fall through */
 673           case 20 : /* fall through */
 674           case 22 : /* fall through */
 675           case 24 : /* fall through */
 676           case 26 : /* fall through */
 677           case 28 : /* fall through */
 678           case 30 : itype = ARM_INSN_TST_REG_IMM_SHIFT; arm_extract_sfmt_tst_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 679           case 17 : /* fall through */
 680           case 19 : /* fall through */
 681           case 21 : /* fall through */
 682           case 23 : itype = ARM_INSN_TST_REG_REG_SHIFT; arm_extract_sfmt_tst_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 683           case 27 :
 684             if ((entire_insn & 0xff00ff0) == 0x11000b0)
 685               { itype = ARM_INSN_LDRH_PRE_DEC_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 686             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 687           case 29 :
 688             if ((entire_insn & 0xff00ff0) == 0x11000d0)
 689               { itype = ARM_INSN_LDRSB_PRE_DEC_REG_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 690             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 691           case 31 :
 692             if ((entire_insn & 0xff00ff0) == 0x11000f0)
 693               { itype = ARM_INSN_LDRSH_PRE_DEC_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 694             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 695           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 696           }
 697         }
 698       case 9 :
 699         {
 700           unsigned int val = (((insn >> 14) & (1 << 6)) | ((insn >> 4) & (63 << 0)));
 701           switch (val)
 702           {
 703           case 0 :
 704             if ((entire_insn & 0xffffff0) == 0x129f000)
 705               { itype = ARM_INSN_MSR_C; arm_extract_sfmt_msr_c (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 706             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 707           case 11 :
 708             if ((entire_insn & 0xff00ff0) == 0x12000b0)
 709               { itype = ARM_INSN_STRH_PRE_DEC_WB_REG_OFFSET; arm_extract_sfmt_strh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 710             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 711           case 49 :
 712             if ((entire_insn & 0xffffff0) == 0x12fff10)
 713               { itype = ARM_INSN_BX; arm_extract_sfmt_bx (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 714             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 715           case 64 : /* fall through */
 716           case 66 : /* fall through */
 717           case 68 : /* fall through */
 718           case 70 : /* fall through */
 719           case 72 : /* fall through */
 720           case 74 : /* fall through */
 721           case 76 : /* fall through */
 722           case 78 : /* fall through */
 723           case 80 : /* fall through */
 724           case 82 : /* fall through */
 725           case 84 : /* fall through */
 726           case 86 : /* fall through */
 727           case 88 : /* fall through */
 728           case 90 : /* fall through */
 729           case 92 : /* fall through */
 730           case 94 : /* fall through */
 731           case 96 : /* fall through */
 732           case 98 : /* fall through */
 733           case 100 : /* fall through */
 734           case 102 : /* fall through */
 735           case 104 : /* fall through */
 736           case 106 : /* fall through */
 737           case 108 : /* fall through */
 738           case 110 : /* fall through */
 739           case 112 : /* fall through */
 740           case 114 : /* fall through */
 741           case 116 : /* fall through */
 742           case 118 : /* fall through */
 743           case 120 : /* fall through */
 744           case 122 : /* fall through */
 745           case 124 : /* fall through */
 746           case 126 : itype = ARM_INSN_TEQ_REG_IMM_SHIFT; arm_extract_sfmt_tst_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 747           case 65 : /* fall through */
 748           case 67 : /* fall through */
 749           case 69 : /* fall through */
 750           case 71 : /* fall through */
 751           case 81 : /* fall through */
 752           case 83 : /* fall through */
 753           case 85 : /* fall through */
 754           case 87 : /* fall through */
 755           case 97 : /* fall through */
 756           case 99 : /* fall through */
 757           case 101 : /* fall through */
 758           case 103 : /* fall through */
 759           case 113 : /* fall through */
 760           case 115 : /* fall through */
 761           case 117 : /* fall through */
 762           case 119 : itype = ARM_INSN_TEQ_REG_REG_SHIFT; arm_extract_sfmt_tst_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 763           case 75 :
 764             if ((entire_insn & 0xff00ff0) == 0x13000b0)
 765               { itype = ARM_INSN_LDRH_PRE_DEC_WB_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 766             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 767           case 77 :
 768             if ((entire_insn & 0xff00ff0) == 0x13000d0)
 769               { itype = ARM_INSN_LDRSB_PRE_DEC_WB_REG_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 770             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 771           case 79 :
 772             if ((entire_insn & 0xff00ff0) == 0x13000f0)
 773               { itype = ARM_INSN_LDRSH_PRE_DEC_WB_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 774             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 775           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 776           }
 777         }
 778       case 10 :
 779         {
 780           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 781           switch (val)
 782           {
 783           case 0 :
 784             if ((entire_insn & 0xfff0fff) == 0x14f0000)
 785               { itype = ARM_INSN_MRS_S; arm_extract_sfmt_mrs_s (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 786             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 787           case 9 :
 788             if ((entire_insn & 0xff00ff0) == 0x1400090)
 789               { itype = ARM_INSN_SWPB; arm_extract_sfmt_swpb (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 790             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 791           case 11 : itype = ARM_INSN_STRH_PRE_DEC_IMM_OFFSET; arm_extract_sfmt_strh_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 792           case 16 : /* fall through */
 793           case 18 : /* fall through */
 794           case 20 : /* fall through */
 795           case 22 : /* fall through */
 796           case 24 : /* fall through */
 797           case 26 : /* fall through */
 798           case 28 : /* fall through */
 799           case 30 : itype = ARM_INSN_CMP_REG_IMM_SHIFT; arm_extract_sfmt_cmp_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 800           case 17 : /* fall through */
 801           case 19 : /* fall through */
 802           case 21 : /* fall through */
 803           case 23 : itype = ARM_INSN_CMP_REG_REG_SHIFT; arm_extract_sfmt_cmp_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 804           case 27 : itype = ARM_INSN_LDRH_PRE_DEC_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 805           case 29 : itype = ARM_INSN_LDRSB_PRE_DEC_IMM_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 806           case 31 : itype = ARM_INSN_LDRSH_PRE_DEC_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 807           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 808           }
 809         }
 810       case 11 :
 811         {
 812           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 813           switch (val)
 814           {
 815           case 0 :
 816             if ((entire_insn & 0xffffff0) == 0x169f000)
 817               { itype = ARM_INSN_MSR_S; arm_extract_sfmt_msr_s (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 818             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 819           case 11 : itype = ARM_INSN_STRH_PRE_DEC_WB_IMM_OFFSET; arm_extract_sfmt_strh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 820           case 16 : /* fall through */
 821           case 18 : /* fall through */
 822           case 20 : /* fall through */
 823           case 22 : /* fall through */
 824           case 24 : /* fall through */
 825           case 26 : /* fall through */
 826           case 28 : /* fall through */
 827           case 30 : itype = ARM_INSN_CMN_REG_IMM_SHIFT; arm_extract_sfmt_cmp_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 828           case 17 : /* fall through */
 829           case 19 : /* fall through */
 830           case 21 : /* fall through */
 831           case 23 : itype = ARM_INSN_CMN_REG_REG_SHIFT; arm_extract_sfmt_cmp_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 832           case 27 : itype = ARM_INSN_LDRH_PRE_DEC_WB_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 833           case 29 : itype = ARM_INSN_LDRSB_PRE_DEC_WB_IMM_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 834           case 31 : itype = ARM_INSN_LDRSH_PRE_DEC_WB_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 835           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 836           }
 837         }
 838       case 12 :
 839         {
 840           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 841           switch (val)
 842           {
 843           case 0 : /* fall through */
 844           case 2 : /* fall through */
 845           case 4 : /* fall through */
 846           case 6 : /* fall through */
 847           case 8 : /* fall through */
 848           case 10 : /* fall through */
 849           case 12 : /* fall through */
 850           case 14 : /* fall through */
 851           case 16 : /* fall through */
 852           case 18 : /* fall through */
 853           case 20 : /* fall through */
 854           case 22 : /* fall through */
 855           case 24 : /* fall through */
 856           case 26 : /* fall through */
 857           case 28 : /* fall through */
 858           case 30 : itype = ARM_INSN_ORR_REG_IMM_SHIFT; arm_extract_sfmt_and_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 859           case 1 : /* fall through */
 860           case 3 : /* fall through */
 861           case 5 : /* fall through */
 862           case 7 : /* fall through */
 863           case 17 : /* fall through */
 864           case 19 : /* fall through */
 865           case 21 : /* fall through */
 866           case 23 : itype = ARM_INSN_ORR_REG_REG_SHIFT; arm_extract_sfmt_and_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 867           case 11 :
 868             if ((entire_insn & 0xff00ff0) == 0x18000b0)
 869               { itype = ARM_INSN_STRH_PRE_INC_REG_OFFSET; arm_extract_sfmt_strh_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 870             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 871           case 27 :
 872             if ((entire_insn & 0xff00ff0) == 0x19000b0)
 873               { itype = ARM_INSN_LDRH_PRE_INC_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 874             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 875           case 29 :
 876             if ((entire_insn & 0xff00ff0) == 0x19000d0)
 877               { itype = ARM_INSN_LDRSB_PRE_INC_REG_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 878             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 879           case 31 :
 880             if ((entire_insn & 0xff00ff0) == 0x19000f0)
 881               { itype = ARM_INSN_LDRSH_PRE_INC_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 882             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 883           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 884           }
 885         }
 886       case 13 :
 887         {
 888           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 889           switch (val)
 890           {
 891           case 0 : /* fall through */
 892           case 2 : /* fall through */
 893           case 4 : /* fall through */
 894           case 6 : /* fall through */
 895           case 8 : /* fall through */
 896           case 10 : /* fall through */
 897           case 12 : /* fall through */
 898           case 14 : /* fall through */
 899           case 16 : /* fall through */
 900           case 18 : /* fall through */
 901           case 20 : /* fall through */
 902           case 22 : /* fall through */
 903           case 24 : /* fall through */
 904           case 26 : /* fall through */
 905           case 28 : /* fall through */
 906           case 30 : itype = ARM_INSN_MOV_REG_IMM_SHIFT; arm_extract_sfmt_mov_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 907           case 1 : /* fall through */
 908           case 3 : /* fall through */
 909           case 5 : /* fall through */
 910           case 7 : /* fall through */
 911           case 17 : /* fall through */
 912           case 19 : /* fall through */
 913           case 21 : /* fall through */
 914           case 23 : itype = ARM_INSN_MOV_REG_REG_SHIFT; arm_extract_sfmt_mov_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 915           case 11 :
 916             if ((entire_insn & 0xff00ff0) == 0x1a000b0)
 917               { itype = ARM_INSN_STRH_PRE_INC_WB_REG_OFFSET; arm_extract_sfmt_strh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 918             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 919           case 27 :
 920             if ((entire_insn & 0xff00ff0) == 0x1b000b0)
 921               { itype = ARM_INSN_LDRH_PRE_INC_WB_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 922             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 923           case 29 :
 924             if ((entire_insn & 0xff00ff0) == 0x1b000d0)
 925               { itype = ARM_INSN_LDRSB_PRE_INC_WB_REG_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 926             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 927           case 31 :
 928             if ((entire_insn & 0xff00ff0) == 0x1b000f0)
 929               { itype = ARM_INSN_LDRSH_PRE_INC_WB_REG_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
 930             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 931           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 932           }
 933         }
 934       case 14 :
 935         {
 936           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 937           switch (val)
 938           {
 939           case 0 : /* fall through */
 940           case 2 : /* fall through */
 941           case 4 : /* fall through */
 942           case 6 : /* fall through */
 943           case 8 : /* fall through */
 944           case 10 : /* fall through */
 945           case 12 : /* fall through */
 946           case 14 : /* fall through */
 947           case 16 : /* fall through */
 948           case 18 : /* fall through */
 949           case 20 : /* fall through */
 950           case 22 : /* fall through */
 951           case 24 : /* fall through */
 952           case 26 : /* fall through */
 953           case 28 : /* fall through */
 954           case 30 : itype = ARM_INSN_BIC_REG_IMM_SHIFT; arm_extract_sfmt_and_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 955           case 1 : /* fall through */
 956           case 3 : /* fall through */
 957           case 5 : /* fall through */
 958           case 7 : /* fall through */
 959           case 17 : /* fall through */
 960           case 19 : /* fall through */
 961           case 21 : /* fall through */
 962           case 23 : itype = ARM_INSN_BIC_REG_REG_SHIFT; arm_extract_sfmt_and_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 963           case 11 : itype = ARM_INSN_STRH_PRE_INC_IMM_OFFSET; arm_extract_sfmt_strh_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 964           case 27 : itype = ARM_INSN_LDRH_PRE_INC_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 965           case 29 : itype = ARM_INSN_LDRSB_PRE_INC_IMM_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 966           case 31 : itype = ARM_INSN_LDRSH_PRE_INC_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
 967           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
 968           }
 969         }
 970       case 15 :
 971         {
 972           unsigned int val = (((insn >> 16) & (1 << 4)) | ((insn >> 4) & (15 << 0)));
 973           switch (val)
 974           {
 975           case 0 : /* fall through */
 976           case 2 : /* fall through */
 977           case 4 : /* fall through */
 978           case 6 : /* fall through */
 979           case 8 : /* fall through */
 980           case 10 : /* fall through */
 981           case 12 : /* fall through */
 982           case 14 : /* fall through */
 983           case 16 : /* fall through */
 984           case 18 : /* fall through */
 985           case 20 : /* fall through */
 986           case 22 : /* fall through */
 987           case 24 : /* fall through */
 988           case 26 : /* fall through */
 989           case 28 : /* fall through */
 990           case 30 : itype = ARM_INSN_MVN_REG_IMM_SHIFT; arm_extract_sfmt_mov_reg_imm_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 991           case 1 : /* fall through */
 992           case 3 : /* fall through */
 993           case 5 : /* fall through */
 994           case 7 : /* fall through */
 995           case 17 : /* fall through */
 996           case 19 : /* fall through */
 997           case 21 : /* fall through */
 998           case 23 : itype = ARM_INSN_MVN_REG_REG_SHIFT; arm_extract_sfmt_mov_reg_reg_shift (this, current_cpu, pc, base_insn, entire_insn); goto done;
 999           case 11 : itype = ARM_INSN_STRH_PRE_INC_WB_IMM_OFFSET; arm_extract_sfmt_strh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1000           case 27 : itype = ARM_INSN_LDRH_PRE_INC_WB_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1001           case 29 : itype = ARM_INSN_LDRSB_PRE_INC_WB_IMM_OFFSET; arm_extract_sfmt_ldrsb_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1002           case 31 : itype = ARM_INSN_LDRSH_PRE_INC_WB_IMM_OFFSET; arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1003           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1004           }
1005         }
1006       case 16 : itype = ARM_INSN_AND_IMM; arm_extract_sfmt_and_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1007       case 17 : itype = ARM_INSN_EOR_IMM; arm_extract_sfmt_and_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1008       case 18 : itype = ARM_INSN_SUB_IMM; arm_extract_sfmt_add_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1009       case 19 : itype = ARM_INSN_RSB_IMM; arm_extract_sfmt_add_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1010       case 20 : itype = ARM_INSN_ADD_IMM; arm_extract_sfmt_add_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1011       case 21 : itype = ARM_INSN_ADC_IMM; arm_extract_sfmt_adc_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1012       case 22 : itype = ARM_INSN_SBC_IMM; arm_extract_sfmt_adc_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1013       case 23 : itype = ARM_INSN_RSC_IMM; arm_extract_sfmt_adc_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1014       case 24 :
1015         if ((entire_insn & 0xff00000) == 0x3100000)
1016           { itype = ARM_INSN_TST_IMM; arm_extract_sfmt_tst_imm (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1017         itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1018       case 25 :
1019         if ((entire_insn & 0xff00000) == 0x3300000)
1020           { itype = ARM_INSN_TEQ_IMM; arm_extract_sfmt_tst_imm (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1021         itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1022       case 26 :
1023         if ((entire_insn & 0xff00000) == 0x3500000)
1024           { itype = ARM_INSN_CMP_IMM; arm_extract_sfmt_cmp_imm (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1025         itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1026       case 27 :
1027         if ((entire_insn & 0xff00000) == 0x3700000)
1028           { itype = ARM_INSN_CMN_IMM; arm_extract_sfmt_cmp_imm (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1029         itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1030       case 28 : itype = ARM_INSN_ORR_IMM; arm_extract_sfmt_and_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1031       case 29 : itype = ARM_INSN_MOV_IMM; arm_extract_sfmt_mov_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1032       case 30 : itype = ARM_INSN_BIC_IMM; arm_extract_sfmt_and_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1033       case 31 : itype = ARM_INSN_MVN_IMM; arm_extract_sfmt_mov_imm (this, current_cpu, pc, base_insn, entire_insn); goto done;
1034       case 32 :
1035         {
1036           unsigned int val = (((insn >> 20) & (1 << 0)));
1037           switch (val)
1038           {
1039           case 0 : itype = ARM_INSN_STR_POST_DEC_IMM_OFFSET; arm_extract_sfmt_str_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1040           case 1 : itype = ARM_INSN_LDR_POST_DEC_IMM_OFFSET; arm_extract_sfmt_ldr_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1041           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1042           }
1043         }
1044       case 33 :
1045         {
1046           unsigned int val = (((insn >> 20) & (1 << 0)));
1047           switch (val)
1048           {
1049           case 0 : itype = ARM_INSN_STR_POST_DEC_NONPRIV_IMM_OFFSET; arm_extract_sfmt_str_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1050           case 1 : itype = ARM_INSN_LDR_POST_DEC_NONPRIV_IMM_OFFSET; arm_extract_sfmt_ldr_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1051           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1052           }
1053         }
1054       case 34 :
1055         {
1056           unsigned int val = (((insn >> 20) & (1 << 0)));
1057           switch (val)
1058           {
1059           case 0 : itype = ARM_INSN_STRB_POST_DEC_IMM_OFFSET; arm_extract_sfmt_strb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1060           case 1 : itype = ARM_INSN_LDRB_POST_DEC_IMM_OFFSET; arm_extract_sfmt_ldrb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1061           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1062           }
1063         }
1064       case 35 :
1065         {
1066           unsigned int val = (((insn >> 20) & (1 << 0)));
1067           switch (val)
1068           {
1069           case 0 : itype = ARM_INSN_STRB_POST_DEC_NONPRIV_IMM_OFFSET; arm_extract_sfmt_strb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1070           case 1 : itype = ARM_INSN_LDRB_POST_DEC_NONPRIV_IMM_OFFSET; arm_extract_sfmt_ldrb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1071           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1072           }
1073         }
1074       case 36 :
1075         {
1076           unsigned int val = (((insn >> 20) & (1 << 0)));
1077           switch (val)
1078           {
1079           case 0 : itype = ARM_INSN_STR_POST_INC_IMM_OFFSET; arm_extract_sfmt_str_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1080           case 1 : itype = ARM_INSN_LDR_POST_INC_IMM_OFFSET; arm_extract_sfmt_ldr_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1081           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1082           }
1083         }
1084       case 37 :
1085         {
1086           unsigned int val = (((insn >> 20) & (1 << 0)));
1087           switch (val)
1088           {
1089           case 0 : itype = ARM_INSN_STR_POST_INC_NONPRIV_IMM_OFFSET; arm_extract_sfmt_str_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1090           case 1 : itype = ARM_INSN_LDR_POST_INC_NONPRIV_IMM_OFFSET; arm_extract_sfmt_ldr_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1091           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1092           }
1093         }
1094       case 38 :
1095         {
1096           unsigned int val = (((insn >> 20) & (1 << 0)));
1097           switch (val)
1098           {
1099           case 0 : itype = ARM_INSN_STRB_POST_INC_IMM_OFFSET; arm_extract_sfmt_strb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1100           case 1 : itype = ARM_INSN_LDRB_POST_INC_IMM_OFFSET; arm_extract_sfmt_ldrb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1101           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1102           }
1103         }
1104       case 39 :
1105         {
1106           unsigned int val = (((insn >> 20) & (1 << 0)));
1107           switch (val)
1108           {
1109           case 0 : itype = ARM_INSN_STRB_POST_INC_NONPRIV_IMM_OFFSET; arm_extract_sfmt_strb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1110           case 1 : itype = ARM_INSN_LDRB_POST_INC_NONPRIV_IMM_OFFSET; arm_extract_sfmt_ldrb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1111           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1112           }
1113         }
1114       case 40 :
1115         {
1116           unsigned int val = (((insn >> 20) & (1 << 0)));
1117           switch (val)
1118           {
1119           case 0 : itype = ARM_INSN_STR_PRE_DEC_IMM_OFFSET; arm_extract_sfmt_str_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1120           case 1 : itype = ARM_INSN_LDR_PRE_DEC_IMM_OFFSET; arm_extract_sfmt_ldr_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1121           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1122           }
1123         }
1124       case 41 :
1125         {
1126           unsigned int val = (((insn >> 20) & (1 << 0)));
1127           switch (val)
1128           {
1129           case 0 : itype = ARM_INSN_STR_PRE_DEC_WB_IMM_OFFSET; arm_extract_sfmt_str_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1130           case 1 : itype = ARM_INSN_LDR_PRE_DEC_WB_IMM_OFFSET; arm_extract_sfmt_ldr_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1131           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1132           }
1133         }
1134       case 42 :
1135         {
1136           unsigned int val = (((insn >> 20) & (1 << 0)));
1137           switch (val)
1138           {
1139           case 0 : itype = ARM_INSN_STRB_PRE_DEC_IMM_OFFSET; arm_extract_sfmt_strb_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1140           case 1 : itype = ARM_INSN_LDRB_PRE_DEC_IMM_OFFSET; arm_extract_sfmt_ldrb_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1141           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1142           }
1143         }
1144       case 43 :
1145         {
1146           unsigned int val = (((insn >> 20) & (1 << 0)));
1147           switch (val)
1148           {
1149           case 0 : itype = ARM_INSN_STRB_PRE_DEC_WB_IMM_OFFSET; arm_extract_sfmt_strb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1150           case 1 : itype = ARM_INSN_LDRB_PRE_DEC_WB_IMM_OFFSET; arm_extract_sfmt_ldrb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1151           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1152           }
1153         }
1154       case 44 :
1155         {
1156           unsigned int val = (((insn >> 20) & (1 << 0)));
1157           switch (val)
1158           {
1159           case 0 : itype = ARM_INSN_STR_PRE_INC_IMM_OFFSET; arm_extract_sfmt_str_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1160           case 1 : itype = ARM_INSN_LDR_PRE_INC_IMM_OFFSET; arm_extract_sfmt_ldr_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1161           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1162           }
1163         }
1164       case 45 :
1165         {
1166           unsigned int val = (((insn >> 20) & (1 << 0)));
1167           switch (val)
1168           {
1169           case 0 : itype = ARM_INSN_STR_PRE_INC_WB_IMM_OFFSET; arm_extract_sfmt_str_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1170           case 1 : itype = ARM_INSN_LDR_PRE_INC_WB_IMM_OFFSET; arm_extract_sfmt_ldr_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1171           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1172           }
1173         }
1174       case 46 :
1175         {
1176           unsigned int val = (((insn >> 20) & (1 << 0)));
1177           switch (val)
1178           {
1179           case 0 : itype = ARM_INSN_STRB_PRE_INC_IMM_OFFSET; arm_extract_sfmt_strb_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1180           case 1 : itype = ARM_INSN_LDRB_PRE_INC_IMM_OFFSET; arm_extract_sfmt_ldrb_pre_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1181           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1182           }
1183         }
1184       case 47 :
1185         {
1186           unsigned int val = (((insn >> 20) & (1 << 0)));
1187           switch (val)
1188           {
1189           case 0 : itype = ARM_INSN_STRB_PRE_INC_WB_IMM_OFFSET; arm_extract_sfmt_strb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1190           case 1 : itype = ARM_INSN_LDRB_PRE_INC_WB_IMM_OFFSET; arm_extract_sfmt_ldrb_post_dec_imm_offset (this, current_cpu, pc, base_insn, entire_insn); goto done;
1191           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1192           }
1193         }
1194       case 48 :
1195         {
1196           unsigned int val = (((insn >> 20) & (1 << 0)));
1197           switch (val)
1198           {
1199           case 0 :
1200             if ((entire_insn & 0xff00010) == 0x6000000)
1201               { itype = ARM_INSN_STR_POST_DEC_REG_OFFSET; arm_extract_sfmt_str_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1202             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1203           case 1 :
1204             if ((entire_insn & 0xff00010) == 0x6100000)
1205               { itype = ARM_INSN_LDR_POST_DEC_REG_OFFSET; arm_extract_sfmt_ldr_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1206             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1207           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1208           }
1209         }
1210       case 49 :
1211         {
1212           unsigned int val = (((insn >> 20) & (1 << 0)));
1213           switch (val)
1214           {
1215           case 0 :
1216             if ((entire_insn & 0xff00010) == 0x6200000)
1217               { itype = ARM_INSN_STR_POST_DEC_NONPRIV_REG_OFFSET; arm_extract_sfmt_str_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1218             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1219           case 1 :
1220             if ((entire_insn & 0xff00010) == 0x6300000)
1221               { itype = ARM_INSN_LDR_POST_DEC_NONPRIV_REG_OFFSET; arm_extract_sfmt_ldr_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1222             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1223           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1224           }
1225         }
1226       case 50 :
1227         {
1228           unsigned int val = (((insn >> 20) & (1 << 0)));
1229           switch (val)
1230           {
1231           case 0 :
1232             if ((entire_insn & 0xff00010) == 0x6400000)
1233               { itype = ARM_INSN_STRB_POST_DEC_REG_OFFSET; arm_extract_sfmt_strb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1234             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1235           case 1 :
1236             if ((entire_insn & 0xff00010) == 0x6500000)
1237               { itype = ARM_INSN_LDRB_POST_DEC_REG_OFFSET; arm_extract_sfmt_ldrb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1238             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1239           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1240           }
1241         }
1242       case 51 :
1243         {
1244           unsigned int val = (((insn >> 20) & (1 << 0)));
1245           switch (val)
1246           {
1247           case 0 :
1248             if ((entire_insn & 0xff00010) == 0x6600000)
1249               { itype = ARM_INSN_STRB_POST_DEC_NONPRIV_REG_OFFSET; arm_extract_sfmt_strb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1250             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1251           case 1 :
1252             if ((entire_insn & 0xff00010) == 0x6700000)
1253               { itype = ARM_INSN_LDRB_POST_DEC_NONPRIV_REG_OFFSET; arm_extract_sfmt_ldrb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1254             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1255           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1256           }
1257         }
1258       case 52 :
1259         {
1260           unsigned int val = (((insn >> 20) & (1 << 0)));
1261           switch (val)
1262           {
1263           case 0 :
1264             if ((entire_insn & 0xff00010) == 0x6800000)
1265               { itype = ARM_INSN_STR_POST_INC_REG_OFFSET; arm_extract_sfmt_str_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1266             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1267           case 1 :
1268             if ((entire_insn & 0xff00010) == 0x6900000)
1269               { itype = ARM_INSN_LDR_POST_INC_REG_OFFSET; arm_extract_sfmt_ldr_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1270             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1271           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1272           }
1273         }
1274       case 53 :
1275         {
1276           unsigned int val = (((insn >> 20) & (1 << 0)));
1277           switch (val)
1278           {
1279           case 0 :
1280             if ((entire_insn & 0xff00010) == 0x6a00000)
1281               { itype = ARM_INSN_STR_POST_INC_NONPRIV_REG_OFFSET; arm_extract_sfmt_str_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1282             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1283           case 1 :
1284             if ((entire_insn & 0xff00010) == 0x6b00000)
1285               { itype = ARM_INSN_LDR_POST_INC_NONPRIV_REG_OFFSET; arm_extract_sfmt_ldr_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1286             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1287           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1288           }
1289         }
1290       case 54 :
1291         {
1292           unsigned int val = (((insn >> 20) & (1 << 0)));
1293           switch (val)
1294           {
1295           case 0 :
1296             if ((entire_insn & 0xff00010) == 0x6c00000)
1297               { itype = ARM_INSN_STRB_POST_INC_REG_OFFSET; arm_extract_sfmt_strb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1298             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1299           case 1 :
1300             if ((entire_insn & 0xff00010) == 0x6d00000)
1301               { itype = ARM_INSN_LDRB_POST_INC_REG_OFFSET; arm_extract_sfmt_ldrb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1302             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1303           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1304           }
1305         }
1306       case 55 :
1307         {
1308           unsigned int val = (((insn >> 20) & (1 << 0)));
1309           switch (val)
1310           {
1311           case 0 :
1312             if ((entire_insn & 0xff00010) == 0x6e00000)
1313               { itype = ARM_INSN_STRB_POST_INC_NONPRIV_REG_OFFSET; arm_extract_sfmt_strb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1314             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1315           case 1 :
1316             if ((entire_insn & 0xff00010) == 0x6f00000)
1317               { itype = ARM_INSN_LDRB_POST_INC_NONPRIV_REG_OFFSET; arm_extract_sfmt_ldrb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1318             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1319           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1320           }
1321         }
1322       case 56 :
1323         {
1324           unsigned int val = (((insn >> 20) & (1 << 0)));
1325           switch (val)
1326           {
1327           case 0 :
1328             if ((entire_insn & 0xff00010) == 0x7000000)
1329               { itype = ARM_INSN_STR_PRE_DEC_REG_OFFSET; arm_extract_sfmt_str_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1330             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1331           case 1 :
1332             if ((entire_insn & 0xff00010) == 0x7100000)
1333               { itype = ARM_INSN_LDR_PRE_DEC_REG_OFFSET; arm_extract_sfmt_ldr_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1334             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1335           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1336           }
1337         }
1338       case 57 :
1339         {
1340           unsigned int val = (((insn >> 20) & (1 << 0)));
1341           switch (val)
1342           {
1343           case 0 :
1344             if ((entire_insn & 0xff00010) == 0x7200000)
1345               { itype = ARM_INSN_STR_PRE_DEC_WB_REG_OFFSET; arm_extract_sfmt_str_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1346             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1347           case 1 :
1348             if ((entire_insn & 0xff00010) == 0x7300000)
1349               { itype = ARM_INSN_LDR_PRE_DEC_WB_REG_OFFSET; arm_extract_sfmt_ldr_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1350             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1351           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1352           }
1353         }
1354       case 58 :
1355         {
1356           unsigned int val = (((insn >> 20) & (1 << 0)));
1357           switch (val)
1358           {
1359           case 0 :
1360             if ((entire_insn & 0xff00010) == 0x7400000)
1361               { itype = ARM_INSN_STRB_PRE_DEC_REG_OFFSET; arm_extract_sfmt_strb_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1362             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1363           case 1 :
1364             if ((entire_insn & 0xff00010) == 0x7500000)
1365               { itype = ARM_INSN_LDRB_PRE_DEC_REG_OFFSET; arm_extract_sfmt_ldrb_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1366             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1367           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1368           }
1369         }
1370       case 59 :
1371         {
1372           unsigned int val = (((insn >> 20) & (1 << 0)));
1373           switch (val)
1374           {
1375           case 0 :
1376             if ((entire_insn & 0xff00010) == 0x7600000)
1377               { itype = ARM_INSN_STRB_PRE_DEC_WB_REG_OFFSET; arm_extract_sfmt_strb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1378             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1379           case 1 :
1380             if ((entire_insn & 0xff00010) == 0x7700000)
1381               { itype = ARM_INSN_LDRB_PRE_DEC_WB_REG_OFFSET; arm_extract_sfmt_ldrb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1382             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1383           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1384           }
1385         }
1386       case 60 :
1387         {
1388           unsigned int val = (((insn >> 20) & (1 << 0)));
1389           switch (val)
1390           {
1391           case 0 :
1392             if ((entire_insn & 0xff00010) == 0x7800000)
1393               { itype = ARM_INSN_STR_PRE_INC_REG_OFFSET; arm_extract_sfmt_str_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1394             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1395           case 1 :
1396             if ((entire_insn & 0xff00010) == 0x7900000)
1397               { itype = ARM_INSN_LDR_PRE_INC_REG_OFFSET; arm_extract_sfmt_ldr_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1398             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1399           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1400           }
1401         }
1402       case 61 :
1403         {
1404           unsigned int val = (((insn >> 20) & (1 << 0)));
1405           switch (val)
1406           {
1407           case 0 :
1408             if ((entire_insn & 0xff00010) == 0x7a00000)
1409               { itype = ARM_INSN_STR_PRE_INC_WB_REG_OFFSET; arm_extract_sfmt_str_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1410             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1411           case 1 :
1412             if ((entire_insn & 0xff00010) == 0x7b00000)
1413               { itype = ARM_INSN_LDR_PRE_INC_WB_REG_OFFSET; arm_extract_sfmt_ldr_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1414             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1415           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1416           }
1417         }
1418       case 62 :
1419         {
1420           unsigned int val = (((insn >> 20) & (1 << 0)));
1421           switch (val)
1422           {
1423           case 0 :
1424             if ((entire_insn & 0xff00010) == 0x7c00000)
1425               { itype = ARM_INSN_STRB_PRE_INC_REG_OFFSET; arm_extract_sfmt_strb_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1426             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1427           case 1 :
1428             if ((entire_insn & 0xff00010) == 0x7d00000)
1429               { itype = ARM_INSN_LDRB_PRE_INC_REG_OFFSET; arm_extract_sfmt_ldrb_pre_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1430             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1431           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1432           }
1433         }
1434       case 63 :
1435         {
1436           unsigned int val = (((insn >> 20) & (1 << 0)));
1437           switch (val)
1438           {
1439           case 0 :
1440             if ((entire_insn & 0xff00010) == 0x7e00000)
1441               { itype = ARM_INSN_STRB_PRE_INC_WB_REG_OFFSET; arm_extract_sfmt_strb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1442             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1443           case 1 :
1444             if ((entire_insn & 0xff00010) == 0x7f00000)
1445               { itype = ARM_INSN_LDRB_PRE_INC_WB_REG_OFFSET; arm_extract_sfmt_ldrb_post_dec_reg_offset (this, current_cpu, pc, base_insn, entire_insn); goto done; }
1446             itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1447           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1448           }
1449         }
1450       case 64 :
1451         {
1452           unsigned int val = (((insn >> 20) & (1 << 0)));
1453           switch (val)
1454           {
1455           case 0 : itype = ARM_INSN_STMDA; arm_extract_sfmt_stmdb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1456           case 1 : itype = ARM_INSN_LDMDA; arm_extract_sfmt_ldmda (this, current_cpu, pc, base_insn, entire_insn); goto done;
1457           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1458           }
1459         }
1460       case 65 :
1461         {
1462           unsigned int val = (((insn >> 20) & (1 << 0)));
1463           switch (val)
1464           {
1465           case 0 : itype = ARM_INSN_STMDA_WB; arm_extract_sfmt_stmdb_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1466           case 1 : itype = ARM_INSN_LDMDA_WB; arm_extract_sfmt_ldmda_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1467           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1468           }
1469         }
1470       case 66 :
1471         {
1472           unsigned int val = (((insn >> 20) & (1 << 0)));
1473           switch (val)
1474           {
1475           case 0 : itype = ARM_INSN_STMDA_SW; arm_extract_sfmt_stmdb_sw (this, current_cpu, pc, base_insn, entire_insn); goto done;
1476           case 1 : itype = ARM_INSN_LDMDA_SW; arm_extract_sfmt_ldmda_sw (this, current_cpu, pc, base_insn, entire_insn); goto done;
1477           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1478           }
1479         }
1480       case 67 :
1481         {
1482           unsigned int val = (((insn >> 20) & (1 << 0)));
1483           switch (val)
1484           {
1485           case 0 : itype = ARM_INSN_STMDA_SW_WB; arm_extract_sfmt_stmdb_sw_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1486           case 1 : itype = ARM_INSN_LDMDA_SW_WB; arm_extract_sfmt_ldmda_sw_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1487           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1488           }
1489         }
1490       case 68 :
1491         {
1492           unsigned int val = (((insn >> 20) & (1 << 0)));
1493           switch (val)
1494           {
1495           case 0 : itype = ARM_INSN_STMIA; arm_extract_sfmt_stmdb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1496           case 1 : itype = ARM_INSN_LDMIA; arm_extract_sfmt_ldmda (this, current_cpu, pc, base_insn, entire_insn); goto done;
1497           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1498           }
1499         }
1500       case 69 :
1501         {
1502           unsigned int val = (((insn >> 20) & (1 << 0)));
1503           switch (val)
1504           {
1505           case 0 : itype = ARM_INSN_STMIA_WB; arm_extract_sfmt_stmdb_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1506           case 1 : itype = ARM_INSN_LDMIA_WB; arm_extract_sfmt_ldmda_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1507           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1508           }
1509         }
1510       case 70 :
1511         {
1512           unsigned int val = (((insn >> 20) & (1 << 0)));
1513           switch (val)
1514           {
1515           case 0 : itype = ARM_INSN_STMIA_SW; arm_extract_sfmt_stmdb_sw (this, current_cpu, pc, base_insn, entire_insn); goto done;
1516           case 1 : itype = ARM_INSN_LDMIA_SW; arm_extract_sfmt_ldmda_sw (this, current_cpu, pc, base_insn, entire_insn); goto done;
1517           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1518           }
1519         }
1520       case 71 :
1521         {
1522           unsigned int val = (((insn >> 20) & (1 << 0)));
1523           switch (val)
1524           {
1525           case 0 : itype = ARM_INSN_STMIA_SW_WB; arm_extract_sfmt_stmdb_sw_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1526           case 1 : itype = ARM_INSN_LDMIA_SW_WB; arm_extract_sfmt_ldmda_sw_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1527           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1528           }
1529         }
1530       case 72 :
1531         {
1532           unsigned int val = (((insn >> 20) & (1 << 0)));
1533           switch (val)
1534           {
1535           case 0 : itype = ARM_INSN_STMDB; arm_extract_sfmt_stmdb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1536           case 1 : itype = ARM_INSN_LDMDB; arm_extract_sfmt_ldmda (this, current_cpu, pc, base_insn, entire_insn); goto done;
1537           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1538           }
1539         }
1540       case 73 :
1541         {
1542           unsigned int val = (((insn >> 20) & (1 << 0)));
1543           switch (val)
1544           {
1545           case 0 : itype = ARM_INSN_STMDB_WB; arm_extract_sfmt_stmdb_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1546           case 1 : itype = ARM_INSN_LDMDB_WB; arm_extract_sfmt_ldmda_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1547           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1548           }
1549         }
1550       case 74 :
1551         {
1552           unsigned int val = (((insn >> 20) & (1 << 0)));
1553           switch (val)
1554           {
1555           case 0 : itype = ARM_INSN_STMDB_SW; arm_extract_sfmt_stmdb_sw (this, current_cpu, pc, base_insn, entire_insn); goto done;
1556           case 1 : itype = ARM_INSN_LDMDB_SW; arm_extract_sfmt_ldmda_sw (this, current_cpu, pc, base_insn, entire_insn); goto done;
1557           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1558           }
1559         }
1560       case 75 :
1561         {
1562           unsigned int val = (((insn >> 20) & (1 << 0)));
1563           switch (val)
1564           {
1565           case 0 : itype = ARM_INSN_STMDB_SW_WB; arm_extract_sfmt_stmdb_sw_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1566           case 1 : itype = ARM_INSN_LDMDB_SW_WB; arm_extract_sfmt_ldmda_sw_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1567           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1568           }
1569         }
1570       case 76 :
1571         {
1572           unsigned int val = (((insn >> 20) & (1 << 0)));
1573           switch (val)
1574           {
1575           case 0 : itype = ARM_INSN_STMIB; arm_extract_sfmt_stmdb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1576           case 1 : itype = ARM_INSN_LDMIB; arm_extract_sfmt_ldmda (this, current_cpu, pc, base_insn, entire_insn); goto done;
1577           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1578           }
1579         }
1580       case 77 :
1581         {
1582           unsigned int val = (((insn >> 20) & (1 << 0)));
1583           switch (val)
1584           {
1585           case 0 : itype = ARM_INSN_STMIB_WB; arm_extract_sfmt_stmdb_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1586           case 1 : itype = ARM_INSN_LDMIB_WB; arm_extract_sfmt_ldmda_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1587           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1588           }
1589         }
1590       case 78 :
1591         {
1592           unsigned int val = (((insn >> 20) & (1 << 0)));
1593           switch (val)
1594           {
1595           case 0 : itype = ARM_INSN_STMIB_SW; arm_extract_sfmt_stmdb_sw (this, current_cpu, pc, base_insn, entire_insn); goto done;
1596           case 1 : itype = ARM_INSN_LDMIB_SW; arm_extract_sfmt_ldmda_sw (this, current_cpu, pc, base_insn, entire_insn); goto done;
1597           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1598           }
1599         }
1600       case 79 :
1601         {
1602           unsigned int val = (((insn >> 20) & (1 << 0)));
1603           switch (val)
1604           {
1605           case 0 : itype = ARM_INSN_STMIB_SW_WB; arm_extract_sfmt_stmdb_sw_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1606           case 1 : itype = ARM_INSN_LDMIB_SW_WB; arm_extract_sfmt_ldmda_sw_wb (this, current_cpu, pc, base_insn, entire_insn); goto done;
1607           default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1608           }
1609         }
1610       case 80 : /* fall through */
1611       case 81 : /* fall through */
1612       case 82 : /* fall through */
1613       case 83 : /* fall through */
1614       case 84 : /* fall through */
1615       case 85 : /* fall through */
1616       case 86 : /* fall through */
1617       case 87 : itype = ARM_INSN_B; arm_extract_sfmt_b (this, current_cpu, pc, base_insn, entire_insn); goto done;
1618       case 88 : /* fall through */
1619       case 89 : /* fall through */
1620       case 90 : /* fall through */
1621       case 91 : /* fall through */
1622       case 92 : /* fall through */
1623       case 93 : /* fall through */
1624       case 94 : /* fall through */
1625       case 95 : itype = ARM_INSN_BL; arm_extract_sfmt_bl (this, current_cpu, pc, base_insn, entire_insn); goto done;
1626       case 120 : /* fall through */
1627       case 121 : /* fall through */
1628       case 122 : /* fall through */
1629       case 123 : /* fall through */
1630       case 124 : /* fall through */
1631       case 125 : /* fall through */
1632       case 126 : /* fall through */
1633       case 127 : itype = ARM_INSN_SWI; arm_extract_sfmt_swi (this, current_cpu, pc, base_insn, entire_insn); goto done;
1634       default : itype = ARM_INSN_X_INVALID; arm_extract_sfmt_empty (this, current_cpu, pc, base_insn, entire_insn); goto done;
1635       }
1636     }
1637
1638   }
1639
1640   /* The instruction has been decoded and fields extracted.  */
1641   done:
1642   {
1643     UINT f_cond;
1644     f_cond = EXTRACT_LSB0_UINT (base_insn, 32, 31, 4);
1645     this->cond = f_cond;
1646   }
1647
1648   this->addr = pc;
1649   // FIXME: To be redone (to handle ISA variants).
1650   this->idesc = & arm_idesc::idesc_table[itype];
1651   // ??? record semantic handler?
1652   assert(this->idesc->sem_index == itype);
1653 }
1654
1655 void
1656 arm_extract_sfmt_empty (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1657     arm_insn_word insn = entire_insn;
1658 #define FLD(f) abuf->fields.fmt_empty.f
1659
1660
1661   /* Record the fields for the semantic handler.  */
1662   if (UNLIKELY(current_cpu->trace_extract_p))
1663     {
1664       current_cpu->trace_stream
1665         << "0x" << hex << pc << dec << " (sfmt_empty)\t"
1666         << endl;
1667     }
1668
1669 #undef FLD
1670 }
1671
1672 void
1673 arm_extract_sfmt_b (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1674     arm_insn_word insn = entire_insn;
1675 #define FLD(f) abuf->fields.sfmt_b.f
1676     SI f_offset24;
1677
1678     f_offset24 = ((((EXTRACT_LSB0_SINT (insn, 32, 23, 24)) << (2))) + (((pc) + (8))));
1679
1680   /* Record the fields for the semantic handler.  */
1681   FLD (i_offset24) = f_offset24;
1682   if (UNLIKELY(current_cpu->trace_extract_p))
1683     {
1684       current_cpu->trace_stream
1685         << "0x" << hex << pc << dec << " (sfmt_b)\t"
1686         << endl;
1687     }
1688
1689 #undef FLD
1690 }
1691
1692 void
1693 arm_extract_sfmt_bl (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1694     arm_insn_word insn = entire_insn;
1695 #define FLD(f) abuf->fields.sfmt_b.f
1696     SI f_offset24;
1697
1698     f_offset24 = ((((EXTRACT_LSB0_SINT (insn, 32, 23, 24)) << (2))) + (((pc) + (8))));
1699
1700   /* Record the fields for the semantic handler.  */
1701   FLD (i_offset24) = f_offset24;
1702   if (UNLIKELY(current_cpu->trace_extract_p))
1703     {
1704       current_cpu->trace_stream
1705         << "0x" << hex << pc << dec << " (sfmt_bl)\t"
1706         << endl;
1707     }
1708
1709 #undef FLD
1710 }
1711
1712 void
1713 arm_extract_sfmt_bx (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1714     arm_insn_word insn = entire_insn;
1715 #define FLD(f) abuf->fields.sfmt_bx.f
1716     UINT f_bx_rn;
1717
1718     f_bx_rn = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
1719
1720   /* Record the fields for the semantic handler.  */
1721   FLD (f_bx_rn) = f_bx_rn;
1722   FLD (i_bx_rn) = & current_cpu->hardware.h_gr[f_bx_rn];
1723   if (UNLIKELY(current_cpu->trace_extract_p))
1724     {
1725       current_cpu->trace_stream
1726         << "0x" << hex << pc << dec << " (sfmt_bx)\t"
1727         << " f_bx_rn:0x" << hex << f_bx_rn << dec
1728         << endl;
1729     }
1730
1731 #undef FLD
1732 }
1733
1734 void
1735 arm_extract_sfmt_ldr_post_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1736     arm_insn_word insn = entire_insn;
1737 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1738     UINT f_rn;
1739     UINT f_rd;
1740     UINT f_uimm12;
1741
1742     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
1743     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
1744     f_uimm12 = EXTRACT_LSB0_UINT (insn, 32, 11, 12);
1745
1746   /* Record the fields for the semantic handler.  */
1747   FLD (f_rd) = f_rd;
1748   FLD (f_rn) = f_rn;
1749   FLD (f_uimm12) = f_uimm12;
1750   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
1751   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
1752   if (UNLIKELY(current_cpu->trace_extract_p))
1753     {
1754       current_cpu->trace_stream
1755         << "0x" << hex << pc << dec << " (sfmt_ldr_post_dec_imm_offset)\t"
1756         << " f_rd:0x" << hex << f_rd << dec
1757         << " f_rn:0x" << hex << f_rn << dec
1758         << " f_uimm12:0x" << hex << f_uimm12 << dec
1759         << endl;
1760     }
1761
1762 #undef FLD
1763 }
1764
1765 void
1766 arm_extract_sfmt_ldr_post_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1767     arm_insn_word insn = entire_insn;
1768 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1769     UINT f_rn;
1770     UINT f_rd;
1771     UINT f_operand2_shiftimm;
1772     UINT f_operand2_shifttype;
1773     UINT f_rm;
1774
1775     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
1776     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
1777     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
1778     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
1779     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
1780
1781   /* Record the fields for the semantic handler.  */
1782   FLD (f_rd) = f_rd;
1783   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
1784   FLD (f_operand2_shifttype) = f_operand2_shifttype;
1785   FLD (f_rm) = f_rm;
1786   FLD (f_rn) = f_rn;
1787   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
1788   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
1789   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
1790   if (UNLIKELY(current_cpu->trace_extract_p))
1791     {
1792       current_cpu->trace_stream
1793         << "0x" << hex << pc << dec << " (sfmt_ldr_post_dec_reg_offset)\t"
1794         << " f_rd:0x" << hex << f_rd << dec
1795         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
1796         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
1797         << " f_rm:0x" << hex << f_rm << dec
1798         << " f_rn:0x" << hex << f_rn << dec
1799         << endl;
1800     }
1801
1802 #undef FLD
1803 }
1804
1805 void
1806 arm_extract_sfmt_ldr_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1807     arm_insn_word insn = entire_insn;
1808 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1809     UINT f_rn;
1810     UINT f_rd;
1811     UINT f_uimm12;
1812
1813     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
1814     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
1815     f_uimm12 = EXTRACT_LSB0_UINT (insn, 32, 11, 12);
1816
1817   /* Record the fields for the semantic handler.  */
1818   FLD (f_rd) = f_rd;
1819   FLD (f_rn) = f_rn;
1820   FLD (f_uimm12) = f_uimm12;
1821   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
1822   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
1823   if (UNLIKELY(current_cpu->trace_extract_p))
1824     {
1825       current_cpu->trace_stream
1826         << "0x" << hex << pc << dec << " (sfmt_ldr_pre_dec_imm_offset)\t"
1827         << " f_rd:0x" << hex << f_rd << dec
1828         << " f_rn:0x" << hex << f_rn << dec
1829         << " f_uimm12:0x" << hex << f_uimm12 << dec
1830         << endl;
1831     }
1832
1833 #undef FLD
1834 }
1835
1836 void
1837 arm_extract_sfmt_ldr_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1838     arm_insn_word insn = entire_insn;
1839 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1840     UINT f_rn;
1841     UINT f_rd;
1842     UINT f_operand2_shiftimm;
1843     UINT f_operand2_shifttype;
1844     UINT f_rm;
1845
1846     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
1847     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
1848     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
1849     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
1850     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
1851
1852   /* Record the fields for the semantic handler.  */
1853   FLD (f_rd) = f_rd;
1854   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
1855   FLD (f_operand2_shifttype) = f_operand2_shifttype;
1856   FLD (f_rm) = f_rm;
1857   FLD (f_rn) = f_rn;
1858   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
1859   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
1860   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
1861   if (UNLIKELY(current_cpu->trace_extract_p))
1862     {
1863       current_cpu->trace_stream
1864         << "0x" << hex << pc << dec << " (sfmt_ldr_pre_dec_reg_offset)\t"
1865         << " f_rd:0x" << hex << f_rd << dec
1866         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
1867         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
1868         << " f_rm:0x" << hex << f_rm << dec
1869         << " f_rn:0x" << hex << f_rn << dec
1870         << endl;
1871     }
1872
1873 #undef FLD
1874 }
1875
1876 void
1877 arm_extract_sfmt_ldrb_post_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1878     arm_insn_word insn = entire_insn;
1879 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1880     UINT f_rn;
1881     UINT f_rd;
1882     UINT f_uimm12;
1883
1884     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
1885     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
1886     f_uimm12 = EXTRACT_LSB0_UINT (insn, 32, 11, 12);
1887
1888   /* Record the fields for the semantic handler.  */
1889   FLD (f_rd) = f_rd;
1890   FLD (f_rn) = f_rn;
1891   FLD (f_uimm12) = f_uimm12;
1892   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
1893   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
1894   if (UNLIKELY(current_cpu->trace_extract_p))
1895     {
1896       current_cpu->trace_stream
1897         << "0x" << hex << pc << dec << " (sfmt_ldrb_post_dec_imm_offset)\t"
1898         << " f_rd:0x" << hex << f_rd << dec
1899         << " f_rn:0x" << hex << f_rn << dec
1900         << " f_uimm12:0x" << hex << f_uimm12 << dec
1901         << endl;
1902     }
1903
1904 #undef FLD
1905 }
1906
1907 void
1908 arm_extract_sfmt_ldrb_post_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1909     arm_insn_word insn = entire_insn;
1910 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1911     UINT f_rn;
1912     UINT f_rd;
1913     UINT f_operand2_shiftimm;
1914     UINT f_operand2_shifttype;
1915     UINT f_rm;
1916
1917     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
1918     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
1919     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
1920     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
1921     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
1922
1923   /* Record the fields for the semantic handler.  */
1924   FLD (f_rd) = f_rd;
1925   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
1926   FLD (f_operand2_shifttype) = f_operand2_shifttype;
1927   FLD (f_rm) = f_rm;
1928   FLD (f_rn) = f_rn;
1929   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
1930   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
1931   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
1932   if (UNLIKELY(current_cpu->trace_extract_p))
1933     {
1934       current_cpu->trace_stream
1935         << "0x" << hex << pc << dec << " (sfmt_ldrb_post_dec_reg_offset)\t"
1936         << " f_rd:0x" << hex << f_rd << dec
1937         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
1938         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
1939         << " f_rm:0x" << hex << f_rm << dec
1940         << " f_rn:0x" << hex << f_rn << dec
1941         << endl;
1942     }
1943
1944 #undef FLD
1945 }
1946
1947 void
1948 arm_extract_sfmt_ldrb_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1949     arm_insn_word insn = entire_insn;
1950 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
1951     UINT f_rn;
1952     UINT f_rd;
1953     UINT f_uimm12;
1954
1955     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
1956     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
1957     f_uimm12 = EXTRACT_LSB0_UINT (insn, 32, 11, 12);
1958
1959   /* Record the fields for the semantic handler.  */
1960   FLD (f_rd) = f_rd;
1961   FLD (f_rn) = f_rn;
1962   FLD (f_uimm12) = f_uimm12;
1963   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
1964   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
1965   if (UNLIKELY(current_cpu->trace_extract_p))
1966     {
1967       current_cpu->trace_stream
1968         << "0x" << hex << pc << dec << " (sfmt_ldrb_pre_dec_imm_offset)\t"
1969         << " f_rd:0x" << hex << f_rd << dec
1970         << " f_rn:0x" << hex << f_rn << dec
1971         << " f_uimm12:0x" << hex << f_uimm12 << dec
1972         << endl;
1973     }
1974
1975 #undef FLD
1976 }
1977
1978 void
1979 arm_extract_sfmt_ldrb_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
1980     arm_insn_word insn = entire_insn;
1981 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
1982     UINT f_rn;
1983     UINT f_rd;
1984     UINT f_operand2_shiftimm;
1985     UINT f_operand2_shifttype;
1986     UINT f_rm;
1987
1988     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
1989     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
1990     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
1991     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
1992     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
1993
1994   /* Record the fields for the semantic handler.  */
1995   FLD (f_rd) = f_rd;
1996   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
1997   FLD (f_operand2_shifttype) = f_operand2_shifttype;
1998   FLD (f_rm) = f_rm;
1999   FLD (f_rn) = f_rn;
2000   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2001   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2002   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2003   if (UNLIKELY(current_cpu->trace_extract_p))
2004     {
2005       current_cpu->trace_stream
2006         << "0x" << hex << pc << dec << " (sfmt_ldrb_pre_dec_reg_offset)\t"
2007         << " f_rd:0x" << hex << f_rd << dec
2008         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
2009         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
2010         << " f_rm:0x" << hex << f_rm << dec
2011         << " f_rn:0x" << hex << f_rn << dec
2012         << endl;
2013     }
2014
2015 #undef FLD
2016 }
2017
2018 void
2019 arm_extract_sfmt_str_post_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2020     arm_insn_word insn = entire_insn;
2021 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2022     UINT f_rn;
2023     UINT f_rd;
2024     UINT f_uimm12;
2025
2026     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2027     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2028     f_uimm12 = EXTRACT_LSB0_UINT (insn, 32, 11, 12);
2029
2030   /* Record the fields for the semantic handler.  */
2031   FLD (f_rd) = f_rd;
2032   FLD (f_rn) = f_rn;
2033   FLD (f_uimm12) = f_uimm12;
2034   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2035   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2036   if (UNLIKELY(current_cpu->trace_extract_p))
2037     {
2038       current_cpu->trace_stream
2039         << "0x" << hex << pc << dec << " (sfmt_str_post_dec_imm_offset)\t"
2040         << " f_rd:0x" << hex << f_rd << dec
2041         << " f_rn:0x" << hex << f_rn << dec
2042         << " f_uimm12:0x" << hex << f_uimm12 << dec
2043         << endl;
2044     }
2045
2046 #undef FLD
2047 }
2048
2049 void
2050 arm_extract_sfmt_str_post_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2051     arm_insn_word insn = entire_insn;
2052 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2053     UINT f_rn;
2054     UINT f_rd;
2055     UINT f_operand2_shiftimm;
2056     UINT f_operand2_shifttype;
2057     UINT f_rm;
2058
2059     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2060     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2061     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
2062     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
2063     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2064
2065   /* Record the fields for the semantic handler.  */
2066   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
2067   FLD (f_operand2_shifttype) = f_operand2_shifttype;
2068   FLD (f_rd) = f_rd;
2069   FLD (f_rm) = f_rm;
2070   FLD (f_rn) = f_rn;
2071   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2072   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2073   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2074   if (UNLIKELY(current_cpu->trace_extract_p))
2075     {
2076       current_cpu->trace_stream
2077         << "0x" << hex << pc << dec << " (sfmt_str_post_dec_reg_offset)\t"
2078         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
2079         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
2080         << " f_rd:0x" << hex << f_rd << dec
2081         << " f_rm:0x" << hex << f_rm << dec
2082         << " f_rn:0x" << hex << f_rn << dec
2083         << endl;
2084     }
2085
2086 #undef FLD
2087 }
2088
2089 void
2090 arm_extract_sfmt_str_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2091     arm_insn_word insn = entire_insn;
2092 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2093     UINT f_rn;
2094     UINT f_rd;
2095     UINT f_uimm12;
2096
2097     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2098     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2099     f_uimm12 = EXTRACT_LSB0_UINT (insn, 32, 11, 12);
2100
2101   /* Record the fields for the semantic handler.  */
2102   FLD (f_rd) = f_rd;
2103   FLD (f_rn) = f_rn;
2104   FLD (f_uimm12) = f_uimm12;
2105   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2106   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2107   if (UNLIKELY(current_cpu->trace_extract_p))
2108     {
2109       current_cpu->trace_stream
2110         << "0x" << hex << pc << dec << " (sfmt_str_pre_dec_imm_offset)\t"
2111         << " f_rd:0x" << hex << f_rd << dec
2112         << " f_rn:0x" << hex << f_rn << dec
2113         << " f_uimm12:0x" << hex << f_uimm12 << dec
2114         << endl;
2115     }
2116
2117 #undef FLD
2118 }
2119
2120 void
2121 arm_extract_sfmt_str_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2122     arm_insn_word insn = entire_insn;
2123 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2124     UINT f_rn;
2125     UINT f_rd;
2126     UINT f_operand2_shiftimm;
2127     UINT f_operand2_shifttype;
2128     UINT f_rm;
2129
2130     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2131     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2132     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
2133     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
2134     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2135
2136   /* Record the fields for the semantic handler.  */
2137   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
2138   FLD (f_operand2_shifttype) = f_operand2_shifttype;
2139   FLD (f_rd) = f_rd;
2140   FLD (f_rm) = f_rm;
2141   FLD (f_rn) = f_rn;
2142   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2143   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2144   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2145   if (UNLIKELY(current_cpu->trace_extract_p))
2146     {
2147       current_cpu->trace_stream
2148         << "0x" << hex << pc << dec << " (sfmt_str_pre_dec_reg_offset)\t"
2149         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
2150         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
2151         << " f_rd:0x" << hex << f_rd << dec
2152         << " f_rm:0x" << hex << f_rm << dec
2153         << " f_rn:0x" << hex << f_rn << dec
2154         << endl;
2155     }
2156
2157 #undef FLD
2158 }
2159
2160 void
2161 arm_extract_sfmt_strb_post_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2162     arm_insn_word insn = entire_insn;
2163 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2164     UINT f_rn;
2165     UINT f_rd;
2166     UINT f_uimm12;
2167
2168     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2169     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2170     f_uimm12 = EXTRACT_LSB0_UINT (insn, 32, 11, 12);
2171
2172   /* Record the fields for the semantic handler.  */
2173   FLD (f_rd) = f_rd;
2174   FLD (f_rn) = f_rn;
2175   FLD (f_uimm12) = f_uimm12;
2176   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2177   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2178   if (UNLIKELY(current_cpu->trace_extract_p))
2179     {
2180       current_cpu->trace_stream
2181         << "0x" << hex << pc << dec << " (sfmt_strb_post_dec_imm_offset)\t"
2182         << " f_rd:0x" << hex << f_rd << dec
2183         << " f_rn:0x" << hex << f_rn << dec
2184         << " f_uimm12:0x" << hex << f_uimm12 << dec
2185         << endl;
2186     }
2187
2188 #undef FLD
2189 }
2190
2191 void
2192 arm_extract_sfmt_strb_post_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2193     arm_insn_word insn = entire_insn;
2194 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2195     UINT f_rn;
2196     UINT f_rd;
2197     UINT f_operand2_shiftimm;
2198     UINT f_operand2_shifttype;
2199     UINT f_rm;
2200
2201     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2202     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2203     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
2204     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
2205     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2206
2207   /* Record the fields for the semantic handler.  */
2208   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
2209   FLD (f_operand2_shifttype) = f_operand2_shifttype;
2210   FLD (f_rd) = f_rd;
2211   FLD (f_rm) = f_rm;
2212   FLD (f_rn) = f_rn;
2213   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2214   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2215   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2216   if (UNLIKELY(current_cpu->trace_extract_p))
2217     {
2218       current_cpu->trace_stream
2219         << "0x" << hex << pc << dec << " (sfmt_strb_post_dec_reg_offset)\t"
2220         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
2221         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
2222         << " f_rd:0x" << hex << f_rd << dec
2223         << " f_rm:0x" << hex << f_rm << dec
2224         << " f_rn:0x" << hex << f_rn << dec
2225         << endl;
2226     }
2227
2228 #undef FLD
2229 }
2230
2231 void
2232 arm_extract_sfmt_strb_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2233     arm_insn_word insn = entire_insn;
2234 #define FLD(f) abuf->fields.sfmt_ldr_post_dec_imm_offset.f
2235     UINT f_rn;
2236     UINT f_rd;
2237     UINT f_uimm12;
2238
2239     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2240     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2241     f_uimm12 = EXTRACT_LSB0_UINT (insn, 32, 11, 12);
2242
2243   /* Record the fields for the semantic handler.  */
2244   FLD (f_rd) = f_rd;
2245   FLD (f_rn) = f_rn;
2246   FLD (f_uimm12) = f_uimm12;
2247   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2248   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2249   if (UNLIKELY(current_cpu->trace_extract_p))
2250     {
2251       current_cpu->trace_stream
2252         << "0x" << hex << pc << dec << " (sfmt_strb_pre_dec_imm_offset)\t"
2253         << " f_rd:0x" << hex << f_rd << dec
2254         << " f_rn:0x" << hex << f_rn << dec
2255         << " f_uimm12:0x" << hex << f_uimm12 << dec
2256         << endl;
2257     }
2258
2259 #undef FLD
2260 }
2261
2262 void
2263 arm_extract_sfmt_strb_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2264     arm_insn_word insn = entire_insn;
2265 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2266     UINT f_rn;
2267     UINT f_rd;
2268     UINT f_operand2_shiftimm;
2269     UINT f_operand2_shifttype;
2270     UINT f_rm;
2271
2272     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2273     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2274     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
2275     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
2276     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2277
2278   /* Record the fields for the semantic handler.  */
2279   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
2280   FLD (f_operand2_shifttype) = f_operand2_shifttype;
2281   FLD (f_rd) = f_rd;
2282   FLD (f_rm) = f_rm;
2283   FLD (f_rn) = f_rn;
2284   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2285   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2286   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2287   if (UNLIKELY(current_cpu->trace_extract_p))
2288     {
2289       current_cpu->trace_stream
2290         << "0x" << hex << pc << dec << " (sfmt_strb_pre_dec_reg_offset)\t"
2291         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
2292         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
2293         << " f_rd:0x" << hex << f_rd << dec
2294         << " f_rm:0x" << hex << f_rm << dec
2295         << " f_rn:0x" << hex << f_rn << dec
2296         << endl;
2297     }
2298
2299 #undef FLD
2300 }
2301
2302 void
2303 arm_extract_sfmt_strh_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2304     arm_insn_word insn = entire_insn;
2305 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
2306     UINT f_rn;
2307     UINT f_rd;
2308     UINT f_offset4_hi;
2309     UINT f_offset4_lo;
2310     UINT f_hdt_offset8;
2311
2312     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2313     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2314     f_offset4_hi = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2315     f_offset4_lo = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2316   f_hdt_offset8 = ((((f_offset4_hi) << (4))) | (f_offset4_lo));
2317
2318   /* Record the fields for the semantic handler.  */
2319   FLD (f_rd) = f_rd;
2320   FLD (f_rn) = f_rn;
2321   FLD (i_hdt_offset8) = f_hdt_offset8;
2322   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2323   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2324   if (UNLIKELY(current_cpu->trace_extract_p))
2325     {
2326       current_cpu->trace_stream
2327         << "0x" << hex << pc << dec << " (sfmt_strh_pre_dec_imm_offset)\t"
2328         << " f_rd:0x" << hex << f_rd << dec
2329         << " f_rn:0x" << hex << f_rn << dec
2330         << endl;
2331     }
2332
2333 #undef FLD
2334 }
2335
2336 void
2337 arm_extract_sfmt_strh_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2338     arm_insn_word insn = entire_insn;
2339 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2340     UINT f_rn;
2341     UINT f_rd;
2342     UINT f_rm;
2343
2344     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2345     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2346     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2347
2348   /* Record the fields for the semantic handler.  */
2349   FLD (f_rd) = f_rd;
2350   FLD (f_rm) = f_rm;
2351   FLD (f_rn) = f_rn;
2352   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2353   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2354   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2355   if (UNLIKELY(current_cpu->trace_extract_p))
2356     {
2357       current_cpu->trace_stream
2358         << "0x" << hex << pc << dec << " (sfmt_strh_pre_dec_reg_offset)\t"
2359         << " f_rd:0x" << hex << f_rd << dec
2360         << " f_rm:0x" << hex << f_rm << dec
2361         << " f_rn:0x" << hex << f_rn << dec
2362         << endl;
2363     }
2364
2365 #undef FLD
2366 }
2367
2368 void
2369 arm_extract_sfmt_strh_pre_dec_wb_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2370     arm_insn_word insn = entire_insn;
2371 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
2372     UINT f_rn;
2373     UINT f_rd;
2374     UINT f_offset4_hi;
2375     UINT f_offset4_lo;
2376     UINT f_hdt_offset8;
2377
2378     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2379     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2380     f_offset4_hi = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2381     f_offset4_lo = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2382   f_hdt_offset8 = ((((f_offset4_hi) << (4))) | (f_offset4_lo));
2383
2384   /* Record the fields for the semantic handler.  */
2385   FLD (f_rd) = f_rd;
2386   FLD (f_rn) = f_rn;
2387   FLD (i_hdt_offset8) = f_hdt_offset8;
2388   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2389   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2390   if (UNLIKELY(current_cpu->trace_extract_p))
2391     {
2392       current_cpu->trace_stream
2393         << "0x" << hex << pc << dec << " (sfmt_strh_pre_dec_wb_imm_offset)\t"
2394         << " f_rd:0x" << hex << f_rd << dec
2395         << " f_rn:0x" << hex << f_rn << dec
2396         << endl;
2397     }
2398
2399 #undef FLD
2400 }
2401
2402 void
2403 arm_extract_sfmt_strh_pre_dec_wb_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2404     arm_insn_word insn = entire_insn;
2405 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2406     UINT f_rn;
2407     UINT f_rd;
2408     UINT f_rm;
2409
2410     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2411     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2412     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2413
2414   /* Record the fields for the semantic handler.  */
2415   FLD (f_rd) = f_rd;
2416   FLD (f_rm) = f_rm;
2417   FLD (f_rn) = f_rn;
2418   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2419   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2420   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2421   if (UNLIKELY(current_cpu->trace_extract_p))
2422     {
2423       current_cpu->trace_stream
2424         << "0x" << hex << pc << dec << " (sfmt_strh_pre_dec_wb_reg_offset)\t"
2425         << " f_rd:0x" << hex << f_rd << dec
2426         << " f_rm:0x" << hex << f_rm << dec
2427         << " f_rn:0x" << hex << f_rn << dec
2428         << endl;
2429     }
2430
2431 #undef FLD
2432 }
2433
2434 void
2435 arm_extract_sfmt_ldrsb_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2436     arm_insn_word insn = entire_insn;
2437 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
2438     UINT f_rn;
2439     UINT f_rd;
2440     UINT f_offset4_hi;
2441     UINT f_offset4_lo;
2442     UINT f_hdt_offset8;
2443
2444     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2445     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2446     f_offset4_hi = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2447     f_offset4_lo = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2448   f_hdt_offset8 = ((((f_offset4_hi) << (4))) | (f_offset4_lo));
2449
2450   /* Record the fields for the semantic handler.  */
2451   FLD (f_rd) = f_rd;
2452   FLD (f_rn) = f_rn;
2453   FLD (i_hdt_offset8) = f_hdt_offset8;
2454   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2455   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2456   if (UNLIKELY(current_cpu->trace_extract_p))
2457     {
2458       current_cpu->trace_stream
2459         << "0x" << hex << pc << dec << " (sfmt_ldrsb_pre_dec_imm_offset)\t"
2460         << " f_rd:0x" << hex << f_rd << dec
2461         << " f_rn:0x" << hex << f_rn << dec
2462         << endl;
2463     }
2464
2465 #undef FLD
2466 }
2467
2468 void
2469 arm_extract_sfmt_ldrsb_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2470     arm_insn_word insn = entire_insn;
2471 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2472     UINT f_rn;
2473     UINT f_rd;
2474     UINT f_rm;
2475
2476     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2477     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2478     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2479
2480   /* Record the fields for the semantic handler.  */
2481   FLD (f_rd) = f_rd;
2482   FLD (f_rm) = f_rm;
2483   FLD (f_rn) = f_rn;
2484   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2485   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2486   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2487   if (UNLIKELY(current_cpu->trace_extract_p))
2488     {
2489       current_cpu->trace_stream
2490         << "0x" << hex << pc << dec << " (sfmt_ldrsb_pre_dec_reg_offset)\t"
2491         << " f_rd:0x" << hex << f_rd << dec
2492         << " f_rm:0x" << hex << f_rm << dec
2493         << " f_rn:0x" << hex << f_rn << dec
2494         << endl;
2495     }
2496
2497 #undef FLD
2498 }
2499
2500 void
2501 arm_extract_sfmt_ldrsb_pre_dec_wb_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2502     arm_insn_word insn = entire_insn;
2503 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
2504     UINT f_rn;
2505     UINT f_rd;
2506     UINT f_offset4_hi;
2507     UINT f_offset4_lo;
2508     UINT f_hdt_offset8;
2509
2510     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2511     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2512     f_offset4_hi = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2513     f_offset4_lo = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2514   f_hdt_offset8 = ((((f_offset4_hi) << (4))) | (f_offset4_lo));
2515
2516   /* Record the fields for the semantic handler.  */
2517   FLD (f_rd) = f_rd;
2518   FLD (f_rn) = f_rn;
2519   FLD (i_hdt_offset8) = f_hdt_offset8;
2520   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2521   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2522   if (UNLIKELY(current_cpu->trace_extract_p))
2523     {
2524       current_cpu->trace_stream
2525         << "0x" << hex << pc << dec << " (sfmt_ldrsb_pre_dec_wb_imm_offset)\t"
2526         << " f_rd:0x" << hex << f_rd << dec
2527         << " f_rn:0x" << hex << f_rn << dec
2528         << endl;
2529     }
2530
2531 #undef FLD
2532 }
2533
2534 void
2535 arm_extract_sfmt_ldrsb_pre_dec_wb_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2536     arm_insn_word insn = entire_insn;
2537 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2538     UINT f_rn;
2539     UINT f_rd;
2540     UINT f_rm;
2541
2542     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2543     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2544     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2545
2546   /* Record the fields for the semantic handler.  */
2547   FLD (f_rd) = f_rd;
2548   FLD (f_rm) = f_rm;
2549   FLD (f_rn) = f_rn;
2550   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2551   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2552   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2553   if (UNLIKELY(current_cpu->trace_extract_p))
2554     {
2555       current_cpu->trace_stream
2556         << "0x" << hex << pc << dec << " (sfmt_ldrsb_pre_dec_wb_reg_offset)\t"
2557         << " f_rd:0x" << hex << f_rd << dec
2558         << " f_rm:0x" << hex << f_rm << dec
2559         << " f_rn:0x" << hex << f_rn << dec
2560         << endl;
2561     }
2562
2563 #undef FLD
2564 }
2565
2566 void
2567 arm_extract_sfmt_ldrh_pre_dec_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2568     arm_insn_word insn = entire_insn;
2569 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
2570     UINT f_rn;
2571     UINT f_rd;
2572     UINT f_offset4_hi;
2573     UINT f_offset4_lo;
2574     UINT f_hdt_offset8;
2575
2576     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2577     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2578     f_offset4_hi = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2579     f_offset4_lo = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2580   f_hdt_offset8 = ((((f_offset4_hi) << (4))) | (f_offset4_lo));
2581
2582   /* Record the fields for the semantic handler.  */
2583   FLD (f_rd) = f_rd;
2584   FLD (f_rn) = f_rn;
2585   FLD (i_hdt_offset8) = f_hdt_offset8;
2586   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2587   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2588   if (UNLIKELY(current_cpu->trace_extract_p))
2589     {
2590       current_cpu->trace_stream
2591         << "0x" << hex << pc << dec << " (sfmt_ldrh_pre_dec_imm_offset)\t"
2592         << " f_rd:0x" << hex << f_rd << dec
2593         << " f_rn:0x" << hex << f_rn << dec
2594         << endl;
2595     }
2596
2597 #undef FLD
2598 }
2599
2600 void
2601 arm_extract_sfmt_ldrh_pre_dec_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2602     arm_insn_word insn = entire_insn;
2603 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2604     UINT f_rn;
2605     UINT f_rd;
2606     UINT f_rm;
2607
2608     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2609     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2610     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2611
2612   /* Record the fields for the semantic handler.  */
2613   FLD (f_rd) = f_rd;
2614   FLD (f_rm) = f_rm;
2615   FLD (f_rn) = f_rn;
2616   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2617   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2618   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2619   if (UNLIKELY(current_cpu->trace_extract_p))
2620     {
2621       current_cpu->trace_stream
2622         << "0x" << hex << pc << dec << " (sfmt_ldrh_pre_dec_reg_offset)\t"
2623         << " f_rd:0x" << hex << f_rd << dec
2624         << " f_rm:0x" << hex << f_rm << dec
2625         << " f_rn:0x" << hex << f_rn << dec
2626         << endl;
2627     }
2628
2629 #undef FLD
2630 }
2631
2632 void
2633 arm_extract_sfmt_ldrh_pre_dec_wb_imm_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2634     arm_insn_word insn = entire_insn;
2635 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
2636     UINT f_rn;
2637     UINT f_rd;
2638     UINT f_offset4_hi;
2639     UINT f_offset4_lo;
2640     UINT f_hdt_offset8;
2641
2642     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2643     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2644     f_offset4_hi = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2645     f_offset4_lo = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2646   f_hdt_offset8 = ((((f_offset4_hi) << (4))) | (f_offset4_lo));
2647
2648   /* Record the fields for the semantic handler.  */
2649   FLD (f_rd) = f_rd;
2650   FLD (f_rn) = f_rn;
2651   FLD (i_hdt_offset8) = f_hdt_offset8;
2652   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2653   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2654   if (UNLIKELY(current_cpu->trace_extract_p))
2655     {
2656       current_cpu->trace_stream
2657         << "0x" << hex << pc << dec << " (sfmt_ldrh_pre_dec_wb_imm_offset)\t"
2658         << " f_rd:0x" << hex << f_rd << dec
2659         << " f_rn:0x" << hex << f_rn << dec
2660         << endl;
2661     }
2662
2663 #undef FLD
2664 }
2665
2666 void
2667 arm_extract_sfmt_ldrh_pre_dec_wb_reg_offset (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2668     arm_insn_word insn = entire_insn;
2669 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2670     UINT f_rn;
2671     UINT f_rd;
2672     UINT f_rm;
2673
2674     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2675     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2676     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2677
2678   /* Record the fields for the semantic handler.  */
2679   FLD (f_rd) = f_rd;
2680   FLD (f_rm) = f_rm;
2681   FLD (f_rn) = f_rn;
2682   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2683   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2684   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2685   if (UNLIKELY(current_cpu->trace_extract_p))
2686     {
2687       current_cpu->trace_stream
2688         << "0x" << hex << pc << dec << " (sfmt_ldrh_pre_dec_wb_reg_offset)\t"
2689         << " f_rd:0x" << hex << f_rd << dec
2690         << " f_rm:0x" << hex << f_rm << dec
2691         << " f_rn:0x" << hex << f_rn << dec
2692         << endl;
2693     }
2694
2695 #undef FLD
2696 }
2697
2698 void
2699 arm_extract_sfmt_mul (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2700     arm_insn_word insn = entire_insn;
2701 #define FLD(f) abuf->fields.sfmt_mla.f
2702     UINT f_set_cc_;
2703     UINT f_mul_rd;
2704     UINT f_rs;
2705     UINT f_rm;
2706
2707     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
2708     f_mul_rd = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2709     f_rs = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2710     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2711
2712   /* Record the fields for the semantic handler.  */
2713   FLD (f_rm) = f_rm;
2714   FLD (f_rs) = f_rs;
2715   FLD (f_set_cc_) = f_set_cc_;
2716   FLD (f_mul_rd) = f_mul_rd;
2717   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2718   FLD (i_rs) = & current_cpu->hardware.h_gr[f_rs];
2719   FLD (i_mul_rd) = & current_cpu->hardware.h_gr[f_mul_rd];
2720   if (UNLIKELY(current_cpu->trace_extract_p))
2721     {
2722       current_cpu->trace_stream
2723         << "0x" << hex << pc << dec << " (sfmt_mul)\t"
2724         << " f_rm:0x" << hex << f_rm << dec
2725         << " f_rs:0x" << hex << f_rs << dec
2726         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
2727         << " f_mul_rd:0x" << hex << f_mul_rd << dec
2728         << endl;
2729     }
2730
2731 #undef FLD
2732 }
2733
2734 void
2735 arm_extract_sfmt_mla (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2736     arm_insn_word insn = entire_insn;
2737 #define FLD(f) abuf->fields.sfmt_mla.f
2738     UINT f_set_cc_;
2739     UINT f_mul_rd;
2740     UINT f_mul_rn;
2741     UINT f_rs;
2742     UINT f_rm;
2743
2744     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
2745     f_mul_rd = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2746     f_mul_rn = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2747     f_rs = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2748     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2749
2750   /* Record the fields for the semantic handler.  */
2751   FLD (f_mul_rn) = f_mul_rn;
2752   FLD (f_rm) = f_rm;
2753   FLD (f_rs) = f_rs;
2754   FLD (f_set_cc_) = f_set_cc_;
2755   FLD (f_mul_rd) = f_mul_rd;
2756   FLD (i_mul_rn) = & current_cpu->hardware.h_gr[f_mul_rn];
2757   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2758   FLD (i_rs) = & current_cpu->hardware.h_gr[f_rs];
2759   FLD (i_mul_rd) = & current_cpu->hardware.h_gr[f_mul_rd];
2760   if (UNLIKELY(current_cpu->trace_extract_p))
2761     {
2762       current_cpu->trace_stream
2763         << "0x" << hex << pc << dec << " (sfmt_mla)\t"
2764         << " f_mul_rn:0x" << hex << f_mul_rn << dec
2765         << " f_rm:0x" << hex << f_rm << dec
2766         << " f_rs:0x" << hex << f_rs << dec
2767         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
2768         << " f_mul_rd:0x" << hex << f_mul_rd << dec
2769         << endl;
2770     }
2771
2772 #undef FLD
2773 }
2774
2775 void
2776 arm_extract_sfmt_umull (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2777     arm_insn_word insn = entire_insn;
2778 #define FLD(f) abuf->fields.sfmt_umull.f
2779     UINT f_set_cc_;
2780     UINT f_rdhi;
2781     UINT f_rdlo;
2782     UINT f_rs;
2783     UINT f_rm;
2784
2785     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
2786     f_rdhi = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2787     f_rdlo = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2788     f_rs = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2789     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2790
2791   /* Record the fields for the semantic handler.  */
2792   FLD (f_rm) = f_rm;
2793   FLD (f_rs) = f_rs;
2794   FLD (f_set_cc_) = f_set_cc_;
2795   FLD (f_rdhi) = f_rdhi;
2796   FLD (f_rdlo) = f_rdlo;
2797   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2798   FLD (i_rs) = & current_cpu->hardware.h_gr[f_rs];
2799   FLD (i_rdhi) = & current_cpu->hardware.h_gr[f_rdhi];
2800   FLD (i_rdlo) = & current_cpu->hardware.h_gr[f_rdlo];
2801   if (UNLIKELY(current_cpu->trace_extract_p))
2802     {
2803       current_cpu->trace_stream
2804         << "0x" << hex << pc << dec << " (sfmt_umull)\t"
2805         << " f_rm:0x" << hex << f_rm << dec
2806         << " f_rs:0x" << hex << f_rs << dec
2807         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
2808         << " f_rdhi:0x" << hex << f_rdhi << dec
2809         << " f_rdlo:0x" << hex << f_rdlo << dec
2810         << endl;
2811     }
2812
2813 #undef FLD
2814 }
2815
2816 void
2817 arm_extract_sfmt_umlal (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2818     arm_insn_word insn = entire_insn;
2819 #define FLD(f) abuf->fields.sfmt_umull.f
2820     UINT f_set_cc_;
2821     UINT f_rdhi;
2822     UINT f_rdlo;
2823     UINT f_rs;
2824     UINT f_rm;
2825
2826     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
2827     f_rdhi = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2828     f_rdlo = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2829     f_rs = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
2830     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2831
2832   /* Record the fields for the semantic handler.  */
2833   FLD (f_rdhi) = f_rdhi;
2834   FLD (f_rdlo) = f_rdlo;
2835   FLD (f_rm) = f_rm;
2836   FLD (f_rs) = f_rs;
2837   FLD (f_set_cc_) = f_set_cc_;
2838   FLD (i_rdhi) = & current_cpu->hardware.h_gr[f_rdhi];
2839   FLD (i_rdlo) = & current_cpu->hardware.h_gr[f_rdlo];
2840   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2841   FLD (i_rs) = & current_cpu->hardware.h_gr[f_rs];
2842   if (UNLIKELY(current_cpu->trace_extract_p))
2843     {
2844       current_cpu->trace_stream
2845         << "0x" << hex << pc << dec << " (sfmt_umlal)\t"
2846         << " f_rdhi:0x" << hex << f_rdhi << dec
2847         << " f_rdlo:0x" << hex << f_rdlo << dec
2848         << " f_rm:0x" << hex << f_rm << dec
2849         << " f_rs:0x" << hex << f_rs << dec
2850         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
2851         << endl;
2852     }
2853
2854 #undef FLD
2855 }
2856
2857 void
2858 arm_extract_sfmt_swp (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2859     arm_insn_word insn = entire_insn;
2860 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2861     UINT f_rn;
2862     UINT f_rd;
2863     UINT f_rm;
2864
2865     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2866     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2867     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2868
2869   /* Record the fields for the semantic handler.  */
2870   FLD (f_rm) = f_rm;
2871   FLD (f_rn) = f_rn;
2872   FLD (f_rd) = f_rd;
2873   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2874   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2875   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2876   if (UNLIKELY(current_cpu->trace_extract_p))
2877     {
2878       current_cpu->trace_stream
2879         << "0x" << hex << pc << dec << " (sfmt_swp)\t"
2880         << " f_rm:0x" << hex << f_rm << dec
2881         << " f_rn:0x" << hex << f_rn << dec
2882         << " f_rd:0x" << hex << f_rd << dec
2883         << endl;
2884     }
2885
2886 #undef FLD
2887 }
2888
2889 void
2890 arm_extract_sfmt_swpb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2891     arm_insn_word insn = entire_insn;
2892 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2893     UINT f_rn;
2894     UINT f_rd;
2895     UINT f_rm;
2896
2897     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2898     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2899     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2900
2901   /* Record the fields for the semantic handler.  */
2902   FLD (f_rm) = f_rm;
2903   FLD (f_rn) = f_rn;
2904   FLD (f_rd) = f_rd;
2905   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2906   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2907   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2908   if (UNLIKELY(current_cpu->trace_extract_p))
2909     {
2910       current_cpu->trace_stream
2911         << "0x" << hex << pc << dec << " (sfmt_swpb)\t"
2912         << " f_rm:0x" << hex << f_rm << dec
2913         << " f_rn:0x" << hex << f_rn << dec
2914         << " f_rd:0x" << hex << f_rd << dec
2915         << endl;
2916     }
2917
2918 #undef FLD
2919 }
2920
2921 void
2922 arm_extract_sfmt_swi (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2923     arm_insn_word insn = entire_insn;
2924 #define FLD(f) abuf->fields.sfmt_swi.f
2925     UINT f_swi_comment;
2926
2927     f_swi_comment = EXTRACT_LSB0_UINT (insn, 32, 23, 24);
2928
2929   /* Record the fields for the semantic handler.  */
2930   FLD (f_swi_comment) = f_swi_comment;
2931   if (UNLIKELY(current_cpu->trace_extract_p))
2932     {
2933       current_cpu->trace_stream
2934         << "0x" << hex << pc << dec << " (sfmt_swi)\t"
2935         << " f_swi_comment:0x" << hex << f_swi_comment << dec
2936         << endl;
2937     }
2938
2939 #undef FLD
2940 }
2941
2942 void
2943 arm_extract_sfmt_and_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2944     arm_insn_word insn = entire_insn;
2945 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
2946     UINT f_set_cc_;
2947     UINT f_rn;
2948     UINT f_rd;
2949     UINT f_operand2_shiftimm;
2950     UINT f_operand2_shifttype;
2951     UINT f_rm;
2952
2953     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
2954     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2955     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
2956     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
2957     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
2958     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
2959
2960   /* Record the fields for the semantic handler.  */
2961   FLD (f_rd) = f_rd;
2962   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
2963   FLD (f_operand2_shifttype) = f_operand2_shifttype;
2964   FLD (f_rm) = f_rm;
2965   FLD (f_rn) = f_rn;
2966   FLD (f_set_cc_) = f_set_cc_;
2967   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
2968   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
2969   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
2970   if (UNLIKELY(current_cpu->trace_extract_p))
2971     {
2972       current_cpu->trace_stream
2973         << "0x" << hex << pc << dec << " (sfmt_and_reg_imm_shift)\t"
2974         << " f_rd:0x" << hex << f_rd << dec
2975         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
2976         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
2977         << " f_rm:0x" << hex << f_rm << dec
2978         << " f_rn:0x" << hex << f_rn << dec
2979         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
2980         << endl;
2981     }
2982
2983 #undef FLD
2984 }
2985
2986 void
2987 arm_extract_sfmt_and_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
2988     arm_insn_word insn = entire_insn;
2989 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
2990     UINT f_set_cc_;
2991     UINT f_rn;
2992     UINT f_rd;
2993     UINT f_operand2_shiftreg;
2994     UINT f_operand2_shifttype;
2995     UINT f_rm;
2996
2997     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
2998     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
2999     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3000     f_operand2_shiftreg = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
3001     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3002     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3003
3004   /* Record the fields for the semantic handler.  */
3005   FLD (f_rd) = f_rd;
3006   FLD (f_operand2_shiftreg) = f_operand2_shiftreg;
3007   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3008   FLD (f_rm) = f_rm;
3009   FLD (f_rn) = f_rn;
3010   FLD (f_set_cc_) = f_set_cc_;
3011   FLD (i_operand2_shiftreg) = & current_cpu->hardware.h_gr[f_operand2_shiftreg];
3012   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3013   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3014   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3015   if (UNLIKELY(current_cpu->trace_extract_p))
3016     {
3017       current_cpu->trace_stream
3018         << "0x" << hex << pc << dec << " (sfmt_and_reg_reg_shift)\t"
3019         << " f_rd:0x" << hex << f_rd << dec
3020         << " f_operand2_shiftreg:0x" << hex << f_operand2_shiftreg << dec
3021         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3022         << " f_rm:0x" << hex << f_rm << dec
3023         << " f_rn:0x" << hex << f_rn << dec
3024         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3025         << endl;
3026     }
3027
3028 #undef FLD
3029 }
3030
3031 void
3032 arm_extract_sfmt_and_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3033     arm_insn_word insn = entire_insn;
3034 #define FLD(f) abuf->fields.sfmt_and_imm.f
3035     UINT f_set_cc_;
3036     UINT f_rn;
3037     UINT f_rd;
3038     SI f_imm12;
3039
3040     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3041     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3042     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3043     f_imm12 = RORSI (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (255)), ((2) * (((unsigned int) (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (3840))) >> (8)))));
3044
3045   /* Record the fields for the semantic handler.  */
3046   FLD (f_rd) = f_rd;
3047   FLD (f_imm12) = f_imm12;
3048   FLD (f_rn) = f_rn;
3049   FLD (f_set_cc_) = f_set_cc_;
3050   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3051   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3052   if (UNLIKELY(current_cpu->trace_extract_p))
3053     {
3054       current_cpu->trace_stream
3055         << "0x" << hex << pc << dec << " (sfmt_and_imm)\t"
3056         << " f_rd:0x" << hex << f_rd << dec
3057         << " f_imm12:0x" << hex << f_imm12 << dec
3058         << " f_rn:0x" << hex << f_rn << dec
3059         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3060         << endl;
3061     }
3062
3063 #undef FLD
3064 }
3065
3066 void
3067 arm_extract_sfmt_mov_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3068     arm_insn_word insn = entire_insn;
3069 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3070     UINT f_set_cc_;
3071     UINT f_rd;
3072     UINT f_operand2_shiftimm;
3073     UINT f_operand2_shifttype;
3074     UINT f_rm;
3075
3076     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3077     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3078     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
3079     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3080     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3081
3082   /* Record the fields for the semantic handler.  */
3083   FLD (f_rd) = f_rd;
3084   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
3085   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3086   FLD (f_rm) = f_rm;
3087   FLD (f_set_cc_) = f_set_cc_;
3088   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3089   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3090   if (UNLIKELY(current_cpu->trace_extract_p))
3091     {
3092       current_cpu->trace_stream
3093         << "0x" << hex << pc << dec << " (sfmt_mov_reg_imm_shift)\t"
3094         << " f_rd:0x" << hex << f_rd << dec
3095         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
3096         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3097         << " f_rm:0x" << hex << f_rm << dec
3098         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3099         << endl;
3100     }
3101
3102 #undef FLD
3103 }
3104
3105 void
3106 arm_extract_sfmt_mov_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3107     arm_insn_word insn = entire_insn;
3108 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
3109     UINT f_set_cc_;
3110     UINT f_rd;
3111     UINT f_operand2_shiftreg;
3112     UINT f_operand2_shifttype;
3113     UINT f_rm;
3114
3115     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3116     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3117     f_operand2_shiftreg = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
3118     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3119     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3120
3121   /* Record the fields for the semantic handler.  */
3122   FLD (f_rd) = f_rd;
3123   FLD (f_operand2_shiftreg) = f_operand2_shiftreg;
3124   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3125   FLD (f_rm) = f_rm;
3126   FLD (f_set_cc_) = f_set_cc_;
3127   FLD (i_operand2_shiftreg) = & current_cpu->hardware.h_gr[f_operand2_shiftreg];
3128   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3129   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3130   if (UNLIKELY(current_cpu->trace_extract_p))
3131     {
3132       current_cpu->trace_stream
3133         << "0x" << hex << pc << dec << " (sfmt_mov_reg_reg_shift)\t"
3134         << " f_rd:0x" << hex << f_rd << dec
3135         << " f_operand2_shiftreg:0x" << hex << f_operand2_shiftreg << dec
3136         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3137         << " f_rm:0x" << hex << f_rm << dec
3138         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3139         << endl;
3140     }
3141
3142 #undef FLD
3143 }
3144
3145 void
3146 arm_extract_sfmt_mov_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3147     arm_insn_word insn = entire_insn;
3148 #define FLD(f) abuf->fields.sfmt_and_imm.f
3149     UINT f_set_cc_;
3150     UINT f_rd;
3151     SI f_imm12;
3152
3153     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3154     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3155     f_imm12 = RORSI (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (255)), ((2) * (((unsigned int) (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (3840))) >> (8)))));
3156
3157   /* Record the fields for the semantic handler.  */
3158   FLD (f_rd) = f_rd;
3159   FLD (f_imm12) = f_imm12;
3160   FLD (f_set_cc_) = f_set_cc_;
3161   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3162   if (UNLIKELY(current_cpu->trace_extract_p))
3163     {
3164       current_cpu->trace_stream
3165         << "0x" << hex << pc << dec << " (sfmt_mov_imm)\t"
3166         << " f_rd:0x" << hex << f_rd << dec
3167         << " f_imm12:0x" << hex << f_imm12 << dec
3168         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3169         << endl;
3170     }
3171
3172 #undef FLD
3173 }
3174
3175 void
3176 arm_extract_sfmt_add_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3177     arm_insn_word insn = entire_insn;
3178 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3179     UINT f_set_cc_;
3180     UINT f_rn;
3181     UINT f_rd;
3182     UINT f_operand2_shiftimm;
3183     UINT f_operand2_shifttype;
3184     UINT f_rm;
3185
3186     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3187     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3188     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3189     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
3190     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3191     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3192
3193   /* Record the fields for the semantic handler.  */
3194   FLD (f_rd) = f_rd;
3195   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
3196   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3197   FLD (f_rm) = f_rm;
3198   FLD (f_rn) = f_rn;
3199   FLD (f_set_cc_) = f_set_cc_;
3200   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3201   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3202   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3203   if (UNLIKELY(current_cpu->trace_extract_p))
3204     {
3205       current_cpu->trace_stream
3206         << "0x" << hex << pc << dec << " (sfmt_add_reg_imm_shift)\t"
3207         << " f_rd:0x" << hex << f_rd << dec
3208         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
3209         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3210         << " f_rm:0x" << hex << f_rm << dec
3211         << " f_rn:0x" << hex << f_rn << dec
3212         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3213         << endl;
3214     }
3215
3216 #undef FLD
3217 }
3218
3219 void
3220 arm_extract_sfmt_add_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3221     arm_insn_word insn = entire_insn;
3222 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
3223     UINT f_set_cc_;
3224     UINT f_rn;
3225     UINT f_rd;
3226     UINT f_operand2_shiftreg;
3227     UINT f_operand2_shifttype;
3228     UINT f_rm;
3229
3230     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3231     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3232     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3233     f_operand2_shiftreg = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
3234     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3235     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3236
3237   /* Record the fields for the semantic handler.  */
3238   FLD (f_rd) = f_rd;
3239   FLD (f_operand2_shiftreg) = f_operand2_shiftreg;
3240   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3241   FLD (f_rm) = f_rm;
3242   FLD (f_rn) = f_rn;
3243   FLD (f_set_cc_) = f_set_cc_;
3244   FLD (i_operand2_shiftreg) = & current_cpu->hardware.h_gr[f_operand2_shiftreg];
3245   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3246   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3247   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3248   if (UNLIKELY(current_cpu->trace_extract_p))
3249     {
3250       current_cpu->trace_stream
3251         << "0x" << hex << pc << dec << " (sfmt_add_reg_reg_shift)\t"
3252         << " f_rd:0x" << hex << f_rd << dec
3253         << " f_operand2_shiftreg:0x" << hex << f_operand2_shiftreg << dec
3254         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3255         << " f_rm:0x" << hex << f_rm << dec
3256         << " f_rn:0x" << hex << f_rn << dec
3257         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3258         << endl;
3259     }
3260
3261 #undef FLD
3262 }
3263
3264 void
3265 arm_extract_sfmt_add_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3266     arm_insn_word insn = entire_insn;
3267 #define FLD(f) abuf->fields.sfmt_and_imm.f
3268     UINT f_set_cc_;
3269     UINT f_rn;
3270     UINT f_rd;
3271     SI f_imm12;
3272
3273     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3274     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3275     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3276     f_imm12 = RORSI (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (255)), ((2) * (((unsigned int) (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (3840))) >> (8)))));
3277
3278   /* Record the fields for the semantic handler.  */
3279   FLD (f_rd) = f_rd;
3280   FLD (f_imm12) = f_imm12;
3281   FLD (f_rn) = f_rn;
3282   FLD (f_set_cc_) = f_set_cc_;
3283   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3284   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3285   if (UNLIKELY(current_cpu->trace_extract_p))
3286     {
3287       current_cpu->trace_stream
3288         << "0x" << hex << pc << dec << " (sfmt_add_imm)\t"
3289         << " f_rd:0x" << hex << f_rd << dec
3290         << " f_imm12:0x" << hex << f_imm12 << dec
3291         << " f_rn:0x" << hex << f_rn << dec
3292         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3293         << endl;
3294     }
3295
3296 #undef FLD
3297 }
3298
3299 void
3300 arm_extract_sfmt_adc_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3301     arm_insn_word insn = entire_insn;
3302 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3303     UINT f_set_cc_;
3304     UINT f_rn;
3305     UINT f_rd;
3306     UINT f_operand2_shiftimm;
3307     UINT f_operand2_shifttype;
3308     UINT f_rm;
3309
3310     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3311     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3312     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3313     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
3314     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3315     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3316
3317   /* Record the fields for the semantic handler.  */
3318   FLD (f_rd) = f_rd;
3319   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
3320   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3321   FLD (f_rm) = f_rm;
3322   FLD (f_rn) = f_rn;
3323   FLD (f_set_cc_) = f_set_cc_;
3324   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3325   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3326   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3327   if (UNLIKELY(current_cpu->trace_extract_p))
3328     {
3329       current_cpu->trace_stream
3330         << "0x" << hex << pc << dec << " (sfmt_adc_reg_imm_shift)\t"
3331         << " f_rd:0x" << hex << f_rd << dec
3332         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
3333         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3334         << " f_rm:0x" << hex << f_rm << dec
3335         << " f_rn:0x" << hex << f_rn << dec
3336         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3337         << endl;
3338     }
3339
3340 #undef FLD
3341 }
3342
3343 void
3344 arm_extract_sfmt_adc_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3345     arm_insn_word insn = entire_insn;
3346 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
3347     UINT f_set_cc_;
3348     UINT f_rn;
3349     UINT f_rd;
3350     UINT f_operand2_shiftreg;
3351     UINT f_operand2_shifttype;
3352     UINT f_rm;
3353
3354     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3355     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3356     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3357     f_operand2_shiftreg = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
3358     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3359     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3360
3361   /* Record the fields for the semantic handler.  */
3362   FLD (f_rd) = f_rd;
3363   FLD (f_operand2_shiftreg) = f_operand2_shiftreg;
3364   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3365   FLD (f_rm) = f_rm;
3366   FLD (f_rn) = f_rn;
3367   FLD (f_set_cc_) = f_set_cc_;
3368   FLD (i_operand2_shiftreg) = & current_cpu->hardware.h_gr[f_operand2_shiftreg];
3369   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3370   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3371   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3372   if (UNLIKELY(current_cpu->trace_extract_p))
3373     {
3374       current_cpu->trace_stream
3375         << "0x" << hex << pc << dec << " (sfmt_adc_reg_reg_shift)\t"
3376         << " f_rd:0x" << hex << f_rd << dec
3377         << " f_operand2_shiftreg:0x" << hex << f_operand2_shiftreg << dec
3378         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3379         << " f_rm:0x" << hex << f_rm << dec
3380         << " f_rn:0x" << hex << f_rn << dec
3381         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3382         << endl;
3383     }
3384
3385 #undef FLD
3386 }
3387
3388 void
3389 arm_extract_sfmt_adc_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3390     arm_insn_word insn = entire_insn;
3391 #define FLD(f) abuf->fields.sfmt_and_imm.f
3392     UINT f_set_cc_;
3393     UINT f_rn;
3394     UINT f_rd;
3395     SI f_imm12;
3396
3397     f_set_cc_ = EXTRACT_LSB0_UINT (insn, 32, 20, 1);
3398     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3399     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3400     f_imm12 = RORSI (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (255)), ((2) * (((unsigned int) (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (3840))) >> (8)))));
3401
3402   /* Record the fields for the semantic handler.  */
3403   FLD (f_rd) = f_rd;
3404   FLD (f_imm12) = f_imm12;
3405   FLD (f_rn) = f_rn;
3406   FLD (f_set_cc_) = f_set_cc_;
3407   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3408   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3409   if (UNLIKELY(current_cpu->trace_extract_p))
3410     {
3411       current_cpu->trace_stream
3412         << "0x" << hex << pc << dec << " (sfmt_adc_imm)\t"
3413         << " f_rd:0x" << hex << f_rd << dec
3414         << " f_imm12:0x" << hex << f_imm12 << dec
3415         << " f_rn:0x" << hex << f_rn << dec
3416         << " f_set_cc_:0x" << hex << f_set_cc_ << dec
3417         << endl;
3418     }
3419
3420 #undef FLD
3421 }
3422
3423 void
3424 arm_extract_sfmt_tst_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3425     arm_insn_word insn = entire_insn;
3426 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3427     UINT f_rn;
3428     UINT f_rd;
3429     UINT f_operand2_shiftimm;
3430     UINT f_operand2_shifttype;
3431     UINT f_rm;
3432
3433     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3434     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3435     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
3436     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3437     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3438
3439   /* Record the fields for the semantic handler.  */
3440   FLD (f_rd) = f_rd;
3441   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
3442   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3443   FLD (f_rm) = f_rm;
3444   FLD (f_rn) = f_rn;
3445   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3446   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3447   if (UNLIKELY(current_cpu->trace_extract_p))
3448     {
3449       current_cpu->trace_stream
3450         << "0x" << hex << pc << dec << " (sfmt_tst_reg_imm_shift)\t"
3451         << " f_rd:0x" << hex << f_rd << dec
3452         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
3453         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3454         << " f_rm:0x" << hex << f_rm << dec
3455         << " f_rn:0x" << hex << f_rn << dec
3456         << endl;
3457     }
3458
3459 #undef FLD
3460 }
3461
3462 void
3463 arm_extract_sfmt_tst_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3464     arm_insn_word insn = entire_insn;
3465 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
3466     UINT f_rn;
3467     UINT f_rd;
3468     UINT f_operand2_shiftreg;
3469     UINT f_operand2_shifttype;
3470     UINT f_rm;
3471
3472     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3473     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3474     f_operand2_shiftreg = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
3475     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3476     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3477
3478   /* Record the fields for the semantic handler.  */
3479   FLD (f_rd) = f_rd;
3480   FLD (f_operand2_shiftreg) = f_operand2_shiftreg;
3481   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3482   FLD (f_rm) = f_rm;
3483   FLD (f_rn) = f_rn;
3484   FLD (i_operand2_shiftreg) = & current_cpu->hardware.h_gr[f_operand2_shiftreg];
3485   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3486   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3487   if (UNLIKELY(current_cpu->trace_extract_p))
3488     {
3489       current_cpu->trace_stream
3490         << "0x" << hex << pc << dec << " (sfmt_tst_reg_reg_shift)\t"
3491         << " f_rd:0x" << hex << f_rd << dec
3492         << " f_operand2_shiftreg:0x" << hex << f_operand2_shiftreg << dec
3493         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3494         << " f_rm:0x" << hex << f_rm << dec
3495         << " f_rn:0x" << hex << f_rn << dec
3496         << endl;
3497     }
3498
3499 #undef FLD
3500 }
3501
3502 void
3503 arm_extract_sfmt_tst_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3504     arm_insn_word insn = entire_insn;
3505 #define FLD(f) abuf->fields.sfmt_tst_imm.f
3506     UINT f_rn;
3507     UINT f_ror_imm8_rotate;
3508     UINT f_ror_imm8_value;
3509     UINT f_ror_imm8;
3510
3511     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3512     f_ror_imm8_rotate = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
3513     f_ror_imm8_value = EXTRACT_LSB0_UINT (insn, 32, 7, 8);
3514 {
3515   f_ror_imm8 = RORSI (f_ror_imm8_value, ((2) * (f_ror_imm8_rotate)));
3516 }
3517
3518   /* Record the fields for the semantic handler.  */
3519   FLD (f_ror_imm8_rotate) = f_ror_imm8_rotate;
3520   FLD (f_rn) = f_rn;
3521   FLD (f_ror_imm8) = f_ror_imm8;
3522   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3523   if (UNLIKELY(current_cpu->trace_extract_p))
3524     {
3525       current_cpu->trace_stream
3526         << "0x" << hex << pc << dec << " (sfmt_tst_imm)\t"
3527         << " f_ror_imm8_rotate:0x" << hex << f_ror_imm8_rotate << dec
3528         << " f_rn:0x" << hex << f_rn << dec
3529         << " f_ror_imm8:0x" << hex << f_ror_imm8 << dec
3530         << endl;
3531     }
3532
3533 #undef FLD
3534 }
3535
3536 void
3537 arm_extract_sfmt_cmp_reg_imm_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3538     arm_insn_word insn = entire_insn;
3539 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3540     UINT f_rn;
3541     UINT f_rd;
3542     UINT f_operand2_shiftimm;
3543     UINT f_operand2_shifttype;
3544     UINT f_rm;
3545
3546     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3547     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3548     f_operand2_shiftimm = EXTRACT_LSB0_UINT (insn, 32, 11, 5);
3549     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3550     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3551
3552   /* Record the fields for the semantic handler.  */
3553   FLD (f_rd) = f_rd;
3554   FLD (f_operand2_shiftimm) = f_operand2_shiftimm;
3555   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3556   FLD (f_rm) = f_rm;
3557   FLD (f_rn) = f_rn;
3558   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3559   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3560   if (UNLIKELY(current_cpu->trace_extract_p))
3561     {
3562       current_cpu->trace_stream
3563         << "0x" << hex << pc << dec << " (sfmt_cmp_reg_imm_shift)\t"
3564         << " f_rd:0x" << hex << f_rd << dec
3565         << " f_operand2_shiftimm:0x" << hex << f_operand2_shiftimm << dec
3566         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3567         << " f_rm:0x" << hex << f_rm << dec
3568         << " f_rn:0x" << hex << f_rn << dec
3569         << endl;
3570     }
3571
3572 #undef FLD
3573 }
3574
3575 void
3576 arm_extract_sfmt_cmp_reg_reg_shift (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3577     arm_insn_word insn = entire_insn;
3578 #define FLD(f) abuf->fields.sfmt_and_reg_reg_shift.f
3579     UINT f_rn;
3580     UINT f_rd;
3581     UINT f_operand2_shiftreg;
3582     UINT f_operand2_shifttype;
3583     UINT f_rm;
3584
3585     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3586     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3587     f_operand2_shiftreg = EXTRACT_LSB0_UINT (insn, 32, 11, 4);
3588     f_operand2_shifttype = EXTRACT_LSB0_UINT (insn, 32, 6, 2);
3589     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3590
3591   /* Record the fields for the semantic handler.  */
3592   FLD (f_rd) = f_rd;
3593   FLD (f_operand2_shiftreg) = f_operand2_shiftreg;
3594   FLD (f_operand2_shifttype) = f_operand2_shifttype;
3595   FLD (f_rm) = f_rm;
3596   FLD (f_rn) = f_rn;
3597   FLD (i_operand2_shiftreg) = & current_cpu->hardware.h_gr[f_operand2_shiftreg];
3598   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3599   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3600   if (UNLIKELY(current_cpu->trace_extract_p))
3601     {
3602       current_cpu->trace_stream
3603         << "0x" << hex << pc << dec << " (sfmt_cmp_reg_reg_shift)\t"
3604         << " f_rd:0x" << hex << f_rd << dec
3605         << " f_operand2_shiftreg:0x" << hex << f_operand2_shiftreg << dec
3606         << " f_operand2_shifttype:0x" << hex << f_operand2_shifttype << dec
3607         << " f_rm:0x" << hex << f_rm << dec
3608         << " f_rn:0x" << hex << f_rn << dec
3609         << endl;
3610     }
3611
3612 #undef FLD
3613 }
3614
3615 void
3616 arm_extract_sfmt_cmp_imm (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3617     arm_insn_word insn = entire_insn;
3618 #define FLD(f) abuf->fields.sfmt_and_imm.f
3619     UINT f_rn;
3620     SI f_imm12;
3621
3622     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3623     f_imm12 = RORSI (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (255)), ((2) * (((unsigned int) (((EXTRACT_LSB0_UINT (insn, 32, 11, 12)) & (3840))) >> (8)))));
3624
3625   /* Record the fields for the semantic handler.  */
3626   FLD (f_imm12) = f_imm12;
3627   FLD (f_rn) = f_rn;
3628   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3629   if (UNLIKELY(current_cpu->trace_extract_p))
3630     {
3631       current_cpu->trace_stream
3632         << "0x" << hex << pc << dec << " (sfmt_cmp_imm)\t"
3633         << " f_imm12:0x" << hex << f_imm12 << dec
3634         << " f_rn:0x" << hex << f_rn << dec
3635         << endl;
3636     }
3637
3638 #undef FLD
3639 }
3640
3641 void
3642 arm_extract_sfmt_ldmda (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3643     arm_insn_word insn = entire_insn;
3644 #define FLD(f) abuf->fields.sfmt_ldmda.f
3645     UINT f_rn;
3646     UINT f_reg_list;
3647
3648     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3649     f_reg_list = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
3650
3651   /* Record the fields for the semantic handler.  */
3652   FLD (f_reg_list) = f_reg_list;
3653   FLD (f_rn) = f_rn;
3654   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3655   if (UNLIKELY(current_cpu->trace_extract_p))
3656     {
3657       current_cpu->trace_stream
3658         << "0x" << hex << pc << dec << " (sfmt_ldmda)\t"
3659         << " f_reg_list:0x" << hex << f_reg_list << dec
3660         << " f_rn:0x" << hex << f_rn << dec
3661         << endl;
3662     }
3663
3664 #undef FLD
3665 }
3666
3667 void
3668 arm_extract_sfmt_ldmda_sw (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3669     arm_insn_word insn = entire_insn;
3670 #define FLD(f) abuf->fields.sfmt_ldmda.f
3671     UINT f_rn;
3672     UINT f_reg_list;
3673
3674     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3675     f_reg_list = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
3676
3677   /* Record the fields for the semantic handler.  */
3678   FLD (f_reg_list) = f_reg_list;
3679   FLD (f_rn) = f_rn;
3680   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3681   if (UNLIKELY(current_cpu->trace_extract_p))
3682     {
3683       current_cpu->trace_stream
3684         << "0x" << hex << pc << dec << " (sfmt_ldmda_sw)\t"
3685         << " f_reg_list:0x" << hex << f_reg_list << dec
3686         << " f_rn:0x" << hex << f_rn << dec
3687         << endl;
3688     }
3689
3690 #undef FLD
3691 }
3692
3693 void
3694 arm_extract_sfmt_ldmda_wb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3695     arm_insn_word insn = entire_insn;
3696 #define FLD(f) abuf->fields.sfmt_ldmda.f
3697     UINT f_rn;
3698     UINT f_reg_list;
3699
3700     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3701     f_reg_list = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
3702
3703   /* Record the fields for the semantic handler.  */
3704   FLD (f_reg_list) = f_reg_list;
3705   FLD (f_rn) = f_rn;
3706   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3707   if (UNLIKELY(current_cpu->trace_extract_p))
3708     {
3709       current_cpu->trace_stream
3710         << "0x" << hex << pc << dec << " (sfmt_ldmda_wb)\t"
3711         << " f_reg_list:0x" << hex << f_reg_list << dec
3712         << " f_rn:0x" << hex << f_rn << dec
3713         << endl;
3714     }
3715
3716 #undef FLD
3717 }
3718
3719 void
3720 arm_extract_sfmt_ldmda_sw_wb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3721     arm_insn_word insn = entire_insn;
3722 #define FLD(f) abuf->fields.sfmt_ldmda.f
3723     UINT f_rn;
3724     UINT f_reg_list;
3725
3726     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3727     f_reg_list = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
3728
3729   /* Record the fields for the semantic handler.  */
3730   FLD (f_reg_list) = f_reg_list;
3731   FLD (f_rn) = f_rn;
3732   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3733   if (UNLIKELY(current_cpu->trace_extract_p))
3734     {
3735       current_cpu->trace_stream
3736         << "0x" << hex << pc << dec << " (sfmt_ldmda_sw_wb)\t"
3737         << " f_reg_list:0x" << hex << f_reg_list << dec
3738         << " f_rn:0x" << hex << f_rn << dec
3739         << endl;
3740     }
3741
3742 #undef FLD
3743 }
3744
3745 void
3746 arm_extract_sfmt_stmdb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3747     arm_insn_word insn = entire_insn;
3748 #define FLD(f) abuf->fields.sfmt_ldmda.f
3749     UINT f_rn;
3750     UINT f_reg_list;
3751
3752     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3753     f_reg_list = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
3754
3755   /* Record the fields for the semantic handler.  */
3756   FLD (f_reg_list) = f_reg_list;
3757   FLD (f_rn) = f_rn;
3758   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3759   if (UNLIKELY(current_cpu->trace_extract_p))
3760     {
3761       current_cpu->trace_stream
3762         << "0x" << hex << pc << dec << " (sfmt_stmdb)\t"
3763         << " f_reg_list:0x" << hex << f_reg_list << dec
3764         << " f_rn:0x" << hex << f_rn << dec
3765         << endl;
3766     }
3767
3768 #undef FLD
3769 }
3770
3771 void
3772 arm_extract_sfmt_stmdb_sw (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3773     arm_insn_word insn = entire_insn;
3774 #define FLD(f) abuf->fields.sfmt_ldmda.f
3775     UINT f_rn;
3776     UINT f_reg_list;
3777
3778     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3779     f_reg_list = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
3780
3781   /* Record the fields for the semantic handler.  */
3782   FLD (f_reg_list) = f_reg_list;
3783   FLD (f_rn) = f_rn;
3784   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3785   if (UNLIKELY(current_cpu->trace_extract_p))
3786     {
3787       current_cpu->trace_stream
3788         << "0x" << hex << pc << dec << " (sfmt_stmdb_sw)\t"
3789         << " f_reg_list:0x" << hex << f_reg_list << dec
3790         << " f_rn:0x" << hex << f_rn << dec
3791         << endl;
3792     }
3793
3794 #undef FLD
3795 }
3796
3797 void
3798 arm_extract_sfmt_stmdb_wb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3799     arm_insn_word insn = entire_insn;
3800 #define FLD(f) abuf->fields.sfmt_ldmda.f
3801     UINT f_rn;
3802     UINT f_reg_list;
3803
3804     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3805     f_reg_list = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
3806
3807   /* Record the fields for the semantic handler.  */
3808   FLD (f_reg_list) = f_reg_list;
3809   FLD (f_rn) = f_rn;
3810   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3811   if (UNLIKELY(current_cpu->trace_extract_p))
3812     {
3813       current_cpu->trace_stream
3814         << "0x" << hex << pc << dec << " (sfmt_stmdb_wb)\t"
3815         << " f_reg_list:0x" << hex << f_reg_list << dec
3816         << " f_rn:0x" << hex << f_rn << dec
3817         << endl;
3818     }
3819
3820 #undef FLD
3821 }
3822
3823 void
3824 arm_extract_sfmt_stmdb_sw_wb (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3825     arm_insn_word insn = entire_insn;
3826 #define FLD(f) abuf->fields.sfmt_ldmda.f
3827     UINT f_rn;
3828     UINT f_reg_list;
3829
3830     f_rn = EXTRACT_LSB0_UINT (insn, 32, 19, 4);
3831     f_reg_list = EXTRACT_LSB0_UINT (insn, 32, 15, 16);
3832
3833   /* Record the fields for the semantic handler.  */
3834   FLD (f_reg_list) = f_reg_list;
3835   FLD (f_rn) = f_rn;
3836   FLD (i_rn) = & current_cpu->hardware.h_gr[f_rn];
3837   if (UNLIKELY(current_cpu->trace_extract_p))
3838     {
3839       current_cpu->trace_stream
3840         << "0x" << hex << pc << dec << " (sfmt_stmdb_sw_wb)\t"
3841         << " f_reg_list:0x" << hex << f_reg_list << dec
3842         << " f_rn:0x" << hex << f_rn << dec
3843         << endl;
3844     }
3845
3846 #undef FLD
3847 }
3848
3849 void
3850 arm_extract_sfmt_mrs_c (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3851     arm_insn_word insn = entire_insn;
3852 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3853     UINT f_rd;
3854
3855     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3856
3857   /* Record the fields for the semantic handler.  */
3858   FLD (f_rd) = f_rd;
3859   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3860   if (UNLIKELY(current_cpu->trace_extract_p))
3861     {
3862       current_cpu->trace_stream
3863         << "0x" << hex << pc << dec << " (sfmt_mrs_c)\t"
3864         << " f_rd:0x" << hex << f_rd << dec
3865         << endl;
3866     }
3867
3868 #undef FLD
3869 }
3870
3871 void
3872 arm_extract_sfmt_mrs_s (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3873     arm_insn_word insn = entire_insn;
3874 #define FLD(f) abuf->fields.sfmt_strh_pre_dec_imm_offset.f
3875     UINT f_rd;
3876
3877     f_rd = EXTRACT_LSB0_UINT (insn, 32, 15, 4);
3878
3879   /* Record the fields for the semantic handler.  */
3880   FLD (f_rd) = f_rd;
3881   FLD (i_rd) = & current_cpu->hardware.h_gr[f_rd];
3882   if (UNLIKELY(current_cpu->trace_extract_p))
3883     {
3884       current_cpu->trace_stream
3885         << "0x" << hex << pc << dec << " (sfmt_mrs_s)\t"
3886         << " f_rd:0x" << hex << f_rd << dec
3887         << endl;
3888     }
3889
3890 #undef FLD
3891 }
3892
3893 void
3894 arm_extract_sfmt_msr_c (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3895     arm_insn_word insn = entire_insn;
3896 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3897     UINT f_rm;
3898
3899     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3900
3901   /* Record the fields for the semantic handler.  */
3902   FLD (f_rm) = f_rm;
3903   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3904   if (UNLIKELY(current_cpu->trace_extract_p))
3905     {
3906       current_cpu->trace_stream
3907         << "0x" << hex << pc << dec << " (sfmt_msr_c)\t"
3908         << " f_rm:0x" << hex << f_rm << dec
3909         << endl;
3910     }
3911
3912 #undef FLD
3913 }
3914
3915 void
3916 arm_extract_sfmt_msr_s (arm_scache* abuf, arm7f_cpu* current_cpu, PCADDR pc, arm_insn_word base_insn, arm_insn_word entire_insn){
3917     arm_insn_word insn = entire_insn;
3918 #define FLD(f) abuf->fields.sfmt_and_reg_imm_shift.f
3919     UINT f_rm;
3920
3921     f_rm = EXTRACT_LSB0_UINT (insn, 32, 3, 4);
3922
3923   /* Record the fields for the semantic handler.  */
3924   FLD (f_rm) = f_rm;
3925   FLD (i_rm) = & current_cpu->hardware.h_gr[f_rm];
3926   if (UNLIKELY(current_cpu->trace_extract_p))
3927     {
3928       current_cpu->trace_stream
3929         << "0x" << hex << pc << dec << " (sfmt_msr_s)\t"
3930         << " f_rm:0x" << hex << f_rm << dec
3931         << endl;
3932     }
3933
3934 #undef FLD
3935 }
3936