Clang-tidy fixes

9 files changed, 91 insertions, 116 deletions

diff --git a/lib/libc/stdlib/aligned_alloc.c b/lib/libc/stdlib/aligned_alloc.c
index f8ab24db..be5bab4c 100644
--- a/lib/libc/stdlib/aligned_alloc.c
+++ b/lib/libc/stdlib/aligned_alloc.c
@@ -29,8 +29,7 @@ void *aligned_alloc(size_t alignment, size_t size)
 	}
 
 	uintptr_t raw_addr = (uintptr_t)raw_ptr;
-	uintptr_t aligned_addr = (raw_addr + sizeof(void *) + alignment - 1) &
-				 ~(alignment - 1);
+	uintptr_t aligned_addr = (raw_addr + sizeof(void *) + alignment - 1) & ~(alignment - 1);
 
 	void **orig_ptr_slot = (void **)(aligned_addr - sizeof(void *));
 	*orig_ptr_slot = raw_ptr;
diff --git a/lib/libc/stdlib/bsearch.c b/lib/libc/stdlib/bsearch.c
index b4f83d55..3d2ef896 100644
--- a/lib/libc/stdlib/bsearch.c
+++ b/lib/libc/stdlib/bsearch.c
@@ -67,8 +67,7 @@ is respectively less than, matching, or greater than the array member.
  * have to make lim 3, then halve, obtaining 1, so that we will only
  * look at item 3.
  */
-void *bsearch(const void *key, const void *base0, size_t nmemb, size_t size,
-	      int (*compar)(const void *, const void *))
+void *bsearch(const void *key, const void *base0, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
 {
 	const char *base = (const char *)base0;
 	int lim, cmp;
diff --git a/lib/libc/stdlib/calloc.c b/lib/libc/stdlib/calloc.c
index b472d446..d5762de6 100644
--- a/lib/libc/stdlib/calloc.c
+++ b/lib/libc/stdlib/calloc.c
@@ -1,3 +1,4 @@
+#include "stddef.h"
 #include <errno.h>  // for errno, EINVAL, ENOMEM
 #include <stdlib.h> // for calloc, malloc
 #include <string.h> // for size_t, memset
diff --git a/lib/libc/stdlib/heapsort.c b/lib/libc/stdlib/heapsort.c
index 20922f12..b6b97430 100644
--- a/lib/libc/stdlib/heapsort.c
+++ b/lib/libc/stdlib/heapsort.c
@@ -68,21 +68,19 @@
  * There two cases.  If j == nmemb, select largest of Ki and Kj.  If
  * j < nmemb, select largest of Ki, Kj and Kj+1.
  */
-#define CREATE(initval, nmemb, par_i, child_i, par, child, size, count, tmp)  \
-	{                                                                     \
-		for ((par_i) = initval; ((child_i) = (par_i) * 2) <= (nmemb); \
-		     (par_i) = (child_i)) {                                   \
-			(child) = base + (child_i) * (size);                  \
-			if ((child_i) < (nmemb) &&                            \
-			    compar(child, (child) + (size)) < 0) {            \
-				(child) += (size);                            \
-				++(child_i);                                  \
-			}                                                     \
-			(par) = base + (par_i) * (size);                      \
-			if (compar(child, par) <= 0)                          \
-				break;                                        \
-			SWAP(par, child, count, size, tmp);                   \
-		}                                                             \
+#define CREATE(initval, nmemb, par_i, child_i, par, child, size, count, tmp)                         \
+	{                                                                                            \
+		for ((par_i) = initval; ((child_i) = (par_i) * 2) <= (nmemb); (par_i) = (child_i)) { \
+			(child) = base + (child_i) * (size);                                         \
+			if ((child_i) < (nmemb) && compar(child, (child) + (size)) < 0) {            \
+				(child) += (size);                                                   \
+				++(child_i);                                                         \
+			}                                                                            \
+			(par) = base + (par_i) * (size);                                             \
+			if (compar(child, par) <= 0)                                                 \
+				break;                                                               \
+			SWAP(par, child, count, size, tmp);                                          \
+		}                                                                                    \
 	}
 
 /*
@@ -102,30 +100,28 @@
  *
  * XXX Don't break the #define SELECT line, below.  Reiser cpp gets upset.
  */
-#define SELECT(par_i, child_i, nmemb, par, child, size, k, count, tmp1, tmp2) \
-	{                                                                     \
-		for ((par_i) = 1; ((child_i) = (par_i) * 2) <= (nmemb);       \
-		     (par_i) = (child_i)) {                                   \
-			(child) = base + (child_i) * (size);                  \
-			if ((child_i) < (nmemb) &&                            \
-			    compar(child, (child) + (size)) < 0) {            \
-				(child) += (size);                            \
-				++(child_i);                                  \
-			}                                                     \
-			(par) = base + (par_i) * (size);                      \
-			COPY(par, child, count, size, tmp1, tmp2);            \
-		}                                                             \
-		for (;;) {                                                    \
-			(child_i) = par_i;                                    \
-			(par_i) = (child_i) / 2;                              \
-			(child) = base + (child_i) * (size);                  \
-			(par) = base + (par_i) * (size);                      \
-			if ((child_i) == 1 || compar(k, par) < 0) {           \
-				COPY(child, k, count, size, tmp1, tmp2);      \
-				break;                                        \
-			}                                                     \
-			COPY(child, par, count, size, tmp1, tmp2);            \
-		}                                                             \
+#define SELECT(par_i, child_i, nmemb, par, child, size, k, count, tmp1, tmp2)                  \
+	{                                                                                      \
+		for ((par_i) = 1; ((child_i) = (par_i) * 2) <= (nmemb); (par_i) = (child_i)) { \
+			(child) = base + (child_i) * (size);                                   \
+			if ((child_i) < (nmemb) && compar(child, (child) + (size)) < 0) {      \
+				(child) += (size);                                             \
+				++(child_i);                                                   \
+			}                                                                      \
+			(par) = base + (par_i) * (size);                                       \
+			COPY(par, child, count, size, tmp1, tmp2);                             \
+		}                                                                              \
+		for (;;) {                                                                     \
+			(child_i) = par_i;                                                     \
+			(par_i) = (child_i) / 2;                                               \
+			(child) = base + (child_i) * (size);                                   \
+			(par) = base + (par_i) * (size);                                       \
+			if ((child_i) == 1 || compar(k, par) < 0) {                            \
+				COPY(child, k, count, size, tmp1, tmp2);                       \
+				break;                                                         \
+			}                                                                      \
+			COPY(child, par, count, size, tmp1, tmp2);                             \
+		}                                                                              \
 	}
 
 /*
@@ -135,8 +131,7 @@
  * a data set that will trigger the worst case is nonexistent.  Heapsort's
  * only advantage over quicksort is that it requires little additional memory.
  */
-int heapsort(void *vbase, size_t nmemb, size_t size,
-	     int (*compar)(const void *, const void *))
+int heapsort(void *vbase, size_t nmemb, size_t size, int (*compar)(const void *, const void *))
 {
 	size_t cnt;
 	size_t i;
diff --git a/lib/libc/stdlib/heapsort_r.c b/lib/libc/stdlib/heapsort_r.c
index 05c6e3ae..348d5a07 100644
--- a/lib/libc/stdlib/heapsort_r.c
+++ b/lib/libc/stdlib/heapsort_r.c
@@ -68,21 +68,19 @@
  * There two cases.  If j == nmemb, select largest of Ki and Kj.  If
  * j < nmemb, select largest of Ki, Kj and Kj+1.
  */
-#define CREATE(initval, nmemb, par_i, child_i, par, child, size, count, tmp)  \
-	{                                                                     \
-		for ((par_i) = initval; ((child_i) = (par_i) * 2) <= (nmemb); \
-		     (par_i) = (child_i)) {                                   \
-			(child) = base + (child_i) * (size);                  \
-			if ((child_i) < (nmemb) &&                            \
-			    compar(thunk, child, (child) + (size)) < 0) {     \
-				(child) += (size);                            \
-				++(child_i);                                  \
-			}                                                     \
-			(par) = base + (par_i) * (size);                      \
-			if (compar(thunk, child, par) <= 0)                   \
-				break;                                        \
-			SWAP(par, child, count, size, tmp);                   \
-		}                                                             \
+#define CREATE(initval, nmemb, par_i, child_i, par, child, size, count, tmp)                         \
+	{                                                                                            \
+		for ((par_i) = initval; ((child_i) = (par_i) * 2) <= (nmemb); (par_i) = (child_i)) { \
+			(child) = base + (child_i) * (size);                                         \
+			if ((child_i) < (nmemb) && compar(thunk, child, (child) + (size)) < 0) {     \
+				(child) += (size);                                                   \
+				++(child_i);                                                         \
+			}                                                                            \
+			(par) = base + (par_i) * (size);                                             \
+			if (compar(thunk, child, par) <= 0)                                          \
+				break;                                                               \
+			SWAP(par, child, count, size, tmp);                                          \
+		}                                                                                    \
 	}
 
 /*
@@ -102,30 +100,28 @@
  *
  * XXX Don't break the #define SELECT line, below.  Reiser cpp gets upset.
  */
-#define SELECT(par_i, child_i, nmemb, par, child, size, k, count, tmp1, tmp2) \
-	{                                                                     \
-		for ((par_i) = 1; ((child_i) = (par_i) * 2) <= (nmemb);       \
-		     (par_i) = (child_i)) {                                   \
-			(child) = base + (child_i) * (size);                  \
-			if ((child_i) < (nmemb) &&                            \
-			    compar(thunk, child, (child) + (size)) < 0) {     \
-				(child) += (size);                            \
-				++(child_i);                                  \
-			}                                                     \
-			(par) = base + (par_i) * (size);                      \
-			COPY(par, child, count, size, tmp1, tmp2);            \
-		}                                                             \
-		for (;;) {                                                    \
-			(child_i) = par_i;                                    \
-			(par_i) = (child_i) / 2;                              \
-			(child) = base + (child_i) * (size);                  \
-			(par) = base + (par_i) * (size);                      \
-			if ((child_i) == 1 || compar(thunk, k, par) < 0) {    \
-				COPY(child, k, count, size, tmp1, tmp2);      \
-				break;                                        \
-			}                                                     \
-			COPY(child, par, count, size, tmp1, tmp2);            \
-		}                                                             \
+#define SELECT(par_i, child_i, nmemb, par, child, size, k, count, tmp1, tmp2)                    \
+	{                                                                                        \
+		for ((par_i) = 1; ((child_i) = (par_i) * 2) <= (nmemb); (par_i) = (child_i)) {   \
+			(child) = base + (child_i) * (size);                                     \
+			if ((child_i) < (nmemb) && compar(thunk, child, (child) + (size)) < 0) { \
+				(child) += (size);                                               \
+				++(child_i);                                                     \
+			}                                                                        \
+			(par) = base + (par_i) * (size);                                         \
+			COPY(par, child, count, size, tmp1, tmp2);                               \
+		}                                                                                \
+		for (;;) {                                                                       \
+			(child_i) = par_i;                                                       \
+			(par_i) = (child_i) / 2;                                                 \
+			(child) = base + (child_i) * (size);                                     \
+			(par) = base + (par_i) * (size);                                         \
+			if ((child_i) == 1 || compar(thunk, k, par) < 0) {                       \
+				COPY(child, k, count, size, tmp1, tmp2);                         \
+				break;                                                           \
+			}                                                                        \
+			COPY(child, par, count, size, tmp1, tmp2);                               \
+		}                                                                                \
 	}
 
 /*
@@ -135,8 +131,7 @@
  * a data set that will trigger the worst case is nonexistent.  Heapsort's
  * only advantage over quicksort is that it requires little additional memory.
  */
-int heapsort_r(void *vbase, size_t nmemb, size_t size, void *thunk,
-	       int (*compar)(void *, const void *, const void *))
+int heapsort_r(void *vbase, size_t nmemb, size_t size, void *thunk, int (*compar)(void *, const void *, const void *))
 {
 	size_t cnt;
 	size_t i;
diff --git a/lib/libc/stdlib/malloc.c b/lib/libc/stdlib/malloc.c
index c696e64c..ff89dfa3 100644
--- a/lib/libc/stdlib/malloc.c
+++ b/lib/libc/stdlib/malloc.c
@@ -1,3 +1,4 @@
+#include "stddef.h"
 #include <atomic.h>    // for LIBC_UNLOCK, LIBC_LOCK
 #include <libc.h>      // for libc, libc::(anonymous)
 #include <malloc.h>    // for page, page::(anonymous), class, global_size_c...
diff --git a/lib/libc/stdlib/posix_memalign.c b/lib/libc/stdlib/posix_memalign.c
index f76e63fe..251512a1 100644
--- a/lib/libc/stdlib/posix_memalign.c
+++ b/lib/libc/stdlib/posix_memalign.c
@@ -11,8 +11,7 @@ int posix_memalign(void **memptr, size_t alignment, size_t size)
 
 	*memptr = NULL;
 
-	if (alignment < sizeof(void *) || alignment % sizeof(void *) != 0 ||
-	    (alignment & (alignment - 1)) != 0) {
+	if (alignment < sizeof(void *) || alignment % sizeof(void *) != 0 || (alignment & (alignment - 1)) != 0) {
 		return EINVAL;
 	}
 
diff --git a/lib/libc/stdlib/qsort.c b/lib/libc/stdlib/qsort.c
index ab0256a5..1f78ce9a 100644
--- a/lib/libc/stdlib/qsort.c
+++ b/lib/libc/stdlib/qsort.c
@@ -5,8 +5,7 @@ static int wrapper(const void *a, const void *b, void *compar)
 	return ((int (*)(const void *, const void *))compar)(a, b);
 }
 
-void qsort(void *base, size_t nel, size_t width,
-	   int (*compar)(const void *, const void *))
+void qsort(void *base, size_t nel, size_t width, int (*compar)(const void *, const void *))
 {
 	qsort_r(base, nel, width, wrapper, compar);
 }
diff --git a/lib/libc/stdlib/qsort_r.c b/lib/libc/stdlib/qsort_r.c
index 25a3aa81..54420ebd 100644
--- a/lib/libc/stdlib/qsort_r.c
+++ b/lib/libc/stdlib/qsort_r.c
@@ -38,8 +38,7 @@ typedef int (*cmpfun)(const void *, const void *, void *);
 static inline int pntz(size_t p[2])
 {
 	int r = ntz(p[0] - 1);
-	if (r != 0 ||
-	    (r = 8 * sizeof(size_t) + ntz(p[1])) != 8 * sizeof(size_t)) {
+	if (r != 0 || (r = 8 * sizeof(size_t) + ntz(p[1])) != 8 * sizeof(size_t)) {
 		return r;
 	}
 	return 0;
@@ -98,8 +97,7 @@ static inline void shr(size_t p[2], int n)
 	p[1] >>= n;
 }
 
-static void sift(unsigned char *head, size_t width, cmpfun cmp, void *arg,
-		 int pshift, size_t lp[], int max_lp_index)
+static void sift(unsigned char *head, size_t width, cmpfun cmp, void *arg, int pshift, size_t lp[], int max_lp_index)
 {
 	unsigned char *rt, *lf;
 	unsigned char *ar[14 * sizeof(size_t) + 1];
@@ -129,9 +127,8 @@ static void sift(unsigned char *head, size_t width, cmpfun cmp, void *arg,
 	cycle(width, ar, i);
 }
 
-static void trinkle(unsigned char *head, size_t width, cmpfun cmp, void *arg,
-		    size_t pp[2], int pshift, int trusty, size_t lp[],
-		    int max_lp_index)
+static void trinkle(unsigned char *head, size_t width, cmpfun cmp, void *arg, size_t pp[2], int pshift, int trusty,
+		    size_t lp[], int max_lp_index)
 {
 	unsigned char *stepson, *rt, *lf;
 	size_t p[2];
@@ -151,12 +148,10 @@ static void trinkle(unsigned char *head, size_t width, cmpfun cmp, void *arg,
 		if (cmp(stepson, ar[0], arg) <= 0) {
 			break;
 		}
-		if (!trusty && pshift > 1 && pshift - 2 >= 0 &&
-		    pshift - 2 <= max_lp_index) {
+		if (!trusty && pshift > 1 && pshift - 2 >= 0 && pshift - 2 <= max_lp_index) {
 			rt = head - width;
 			lf = head - width - lp[pshift - 2];
-			if (cmp(rt, stepson, arg) >= 0 ||
-			    cmp(lf, stepson, arg) >= 0) {
+			if (cmp(rt, stepson, arg) >= 0 || cmp(lf, stepson, arg) >= 0) {
 				break;
 			}
 		}
@@ -191,8 +186,7 @@ void qsort_r(void *base, size_t nel, size_t width, cmpfun cmp, void *arg)
 	high = head + size - width;
 
 	/* Precompute Leonardo numbers, scaled by element width */
-	for (lp[0] = lp[1] = width, i = 2;
-	     (lp[i] = lp[i - 2] + lp[i - 1] + width) < size && i < 63; i++)
+	for (lp[0] = lp[1] = width, i = 2; (lp[i] = lp[i - 2] + lp[i - 1] + width) < size && i < 63; i++)
 		;
 	max_lp_index = i - 1;
 
@@ -202,13 +196,10 @@ void qsort_r(void *base, size_t nel, size_t width, cmpfun cmp, void *arg)
 			shr(p, 2);
 			pshift += 2;
 		} else {
-			if (pshift - 1 >= 0 && pshift - 1 <= max_lp_index &&
-			    lp[pshift - 1] >= (size_t)(high - head)) {
-				trinkle(head, width, cmp, arg, p, pshift, 0, lp,
-					max_lp_index);
+			if (pshift - 1 >= 0 && pshift - 1 <= max_lp_index && lp[pshift - 1] >= (size_t)(high - head)) {
+				trinkle(head, width, cmp, arg, p, pshift, 0, lp, max_lp_index);
 			} else {
-				sift(head, width, cmp, arg, pshift, lp,
-				     max_lp_index);
+				sift(head, width, cmp, arg, pshift, lp, max_lp_index);
 			}
 
 			if (pshift == 1) {
@@ -236,16 +227,12 @@ void qsort_r(void *base, size_t nel, size_t width, cmpfun cmp, void *arg)
 			pshift -= 2;
 			p[0] ^= 7;
 			shr(p, 1);
-			if (pshift >= 0 && pshift <= max_lp_index &&
-			    pshift < 64) {
-				trinkle(head - lp[pshift] - width, width, cmp,
-					arg, p, pshift + 1, 1, lp,
-					max_lp_index);
+			if (pshift >= 0 && pshift <= max_lp_index && pshift < 64) {
+				trinkle(head - lp[pshift] - width, width, cmp, arg, p, pshift + 1, 1, lp, max_lp_index);
 			}
 			shl(p, 1);
 			p[0] |= 1;
-			trinkle(head - width, width, cmp, arg, p, pshift, 1, lp,
-				max_lp_index);
+			trinkle(head - width, width, cmp, arg, p, pshift, 1, lp, max_lp_index);
 		}
 		head -= width;
 	}