This is the mail archive of the binutils-cvs@sourceware.org mailing list for the binutils project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[binutils-gdb] [AArch64][SVE 31/32] Add SVE instructions


https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=c0890d26289c4dad0e2ddedb7822a32a0645d150

commit c0890d26289c4dad0e2ddedb7822a32a0645d150
Author: Richard Sandiford <richard.sandiford@arm.com>
Date:   Wed Sep 21 16:58:48 2016 +0100

    [AArch64][SVE 31/32] Add SVE instructions
    
    This patch adds the SVE instruction definitions and associated OP_*
    enum values.
    
    include/
    	* opcode/aarch64.h (AARCH64_FEATURE_SVE): New macro.
    	(OP_MOV_P_P, OP_MOV_Z_P_Z, OP_MOV_Z_V, OP_MOV_Z_Z, OP_MOV_Z_Zi)
    	(OP_MOVM_P_P_P, OP_MOVS_P_P, OP_MOVZS_P_P_P, OP_MOVZ_P_P_P)
    	(OP_NOTS_P_P_P_Z, OP_NOT_P_P_P_Z): New aarch64_ops.
    
    opcodes/
    	* aarch64-tbl.h (OP_SVE_B, OP_SVE_BB, OP_SVE_BBBU, OP_SVE_BMB)
    	(OP_SVE_BPB, OP_SVE_BUB, OP_SVE_BUBB, OP_SVE_BUU, OP_SVE_BZ)
    	(OP_SVE_BZB, OP_SVE_BZBB, OP_SVE_BZU, OP_SVE_DD, OP_SVE_DDD)
    	(OP_SVE_DMD, OP_SVE_DMH, OP_SVE_DMS, OP_SVE_DU, OP_SVE_DUD, OP_SVE_DUU)
    	(OP_SVE_DUV_BHS, OP_SVE_DUV_BHSD, OP_SVE_DZD, OP_SVE_DZU, OP_SVE_HB)
    	(OP_SVE_HMD, OP_SVE_HMS, OP_SVE_HU, OP_SVE_HUU, OP_SVE_HZU, OP_SVE_RR)
    	(OP_SVE_RURV_BHSD, OP_SVE_RUV_BHSD, OP_SVE_SMD, OP_SVE_SMH, OP_SVE_SMS)
    	(OP_SVE_SU, OP_SVE_SUS, OP_SVE_SUU, OP_SVE_SZS, OP_SVE_SZU, OP_SVE_UB)
    	(OP_SVE_UUD, OP_SVE_UUS, OP_SVE_VMR_BHSD, OP_SVE_VMU_SD)
    	(OP_SVE_VMVD_BHS, OP_SVE_VMVU_BHSD, OP_SVE_VMVU_SD, OP_SVE_VMVV_BHSD)
    	(OP_SVE_VMVV_SD, OP_SVE_VMV_BHSD, OP_SVE_VMV_HSD, OP_SVE_VMV_SD)
    	(OP_SVE_VM_SD, OP_SVE_VPU_BHSD, OP_SVE_VPV_BHSD, OP_SVE_VRR_BHSD)
    	(OP_SVE_VRU_BHSD, OP_SVE_VR_BHSD, OP_SVE_VUR_BHSD, OP_SVE_VUU_BHSD)
    	(OP_SVE_VUVV_BHSD, OP_SVE_VUVV_SD, OP_SVE_VUV_BHSD, OP_SVE_VUV_SD)
    	(OP_SVE_VU_BHSD, OP_SVE_VU_HSD, OP_SVE_VU_SD, OP_SVE_VVD_BHS)
    	(OP_SVE_VVU_BHSD, OP_SVE_VVVU_SD, OP_SVE_VVV_BHSD, OP_SVE_VVV_SD)
    	(OP_SVE_VV_BHSD, OP_SVE_VV_HSD_BHS, OP_SVE_VV_SD, OP_SVE_VWW_BHSD)
    	(OP_SVE_VXX_BHSD, OP_SVE_VZVD_BHS, OP_SVE_VZVU_BHSD, OP_SVE_VZVV_BHSD)
    	(OP_SVE_VZVV_SD, OP_SVE_VZV_SD, OP_SVE_V_SD, OP_SVE_WU, OP_SVE_WV_BHSD)
    	(OP_SVE_XU, OP_SVE_XUV_BHSD, OP_SVE_XVW_BHSD, OP_SVE_XV_BHSD)
    	(OP_SVE_XWU, OP_SVE_XXU): New macros.
    	(aarch64_feature_sve): New variable.
    	(SVE): New macro.
    	(_SVE_INSN): Likewise.
    	(aarch64_opcode_table): Add SVE instructions.
    	* aarch64-opc.h (extract_fields): Declare.
    	* aarch64-opc-2.c: Regenerate.
    	* aarch64-asm.c (do_misc_encoding): Handle the new SVE aarch64_ops.
    	* aarch64-asm-2.c: Regenerate.
    	* aarch64-dis.c (extract_fields): Make global.
    	(do_misc_decoding): Handle the new SVE aarch64_ops.
    	* aarch64-dis-2.c: Regenerate.
    
    gas/
    	* doc/c-aarch64.texi: Document the "sve" feature.
    	* config/tc-aarch64.c (REG_TYPE_R_Z_BHSDQ_VZP): New register type.
    	(get_reg_expected_msg): Handle it.
    	(parse_operands): When parsing operands of an SVE instruction,
    	disallow immediates that match REG_TYPE_R_Z_BHSDQ_VZP.
    	(aarch64_features): Add an entry for SVE.

Diff:
---
 gas/ChangeLog            |    9 +
 gas/config/tc-aarch64.c  |   17 +-
 gas/doc/c-aarch64.texi   |    2 +
 include/ChangeLog        |    7 +
 include/opcode/aarch64.h |   13 +
 opcodes/ChangeLog        |   35 +
 opcodes/aarch64-asm-2.c  |  119 +
 opcodes/aarch64-asm.c    |   43 +
 opcodes/aarch64-dis-2.c  | 8138 +++++++++++++++++++++++++++++++++++++++++++++-
 opcodes/aarch64-dis.c    |   44 +-
 opcodes/aarch64-opc-2.c  |   11 +
 opcodes/aarch64-opc.h    |    3 +
 opcodes/aarch64-tbl.h    | 1269 ++++++++
 13 files changed, 9547 insertions(+), 163 deletions(-)

diff --git a/gas/ChangeLog b/gas/ChangeLog
index 7f5f484..f164158 100644
--- a/gas/ChangeLog
+++ b/gas/ChangeLog
@@ -1,5 +1,14 @@
 2016-09-21  Richard Sandiford  <richard.sandiford@arm.com>
 
+	* doc/c-aarch64.texi: Document the "sve" feature.
+	* config/tc-aarch64.c (REG_TYPE_R_Z_BHSDQ_VZP): New register type.
+	(get_reg_expected_msg): Handle it.
+	(parse_operands): When parsing operands of an SVE instruction,
+	disallow immediates that match REG_TYPE_R_Z_BHSDQ_VZP.
+	(aarch64_features): Add an entry for SVE.
+
+2016-09-21  Richard Sandiford  <richard.sandiford@arm.com>
+
 	* config/tc-aarch64.c (parse_operands): Handle the new SVE core
 	and FP register operands.
 
diff --git a/gas/config/tc-aarch64.c b/gas/config/tc-aarch64.c
index b9a988b..0aff0e8 100644
--- a/gas/config/tc-aarch64.c
+++ b/gas/config/tc-aarch64.c
@@ -297,6 +297,14 @@ struct reloc_entry
 		 | REG_TYPE(Z_32) | REG_TYPE(Z_64) | REG_TYPE(VN)	\
 		 | REG_TYPE(FP_B) | REG_TYPE(FP_H)			\
 		 | REG_TYPE(FP_S) | REG_TYPE(FP_D) | REG_TYPE(FP_Q))	\
+  /* Typecheck: as above, but also Zn and Pn.  This should only be	\
+     used for SVE instructions, since Zn and Pn are valid symbols	\
+     in other contexts.  */						\
+  MULTI_REG_TYPE(R_Z_BHSDQ_VZP, REG_TYPE(R_32) | REG_TYPE(R_64)		\
+		 | REG_TYPE(Z_32) | REG_TYPE(Z_64) | REG_TYPE(VN)	\
+		 | REG_TYPE(FP_B) | REG_TYPE(FP_H)			\
+		 | REG_TYPE(FP_S) | REG_TYPE(FP_D) | REG_TYPE(FP_Q)	\
+		 | REG_TYPE(ZN) | REG_TYPE(PN))				\
   /* Any integer register; used for error messages only.  */		\
   MULTI_REG_TYPE(R_N, REG_TYPE(R_32) | REG_TYPE(R_64)			\
 		 | REG_TYPE(SP_32) | REG_TYPE(SP_64)			\
@@ -403,6 +411,7 @@ get_reg_expected_msg (aarch64_reg_type reg_type)
       msg = N_("C0 - C15 expected");
       break;
     case REG_TYPE_R_Z_BHSDQ_V:
+    case REG_TYPE_R_Z_BHSDQ_VZP:
       msg = N_("register expected");
       break;
     case REG_TYPE_BHSDQ:	/* any [BHSDQ]P FP  */
@@ -5246,7 +5255,10 @@ parse_operands (char *str, const aarch64_opcode *opcode)
   clear_error ();
   skip_whitespace (str);
 
-  imm_reg_type = REG_TYPE_R_Z_BHSDQ_V;
+  if (AARCH64_CPU_HAS_FEATURE (AARCH64_FEATURE_SVE, *opcode->avariant))
+    imm_reg_type = REG_TYPE_R_Z_BHSDQ_VZP;
+  else
+    imm_reg_type = REG_TYPE_R_Z_BHSDQ_V;
 
   for (i = 0; operands[i] != AARCH64_OPND_NIL; i++)
     {
@@ -8385,6 +8397,9 @@ static const struct aarch64_option_cpu_value_table aarch64_features[] = {
 			AARCH64_FEATURE (AARCH64_FEATURE_FP, 0)},
   {"profile",		AARCH64_FEATURE (AARCH64_FEATURE_PROFILE, 0),
 			AARCH64_ARCH_NONE},
+  {"sve",		AARCH64_FEATURE (AARCH64_FEATURE_SVE, 0),
+			AARCH64_FEATURE (AARCH64_FEATURE_FP
+					 | AARCH64_FEATURE_SIMD, 0)},
   {NULL,		AARCH64_ARCH_NONE, AARCH64_ARCH_NONE},
 };
 
diff --git a/gas/doc/c-aarch64.texi b/gas/doc/c-aarch64.texi
index 6f9f0cc..80b657b 100644
--- a/gas/doc/c-aarch64.texi
+++ b/gas/doc/c-aarch64.texi
@@ -154,6 +154,8 @@ automatically cause those extensions to be disabled.
  @tab Enable ARMv8.1 Advanced SIMD extensions.  This implies @code{simd}.
 @item @code{simd} @tab ARMv8-A @tab ARMv8-A or later
  @tab Enable Advanced SIMD extensions.  This implies @code{fp}.
+@item @code{sve} @tab ARMv8-A @tab ARMv8-A or later
+ @tab Enable the Scalable Vector Extensions.
 @end multitable
 
 @node AArch64 Syntax
diff --git a/include/ChangeLog b/include/ChangeLog
index 0db1cbb..f2d20eb 100644
--- a/include/ChangeLog
+++ b/include/ChangeLog
@@ -1,5 +1,12 @@
 2016-09-21  Richard Sandiford  <richard.sandiford@arm.com>
 
+	* opcode/aarch64.h (AARCH64_FEATURE_SVE): New macro.
+	(OP_MOV_P_P, OP_MOV_Z_P_Z, OP_MOV_Z_V, OP_MOV_Z_Z, OP_MOV_Z_Zi)
+	(OP_MOVM_P_P_P, OP_MOVS_P_P, OP_MOVZS_P_P_P, OP_MOVZ_P_P_P)
+	(OP_NOTS_P_P_P_Z, OP_NOT_P_P_P_Z): New aarch64_ops.
+
+2016-09-21  Richard Sandiford  <richard.sandiford@arm.com>
+
 	* opcode/aarch64.h (sve_cpy, sve_index, sve_limm, sve_misc)
 	(sve_movprfx, sve_pred_zm, sve_shift_pred, sve_shift_unpred)
 	(sve_size_bhs, sve_size_bhsd, sve_size_hsd, sve_size_sd): New
diff --git a/include/opcode/aarch64.h b/include/opcode/aarch64.h
index 01e6b2c..5913860 100644
--- a/include/opcode/aarch64.h
+++ b/include/opcode/aarch64.h
@@ -51,6 +51,7 @@ typedef uint32_t aarch64_insn;
 #define AARCH64_FEATURE_F16	0x02000000	/* v8.2 FP16 instructions.  */
 #define AARCH64_FEATURE_RAS	0x04000000	/* RAS Extensions.  */
 #define AARCH64_FEATURE_PROFILE	0x08000000	/* Statistical Profiling.  */
+#define AARCH64_FEATURE_SVE	0x10000000	/* SVE instructions.  */
 
 /* Architectures are the sum of the base and extensions.  */
 #define AARCH64_ARCH_V8		AARCH64_FEATURE (AARCH64_FEATURE_V8, \
@@ -587,6 +588,18 @@ enum aarch64_op
   OP_UXTL,
   OP_UXTL2,
 
+  OP_MOV_P_P,
+  OP_MOV_Z_P_Z,
+  OP_MOV_Z_V,
+  OP_MOV_Z_Z,
+  OP_MOV_Z_Zi,
+  OP_MOVM_P_P_P,
+  OP_MOVS_P_P,
+  OP_MOVZS_P_P_P,
+  OP_MOVZ_P_P_P,
+  OP_NOTS_P_P_P_Z,
+  OP_NOT_P_P_P_Z,
+
   OP_TOTAL_NUM,		/* Pseudo.  */
 };
 
diff --git a/opcodes/ChangeLog b/opcodes/ChangeLog
index 8670587..1380def 100644
--- a/opcodes/ChangeLog
+++ b/opcodes/ChangeLog
@@ -1,5 +1,40 @@
 2016-09-21  Richard Sandiford  <richard.sandiford@arm.com>
 
+	* aarch64-tbl.h (OP_SVE_B, OP_SVE_BB, OP_SVE_BBBU, OP_SVE_BMB)
+	(OP_SVE_BPB, OP_SVE_BUB, OP_SVE_BUBB, OP_SVE_BUU, OP_SVE_BZ)
+	(OP_SVE_BZB, OP_SVE_BZBB, OP_SVE_BZU, OP_SVE_DD, OP_SVE_DDD)
+	(OP_SVE_DMD, OP_SVE_DMH, OP_SVE_DMS, OP_SVE_DU, OP_SVE_DUD, OP_SVE_DUU)
+	(OP_SVE_DUV_BHS, OP_SVE_DUV_BHSD, OP_SVE_DZD, OP_SVE_DZU, OP_SVE_HB)
+	(OP_SVE_HMD, OP_SVE_HMS, OP_SVE_HU, OP_SVE_HUU, OP_SVE_HZU, OP_SVE_RR)
+	(OP_SVE_RURV_BHSD, OP_SVE_RUV_BHSD, OP_SVE_SMD, OP_SVE_SMH, OP_SVE_SMS)
+	(OP_SVE_SU, OP_SVE_SUS, OP_SVE_SUU, OP_SVE_SZS, OP_SVE_SZU, OP_SVE_UB)
+	(OP_SVE_UUD, OP_SVE_UUS, OP_SVE_VMR_BHSD, OP_SVE_VMU_SD)
+	(OP_SVE_VMVD_BHS, OP_SVE_VMVU_BHSD, OP_SVE_VMVU_SD, OP_SVE_VMVV_BHSD)
+	(OP_SVE_VMVV_SD, OP_SVE_VMV_BHSD, OP_SVE_VMV_HSD, OP_SVE_VMV_SD)
+	(OP_SVE_VM_SD, OP_SVE_VPU_BHSD, OP_SVE_VPV_BHSD, OP_SVE_VRR_BHSD)
+	(OP_SVE_VRU_BHSD, OP_SVE_VR_BHSD, OP_SVE_VUR_BHSD, OP_SVE_VUU_BHSD)
+	(OP_SVE_VUVV_BHSD, OP_SVE_VUVV_SD, OP_SVE_VUV_BHSD, OP_SVE_VUV_SD)
+	(OP_SVE_VU_BHSD, OP_SVE_VU_HSD, OP_SVE_VU_SD, OP_SVE_VVD_BHS)
+	(OP_SVE_VVU_BHSD, OP_SVE_VVVU_SD, OP_SVE_VVV_BHSD, OP_SVE_VVV_SD)
+	(OP_SVE_VV_BHSD, OP_SVE_VV_HSD_BHS, OP_SVE_VV_SD, OP_SVE_VWW_BHSD)
+	(OP_SVE_VXX_BHSD, OP_SVE_VZVD_BHS, OP_SVE_VZVU_BHSD, OP_SVE_VZVV_BHSD)
+	(OP_SVE_VZVV_SD, OP_SVE_VZV_SD, OP_SVE_V_SD, OP_SVE_WU, OP_SVE_WV_BHSD)
+	(OP_SVE_XU, OP_SVE_XUV_BHSD, OP_SVE_XVW_BHSD, OP_SVE_XV_BHSD)
+	(OP_SVE_XWU, OP_SVE_XXU): New macros.
+	(aarch64_feature_sve): New variable.
+	(SVE): New macro.
+	(_SVE_INSN): Likewise.
+	(aarch64_opcode_table): Add SVE instructions.
+	* aarch64-opc.h (extract_fields): Declare.
+	* aarch64-opc-2.c: Regenerate.
+	* aarch64-asm.c (do_misc_encoding): Handle the new SVE aarch64_ops.
+	* aarch64-asm-2.c: Regenerate.
+	* aarch64-dis.c (extract_fields): Make global.
+	(do_misc_decoding): Handle the new SVE aarch64_ops.
+	* aarch64-dis-2.c: Regenerate.
+
+2016-09-21  Richard Sandiford  <richard.sandiford@arm.com>
+
 	* aarch64-opc.h (FLD_SVE_M_4, FLD_SVE_M_14, FLD_SVE_M_16)
 	(FLD_SVE_sz, FLD_SVE_tsz, FLD_SVE_tszl_8, FLD_SVE_tszl_19): New
 	aarch64_field_kinds.
diff --git a/opcodes/aarch64-asm-2.c b/opcodes/aarch64-asm-2.c
index 5dd6a81..5977a66 100644
--- a/opcodes/aarch64-asm-2.c
+++ b/opcodes/aarch64-asm-2.c
@@ -440,6 +440,125 @@ aarch64_find_real_opcode (const aarch64_opcode *opcode)
     case 1131:	/* sys */
       value = 1131;	/* --> sys.  */
       break;
+    case 1881:	/* bic */
+    case 1186:	/* and */
+      value = 1186;	/* --> and.  */
+      break;
+    case 1169:	/* mov */
+    case 1188:	/* and */
+      value = 1188;	/* --> and.  */
+      break;
+    case 1173:	/* movs */
+    case 1189:	/* ands */
+      value = 1189;	/* --> ands.  */
+      break;
+    case 1882:	/* cmple */
+    case 1224:	/* cmpge */
+      value = 1224;	/* --> cmpge.  */
+      break;
+    case 1885:	/* cmplt */
+    case 1227:	/* cmpgt */
+      value = 1227;	/* --> cmpgt.  */
+      break;
+    case 1883:	/* cmplo */
+    case 1229:	/* cmphi */
+      value = 1229;	/* --> cmphi.  */
+      break;
+    case 1884:	/* cmpls */
+    case 1232:	/* cmphs */
+      value = 1232;	/* --> cmphs.  */
+      break;
+    case 1166:	/* mov */
+    case 1254:	/* cpy */
+      value = 1254;	/* --> cpy.  */
+      break;
+    case 1168:	/* mov */
+    case 1255:	/* cpy */
+      value = 1255;	/* --> cpy.  */
+      break;
+    case 1892:	/* fmov */
+    case 1171:	/* mov */
+    case 1256:	/* cpy */
+      value = 1256;	/* --> cpy.  */
+      break;
+    case 1161:	/* mov */
+    case 1268:	/* dup */
+      value = 1268;	/* --> dup.  */
+      break;
+    case 1163:	/* mov */
+    case 1160:	/* mov */
+    case 1269:	/* dup */
+      value = 1269;	/* --> dup.  */
+      break;
+    case 1891:	/* fmov */
+    case 1165:	/* mov */
+    case 1270:	/* dup */
+      value = 1270;	/* --> dup.  */
+      break;
+    case 1164:	/* mov */
+    case 1271:	/* dupm */
+      value = 1271;	/* --> dupm.  */
+      break;
+    case 1886:	/* eon */
+    case 1273:	/* eor */
+      value = 1273;	/* --> eor.  */
+      break;
+    case 1174:	/* not */
+    case 1275:	/* eor */
+      value = 1275;	/* --> eor.  */
+      break;
+    case 1175:	/* nots */
+    case 1276:	/* eors */
+      value = 1276;	/* --> eors.  */
+      break;
+    case 1887:	/* facle */
+    case 1281:	/* facge */
+      value = 1281;	/* --> facge.  */
+      break;
+    case 1888:	/* faclt */
+    case 1282:	/* facgt */
+      value = 1282;	/* --> facgt.  */
+      break;
+    case 1889:	/* fcmle */
+    case 1291:	/* fcmge */
+      value = 1291;	/* --> fcmge.  */
+      break;
+    case 1890:	/* fcmlt */
+    case 1293:	/* fcmgt */
+      value = 1293;	/* --> fcmgt.  */
+      break;
+    case 1158:	/* fmov */
+    case 1299:	/* fcpy */
+      value = 1299;	/* --> fcpy.  */
+      break;
+    case 1157:	/* fmov */
+    case 1316:	/* fdup */
+      value = 1316;	/* --> fdup.  */
+      break;
+    case 1159:	/* mov */
+    case 1614:	/* orr */
+      value = 1614;	/* --> orr.  */
+      break;
+    case 1893:	/* orn */
+    case 1615:	/* orr */
+      value = 1615;	/* --> orr.  */
+      break;
+    case 1162:	/* mov */
+    case 1617:	/* orr */
+      value = 1617;	/* --> orr.  */
+      break;
+    case 1172:	/* movs */
+    case 1618:	/* orrs */
+      value = 1618;	/* --> orrs.  */
+      break;
+    case 1167:	/* mov */
+    case 1674:	/* sel */
+      value = 1674;	/* --> sel.  */
+      break;
+    case 1170:	/* mov */
+    case 1675:	/* sel */
+      value = 1675;	/* --> sel.  */
+      break;
     default: return NULL;
     }
 
diff --git a/opcodes/aarch64-asm.c b/opcodes/aarch64-asm.c
index 78fd272..dd2859b 100644
--- a/opcodes/aarch64-asm.c
+++ b/opcodes/aarch64-asm.c
@@ -1167,6 +1167,8 @@ aarch64_get_variant (struct aarch64_inst *inst)
 static void
 do_misc_encoding (aarch64_inst *inst)
 {
+  unsigned int value;
+
   switch (inst->opcode->op)
     {
     case OP_FCVT:
@@ -1181,6 +1183,47 @@ do_misc_encoding (aarch64_inst *inst)
     case OP_FCVTXN_S:
       encode_asisd_fcvtxn (inst);
       break;
+    case OP_MOV_P_P:
+    case OP_MOVS_P_P:
+      /* Copy Pn to Pm and Pg.  */
+      value = extract_field (FLD_SVE_Pn, inst->value, 0);
+      insert_field (FLD_SVE_Pm, &inst->value, value, 0);
+      insert_field (FLD_SVE_Pg4_10, &inst->value, value, 0);
+      break;
+    case OP_MOV_Z_P_Z:
+      /* Copy Zd to Zm.  */
+      value = extract_field (FLD_SVE_Zd, inst->value, 0);
+      insert_field (FLD_SVE_Zm_16, &inst->value, value, 0);
+      break;
+    case OP_MOV_Z_V:
+      /* Fill in the zero immediate.  */
+      insert_field (FLD_SVE_tsz, &inst->value,
+		    1 << aarch64_get_variant (inst), 0);
+      break;
+    case OP_MOV_Z_Z:
+      /* Copy Zn to Zm.  */
+      value = extract_field (FLD_SVE_Zn, inst->value, 0);
+      insert_field (FLD_SVE_Zm_16, &inst->value, value, 0);
+      break;
+    case OP_MOV_Z_Zi:
+      break;
+    case OP_MOVM_P_P_P:
+      /* Copy Pd to Pm.  */
+      value = extract_field (FLD_SVE_Pd, inst->value, 0);
+      insert_field (FLD_SVE_Pm, &inst->value, value, 0);
+      break;
+    case OP_MOVZS_P_P_P:
+    case OP_MOVZ_P_P_P:
+      /* Copy Pn to Pm.  */
+      value = extract_field (FLD_SVE_Pn, inst->value, 0);
+      insert_field (FLD_SVE_Pm, &inst->value, value, 0);
+      break;
+    case OP_NOTS_P_P_P_Z:
+    case OP_NOT_P_P_P_Z:
+      /* Copy Pg to Pm.  */
+      value = extract_field (FLD_SVE_Pg4_10, inst->value, 0);
+      insert_field (FLD_SVE_Pm, &inst->value, value, 0);
+      break;
     default: break;
     }
 }
diff --git a/opcodes/aarch64-dis-2.c b/opcodes/aarch64-dis-2.c
index c3bcfdb..a749239 100644
--- a/opcodes/aarch64-dis-2.c
+++ b/opcodes/aarch64-dis-2.c
@@ -3129,239 +3129,7994 @@ aarch64_opcode_lookup_1 (uint32_t word)
     {
       if (((word >> 27) & 0x1) == 0)
         {
-          if (((word >> 29) & 0x1) == 0)
+          if (((word >> 28) & 0x1) == 0)
             {
-              if (((word >> 30) & 0x1) == 0)
+              if (((word >> 24) & 0x1) == 0)
+                {
+                  if (((word >> 13) & 0x1) == 0)
+                    {
+                      if (((word >> 29) & 0x1) == 0)
+                        {
+                          if (((word >> 14) & 0x1) == 0)
+                            {
+                              if (((word >> 15) & 0x1) == 0)
+                                {
+                                  if (((word >> 21) & 0x1) == 0)
+                                    {
+                                      if (((word >> 30) & 0x1) == 0)
+                                        {
+                                          if (((word >> 31) & 0x1) == 0)
+                                            {
+                                              if (((word >> 16) & 0x1) == 0)
+                                                {
+                                                  if (((word >> 17) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 18) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 19) & 0x1) == 0)
+                                                            {
+                                                              if (((word >> 20) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000000000xx0x100000
+                                                                     add.  */
+                                                                  return 1179;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000000010xx0x100000
+                                                                     mul.  */
+                                                                  return 1605;
+                                                                }
+                                                            }
+                                                          else
+                                                            {
+                                                              if (((word >> 20) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000000100xx0x100000
+                                                                     smax.  */
+                                                                  return 1678;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000000110xx0x100000
+                                                                     orr.  */
+                                                                  return 1616;
+                                                                }
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          if (((word >> 19) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0000010x0xx0x100000
+                                                                 sdiv.  */
+                                                              return 1672;
+                                                            }
+                                                          else
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0000011x0xx0x100000
+                                                                 sabd.  */
+                                                              return 1666;
+                                                            }
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      if (((word >> 18) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 19) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0000100x0xx0x100000
+                                                                 smulh.  */
+                                                              return 1683;
+                                                            }
+                                                          else
+                                                            {
+                                                              if (((word >> 20) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000010100xx0x100000
+                                                                     smin.  */
+                                                                  return 1681;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000010110xx0x100000
+                                                                     and.  */
+                                                                  return 1187;
+                                                                }
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxxxxx000011xx0xx0x100000
+                                                             sdivr.  */
+                                                          return 1673;
+                                                        }
+                                                    }
+                                                }
+                                              else
+                                                {
+                                                  if (((word >> 17) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 18) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 19) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0001000x0xx0x100000
+                                                                 sub.  */
+                                                              return 1799;
+                                                            }
+                                                          else
+                                                            {
+                                                              if (((word >> 20) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000100100xx0x100000
+                                                                     umax.  */
+                                                                  return 1821;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000100110xx0x100000
+                                                                     eor.  */
+                                                                  return 1274;
+                                                                }
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          if (((word >> 19) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0001010x0xx0x100000
+                                                                 udiv.  */
+                                                              return 1818;
+                                                            }
+                                                          else
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0001011x0xx0x100000
+                                                                 uabd.  */
+                                                              return 1812;
+                                                            }
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      if (((word >> 18) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 19) & 0x1) == 0)
+                                                            {
+                                                              if (((word >> 20) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000110000xx0x100000
+                                                                     subr.  */
+                                                                  return 1801;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000110010xx0x100000
+                                                                     umulh.  */
+                                                                  return 1826;
+                                                                }
+                                                            }
+                                                          else
+                                                            {
+                                                              if (((word >> 20) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000110100xx0x100000
+                                                                     umin.  */
+                                                                  return 1824;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx000110110xx0x100000
+                                                                     bic.  */
+                                                                  return 1199;
+                                                                }
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxxxxx000111xx0xx0x100000
+                                                             udivr.  */
+                                                          return 1819;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx000xxxxx0x00x100001
+                                                     ld1sb.  */
+                                                  return 1434;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx000xxxxx0x10x100001
+                                                     ld1sh.  */
+                                                  return 1445;
+                                                }
+                                            }
+                                        }
+                                      else
+                                        {
+                                          if (((word >> 23) & 0x1) == 0)
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx000xxxxx0x00x10001x
+                                                 ld1sb.  */
+                                              return 1438;
+                                            }
+                                          else
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx000xxxxx0x10x10001x
+                                                 ld1sh.  */
+                                              return 1449;
+                                            }
+                                        }
+                                    }
+                                  else
+                                    {
+                                      if (((word >> 30) & 0x1) == 0)
+                                        {
+                                          if (((word >> 31) & 0x1) == 0)
+                                            {
+                                              if (((word >> 10) & 0x1) == 0)
+                                                {
+                                                  if (((word >> 11) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 12) & 0x1) == 0)
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx000000xxxxx1xx0x100000
+                                                             add.  */
+                                                          return 1177;
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx001000xxxxx1xx0x100000
+                                                             sqadd.  */
+                                                          return 1685;
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxx01x000xxxxx1xx0x100000
+                                                         sqsub.  */
+                                                      return 1715;
+                                                    }
+                                                }
+                                              else
+                                                {
+                                                  if (((word >> 11) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 12) & 0x1) == 0)
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx100000xxxxx1xx0x100000
+                                                             sub.  */
+                                                          return 1797;
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx101000xxxxx1xx0x100000
+                                                             uqadd.  */
+                                                          return 1827;
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxx11x000xxxxx1xx0x100000
+                                                         uqsub.  */
+                                                      return 1857;
+                                                    }
+                                                }
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx000xxxxx1x00x100001
+                                                     prfb.  */
+                                                  return 1624;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx000xxxxx1x10x100001
+                                                     ld1sh.  */
+                                                  return 1446;
+                                                }
+                                            }
+                                        }
+                                      else
+                                        {
+                                          if (((word >> 23) & 0x1) == 0)
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx000xxxxx1x00x10001x
+                                                 prfb.  */
+                                              return 1625;
+                                            }
+                                          else
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx000xxxxx1x10x10001x
+                                                 ld1sh.  */
+                                              return 1450;
+                                            }
+                                        }
+                                    }
+                                }
+                              else
+                                {
+                                  if (((word >> 30) & 0x1) == 0)
+                                    {
+                                      if (((word >> 31) & 0x1) == 0)
+                                        {
+                                          if (((word >> 21) & 0x1) == 0)
+                                            {
+                                              if (((word >> 16) & 0x1) == 0)
+                                                {
+                                                  if (((word >> 18) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 19) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 20) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0010x0000xx0x100000
+                                                                 asr.  */
+                                                              return 1195;
+                                                            }
+                                                          else
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0010x0010xx0x100000
+                                                                 asr.  */
+                                                              return 1193;
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxxxxx0010x01x0xx0x100000
+                                                             asr.  */
+                                                          return 1194;
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      if (((word >> 20) & 0x1) == 0)
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxxxxx0010x1x00xx0x100000
+                                                             asrd.  */
+                                                          return 1196;
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxxxxx0010x1x10xx0x100000
+                                                             asrr.  */
+                                                          return 1197;
+                                                        }
+                                                    }
+                                                }
+                                              else
+                                                {
+                                                  if (((word >> 17) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 18) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 19) & 0x1) == 0)
+                                                            {
+                                                              if (((word >> 20) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx001100000xx0x100000
+                                                                     lsr.  */
+                                                                  return 1596;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx001100010xx0x100000
+                                                                     lsr.  */
+                                                                  return 1594;
+                                                                }
+                                                            }
+                                                          else
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0011001x0xx0x100000
+                                                                 lsr.  */
+                                                              return 1595;
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxxxxx001101xx0xx0x100000
+                                                             lsrr.  */
+                                                          return 1597;
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      if (((word >> 18) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 19) & 0x1) == 0)
+                                                            {
+                                                              if (((word >> 20) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx001110000xx0x100000
+                                                                     lsl.  */
+                                                                  return 1590;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxxxxx001110010xx0x100000
+                                                                     lsl.  */
+                                                                  return 1588;
+                                                                }
+                                                            }
+                                                          else
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxxxx0011101x0xx0x100000
+                                                                 lsl.  */
+                                                              return 1589;
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxxxxx001111xx0xx0x100000
+                                                             lslr.  */
+                                                          return 1591;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 10) & 0x1) == 0)
+                                                {
+                                                  if (((word >> 12) & 0x1) == 0)
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxx0x0001xxxxx1xx0x100000
+                                                         asr.  */
+                                                      return 1191;
+                                                    }
+                                                  else
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxx0x1001xxxxx1xx0x100000
+                                                         asr.  */
+                                                      return 1192;
+                                                    }
+                                                }
+                                              else
+                                                {
+                                                  if (((word >> 11) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 12) & 0x1) == 0)
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx100001xxxxx1xx0x100000
+                                                             lsr.  */
+                                                          return 1592;
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx101001xxxxx1xx0x100000
+                                                             lsr.  */
+                                                          return 1593;
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      if (((word >> 12) & 0x1) == 0)
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx110001xxxxx1xx0x100000
+                                                             lsl.  */
+                                                          return 1586;
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx111001xxxxx1xx0x100000
+                                                             lsl.  */
+                                                          return 1587;
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                      else
+                                        {
+                                          if (((word >> 22) & 0x1) == 0)
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx001xxxxxx000x100001
+                                                     ld1sb.  */
+                                                  return 1440;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx001xxxxxx010x100001
+                                                     ld1sh.  */
+                                                  return 1453;
+                                                }
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx001xxxxxx100x100001
+                                                     ld1rb.  */
+                                                  return 1418;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx001xxxxxx110x100001
+                                                     ld1rsw.  */
+                                                  return 1431;
+                                                }
+                                            }
+                                        }
+                                    }
+                                  else
+                                    {
+                                      if (((word >> 21) & 0x1) == 0)
+                                        {
+                                          if (((word >> 23) & 0x1) == 0)
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx001xxxxx0x00x10001x
+                                                 ld1sb.  */
+                                              return 1439;
+                                            }
+                                          else
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx001xxxxx0x10x10001x
+                                                 ld1sh.  */
+                                              return 1451;
+                                            }
+                                        }
+                                      else
+                                        {
+                                          if (((word >> 22) & 0x1) == 0)
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx001xxxxx1000x10001x
+                                                     ld1sb.  */
+                                                  return 1444;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx001xxxxx1010x10001x
+                                                     ld1sh.  */
+                                                  return 1456;
+                                                }
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx001xxxxx1100x10001x
+                                                     prfb.  */
+                                                  return 1626;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx001xxxxx1110x10001x
+                                                     ld1sh.  */
+                                                  return 1452;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                          else
+                            {
+                              if (((word >> 15) & 0x1) == 0)
+                                {
+                                  if (((word >> 21) & 0x1) == 0)
+                                    {
+                                      if (((word >> 30) & 0x1) == 0)
+                                        {
+                                          if (((word >> 31) & 0x1) == 0)
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx010xxxxx0xx0x100000
+                                                 mla.  */
+                                              return 1599;
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx010xxxxx0x00x100001
+                                                     ld1b.  */
+                                                  return 1384;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx010xxxxx0x10x100001
+                                                     ld1h.  */
+                                                  return 1404;
+                                                }
+                                            }
+                                        }
+                                      else
+                                        {
+                                          if (((word >> 23) & 0x1) == 0)
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx010xxxxx0x00x10001x
+                                                 ld1b.  */
+                                              return 1389;
+                                            }
+                                          else
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx010xxxxx0x10x10001x
+                                                 ld1h.  */
+                                              return 1409;
+                                            }
+                                        }
+                                    }
+                                  else
+                                    {
+                                      if (((word >> 30) & 0x1) == 0)
+                                        {
+                                          if (((word >> 31) & 0x1) == 0)
+                                            {
+                                              if (((word >> 11) & 0x1) == 0)
+                                                {
+                                                  if (((word >> 12) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 10) & 0x1) == 0)
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx000010xxxxx1xx0x100000
+                                                             index.  */
+                                                          return 1375;
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx100010xxxxx1xx0x100000
+                                                             index.  */
+                                                          return 1376;
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      if (((word >> 22) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 23) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxx01010xxxxx1000x100000
+                                                                 addvl.  */
+                                                              return 1181;
+                                                            }
+                                                          else
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxxx01010xxxxx1010x100000
+                                                                 rdvl.  */
+                                                              return 1660;
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxxx01010xxxxx11x0x100000
+                                                             addpl.  */
+                                                          return 1180;
+                                                        }
+                                                    }
+                                                }
+                                              else
+                                                {
+                                                  if (((word >> 10) & 0x1) == 0)
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxx01x010xxxxx1xx0x100000
+                                                         index.  */
+                                                      return 1377;
+                                                    }
+                                                  else
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxx11x010xxxxx1xx0x100000
+                                                         index.  */
+                                                      return 1374;
+                                                    }
+                                                }
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx010xxxxx1x00x100001
+                                                     prfw.  */
+                                                  return 1644;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx010xxxxx1x10x100001
+                                                     ld1h.  */
+                                                  return 1405;
+                                                }
+                                            }
+                                        }
+                                      else
+                                        {
+                                          if (((word >> 23) & 0x1) == 0)
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx010xxxxx1x00x10001x
+                                                 prfw.  */
+                                              return 1646;
+                                            }
+                                          else
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx010xxxxx1x10x10001x
+                                                 ld1h.  */
+                                              return 1410;
+                                            }
+                                        }
+                                    }
+                                }
+                              else
+                                {
+                                  if (((word >> 30) & 0x1) == 0)
+                                    {
+                                      if (((word >> 31) & 0x1) == 0)
+                                        {
+                                          if (((word >> 21) & 0x1) == 0)
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx011xxxxx0xx0x100000
+                                                 mad.  */
+                                              return 1598;
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 10) & 0x1) == 0)
+                                                {
+                                                  if (((word >> 11) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 20) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 22) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxx00x011xxxx010x0x100000
+                                                                 sqincw.  */
+                                                              return 1712;
+                                                            }
+                                                          else
+                                                            {
+                                                              if (((word >> 23) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxx00x011xxxx01100x100000
+                                                                     sqinch.  */
+                                                                  return 1706;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxx00x011xxxx01110x100000
+                                                                     sqincd.  */
+                                                                  return 1703;
+                                                                }
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          if (((word >> 22) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxx00x011xxxx110x0x100000
+                                                                 incw.  */
+                                                              return 1372;
+                                                            }
+                                                          else
+                                                            {
+                                                              if (((word >> 23) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxx00x011xxxx11100x100000
+                                                                     inch.  */
+                                                                  return 1368;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxx00x011xxxx11110x100000
+                                                                     incd.  */
+                                                                  return 1366;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      if (((word >> 22) & 0x1) == 0)
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx01x011xxxxx10x0x100000
+                                                             sqdecw.  */
+                                                          return 1698;
+                                                        }
+                                                      else
+                                                        {
+                                                          if (((word >> 23) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxx01x011xxxxx1100x100000
+                                                                 sqdech.  */
+                                                              return 1692;
+                                                            }
+                                                          else
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxx01x011xxxxx1110x100000
+                                                                 sqdecd.  */
+                                                              return 1689;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                              else
+                                                {
+                                                  if (((word >> 11) & 0x1) == 0)
+                                                    {
+                                                      if (((word >> 20) & 0x1) == 0)
+                                                        {
+                                                          if (((word >> 22) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxx10x011xxxx010x0x100000
+                                                                 uqincw.  */
+                                                              return 1854;
+                                                            }
+                                                          else
+                                                            {
+                                                              if (((word >> 23) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxx10x011xxxx01100x100000
+                                                                     uqinch.  */
+                                                                  return 1848;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxx10x011xxxx01110x100000
+                                                                     uqincd.  */
+                                                                  return 1845;
+                                                                }
+                                                            }
+                                                        }
+                                                      else
+                                                        {
+                                                          if (((word >> 22) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxx10x011xxxx110x0x100000
+                                                                 decw.  */
+                                                              return 1266;
+                                                            }
+                                                          else
+                                                            {
+                                                              if (((word >> 23) & 0x1) == 0)
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxx10x011xxxx11100x100000
+                                                                     dech.  */
+                                                                  return 1262;
+                                                                }
+                                                              else
+                                                                {
+                                                                  /* 33222222222211111111110000000000
+                                                                     10987654321098765432109876543210
+                                                                     xxxxxxxxxx10x011xxxx11110x100000
+                                                                     decd.  */
+                                                                  return 1260;
+                                                                }
+                                                            }
+                                                        }
+                                                    }
+                                                  else
+                                                    {
+                                                      if (((word >> 22) & 0x1) == 0)
+                                                        {
+                                                          /* 33222222222211111111110000000000
+                                                             10987654321098765432109876543210
+                                                             xxxxxxxxxx11x011xxxxx10x0x100000
+                                                             uqdecw.  */
+                                                          return 1840;
+                                                        }
+                                                      else
+                                                        {
+                                                          if (((word >> 23) & 0x1) == 0)
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxx11x011xxxxx1100x100000
+                                                                 uqdech.  */
+                                                              return 1834;
+                                                            }
+                                                          else
+                                                            {
+                                                              /* 33222222222211111111110000000000
+                                                                 10987654321098765432109876543210
+                                                                 xxxxxxxxxx11x011xxxxx1110x100000
+                                                                 uqdecd.  */
+                                                              return 1831;
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                      else
+                                        {
+                                          if (((word >> 22) & 0x1) == 0)
+                                            {
+                                              if (((word >> 21) & 0x1) == 0)
+                                                {
+                                                  if (((word >> 23) & 0x1) == 0)
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxxxxx011xxxxx0000x100001
+                                                         prfb.  */
+                                                      return 1623;
+                                                    }
+                                                  else
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxxxxx011xxxxx0010x100001
+                                                         prfh.  */
+                                                      return 1638;
+                                                    }
+                                                }
+                                              else
+                                                {
+                                                  if (((word >> 23) & 0x1) == 0)
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxxxxx011xxxxx1000x100001
+                                                         ld1b.  */
+                                                      return 1391;
+                                                    }
+                                                  else
+                                                    {
+                                                      /* 33222222222211111111110000000000
+                                                         10987654321098765432109876543210
+                                                         xxxxxxxxxxxxx011xxxxx1010x100001
+                                                         ld1h.  */
+                                                      return 1413;
+                                                    }
+                                                }
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx011xxxxxx100x100001
+                                                     ld1rb.  */
+                                                  return 1420;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx011xxxxxx110x100001
+                                                     ld1rh.  */
+                                                  return 1424;
+                                                }
+                                            }
+                                        }
+                                    }
+                                  else
+                                    {
+                                      if (((word >> 21) & 0x1) == 0)
+                                        {
+                                          if (((word >> 23) & 0x1) == 0)
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx011xxxxx0x00x10001x
+                                                 ld1b.  */
+                                              return 1390;
+                                            }
+                                          else
+                                            {
+                                              /* 33222222222211111111110000000000
+                                                 10987654321098765432109876543210
+                                                 xxxxxxxxxxxxx011xxxxx0x10x10001x
+                                                 ld1h.  */
+                                              return 1411;
+                                            }
+                                        }
+                                      else
+                                        {
+                                          if (((word >> 22) & 0x1) == 0)
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx011xxxxx1000x10001x
+                                                     ld1b.  */
+                                                  return 1396;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx011xxxxx1010x10001x
+                                                     ld1h.  */
+                                                  return 1417;
+                                                }
+                                            }
+                                          else
+                                            {
+                                              if (((word >> 23) & 0x1) == 0)
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx011xxxxx1100x10001x
+                                                     prfw.  */
+                                                  return 1647;
+                                                }
+                                              else
+                                                {
+                                                  /* 33222222222211111111110000000000
+                                                     10987654321098765432109876543210
+                                                     xxxxxxxxxxxxx011xxxxx1110x10001x
+                                                     ld1h.  */
+                                                  return 1412;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                      else
+                        {
+                          if (((word >> 21) & 0x1) == 0)
+                            {
+                              if (((word >> 15) & 0x1) == 0)
+                                {
+                                  if (((word >> 14) & 0x1) == 0)
+                                    {
+                                      if (((word >> 4) & 0x1) == 0)
+                                        {
+                                          /* 33222222222211111111110000000000
+                                             10987654321098765432109876543210
+                                             xxxx0xxxxxxxx000xxxxx0xx0x1001xx
+                                             cmphs.  */
+                                          return 1232;
+                                        }
+                                      else
+                                        {
+ [...]

[diff truncated at 100000 bytes]


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]