Fix RVC prime register en/decode

Author: Morten Borup Petersen

src/isa/instruction.h

@@ -420,9 +420,21 @@ struct Reg : public Field<tokenIndex, BitRangeSet<BitRange>> {
     if (!success) {
       return Error(line, "Unknown register '" + regToken + "'");
     }
+
+    // Allow implementations to hook into verification.
+    if (auto res = RegImpl::verifyApply(line, regIndex); res.isError()) {
+      return res;
+    }
+
     instruction |= BitRange().apply(regIndex);
     return Result<>::def();
   }
+
+  // Implementation-specific hook for verification of apply-time register index.
+  static Result<> verifyApply(const TokenizedSrcLine &, unsigned) {
+    return Result<>::def();
+  }
+
   /// Decodes this register into its name. Adds it to the assembly line.
   static bool decode(const Instr_T instruction, const Reg_T,
                      const ReverseSymbolMap &, LineTokens &line) {
@@ -484,7 +496,8 @@ struct ImmPartSet {
   constexpr static void apply(const Instr_T value, Instr_T &instruction) {
     (ImmParts::apply(value, instruction), ...);
   }
-  /// Decodes this immediate into its value by combining values from each part.
+  /// Decodes this immediate into its value by combining values from each
+  /// part.
   constexpr static void decode(Instr_T &value, const Instr_T instruction) {
     (ImmParts::decode(value, instruction), ...);
   }
@@ -553,8 +566,8 @@ struct ImmBase : public Field<tokenIndex, typename ImmParts::BitRanges> {
   using Reg_T_S = typename std::make_signed<Reg_T>::type;
   using Reg_T_U = typename std::make_unsigned<Reg_T>::type;
 
-  /// Converts a string to its immediate value (if it exists). Success is set to
-  /// false if this fails.
+  /// Converts a string to its immediate value (if it exists). Success is set
+  /// to false if this fails.
   constexpr static int64_t getImm(const QString &immToken, bool &success,
                                   ImmConvInfo &convInfo) {
     return repr == Repr::Signed
@@ -690,8 +703,8 @@ template <unsigned tokenIndex, unsigned width, Repr repr, typename ImmParts,
 using ImmSym =
     ImmBase<tokenIndex, width, repr, ImmParts, symbolType, defaultTransformer>;
 
-/** @brief Shorthand for an Immediate with the default value transformer and no
- * symbol type. */
+/** @brief Shorthand for an Immediate with the default value transformer and
+ * no symbol type. */
 template <unsigned tokenIndex, unsigned width, Repr repr, typename ImmParts>
 using Imm = ImmBase<tokenIndex, width, repr, ImmParts, SymbolType::None,
                     defaultTransformer>;

src/isa/rv_c_ext.h

@@ -56,19 +56,43 @@ struct RegRs2 : public GPR_Reg<RegRs2<tokenIndex>, tokenIndex, BitRange<2, 6>> {
   constexpr static std::string_view NAME = "rs2";
 };
 
+// A prime bitrange represents rd', rs1', rs2' in compressed instructions, where
+// the bit range represents registers offset by 8.
+template <unsigned start, unsigned stop>
+struct PrimeBitRange : public BitRange<start, stop> {
+  constexpr Instr_T decode(Instr_T instruction) const {
+    return BitRange<start, stop>::decode(instruction) + 8;
+  }
+};
+
+template <typename TImpl, unsigned tokenIndex, typename Range>
+struct RegPrime : public GPR_Reg<TImpl, tokenIndex, Range> {
+  constexpr static std::string_view NAME = TImpl::NAME;
+
+  // Only accept registers x8-x15
+  static Result<> verifyApply(const TokenizedSrcLine &line, unsigned regIndex) {
+    if (regIndex < 8 || regIndex > 15) {
+      return Error(line, "Invalid register index for prime register: " +
+                             QString::number(regIndex) +
+                             " (valid range: x8-x15)");
+    }
+    return Result<>::def();
+  }
+};
+
 /// The RV-C Rs1' field contains a source register index.
 /// It is defined as a 3-bit field in bits 7-9 of the instruction
 template <unsigned tokenIndex>
-struct RegRs1Prime
-    : public GPR_Reg<RegRs1Prime<tokenIndex>, tokenIndex, BitRange<7, 9>> {
+struct RegRs1Prime : public RegPrime<RegRs1Prime<tokenIndex>, tokenIndex,
+                                     PrimeBitRange<7, 9>> {
   constexpr static std::string_view NAME = "rs1'";
 };
 
 /// The RV-C Rs2' field contains a source register index.
 /// It is defined as a 3-bit field in bits 2-4 of the instruction
 template <unsigned tokenIndex>
-struct RegRs2Prime
-    : public GPR_Reg<RegRs2Prime<tokenIndex>, tokenIndex, BitRange<2, 4>> {
+struct RegRs2Prime : public RegPrime<RegRs2Prime<tokenIndex>, tokenIndex,
+                                     PrimeBitRange<2, 4>> {
   constexpr static std::string_view NAME = "rs2'";
 };
 
@@ -77,7 +101,7 @@ struct RegRs2Prime
 /// It is defined as a 3-bit field in bits 2-4 of the instruction
 template <unsigned tokenIndex>
 struct RegRdPrime
-    : public GPR_Reg<RegRdPrime<tokenIndex>, tokenIndex, BitRange<2, 4>> {
+    : public RegPrime<RegRdPrime<tokenIndex>, tokenIndex, PrimeBitRange<2, 4>> {
   constexpr static std::string_view NAME = "rd'";
 };