Optimize __str_base10() using bitwise operations

Replace the loop-based method for converting integers to base-10 with a
more efficient approach using bitwise operations. The new method
simulates division and modulus operations by 10 without using
multiplication, division, or modulus instructions, leading to improved
performance.

This optimization reduces the number of branches compared to the
original loop-based approach, resulting in fewer conditional checks and
a more streamlined execution path.

Experimental results demonstrate significant performance improvements
with the new method. For each test range, values within the range were
used as inputs, and __str_base10() was called 10,000,000 times with
these inputs distributed uniformly. Execution time was measured using
the time command. The results show the following reductions in
execution time:

| Range           | Old    | New    |
|-----------------|--------|--------|
| [0, 10)         | 0.473s | 0.293s |
| [0, 100)        | 0.619s | 0.434s |
| [0, 1000)       | 0.818s | 0.646s |
| [0, 10000)      | 1.715s | 0.902s |
| [0, 100000)     | 2.166s | 1.169s |
| [0, 1000000)    | 2.239s | 1.453s |
| [0, 10000000)   | 2.359s | 1.773s |
| [0, 100000000)  | 2.463s | 2.122s |

Link: http://web.archive.org/web/20180517023231/http://www.hackersdelight.org/divcMore.pdf

Author: visitorckw

lib/c.c

@@ -113,10 +113,25 @@ char *memcpy(char *dest, char *src, int count)
     return dest;
 }
 
-/* set 10 digits (32bit) without div */
+/*
+ * set 10 digits (32bit) without div
+ *
+ * This function converts a given integer value to its string representation
+ * in base-10 without using division operations. The method involves calculating
+ * the approximate quotient and remainder using bitwise operations, which are
+ * then used to derive each digit of the result.
+ *
+ * The logic is based on an efficient method of dividing by constants, as
+ * detailed in the reference link:
+ * http://web.archive.org/web/20180517023231/http://www.hackersdelight.org/divcMore.pdf.
+ * This approach avoids expensive division instructions by using a series of
+ * bitwise shifts and additions to calculate the quotient and remainder.
+ */
 void __str_base10(char *pb, int val)
 {
     int neg = 0;
+    int q, r, t;
+    int i = INT_BUF_LEN - 1;
 
     if (val == -2147483648) {
         strncpy(pb + INT_BUF_LEN - 11, "-2147483648", 11);
@@ -127,45 +142,20 @@ void __str_base10(char *pb, int val)
         val = -val;
     }
 
-    while (val >= 1000000000) {
-        val -= 1000000000;
-        pb[INT_BUF_LEN - 10]++;
-    }
-    while (val >= 100000000) {
-        val -= 100000000;
-        pb[INT_BUF_LEN - 9]++;
-    }
-    while (val >= 10000000) {
-        val -= 10000000;
-        pb[INT_BUF_LEN - 8]++;
-    }
-    while (val >= 1000000) {
-        val -= 1000000;
-        pb[INT_BUF_LEN - 7]++;
-    }
-    while (val >= 100000) {
-        val -= 100000;
-        pb[INT_BUF_LEN - 6]++;
-    }
-    while (val >= 10000) {
-        val -= 10000;
-        pb[INT_BUF_LEN - 5]++;
-    }
-    while (val >= 1000) {
-        val -= 1000;
-        pb[INT_BUF_LEN - 4]++;
-    }
-    while (val >= 100) {
-        val -= 100;
-        pb[INT_BUF_LEN - 3]++;
-    }
-    while (val >= 10) {
-        val -= 10;
-        pb[INT_BUF_LEN - 2]++;
-    }
-    while (val >= 1) {
-        val -= 1;
-        pb[INT_BUF_LEN - 1]++;
+    while (val) {
+        q = (val >> 1) + (val >> 2);
+        q += (q >> 4);
+        q += (q >> 8);
+        q += (q >> 16);
+        q = q >> 3;
+        r = val - (((q << 2) + q) << 1);
+        t = ((r + 6) >> 4);
+        q += t;
+        r = r - (((t << 2) + t) << 1);
+
+        pb[i] += r;
+        val = q;
+        i--;
     }
 
     if (neg == 1) {