[binutils-gdb] aarch64: Add an error code for out-of-range registers

[binutils-gdb] aarch64: Add an error code for out-of-range registers

[Richard Sandiford]

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

commit 859f51df4d0e23c21adc2167d738cf1e6c0f2613
Author: Richard Sandiford <richard.sandiford@arm.com>
Date:   Thu Mar 30 11:09:07 2023 +0100

    aarch64: Add an error code for out-of-range registers
    
    libopcodes currently reports out-of-range registers as a general
    AARCH64_OPDE_OTHER_ERROR.  However, this means that each register
    range needs its own hard-coded string, which is a bit cumbersome
    if the range is determined programmatically.  This patch therefore
    adds a dedicated error type for out-of-range errors.

Diff:
---
 gas/config/tc-aarch64.c  |  8 ++++++++
 include/opcode/aarch64.h | 10 +++++++++-
 opcodes/aarch64-opc.c    | 20 ++++++++++++++------
 3 files changed, 31 insertions(+), 7 deletions(-)

diff --git a/gas/config/tc-aarch64.c b/gas/config/tc-aarch64.c
index 86d5ba992ff..145e241b13b 100644
--- a/gas/config/tc-aarch64.c
+++ b/gas/config/tc-aarch64.c
@@ -5057,6 +5057,7 @@ const char* operand_mismatch_kind_names[] =
   "AARCH64_OPDE_OUT_OF_RANGE",
   "AARCH64_OPDE_UNALIGNED",
   "AARCH64_OPDE_OTHER_ERROR",
+  "AARCH64_OPDE_INVALID_REGNO",
 };
 #endif /* DEBUG_AARCH64 */
 
@@ -5081,6 +5082,7 @@ operand_error_higher_severity_p (enum aarch64_operand_error_kind lhs,
   gas_assert (AARCH64_OPDE_OUT_OF_RANGE > AARCH64_OPDE_REG_LIST);
   gas_assert (AARCH64_OPDE_UNALIGNED > AARCH64_OPDE_OUT_OF_RANGE);
   gas_assert (AARCH64_OPDE_OTHER_ERROR > AARCH64_OPDE_REG_LIST);
+  gas_assert (AARCH64_OPDE_INVALID_REGNO > AARCH64_OPDE_OTHER_ERROR);
   return lhs > rhs;
 }
 
@@ -5712,6 +5714,12 @@ output_operand_error_record (const operand_error_record *record, char *str)
                detail->index + 1, str);
       break;
 
+    case AARCH64_OPDE_INVALID_REGNO:
+      handler (_("%s%d-%s%d expected at operand %d -- `%s'"),
+	       detail->data[0].s, detail->data[1].i,
+	       detail->data[0].s, detail->data[2].i, idx + 1, str);
+      break;
+
     case AARCH64_OPDE_OUT_OF_RANGE:
       if (detail->data[0].i != detail->data[1].i)
 	handler (_("%s out of range %d to %d at operand %d -- `%s'"),
diff --git a/include/opcode/aarch64.h b/include/opcode/aarch64.h
index 10c7983aa2d..6615dec41a7 100644
--- a/include/opcode/aarch64.h
+++ b/include/opcode/aarch64.h
@@ -1311,6 +1311,13 @@ struct aarch64_inst
      Error of the highest severity and used for any severe issue that does not
      fall into any of the above categories.
 
+   AARCH64_OPDE_INVALID_REGNO
+     A register was syntactically valid and had the right type, but it was
+     outside the range supported by the associated operand field.  This is
+     a high severity error because there are currently no instructions that
+     would accept the operands that precede the erroneous one (if any) and
+     yet still accept a wider range of registers.
+
    AARCH64_OPDE_RECOVERABLE, AARCH64_OPDE_SYNTAX_ERROR and
    AARCH64_OPDE_FATAL_SYNTAX_ERROR are only deteced by GAS while the
    AARCH64_OPDE_INVALID_VARIANT error can only be spotted by libopcodes as
@@ -1339,7 +1346,8 @@ enum aarch64_operand_error_kind
   AARCH64_OPDE_UNTIED_OPERAND,
   AARCH64_OPDE_OUT_OF_RANGE,
   AARCH64_OPDE_UNALIGNED,
-  AARCH64_OPDE_OTHER_ERROR
+  AARCH64_OPDE_OTHER_ERROR,
+  AARCH64_OPDE_INVALID_REGNO
 };
 
 /* N.B. GAS assumes that this structure work well with shallow copy.  */
diff --git a/opcodes/aarch64-opc.c b/opcodes/aarch64-opc.c
index 24cca9e8193..c36e4cc67f6 100644
--- a/opcodes/aarch64-opc.c
+++ b/opcodes/aarch64-opc.c
@@ -1335,6 +1335,18 @@ set_syntax_error (aarch64_operand_error *mismatch_detail, int idx,
   set_error (mismatch_detail, AARCH64_OPDE_SYNTAX_ERROR, idx, error);
 }
 
+static inline void
+set_invalid_regno_error (aarch64_operand_error *mismatch_detail, int idx,
+			 const char *prefix, int lower_bound, int upper_bound)
+{
+  if (mismatch_detail == NULL)
+    return;
+  set_error (mismatch_detail, AARCH64_OPDE_INVALID_REGNO, idx, NULL);
+  mismatch_detail->data[0].s = prefix;
+  mismatch_detail->data[1].i = lower_bound;
+  mismatch_detail->data[2].i = upper_bound;
+}
+
 static inline void
 set_out_of_range_error (aarch64_operand_error *mismatch_detail,
 			int idx, int lower_bound, int upper_bound,
@@ -1569,11 +1581,7 @@ operand_general_constraint_met_p (const aarch64_opnd_info *opnds, int idx,
 	  mask = (1 << shift) - 1;
 	  if (opnd->reg.regno > mask)
 	    {
-	      assert (mask == 7 || mask == 15);
-	      set_other_error (mismatch_detail, idx,
-			       mask == 15
-			       ? _("z0-z15 expected")
-			       : _("z0-z7 expected"));
+	      set_invalid_regno_error (mismatch_detail, idx, "z", 0, mask);
 	      return 0;
 	    }
 	  mask = (1u << (size - shift)) - 1;
@@ -1642,7 +1650,7 @@ operand_general_constraint_met_p (const aarch64_opnd_info *opnds, int idx,
       if (opnd->reg.regno >= 8
 	  && get_operand_fields_width (get_operand_from_code (type)) == 3)
 	{
-	  set_other_error (mismatch_detail, idx, _("p0-p7 expected"));
+	  set_invalid_regno_error (mismatch_detail, idx, "p", 0, 7);
 	  return 0;
 	}
       break;