Simplify disassembler for already decoded mnemonics #2
Further simplification of the disassembler using mnemonics provided by the
decoder. Also, improve consistency of "unallocated" being reported for those
instructions that are undefined.
diff --git a/src/aarch64/disasm-aarch64.cc b/src/aarch64/disasm-aarch64.cc
index 855705d..22f1a33 100644
--- a/src/aarch64/disasm-aarch64.cc
+++ b/src/aarch64/disasm-aarch64.cc
@@ -1228,13 +1228,11 @@
void Disassembler::VisitConditionalBranch(const Instruction *instr) {
- switch (instr->Mask(ConditionalBranchMask)) {
- case B_cond:
- Format(instr, "b.'CBrn", "'TImmCond");
- break;
- default:
- VIXL_UNREACHABLE();
- }
+ // We can't use the mnemonic directly here, as there's no space between it and
+ // the condition. Assert that we have the correct mnemonic, then use "b"
+ // explicitly for formatting the output.
+ VIXL_ASSERT(form_hash_ == "b_only_condbranch"_h);
+ Format(instr, "b.'CBrn", "'TImmCond");
}
@@ -1471,24 +1469,11 @@
void Disassembler::VisitTestBranch(const Instruction *instr) {
- const char *mnemonic = "";
// If the top bit of the immediate is clear, the tested register is
// disassembled as Wt, otherwise Xt. As the top bit of the immediate is
// encoded in bit 31 of the instruction, we can reuse the Rt form, which
// uses bit 31 (normally "sf") to choose the register size.
- const char *form = "'Rt, 'It, 'TImmTest";
-
- switch (instr->Mask(TestBranchMask)) {
- case TBZ:
- mnemonic = "tbz";
- break;
- case TBNZ:
- mnemonic = "tbnz";
- break;
- default:
- VIXL_UNREACHABLE();
- }
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, "'Rt, 'It, 'TImmTest");
}
@@ -4226,28 +4211,10 @@
void Disassembler::VisitSVE32BitGatherPrefetch_VectorPlusImm(
const Instruction *instr) {
- const char *mnemonic = "unimplemented";
const char *form = (instr->ExtractBits(20, 16) != 0)
? "'prefSVEOp, 'Pgl, ['Zn.s, #'u2016]"
: "'prefSVEOp, 'Pgl, ['Zn.s]";
-
- switch (instr->Mask(SVE32BitGatherPrefetch_VectorPlusImmMask)) {
- case PRFB_i_p_ai_s:
- mnemonic = "prfb";
- break;
- case PRFD_i_p_ai_s:
- mnemonic = "prfd";
- break;
- case PRFH_i_p_ai_s:
- mnemonic = "prfh";
- break;
- case PRFW_i_p_ai_s:
- mnemonic = "prfw";
- break;
- default:
- break;
- }
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, form);
}
void Disassembler::VisitSVE32BitScatterStore_ScalarPlus32BitScaledOffsets(
@@ -5010,48 +4977,10 @@
void Disassembler::VisitSVEContiguousNonFaultLoad_ScalarPlusImm(
const Instruction *instr) {
- const char *mnemonic = "unimplemented";
const char *form = "{'Zt.'tlss}, 'Pgl/z, ['Xns";
const char *suffix =
(instr->ExtractBits(19, 16) == 0) ? "]" : ", #'s1916, mul vl]";
-
- switch (instr->Mask(SVEContiguousNonFaultLoad_ScalarPlusImmMask)) {
- case LDNF1B_z_p_bi_u16:
- case LDNF1B_z_p_bi_u32:
- case LDNF1B_z_p_bi_u64:
- case LDNF1B_z_p_bi_u8:
- mnemonic = "ldnf1b";
- break;
- case LDNF1D_z_p_bi_u64:
- mnemonic = "ldnf1d";
- break;
- case LDNF1H_z_p_bi_u16:
- case LDNF1H_z_p_bi_u32:
- case LDNF1H_z_p_bi_u64:
- mnemonic = "ldnf1h";
- break;
- case LDNF1SB_z_p_bi_s16:
- case LDNF1SB_z_p_bi_s32:
- case LDNF1SB_z_p_bi_s64:
- mnemonic = "ldnf1sb";
- break;
- case LDNF1SH_z_p_bi_s32:
- case LDNF1SH_z_p_bi_s64:
- mnemonic = "ldnf1sh";
- break;
- case LDNF1SW_z_p_bi_s64:
- mnemonic = "ldnf1sw";
- break;
- case LDNF1W_z_p_bi_u32:
- case LDNF1W_z_p_bi_u64:
- mnemonic = "ldnf1w";
- break;
- default:
- form = "(SVEContiguousNonFaultLoad_ScalarPlusImm)";
- suffix = NULL;
- break;
- }
- Format(instr, mnemonic, form, suffix);
+ FormatWithDecodedMnemonic(instr, form, suffix);
}
void Disassembler::VisitSVEContiguousNonTemporalLoad_ScalarPlusImm(
@@ -5174,28 +5103,10 @@
void Disassembler::VisitSVEContiguousPrefetch_ScalarPlusImm(
const Instruction *instr) {
- const char *mnemonic = "unimplemented";
const char *form = (instr->ExtractBits(21, 16) != 0)
? "'prefSVEOp, 'Pgl, ['Xns, #'s2116, mul vl]"
: "'prefSVEOp, 'Pgl, ['Xns]";
-
- switch (instr->Mask(SVEContiguousPrefetch_ScalarPlusImmMask)) {
- case PRFB_i_p_bi_s:
- mnemonic = "prfb";
- break;
- case PRFD_i_p_bi_s:
- mnemonic = "prfd";
- break;
- case PRFH_i_p_bi_s:
- mnemonic = "prfh";
- break;
- case PRFW_i_p_bi_s:
- mnemonic = "prfw";
- break;
- default:
- break;
- }
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, form);
}
void Disassembler::VisitSVEContiguousPrefetch_ScalarPlusScalar(
@@ -5365,18 +5276,7 @@
}
void Disassembler::VisitSVEFFRInitialise(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "(SVEFFRInitialise)";
-
- switch (instr->Mask(SVEFFRInitialiseMask)) {
- case SETFFR_f:
- mnemonic = "setffr";
- form = " ";
- break;
- default:
- break;
- }
- Format(instr, mnemonic, form);
+ DisassembleNoArgs(instr);
}
void Disassembler::VisitSVEFFRWriteFromPredicate(const Instruction *instr) {
@@ -5434,57 +5334,11 @@
}
void Disassembler::VisitSVEFPArithmetic_Predicated(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'Zd.'t, 'Pgl/m, 'Zd.'t, 'Zn.'t";
-
if (instr->GetSVEVectorFormat() == kFormatVnB) {
- form = "(SVEFPArithmetic_Predicated)";
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPArithmetic_PredicatedMask)) {
- case FABD_z_p_zz:
- mnemonic = "fabd";
- break;
- case FADD_z_p_zz:
- mnemonic = "fadd";
- break;
- case FDIVR_z_p_zz:
- mnemonic = "fdivr";
- break;
- case FDIV_z_p_zz:
- mnemonic = "fdiv";
- break;
- case FMAXNM_z_p_zz:
- mnemonic = "fmaxnm";
- break;
- case FMAX_z_p_zz:
- mnemonic = "fmax";
- break;
- case FMINNM_z_p_zz:
- mnemonic = "fminnm";
- break;
- case FMIN_z_p_zz:
- mnemonic = "fmin";
- break;
- case FMULX_z_p_zz:
- mnemonic = "fmulx";
- break;
- case FMUL_z_p_zz:
- mnemonic = "fmul";
- break;
- case FSCALE_z_p_zz:
- mnemonic = "fscale";
- break;
- case FSUBR_z_p_zz:
- mnemonic = "fsubr";
- break;
- case FSUB_z_p_zz:
- mnemonic = "fsub";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Zd.'t, 'Pgl/m, 'Zd.'t, 'Zn.'t");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEFPConvertPrecision(const Instruction *instr) {
@@ -5609,39 +5463,11 @@
}
void Disassembler::VisitSVEFPRoundToIntegralValue(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'Zd.'t, 'Pgl/m, 'Zn.'t";
-
if (instr->GetSVEVectorFormat() == kFormatVnB) {
- form = "(SVEFPRoundToIntegralValue)";
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPRoundToIntegralValueMask)) {
- case FRINTA_z_p_z:
- mnemonic = "frinta";
- break;
- case FRINTI_z_p_z:
- mnemonic = "frinti";
- break;
- case FRINTM_z_p_z:
- mnemonic = "frintm";
- break;
- case FRINTN_z_p_z:
- mnemonic = "frintn";
- break;
- case FRINTP_z_p_z:
- mnemonic = "frintp";
- break;
- case FRINTX_z_p_z:
- mnemonic = "frintx";
- break;
- case FRINTZ_z_p_z:
- mnemonic = "frintz";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Zd.'t, 'Pgl/m, 'Zn.'t");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEFPTrigMulAddCoefficient(const Instruction *instr) {
@@ -5683,25 +5509,11 @@
}
void Disassembler::VisitSVEFPUnaryOp(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'Zd.'t, 'Pgl/m, 'Zn.'t";
-
if (instr->GetSVESize() == kBRegSizeInBytesLog2) {
- form = "(SVEFPUnaryOp)";
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPUnaryOpMask)) {
- case FRECPX_z_p_z:
- mnemonic = "frecpx";
- break;
- case FSQRT_z_p_z:
- mnemonic = "fsqrt";
- break;
- default:
- form = "(SVEFPUnaryOp)";
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Zd.'t, 'Pgl/m, 'Zn.'t");
}
- Format(instr, mnemonic, form);
}
static const char *IncDecFormHelper(const Instruction *instr,
@@ -5762,22 +5574,11 @@
}
void Disassembler::VisitSVEInsertGeneralRegister(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "(SVEInsertGeneralRegister)";
-
- switch (instr->Mask(SVEInsertGeneralRegisterMask)) {
- case INSR_z_r:
- mnemonic = "insr";
- if (instr->GetSVESize() == kDRegSizeInBytesLog2) {
- form = "'Zd.'t, 'Xn";
- } else {
- form = "'Zd.'t, 'Wn";
- }
- break;
- default:
- break;
+ const char *form = "'Zd.'t, 'Wn";
+ if (instr->GetSVESize() == kDRegSizeInBytesLog2) {
+ form = "'Zd.'t, 'Xn";
}
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, form);
}
void Disassembler::VisitSVEInsertSIMDFPScalarRegister(
@@ -5787,38 +5588,10 @@
void Disassembler::VisitSVEIntAddSubtractImm_Unpredicated(
const Instruction *instr) {
- const char *mnemonic = "unimplemented";
const char *form = (instr->ExtractBit(13) == 0)
? "'Zd.'t, 'Zd.'t, #'u1205"
: "'Zd.'t, 'Zd.'t, #'u1205, lsl #8";
-
- switch (instr->Mask(SVEIntAddSubtractImm_UnpredicatedMask)) {
- case ADD_z_zi:
- mnemonic = "add";
- break;
- case SQADD_z_zi:
- mnemonic = "sqadd";
- break;
- case SQSUB_z_zi:
- mnemonic = "sqsub";
- break;
- case SUBR_z_zi:
- mnemonic = "subr";
- break;
- case SUB_z_zi:
- mnemonic = "sub";
- break;
- case UQADD_z_zi:
- mnemonic = "uqadd";
- break;
- case UQSUB_z_zi:
- mnemonic = "uqsub";
- break;
- default:
- form = "(SVEIntAddSubtractImm_Unpredicated)";
- break;
- }
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, form);
}
void Disassembler::VisitSVEIntAddSubtractVectors_Predicated(
@@ -6276,41 +6049,19 @@
}
void Disassembler::VisitSVELoadPredicateRegister(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "(SVELoadPredicateRegister)";
-
- switch (instr->Mask(SVELoadPredicateRegisterMask)) {
- case LDR_p_bi:
- mnemonic = "ldr";
- if (instr->Mask(0x003f1c00) == 0) {
- form = "'Pd, ['Xns]";
- } else {
- form = "'Pd, ['Xns, #'s2116:1210, mul vl]";
- }
- break;
- default:
- break;
+ const char *form = "'Pd, ['Xns, #'s2116:1210, mul vl]";
+ if (instr->Mask(0x003f1c00) == 0) {
+ form = "'Pd, ['Xns]";
}
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, form);
}
void Disassembler::VisitSVELoadVectorRegister(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "(SVELoadVectorRegister)";
-
- switch (instr->Mask(SVELoadVectorRegisterMask)) {
- case LDR_z_bi:
- mnemonic = "ldr";
- if (instr->Mask(0x003f1c00) == 0) {
- form = "'Zd, ['Xns]";
- } else {
- form = "'Zt, ['Xns, #'s2116:1210, mul vl]";
- }
- break;
- default:
- break;
+ const char *form = "'Zt, ['Xns, #'s2116:1210, mul vl]";
+ if (instr->Mask(0x003f1c00) == 0) {
+ form = "'Zd, ['Xns]";
}
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, form);
}
void Disassembler::VisitSVEPartitionBreakCondition(const Instruction *instr) {
@@ -6682,41 +6433,19 @@
}
void Disassembler::VisitSVEStorePredicateRegister(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "(SVEStorePredicateRegister)";
-
- switch (instr->Mask(SVEStorePredicateRegisterMask)) {
- case STR_p_bi:
- mnemonic = "str";
- if (instr->Mask(0x003f1c00) == 0) {
- form = "'Pd, ['Xns]";
- } else {
- form = "'Pd, ['Xns, #'s2116:1210, mul vl]";
- }
- break;
- default:
- break;
+ const char *form = "'Pd, ['Xns, #'s2116:1210, mul vl]";
+ if (instr->Mask(0x003f1c00) == 0) {
+ form = "'Pd, ['Xns]";
}
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, form);
}
void Disassembler::VisitSVEStoreVectorRegister(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "(SVEStoreVectorRegister)";
-
- switch (instr->Mask(SVEStoreVectorRegisterMask)) {
- case STR_z_bi:
- mnemonic = "str";
- if (instr->Mask(0x003f1c00) == 0) {
- form = "'Zd, ['Xns]";
- } else {
- form = "'Zt, ['Xns, #'s2116:1210, mul vl]";
- }
- break;
- default:
- break;
+ const char *form = "'Zt, ['Xns, #'s2116:1210, mul vl]";
+ if (instr->Mask(0x003f1c00) == 0) {
+ form = "'Zd, ['Xns]";
}
- Format(instr, mnemonic, form);
+ FormatWithDecodedMnemonic(instr, form);
}
void Disassembler::VisitSVETableLookup(const Instruction *instr) {
@@ -6871,122 +6600,35 @@
}
void Disassembler::VisitSVEFPAccumulatingReduction(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "(SVEFPAccumulatingReduction)";
-
- if (instr->GetSVEVectorFormat() != kFormatVnB) {
- switch (instr->Mask(SVEFPAccumulatingReductionMask)) {
- case FADDA_v_p_z:
- mnemonic = "fadda";
- form = "'t'u0400, 'Pgl, 't'u0400, 'Zn.'t";
- break;
- default:
- break;
- }
+ if (instr->GetSVEVectorFormat() == kFormatVnB) {
+ VisitUnallocated(instr);
+ } else {
+ FormatWithDecodedMnemonic(instr, "'t'u0400, 'Pgl, 't'u0400, 'Zn.'t");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEFPArithmeticUnpredicated(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'Zd.'t, 'Zn.'t, 'Zm.'t";
-
if (instr->GetSVEVectorFormat() == kFormatVnB) {
- form = ("(SVEFPArithmeticUnpredicated)");
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPArithmeticUnpredicatedMask)) {
- case FADD_z_zz:
- mnemonic = "fadd";
- break;
- case FMUL_z_zz:
- mnemonic = "fmul";
- break;
- case FRECPS_z_zz:
- mnemonic = "frecps";
- break;
- case FRSQRTS_z_zz:
- mnemonic = "frsqrts";
- break;
- case FSUB_z_zz:
- mnemonic = "fsub";
- break;
- case FTSMUL_z_zz:
- mnemonic = "ftsmul";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Zd.'t, 'Zn.'t, 'Zm.'t");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEFPCompareVectors(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'Pd.'t, 'Pgl/z, 'Zn.'t, 'Zm.'t";
-
if (instr->GetSVEVectorFormat() == kFormatVnB) {
- form = "(SVEFPCompareVectors)";
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPCompareVectorsMask)) {
- case FACGE_p_p_zz:
- mnemonic = "facge";
- break;
- case FACGT_p_p_zz:
- mnemonic = "facgt";
- break;
- case FCMEQ_p_p_zz:
- mnemonic = "fcmeq";
- break;
- case FCMGE_p_p_zz:
- mnemonic = "fcmge";
- break;
- case FCMGT_p_p_zz:
- mnemonic = "fcmgt";
- break;
- case FCMNE_p_p_zz:
- mnemonic = "fcmne";
- break;
- case FCMUO_p_p_zz:
- mnemonic = "fcmuo";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Pd.'t, 'Pgl/z, 'Zn.'t, 'Zm.'t");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEFPCompareWithZero(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'Pd.'t, 'Pgl/z, 'Zn.'t, #0.0";
-
if (instr->GetSVEVectorFormat() == kFormatVnB) {
- form = "(SVEFPCompareWithZero)";
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPCompareWithZeroMask)) {
- case FCMEQ_p_p_z0:
- mnemonic = "fcmeq";
- break;
- case FCMGE_p_p_z0:
- mnemonic = "fcmge";
- break;
- case FCMGT_p_p_z0:
- mnemonic = "fcmgt";
- break;
- case FCMLE_p_p_z0:
- mnemonic = "fcmle";
- break;
- case FCMLT_p_p_z0:
- mnemonic = "fcmlt";
- break;
- case FCMNE_p_p_z0:
- mnemonic = "fcmne";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Pd.'t, 'Pgl/z, 'Zn.'t, #0.0");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEFPComplexAddition(const Instruction *instr) {
@@ -7055,33 +6697,11 @@
}
void Disassembler::VisitSVEFPFastReduction(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'t'u0400, 'Pgl, 'Zn.'t";
-
if (instr->GetSVEVectorFormat() == kFormatVnB) {
- form = "(SVEFPFastReduction)";
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPFastReductionMask)) {
- case FADDV_v_p_z:
- mnemonic = "faddv";
- break;
- case FMAXNMV_v_p_z:
- mnemonic = "fmaxnmv";
- break;
- case FMAXV_v_p_z:
- mnemonic = "fmaxv";
- break;
- case FMINNMV_v_p_z:
- mnemonic = "fminnmv";
- break;
- case FMINV_v_p_z:
- mnemonic = "fminv";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'t'u0400, 'Pgl, 'Zn.'t");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEFPMulIndex(const Instruction *instr) {
@@ -7109,42 +6729,11 @@
}
void Disassembler::VisitSVEFPMulAdd(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'Zd.'t, 'Pgl/m, 'Zn.'t, 'Zm.'t";
-
if (instr->GetSVEVectorFormat() == kFormatVnB) {
- form = "(SVEFPMulAdd)";
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPMulAddMask)) {
- case FMAD_z_p_zzz:
- mnemonic = "fmad";
- break;
- case FMLA_z_p_zzz:
- mnemonic = "fmla";
- break;
- case FMLS_z_p_zzz:
- mnemonic = "fmls";
- break;
- case FMSB_z_p_zzz:
- mnemonic = "fmsb";
- break;
- case FNMAD_z_p_zzz:
- mnemonic = "fnmad";
- break;
- case FNMLA_z_p_zzz:
- mnemonic = "fnmla";
- break;
- case FNMLS_z_p_zzz:
- mnemonic = "fnmls";
- break;
- case FNMSB_z_p_zzz:
- mnemonic = "fnmsb";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Zd.'t, 'Pgl/m, 'Zn.'t, 'Zm.'t");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEFPMulAddIndex(const Instruction *instr) {
@@ -7186,24 +6775,11 @@
}
void Disassembler::VisitSVEFPUnaryOpUnpredicated(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "'Zd.'t, 'Zn.'t";
-
if (instr->GetSVEVectorFormat() == kFormatVnB) {
- form = "(SVEFPUnaryOpUnpredicated)";
+ VisitUnallocated(instr);
} else {
- switch (instr->Mask(SVEFPUnaryOpUnpredicatedMask)) {
- case FRECPE_z_z:
- mnemonic = "frecpe";
- break;
- case FRSQRTE_z_z:
- mnemonic = "frsqrte";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Zd.'t, 'Zn.'t");
}
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEIncDecByPredicateCount(const Instruction *instr) {
@@ -7416,24 +6992,11 @@
}
void Disassembler::VisitSVEIntMulAddUnpredicated(const Instruction *instr) {
- const char *mnemonic = "unimplemented";
- const char *form = "(SVEIntMulAddUnpredicated)";
-
if (static_cast<unsigned>(instr->GetSVESize()) >= kSRegSizeInBytesLog2) {
- form = "'Zd.'t, 'Zn.'tq, 'Zm.'tq";
- switch (instr->Mask(SVEIntMulAddUnpredicatedMask)) {
- case SDOT_z_zzz:
- mnemonic = "sdot";
- break;
- case UDOT_z_zzz:
- mnemonic = "udot";
- break;
- default:
- break;
- }
+ FormatWithDecodedMnemonic(instr, "'Zd.'t, 'Zn.'tq, 'Zm.'tq");
+ } else {
+ VisitUnallocated(instr);
}
-
- Format(instr, mnemonic, form);
}
void Disassembler::VisitSVEMovprfx(const Instruction *instr) {
@@ -7697,49 +7260,10 @@
void Disassembler::VisitSVEContiguousLoad_ScalarPlusImm(
const Instruction *instr) {
- const char *mnemonic = "unimplemented";
const char *form = "{'Zt.'tlss}, 'Pgl/z, ['Xns";
const char *suffix =
(instr->ExtractBits(19, 16) == 0) ? "]" : ", #'s1916, mul vl]";
-
- switch (instr->Mask(SVEContiguousLoad_ScalarPlusImmMask)) {
- case LD1B_z_p_bi_u16:
- case LD1B_z_p_bi_u32:
- case LD1B_z_p_bi_u64:
- case LD1B_z_p_bi_u8:
- mnemonic = "ld1b";
- break;
- case LD1D_z_p_bi_u64:
- mnemonic = "ld1d";
- break;
- case LD1H_z_p_bi_u16:
- case LD1H_z_p_bi_u32:
- case LD1H_z_p_bi_u64:
- mnemonic = "ld1h";
- break;
- case LD1SB_z_p_bi_s16:
- case LD1SB_z_p_bi_s32:
- case LD1SB_z_p_bi_s64:
- mnemonic = "ld1sb";
- break;
- case LD1SH_z_p_bi_s32:
- case LD1SH_z_p_bi_s64:
- mnemonic = "ld1sh";
- break;
- case LD1SW_z_p_bi_s64:
- mnemonic = "ld1sw";
- break;
- case LD1W_z_p_bi_u32:
- case LD1W_z_p_bi_u64:
- mnemonic = "ld1w";
- break;
- default:
- form = "(SVEContiguousLoad_ScalarPlusImm)";
- suffix = NULL;
- break;
- }
-
- Format(instr, mnemonic, form, suffix);
+ FormatWithDecodedMnemonic(instr, form, suffix);
}
void Disassembler::VisitSVEContiguousLoad_ScalarPlusScalar(
diff --git a/test/aarch64/test-disasm-sve-aarch64.cc b/test/aarch64/test-disasm-sve-aarch64.cc
index 03abdee..933e808 100644
--- a/test/aarch64/test-disasm-sve-aarch64.cc
+++ b/test/aarch64/test-disasm-sve-aarch64.cc
@@ -66,59 +66,59 @@
CLEANUP();
}
-TEST(sve_unimplemented_fp_byte_type) {
+TEST(sve_unallocated_fp_byte_type) {
// Ensure disassembly of FP instructions does not report byte-sized lanes.
SETUP();
- COMPARE_PREFIX(dci(0x650003ca), "unimplemented");
- COMPARE_PREFIX(dci(0x6500230b), "unimplemented");
- COMPARE_PREFIX(dci(0x6500424c), "unimplemented");
- COMPARE_PREFIX(dci(0x6500618d), "unimplemented");
- COMPARE_PREFIX(dci(0x6500a00f), "unimplemented");
- COMPARE_PREFIX(dci(0x6500de91), "unimplemented");
- COMPARE_PREFIX(dci(0x6500fdd2), "unimplemented");
- COMPARE_PREFIX(dci(0x65011d13), "unimplemented");
- COMPARE_PREFIX(dci(0x65015b95), "unimplemented");
- COMPARE_PREFIX(dci(0x65017ad6), "unimplemented");
- COMPARE_PREFIX(dci(0x65019a17), "unimplemented");
- COMPARE_PREFIX(dci(0x6501b958), "unimplemented");
- COMPARE_PREFIX(dci(0x6502941f), "unimplemented");
- COMPARE_PREFIX(dci(0x6502b360), "unimplemented");
- COMPARE_PREFIX(dci(0x6502d2a1), "unimplemented");
- COMPARE_PREFIX(dci(0x65038e27), "unimplemented");
- COMPARE_PREFIX(dci(0x6503ad68), "unimplemented");
- COMPARE_PREFIX(dci(0x65042a6c), "unimplemented");
- COMPARE_PREFIX(dci(0x6504882f), "unimplemented");
- COMPARE_PREFIX(dci(0x6504a770), "unimplemented");
- COMPARE_PREFIX(dci(0x65052474), "unimplemented");
- COMPARE_PREFIX(dci(0x65058237), "unimplemented");
- COMPARE_PREFIX(dci(0x65063dbd), "unimplemented");
- COMPARE_PREFIX(dci(0x65069b80), "unimplemented");
- COMPARE_PREFIX(dci(0x6506bac1), "unimplemented");
- COMPARE_PREFIX(dci(0x65071884), "unimplemented");
- COMPARE_PREFIX(dci(0x650737c5), "unimplemented");
- COMPARE_PREFIX(dci(0x65079588), "unimplemented");
- COMPARE_PREFIX(dci(0x6507b4c9), "unimplemented");
- COMPARE_PREFIX(dci(0x65088f90), "unimplemented");
- COMPARE_PREFIX(dci(0x65090c94), "unimplemented");
- COMPARE_PREFIX(dci(0x65098998), "unimplemented");
- COMPARE_PREFIX(dci(0x650a83a0), "unimplemented");
- COMPARE_PREFIX(dci(0x650c96f1), "unimplemented");
- COMPARE_PREFIX(dci(0x650d90f9), "unimplemented");
- COMPARE_PREFIX(dci(0x65113a97), "unimplemented");
- COMPARE_PREFIX(dci(0x65183010), "unimplemented");
- COMPARE_PREFIX(dci(0x65200050), "unimplemented");
- COMPARE_PREFIX(dci(0x65203ed2), "unimplemented");
- COMPARE_PREFIX(dci(0x65205e13), "unimplemented");
- COMPARE_PREFIX(dci(0x65207d54), "unimplemented");
- COMPARE_PREFIX(dci(0x65209c95), "unimplemented");
- COMPARE_PREFIX(dci(0x6520bbd6), "unimplemented");
- COMPARE_PREFIX(dci(0x6520db17), "unimplemented");
- COMPARE_PREFIX(dci(0x6520fa58), "unimplemented");
- COMPARE_PREFIX(dci(0x650f31e1), "unimplemented");
- COMPARE_PREFIX(dci(0x650e30f7), "unimplemented");
- COMPARE_PREFIX(dci(0x6511376e), "unimplemented");
+ COMPARE_PREFIX(dci(0x650003ca), "unallocated");
+ COMPARE_PREFIX(dci(0x6500230b), "unallocated");
+ COMPARE_PREFIX(dci(0x6500424c), "unallocated");
+ COMPARE_PREFIX(dci(0x6500618d), "unallocated");
+ COMPARE_PREFIX(dci(0x6500a00f), "unallocated");
+ COMPARE_PREFIX(dci(0x6500de91), "unallocated");
+ COMPARE_PREFIX(dci(0x6500fdd2), "unallocated");
+ COMPARE_PREFIX(dci(0x65011d13), "unallocated");
+ COMPARE_PREFIX(dci(0x65015b95), "unallocated");
+ COMPARE_PREFIX(dci(0x65017ad6), "unallocated");
+ COMPARE_PREFIX(dci(0x65019a17), "unallocated");
+ COMPARE_PREFIX(dci(0x6501b958), "unallocated");
+ COMPARE_PREFIX(dci(0x6502941f), "unallocated");
+ COMPARE_PREFIX(dci(0x6502b360), "unallocated");
+ COMPARE_PREFIX(dci(0x6502d2a1), "unallocated");
+ COMPARE_PREFIX(dci(0x65038e27), "unallocated");
+ COMPARE_PREFIX(dci(0x6503ad68), "unallocated");
+ COMPARE_PREFIX(dci(0x65042a6c), "unallocated");
+ COMPARE_PREFIX(dci(0x6504882f), "unallocated");
+ COMPARE_PREFIX(dci(0x6504a770), "unallocated");
+ COMPARE_PREFIX(dci(0x65052474), "unallocated");
+ COMPARE_PREFIX(dci(0x65058237), "unallocated");
+ COMPARE_PREFIX(dci(0x65063dbd), "unallocated");
+ COMPARE_PREFIX(dci(0x65069b80), "unallocated");
+ COMPARE_PREFIX(dci(0x6506bac1), "unallocated");
+ COMPARE_PREFIX(dci(0x65071884), "unallocated");
+ COMPARE_PREFIX(dci(0x650737c5), "unallocated");
+ COMPARE_PREFIX(dci(0x65079588), "unallocated");
+ COMPARE_PREFIX(dci(0x6507b4c9), "unallocated");
+ COMPARE_PREFIX(dci(0x65088f90), "unallocated");
+ COMPARE_PREFIX(dci(0x65090c94), "unallocated");
+ COMPARE_PREFIX(dci(0x65098998), "unallocated");
+ COMPARE_PREFIX(dci(0x650a83a0), "unallocated");
+ COMPARE_PREFIX(dci(0x650c96f1), "unallocated");
+ COMPARE_PREFIX(dci(0x650d90f9), "unallocated");
+ COMPARE_PREFIX(dci(0x65113a97), "unallocated");
+ COMPARE_PREFIX(dci(0x65183010), "unallocated");
+ COMPARE_PREFIX(dci(0x65200050), "unallocated");
+ COMPARE_PREFIX(dci(0x65203ed2), "unallocated");
+ COMPARE_PREFIX(dci(0x65205e13), "unallocated");
+ COMPARE_PREFIX(dci(0x65207d54), "unallocated");
+ COMPARE_PREFIX(dci(0x65209c95), "unallocated");
+ COMPARE_PREFIX(dci(0x6520bbd6), "unallocated");
+ COMPARE_PREFIX(dci(0x6520db17), "unallocated");
+ COMPARE_PREFIX(dci(0x6520fa58), "unallocated");
+ COMPARE_PREFIX(dci(0x650f31e1), "unallocated");
+ COMPARE_PREFIX(dci(0x650e30f7), "unallocated");
+ COMPARE_PREFIX(dci(0x6511376e), "unallocated");
CLEANUP();
}