target/arm: expose remaining CPUID registers as RAZ

There are a whole bunch more registers in the CPUID space which are
currently not used but are exposed as RAZ. To avoid too much
duplication we expand ARMCPRegUserSpaceInfo to understand glob
patterns so we only need one entry to tweak whole ranges of registers.

Backports commit d040242effe47850060d2ef1c461ff637d88a84d from qemu

qemu/glib_compat.c

@@ -2557,3 +2557,478 @@ guchar *g_base64_decode_inplace(gchar *text, gsize *out_len)
 
   return (guchar *) text;
 }
+
+/** SECTION: unicode
+ */
+
+static const gchar utf8_skip_data[256] = {
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+  2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
+  3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,6,6,1,1
+};
+
+const gchar * const g_utf8_skip = utf8_skip_data;
+
+char* g_utf8_strreverse(const gchar *str, long long len)
+{
+  gchar *r, *result;
+  const gchar *p;
+
+  if (len < 0)
+    len = strlen (str);
+
+  result = g_new (gchar, len + 1);
+  r = result + len;
+  p = str;
+  while (r > result)
+    {
+      gchar *m, skip = g_utf8_skip[*(guchar*) p];
+      r -= skip;
+      for (m = r; skip; skip--)
+        *m++ = *p++;
+    }
+  result[len] = 0;
+
+  return result;
+}
+
+/**
+ * SECTION:patterns
+ * @title: Glob-style pattern matching
+ * @short_description: matches strings against patterns containing '*'
+ *                     (wildcard) and '?' (joker)
+ *
+ * The g_pattern_match* functions match a string
+ * against a pattern containing '*' and '?' wildcards with similar
+ * semantics as the standard glob() function: '*' matches an arbitrary,
+ * possibly empty, string, '?' matches an arbitrary character.
+ *
+ * Note that in contrast to glob(), the '/' character can be matched by
+ * the wildcards, there are no '[...]' character ranges and '*' and '?'
+ * can not be escaped to include them literally in a pattern.
+ *
+ * When multiple strings must be matched against the same pattern, it
+ * is better to compile the pattern to a #GPatternSpec using
+ * g_pattern_spec_new() and use g_pattern_match_string() instead of
+ * g_pattern_match_simple(). This avoids the overhead of repeated
+ * pattern compilation.
+ **/
+
+/**
+ * GPatternSpec:
+ *
+ * A GPatternSpec struct is the 'compiled' form of a pattern. This
+ * structure is opaque and its fields cannot be accessed directly.
+ */
+
+/* keep enum and structure of gpattern.c and patterntest.c in sync */
+typedef enum
+{
+  G_MATCH_ALL,       /* "*A?A*" */
+  G_MATCH_ALL_TAIL,  /* "*A?AA" */
+  G_MATCH_HEAD,      /* "AAAA*" */
+  G_MATCH_TAIL,      /* "*AAAA" */
+  G_MATCH_EXACT,     /* "AAAAA" */
+  G_MATCH_LAST
+} GMatchType;
+
+struct _GPatternSpec
+{
+  GMatchType match_type;
+  guint      pattern_length;
+  guint      min_length;
+  guint      max_length;
+  gchar     *pattern;
+};
+
+
+/* --- functions --- */
+static inline int
+g_pattern_ph_match (const char *match_pattern,
+        const char *match_string,
+        int    *wildcard_reached_p)
+{
+  const char *pattern, *string;
+  char ch;
+
+  pattern = match_pattern;
+  string = match_string;
+
+  ch = *pattern;
+  pattern++;
+  while (ch)
+    {
+      switch (ch)
+  {
+  case '?':
+    if (!*string)
+      return FALSE;
+    string = g_utf8_next_char (string);
+    break;
+
+  case '*':
+    *wildcard_reached_p = TRUE;
+    do
+      {
+        ch = *pattern;
+        pattern++;
+        if (ch == '?')
+    {
+      if (!*string)
+        return FALSE;
+      string = g_utf8_next_char (string);
+    }
+      }
+    while (ch == '*' || ch == '?');
+    if (!ch)
+      return TRUE;
+    do
+      {
+              int next_wildcard_reached = FALSE;
+        while (ch != *string)
+    {
+      if (!*string)
+        return FALSE;
+      string = g_utf8_next_char (string);
+    }
+        string++;
+        if (g_pattern_ph_match (pattern, string, &next_wildcard_reached))
+    return TRUE;
+              if (next_wildcard_reached)
+                /* the forthcoming pattern substring up to the next wildcard has
+                 * been matched, but a mismatch occoured for the rest of the
+                 * pattern, following the next wildcard.
+                 * there's no need to advance the current match position any
+                 * further if the rest pattern will not match.
+                 */
+    return FALSE;
+      }
+    while (*string);
+    break;
+
+  default:
+    if (ch == *string)
+      string++;
+    else
+      return FALSE;
+    break;
+  }
+
+      ch = *pattern;
+      pattern++;
+    }
+
+  return *string == 0;
+}
+
+/**
+ * g_pattern_match:
+ * @pspec: a #GPatternSpec
+ * @string_length: the length of @string (in bytes, i.e. strlen(),
+ *     not g_utf8_strlen())
+ * @string: the UTF-8 encoded string to match
+ * @string_reversed: (nullable): the reverse of @string or %NULL
+ *
+ * Matches a string against a compiled pattern. Passing the correct
+ * length of the string given is mandatory. The reversed string can be
+ * omitted by passing %NULL, this is more efficient if the reversed
+ * version of the string to be matched is not at hand, as
+ * g_pattern_match() will only construct it if the compiled pattern
+ * requires reverse matches.
+ *
+ * Note that, if the user code will (possibly) match a string against a
+ * multitude of patterns containing wildcards, chances are high that
+ * some patterns will require a reversed string. In this case, it's
+ * more efficient to provide the reversed string to avoid multiple
+ * constructions thereof in the various calls to g_pattern_match().
+ *
+ * Note also that the reverse of a UTF-8 encoded string can in general
+ * not be obtained by g_strreverse(). This works only if the string
+ * does not contain any multibyte characters. GLib offers the
+ * g_utf8_strreverse() function to reverse UTF-8 encoded strings.
+ *
+ * Returns: %TRUE if @string matches @pspec
+ **/
+int
+g_pattern_match (GPatternSpec *pspec,
+     unsigned int string_length,
+     const char   *string,
+     const char   *string_reversed)
+{
+  if (!pspec) {
+    return 0;
+  }
+
+  if (!string) {
+    return 0;
+  }
+
+  if (string_length < pspec->min_length ||
+      string_length > pspec->max_length)
+    return FALSE;
+
+  switch (pspec->match_type)
+    {
+      int dummy;
+    case G_MATCH_ALL:
+      return g_pattern_ph_match (pspec->pattern, string, &dummy);
+    case G_MATCH_ALL_TAIL:
+      if (string_reversed)
+  return g_pattern_ph_match (pspec->pattern, string_reversed, &dummy);
+      else
+  {
+          int result;
+          char *tmp;
+    tmp = g_utf8_strreverse (string, string_length);
+    result = g_pattern_ph_match (pspec->pattern, tmp, &dummy);
+    g_free (tmp);
+    return result;
+  }
+    case G_MATCH_HEAD:
+      if (pspec->pattern_length == string_length)
+  return strcmp (pspec->pattern, string) == 0;
+      else if (pspec->pattern_length)
+  return strncmp (pspec->pattern, string, pspec->pattern_length) == 0;
+      else
+  return TRUE;
+    case G_MATCH_TAIL:
+      if (pspec->pattern_length)
+        return strcmp (pspec->pattern, string + (string_length - pspec->pattern_length)) == 0;
+      else
+  return TRUE;
+    case G_MATCH_EXACT:
+      if (pspec->pattern_length != string_length)
+        return FALSE;
+      else
+        return strcmp (pspec->pattern, string) == 0;
+    default:
+      return FALSE;
+    }
+}
+
+/**
+ * g_pattern_spec_new:
+ * @pattern: a zero-terminated UTF-8 encoded string
+ *
+ * Compiles a pattern to a #GPatternSpec.
+ *
+ * Returns: a newly-allocated #GPatternSpec
+ **/
+GPatternSpec*
+g_pattern_spec_new (const char *pattern)
+{
+  GPatternSpec *pspec;
+  int seen_joker = FALSE, seen_wildcard = FALSE, more_wildcards = FALSE;
+  int hw_pos = -1, tw_pos = -1, hj_pos = -1, tj_pos = -1;
+  int follows_wildcard = FALSE;
+  unsigned int pending_jokers = 0;
+  const char *s;
+  char *d;
+  unsigned int i;
+
+  if (!pattern) {
+    return NULL;
+  }
+
+  /* canonicalize pattern and collect necessary stats */
+  pspec = g_new (GPatternSpec, 1);
+  pspec->pattern_length = strlen (pattern);
+  pspec->min_length = 0;
+  pspec->max_length = 0;
+  pspec->pattern = g_new (gchar, pspec->pattern_length + 1);
+  d = pspec->pattern;
+  for (i = 0, s = pattern; *s != 0; s++)
+    {
+      switch (*s)
+  {
+  case '*':
+    if (follows_wildcard) /* compress multiple wildcards */
+      {
+        pspec->pattern_length--;
+        continue;
+      }
+    follows_wildcard = TRUE;
+    if (hw_pos < 0)
+      hw_pos = i;
+    tw_pos = i;
+    break;
+  case '?':
+    pending_jokers++;
+    pspec->min_length++;
+    pspec->max_length += 4; /* maximum UTF-8 character length */
+    continue;
+  default:
+    for (; pending_jokers; pending_jokers--, i++) {
+      *d++ = '?';
+        if (hj_pos < 0)
+       hj_pos = i;
+      tj_pos = i;
+    }
+    follows_wildcard = FALSE;
+    pspec->min_length++;
+    pspec->max_length++;
+    break;
+  }
+      *d++ = *s;
+      i++;
+    }
+  for (; pending_jokers; pending_jokers--) {
+    *d++ = '?';
+    if (hj_pos < 0)
+      hj_pos = i;
+    tj_pos = i;
+  }
+  *d++ = 0;
+  seen_joker = hj_pos >= 0;
+  seen_wildcard = hw_pos >= 0;
+  more_wildcards = seen_wildcard && hw_pos != tw_pos;
+  if (seen_wildcard)
+    pspec->max_length = 0xffffffff;
+
+  /* special case sole head/tail wildcard or exact matches */
+  if (!seen_joker && !more_wildcards)
+    {
+      if (pspec->pattern[0] == '*')
+  {
+    pspec->match_type = G_MATCH_TAIL;
+          memmove (pspec->pattern, pspec->pattern + 1, --pspec->pattern_length);
+    pspec->pattern[pspec->pattern_length] = 0;
+    return pspec;
+  }
+      if (pspec->pattern_length > 0 &&
+    pspec->pattern[pspec->pattern_length - 1] == '*')
+  {
+    pspec->match_type = G_MATCH_HEAD;
+    pspec->pattern[--pspec->pattern_length] = 0;
+    return pspec;
+  }
+      if (!seen_wildcard)
+  {
+    pspec->match_type = G_MATCH_EXACT;
+    return pspec;
+  }
+    }
+
+  /* now just need to distinguish between head or tail match start */
+  tw_pos = pspec->pattern_length - 1 - tw_pos;  /* last pos to tail distance */
+  tj_pos = pspec->pattern_length - 1 - tj_pos;  /* last pos to tail distance */
+  if (seen_wildcard)
+    pspec->match_type = tw_pos > hw_pos ? G_MATCH_ALL_TAIL : G_MATCH_ALL;
+  else /* seen_joker */
+    pspec->match_type = tj_pos > hj_pos ? G_MATCH_ALL_TAIL : G_MATCH_ALL;
+  if (pspec->match_type == G_MATCH_ALL_TAIL) {
+    gchar *tmp = pspec->pattern;
+    pspec->pattern = g_utf8_strreverse (pspec->pattern, pspec->pattern_length);
+    g_free (tmp);
+  }
+  return pspec;
+}
+
+/**
+ * g_pattern_spec_free:
+ * @pspec: a #GPatternSpec
+ *
+ * Frees the memory allocated for the #GPatternSpec.
+ **/
+void
+g_pattern_spec_free (GPatternSpec *pspec)
+{
+  if (!pspec) {
+    return;
+  }
+
+  g_free (pspec->pattern);
+  g_free (pspec);
+}
+
+/**
+ * g_pattern_spec_equal:
+ * @pspec1: a #GPatternSpec
+ * @pspec2: another #GPatternSpec
+ *
+ * Compares two compiled pattern specs and returns whether they will
+ * match the same set of strings.
+ *
+ * Returns: Whether the compiled patterns are equal
+ **/
+int
+g_pattern_spec_equal (GPatternSpec *pspec1,
+          GPatternSpec *pspec2)
+{
+  if (!pspec1) {
+    return 0;
+  }
+
+  if (!pspec2) {
+    return 0;
+  }
+
+  return (pspec1->pattern_length == pspec2->pattern_length &&
+    pspec1->match_type == pspec2->match_type &&
+    strcmp (pspec1->pattern, pspec2->pattern) == 0);
+}
+
+/**
+ * g_pattern_match_string:
+ * @pspec: a #GPatternSpec
+ * @string: the UTF-8 encoded string to match
+ *
+ * Matches a string against a compiled pattern. If the string is to be
+ * matched against more than one pattern, consider using
+ * g_pattern_match() instead while supplying the reversed string.
+ *
+ * Returns: %TRUE if @string matches @pspec
+ **/
+int
+g_pattern_match_string (GPatternSpec *pspec,
+      const char  *string)
+{
+  if (!pspec) {
+    return 0;
+  }
+
+  if (!string) {
+    return 0;
+  }
+
+  return g_pattern_match (pspec, strlen (string), string, NULL);
+}
+
+/**
+ * g_pattern_match_simple:
+ * @pattern: the UTF-8 encoded pattern
+ * @string: the UTF-8 encoded string to match
+ *
+ * Matches a string against a pattern given as a string. If this
+ * function is to be called in a loop, it's more efficient to compile
+ * the pattern once with g_pattern_spec_new() and call
+ * g_pattern_match_string() repeatedly.
+ *
+ * Returns: %TRUE if @string matches @pspec
+ **/
+int
+g_pattern_match_simple (const char *pattern,
+      const char *string)
+{
+  GPatternSpec *pspec;
+  int ergo;
+
+  if (!pattern) {
+    return 0;
+  }
+
+  if (!string) {
+    return 0;
+  }
+
+  pspec = g_pattern_spec_new (pattern);
+  ergo = g_pattern_match (pspec, strlen (string), string, NULL);
+  g_pattern_spec_free (pspec);
+
+  return ergo;
+}

qemu/include/glib_compat.h

@@ -187,6 +187,19 @@ gchar *g_base64_encode(const guchar *data, gsize len);
 guchar *g_base64_decode(const gchar *text, gsize *out_len);
 guchar *g_base64_decode_inplace(gchar *text, gsize *out_len);
 
+extern const gchar * const g_utf8_skip;
+#define g_utf8_next_char(p) (char *)((p) + g_utf8_skip[*(const guchar *)(p)])
+char* g_utf8_strreverse (const char *str, long long len);
+
+typedef struct _GPatternSpec    GPatternSpec;
+
+GPatternSpec* g_pattern_spec_new(const char *pattern);
+void g_pattern_spec_free(GPatternSpec *pspec);
+int g_pattern_spec_equal(GPatternSpec *pspec1, GPatternSpec *pspec2);
+int g_pattern_match(GPatternSpec *pspec, unsigned int string_length, const char *string, const char *string_reversed);
+int g_pattern_match_string(GPatternSpec *pspec, const char *string);
+int g_pattern_match_simple(const char *pattern, const char *string);
+
 #define g_new(struct_type, n_structs) ((struct_type*)g_new_(sizeof(struct_type), n_structs))
 #define g_new0(struct_type, n_structs) ((struct_type*)g_new0_(sizeof(struct_type), n_structs))
 #define g_renew(struct_type, mem, n_structs) ((struct_type*)g_renew_(sizeof(struct_type), mem, n_structs))

qemu/target/arm/cpu.h

@@ -2416,6 +2416,9 @@ typedef struct ARMCPRegUserSpaceInfo {
     /* Name of register */
     const char *name;
 
+    /* Is the name actually a glob pattern */
+    bool is_glob;
+
     /* Only some bits are exported to user space */
     uint64_t exported_bits;
 

qemu/target/arm/helper.c

@@ -5290,19 +5290,27 @@ void register_cp_regs_for_features(ARMCPU *cpu)
               .fixed_bits    = 0x0000000000000011 },
             { .name = "ID_AA64PFR1_EL1",
               .exported_bits = 0x00000000000000f0 },
+            { .name = "ID_AA64PFR*_EL1_RESERVED",
+              .is_glob = true                     },
             { .name = "ID_AA64ZFR0_EL1"           },
             { .name = "ID_AA64MMFR0_EL1",
               .fixed_bits    = 0x00000000ff000000 },
+            { .name = "ID_AA64MMFR*_EL1_RESERVED",
+              .is_glob = true                     },
             { .name = "ID_AA64MMFR1_EL1"          },
             { .name = "ID_AA64DFR0_EL1",
               .fixed_bits    = 0x0000000000000006 },
             { .name = "ID_AA64DFR1_EL1"           },
-            { .name = "ID_AA64AFR0_EL1"           },
-            { .name = "ID_AA64AFR1_EL1"           },
+            { .name = "ID_AA64DFR*_EL1_RESERVED",
+              .is_glob = true                     },
+            { .name = "ID_AA64AFR*",
+              .is_glob = true                     },
             { .name = "ID_AA64ISAR0_EL1",
               .exported_bits = 0x00fffffff0fffff0 },
             { .name = "ID_AA64ISAR1_EL1",
               .exported_bits = 0x000000f0ffffffff },
+            { .name = "ID_AA64ISAR*_EL1_RESERVED",
+              .is_glob = true                     },
             REGUSERINFO_SENTINEL
         };
         modify_arm_cp_regs(v8_idregs, v8_user_idregs);
@@ -6100,8 +6108,17 @@ void modify_arm_cp_regs(ARMCPRegInfo *regs, const ARMCPRegUserSpaceInfo *mods)
     ARMCPRegInfo *r;
 
     for (m = mods; m->name; m++) {
+        GPatternSpec *pat = NULL;
+        if (m->is_glob) {
+            pat = g_pattern_spec_new(m->name);
+        }
         for (r = regs; r->type != ARM_CP_SENTINEL; r++) {
-            if (strcmp(r->name, m->name) == 0) {
+            if (pat && g_pattern_match_string(pat, r->name)) {
+                r->type = ARM_CP_CONST;
+                r->access = PL0U_R;
+                r->resetvalue = 0;
+                /* continue */
+            } else if (strcmp(r->name, m->name) == 0) {
                 r->type = ARM_CP_CONST;
                 r->access = PL0U_R;
                 r->resetvalue &= m->exported_bits;
@@ -6109,6 +6126,9 @@ void modify_arm_cp_regs(ARMCPRegInfo *regs, const ARMCPRegUserSpaceInfo *mods)
                 break;
             }
         }
+        if (pat) {
+            g_pattern_spec_free(pat);
+        }
     }
 }