[PATCH 4/4] elf: Simplify hwcaps power set string construction

[Javier Pello <devel@otheo.eu>]

The power set strings in _dl_important_hwcaps were being computed
in two passes, one to generate the strings and another one to store
the pointers in the result array. Do it in a single pass instead,
as this is simpler.

Signed-off-by: Javier Pello <devel@otheo.eu>
---
 elf/dl-hwcaps.c | 58 ++++++++++++++++++-------------------------------
 1 file changed, 21 insertions(+), 37 deletions(-)

diff --git a/elf/dl-hwcaps.c b/elf/dl-hwcaps.c
index b248f74b..93a9c56d 100644
--- a/elf/dl-hwcaps.c
+++ b/elf/dl-hwcaps.c
@@ -176,7 +176,6 @@ _dl_important_hwcaps (const char *glibc_hwcaps_prepend,
   size_t cnt = GLRO (dl_platform) != NULL;
   size_t n, m;
   struct r_strlenpair *result;
-  struct r_strlenpair *rp;
   char *cp;
 
   /* glibc-hwcaps subdirectories.  These are exempted from the power
@@ -304,63 +303,48 @@ _dl_important_hwcaps (const char *glibc_hwcaps_prepend,
 	      #3: 0, 3			1001
      This allows the representation of all possible combinations of
      capability names in the string.  First generate the strings.  */
-  result[1].str = result[0].str = cp;
+  struct r_strlenpair *rp = result;
+  n = 1 << (cnt - 1);
+  struct r_strlenpair *rq = rp + n;
 #define add(idx) \
       cp = __mempcpy (__mempcpy (cp, temp[idx].str, temp[idx].len), "/", 1);
-  n = 1 << (cnt - 1);
   do
     {
       n -= 2;
 
+      /* Strings in the first half include the first component. */
+      rp[1].str = rp[0].str = cp;
+
       /* We always add the last string.  */
       add (cnt - 1);
 
+      /* Strings in the second half start after the first component. */
+      rq[1].str = rq[0].str = cp;
+
       /* Add the strings which have the bit set in N.  */
       for (m = cnt - 2; m > 0; --m)
 	if ((n & (1 << m)) != 0)
 	  add (m);
 
+      /* Odd-numbered strings end before before the last component. */
+      rp[1].len = cp - rp[1].str;
+      rq[1].len = cp - rq[1].str;
+
       /* Always add the first string.  */
       add (0);
-    }
-  while (n != 0);
-#undef add
 
-  /* Now we are ready to install the string pointers and length.  */
-  for (n = 0; n < (1UL << cnt); ++n)
-    result[n].len = 0;
-  n = cnt;
-  do
-    {
-      size_t mask = 1 << --n;
+      /* Even-numbered strings include the last component. */
+      rp[0].len = cp - rp[0].str;
+      rq[0].len = cp - rq[0].str;
 
-      rp = result;
-      for (m = 1 << cnt; m > 0; ++rp)
-	if ((--m & mask) != 0)
-	  rp->len += temp[n].len + 1;
+      rp += 2;
+      rq += 2;
     }
   while (n != 0);
+#undef add
 
-  /* The first half of the strings all include the first string.  */
-  n = (1 << cnt) - 2;
-  rp = &result[2];
-  while (n != (1UL << (cnt - 1)))
-    {
-      if ((--n & 1) != 0)
-	rp[0].str = rp[-2].str + rp[-2].len;
-      else
-	rp[0].str = rp[-1].str;
-      ++rp;
-    }
-
-  /* The second half starts right after the first part of the string of
-     the corresponding entry in the first half.  */
-  do
-    {
-      rp[0].str = rp[-(1 << (cnt - 1))].str + temp[cnt - 1].len + 1;
-      ++rp;
-    }
-  while (--n != 0);
+  /* Assert that we got memory allocation right. */
+  assert (cp == (char *) (overall_result + *sz) + total);
 
   /* The maximum string length.  */
   if (result[0].len > hwcaps_counts.maximum_length)
-- 
2.36.0