Make trivial code size enhancements

libc/fmt/fmt.c

@@ -308,7 +308,7 @@ hidden int __fmt(void *fn, void *arg, const char *format, va_list va) {
     /* evaluate specifier */
     qchar = '"';
     log2base = 0;
-    alphabet = "0123456789abcdef";
+    alphabet = "0123456789abcdefpx";
     switch ((d = *format++)) {
       case 'p':
         flags |= FLAGS_HASH;
@@ -316,7 +316,7 @@ hidden int __fmt(void *fn, void *arg, const char *format, va_list va) {
         signbit = 63;
         goto FormatNumber;
       case 'X':
-        alphabet = "0123456789ABCDEF";
+        alphabet = "0123456789ABCDEFPX";
         /* fallthrough */
       case 'x':
         log2base = 4;
@@ -548,8 +548,7 @@ hidden int __fmt(void *fn, void *arg, const char *format, va_list va) {
         } else {
           PUT('+');
         }
-        for (c = 2, k = 10; 10 * k <= decpt; c++, k *= 10) {
+        for (c = 2, k = 10; 10 * k <= decpt; c++) k *= 10;
-        }
         for (;;) {
           i1 = decpt / k;
           PUT(i1 + '0');
@@ -657,7 +656,7 @@ hidden int __fmt(void *fn, void *arg, const char *format, va_list va) {
             i1 /= 10;
           }
         }
-        if ((sgn = pun.u[1] & 0x80000000)) {
+        if (pun.u[1] & 0x80000000) {
           pun.u[1] &= 0x7fffffff;
           if (pun.d || sign) sign = '-';
         }
@@ -686,18 +685,9 @@ hidden int __fmt(void *fn, void *arg, const char *format, va_list va) {
         PUT(alphabet[17]);
         PUT(c);
         if (prec > 0 || alt) PUT('.');
-        if (prec > 0) {
+        while (prec-- > 0) {
-          if ((i1 = prec) > 5) i1 = 5;
+          PUT(alphabet[(pun.q >> 48) & 0xf]);
-          prec -= i1;
+          pun.q <<= 4;
-          do {
-            PUT(alphabet[(pun.u[1] >> 16) & 0xf]);
-            pun.u[1] <<= 4;
-          } while (--i1 > 0);
-          while (prec > 0) {
-            --prec;
-            PUT(alphabet[(pun.u[0] >> 28) & 0xf]);
-            pun.u[0] <<= 4;
-          }
         }
         PUT(alphabet[16]);
         if (bex < 0) {
@@ -706,8 +696,7 @@ hidden int __fmt(void *fn, void *arg, const char *format, va_list va) {
         } else {
           PUT('+');
         }
-        for (c = 1; 10 * c <= bex; c *= 10) {
+        for (c = 1; 10 * c <= bex;) c *= 10;
-        }
         for (;;) {
           i1 = bex / c;
           PUT('0' + i1);
@@ -715,7 +704,7 @@ hidden int __fmt(void *fn, void *arg, const char *format, va_list va) {
           bex -= i1 * c;
           bex *= 10;
         }
-        continue;
+        break;
 
       case '%':
         PUT('%');

net/http/parseurl.c

@@ -24,15 +24,10 @@
 #include "net/http/url.h"
 
 struct UrlParser {
-  unsigned i;
+  char *p, *q;
-  int c;
+  const char *s;
-  const char *data;
+  unsigned c, i, n;
-  size_t size;
+  char isform, islatin1, isopaque;
-  char isform;
-  char islatin1;
-  char isopaque;
-  char *p;
-  char *q;
 };
 
 static void EmitLatin1(char **p, int c) {
@@ -71,9 +66,8 @@ static void EmitVal(struct UrlParser *u, struct UrlParams *h, bool t) {
 
 static void ParseEscape(struct UrlParser *u) {
   int a, b, c = '%';
-  if (u->i + 2 <= u->size &&
+  if (u->i + 2 <= u->n && ((a = kHexToInt[u->s[u->i + 0] & 255]) != -1 &&
-      ((a = kHexToInt[u->data[u->i + 0] & 0xff]) != -1 &&
+                           (b = kHexToInt[u->s[u->i + 1] & 255]) != -1)) {
-       (b = kHexToInt[u->data[u->i + 1] & 0xff]) != -1)) {
     c = a << 4 | b;
     u->i += 2;
   }
@@ -81,10 +75,10 @@ static void ParseEscape(struct UrlParser *u) {
 }
 
 static bool ParseScheme(struct UrlParser *u, struct Url *h) {
-  while (u->i < u->size) {
+  while (u->i < u->n) {
-    u->c = u->data[u->i++] & 0xff;
+    u->c = u->s[u->i++] & 255;
     if (u->c == '/') {
-      if (u->i == 1 && u->i < u->size && u->data[u->i] == '/') {
+      if (u->i == 1 && u->i < u->n && u->s[u->i] == '/') {
         ++u->i;
         return true;
       } else {
@@ -95,8 +89,8 @@ static bool ParseScheme(struct UrlParser *u, struct Url *h) {
       h->scheme.p = u->q;
       h->scheme.n = u->p - u->q;
       u->q = u->p;
-      if (u->i < u->size && u->data[u->i] == '/') {
+      if (u->i < u->n && u->s[u->i] == '/') {
-        if (u->i + 1 < u->size && u->data[u->i + 1] == '/') {
+        if (u->i + 1 < u->n && u->s[u->i + 1] == '/') {
           u->i += 2;
           return true;
         } else {
@@ -138,8 +132,8 @@ static bool ParseScheme(struct UrlParser *u, struct Url *h) {
 static void ParseAuthority(struct UrlParser *u, struct Url *h) {
   unsigned t = 1;
   const char *c = NULL;
-  while (u->i < u->size) {
+  while (u->i < u->n) {
-    u->c = u->data[u->i++] & 0xff;
+    u->c = u->s[u->i++] & 255;
     if (u->c == '/' || u->c == '#' || u->c == '?') {
       break;
     } else if (u->c == '[') {
@@ -188,8 +182,8 @@ static void ParseAuthority(struct UrlParser *u, struct Url *h) {
 }
 
 static void ParsePath(struct UrlParser *u, struct UrlView *h) {
-  while (u->i < u->size) {
+  while (u->i < u->n) {
-    u->c = u->data[u->i++] & 0xff;
+    u->c = u->s[u->i++] & 255;
     if (u->c == '#') {
       break;
     } else if (u->c == '?' && !u->isopaque) {
@@ -209,9 +203,9 @@ static void ParsePath(struct UrlParser *u, struct UrlView *h) {
 
 static void ParseQuery(struct UrlParser *u, struct UrlParams *h) {
   bool t = false;
-  if (!h->p) h->p = xmalloc(0);
+  if (!h->p) h->p = malloc(0);
-  while (u->i < u->size) {
+  while (u->i < u->n) {
-    u->c = u->data[u->i++] & 0xff;
+    u->c = u->s[u->i++] & 255;
     if (u->c == '#') {
       break;
     } else if (u->c == '%') {
@@ -237,8 +231,8 @@ static void ParseQuery(struct UrlParser *u, struct UrlParams *h) {
 }
 
 static void ParseFragment(struct UrlParser *u, struct UrlView *h) {
-  while (u->i < u->size) {
+  while (u->i < u->n) {
-    u->c = u->data[u->i++] & 0xff;
+    u->c = u->s[u->i++] & 255;
     if (u->c == '%') {
       ParseEscape(u);
     } else if (u->c >= 0200 && u->islatin1) {
@@ -252,20 +246,19 @@ static void ParseFragment(struct UrlParser *u, struct UrlView *h) {
   u->q = u->p;
 }
 
-static char *ParseUrlImpl(const char *data, size_t size, struct Url *h,
+static char *ParseUrlImpl(const char *s, size_t n, struct Url *h, bool latin1) {
-                          bool latin1) {
   char *m;
   struct UrlParser u;
-  if (size == -1) size = data ? strlen(data) : 0;
+  if (n == -1) n = s ? strlen(s) : 0;
   u.i = 0;
   u.c = 0;
+  u.s = s;
+  u.n = n;
   u.isform = false;
   u.isopaque = false;
   u.islatin1 = latin1;
-  u.data = data;
-  u.size = size;
   memset(h, 0, sizeof(*h));
-  if ((m = malloc(latin1 ? u.size * 2 : u.size))) {
+  if ((m = malloc(latin1 ? u.n * 2 : u.n))) {
     u.q = u.p = m;
     if (ParseScheme(&u, h)) ParseAuthority(&u, h);
     if (u.c != '#' && u.c != '?') ParsePath(&u, &h->path);
@@ -287,7 +280,7 @@ static char *ParseUrlImpl(const char *data, size_t size, struct Url *h,
  * There's no failure condition for this routine. This is a permissive
  * parser. This doesn't normalize path segments like `.` or `..` so use
  * IsAcceptablePath() to check for those. No restrictions are imposed
- * beyond that which is strictly necessary for parsing. All the data
+ * beyond that which is strictly necessary for parsing. All the s
  * that is provided will be consumed to the one of the fields. Strict
  * conformance is enforced on some fields more than others, like scheme,
  * since it's the most non-deterministically defined field of them all.
@@ -297,18 +290,18 @@ static char *ParseUrlImpl(const char *data, size_t size, struct Url *h,
  * for the things we won't do, like tokenizing path segments into an
  * array and then nesting another array beneath each of those for
  * storing semicolon parameters. So this parser won't make SIP easy.
- * What it can do is parse HTTP URLs and most URIs like data:opaque,
+ * What it can do is parse HTTP URLs and most URIs like s:opaque,
  * better in fact than most things which claim to be URI parsers.
  *
- * @param data is value like `/hi?x=y&z` or `http://a.example/hi#x`
+ * @param s is value like `/hi?x=y&z` or `http://a.example/hi#x`
- * @param size is byte length and -1 implies strlen
+ * @param n is byte length and -1 implies strlen
  * @param h is assumed to be uninitialized
  * @return memory backing UrlView needing free (and h.params.p too)
  * @see URI Generic Syntax RFC3986 RFC2396
  * @see EncodeUrl()
  */
-char *ParseUrl(const char *data, size_t size, struct Url *h) {
+char *ParseUrl(const char *s, size_t n, struct Url *h) {
-  return ParseUrlImpl(data, size, h, false);
+  return ParseUrlImpl(s, n, h, false);
 }
 
 /**
@@ -325,13 +318,13 @@ char *ParseUrl(const char *data, size_t size, struct Url *h) {
  * necessary for parsing. This doesn't normalize path segments like `.`
  * or `..`. Use IsAcceptablePath() to check for those.
  *
- * @param data is value like `/hi?x=y&z` or `http://a.example/hi#x`
+ * @param s is value like `/hi?x=y&z` or `http://a.example/hi#x`
- * @param size is byte length and -1 implies strlen
+ * @param n is byte length and -1 implies strlen
  * @param h is assumed to be uninitialized
  * @return memory backing UrlView needing free (and h.params.p too)
  */
-char *ParseRequestUri(const char *data, size_t size, struct Url *h) {
+char *ParseRequestUri(const char *s, size_t n, struct Url *h) {
-  return ParseUrlImpl(data, size, h, true);
+  return ParseUrlImpl(s, n, h, true);
 }
 
 /**
@@ -349,23 +342,23 @@ char *ParseRequestUri(const char *data, size_t size, struct Url *h) {
  * parser that doesn't impose character restrictions beyond what is
  * necessary for parsing.
  *
- * @param data is value like `foo=bar&x=y&z`
+ * @param s is value like `foo=bar&x=y&z`
- * @param size is byte length and -1 implies strlen
+ * @param n is byte length and -1 implies strlen
  * @param h must be zeroed by caller and this appends if reused
- * @return UrlView memory with same size needing free (h.p needs free too)
+ * @return UrlView memory with same n needing free (h.p needs free too)
  */
-char *ParseParams(const char *data, size_t size, struct UrlParams *h) {
+char *ParseParams(const char *s, size_t n, struct UrlParams *h) {
   char *m;
   struct UrlParser u;
-  if (size == -1) size = data ? strlen(data) : 0;
+  if (n == -1) n = s ? strlen(s) : 0;
   u.i = 0;
+  u.s = s;
+  u.n = n;
   u.c = '?';
   u.isform = true;
   u.islatin1 = false;
   u.isopaque = false;
-  u.data = data;
+  if ((m = malloc(u.n))) {
-  u.size = size;
-  if ((m = malloc(u.size))) {
     u.q = u.p = m;
     ParseQuery(&u, h);
   }
@@ -391,23 +384,23 @@ char *ParseParams(const char *data, size_t size, struct UrlParams *h) {
  * called conditionally after ParseRequestUri() if the host is absent.
  * Fields unrelated to authority won't be impacted by this function.
  *
- * @param data is value like `127.0.0.1` or `foo.example:80`
+ * @param s is value like `127.0.0.1` or `foo.example:80`
- * @param size is byte length and -1 implies strlen
+ * @param n is byte length and -1 implies strlen
  * @param h is needs to be initialized by caller
  * @return memory backing UrlView needing free
  */
-char *ParseHost(const char *data, size_t size, struct Url *h) {
+char *ParseHost(const char *s, size_t n, struct Url *h) {
   char *m;
   struct UrlParser u;
-  if (size == -1) size = data ? strlen(data) : 0;
+  if (n == -1) n = s ? strlen(s) : 0;
   u.i = 0;
   u.c = 0;
+  u.s = s;
+  u.n = n;
   u.isform = false;
   u.islatin1 = true;
   u.isopaque = false;
-  u.data = data;
+  if ((m = malloc(u.n * 2))) {
-  u.size = size;
-  if ((m = malloc(u.size * 2))) {
     u.q = u.p = m;
     ParseAuthority(&u, h);
   }

test/libc/str/strlen_test.c

@@ -159,25 +159,47 @@ BENCH(strlen, bench) {
   extern size_t strlen_(const char *) asm("strlen");
   extern size_t strlen_pure_(const char *) asm("strlen_pure");
   static char b[2048];
+  static char c[512];
+  static char d[256];
   memset(b, -1, sizeof(b) - 1);
-  EZBENCH2("strlen 1", donothing, strlen_(""));
+  memset(c, -1, sizeof(c) - 1);
-  EZBENCH2("strlen_pure 1", donothing, strlen_pure_(""));
+  memset(d, -1, sizeof(d) - 1);
-  EZBENCH2("strlen 2", donothing, strlen_("1"));
+  EZBENCH2("strlen_sse  1", donothing, strlen_(""));
-  EZBENCH2("strlen_pure 2", donothing, strlen_pure_("1"));
+  EZBENCH2("strlen_swar 1", donothing, strlen_pure_(""));
-  EZBENCH2("strlen 7", donothing, strlen_("123456"));
+  EZBENCH2("strlen_sse  2", donothing, strlen_("1"));
-  EZBENCH2("strlen_pure 7", donothing, strlen_pure_("123456"));
+  EZBENCH2("strlen_swar 2", donothing, strlen_pure_("1"));
-  EZBENCH2("strlen 8", donothing, strlen_("1234567"));
+  EZBENCH2("strlen_sse  3", donothing, strlen_("11"));
-  EZBENCH2("strlen_pure 8", donothing, strlen_pure_("1234567"));
+  EZBENCH2("strlen_swar 3", donothing, strlen_pure_("11"));
-  EZBENCH2("strlen 9", donothing, strlen_("12345678"));
+  EZBENCH2("strlen_sse  4", donothing, strlen_("113"));
-  EZBENCH2("strlen_pure 9", donothing, strlen_pure_("12345678"));
+  EZBENCH2("strlen_swar 4", donothing, strlen_pure_("113"));
-  EZBENCH2("strlen 11", donothing, strlen_("12345678aa"));
+  EZBENCH2("strlen_sse  7", donothing, strlen_("123456"));
-  EZBENCH2("strlen_pure 11", donothing, strlen_pure_("12345678aa"));
+  EZBENCH2("strlen_swar 7", donothing, strlen_pure_("123456"));
-  EZBENCH2("strlen 13", donothing, strlen_("12345678aabb"));
+  EZBENCH2("strlen_sse  8", donothing, strlen_("1234567"));
-  EZBENCH2("strlen_pure 13", donothing, strlen_pure_("12345678aabb"));
+  EZBENCH2("strlen_swar 8", donothing, strlen_pure_("1234567"));
-  EZBENCH2("strlen 16", donothing, strlen_("123456781234567"));
+  EZBENCH2("strlen_sse  9", donothing, strlen_("12345678"));
-  EZBENCH2("strlen_pure 16", donothing, strlen_pure_("123456781234567"));
+  EZBENCH2("strlen_swar 9", donothing, strlen_pure_("12345678"));
-  EZBENCH2("strlen 17", donothing, strlen_("123456781234567e"));
+  EZBENCH2("strlen_sse  11", donothing, strlen_("12345678aa"));
-  EZBENCH2("strlen_pure 17", donothing, strlen_pure_("123456781234567e"));
+  EZBENCH2("strlen_swar 11", donothing, strlen_pure_("12345678aa"));
-  EZBENCH2("strlen 1023", donothing, strlen_(b));
+  EZBENCH2("strlen_sse  13", donothing, strlen_("12345678aabb"));
-  EZBENCH2("strlen_pure 1023", donothing, strlen_pure_(b));
+  EZBENCH2("strlen_swar 13", donothing, strlen_pure_("12345678aabb"));
+  EZBENCH2("strlen_sse  16", donothing, strlen_("123456781234567"));
+  EZBENCH2("strlen_swar 16", donothing, strlen_pure_("123456781234567"));
+  EZBENCH2("strlen_sse  17", donothing, strlen_("123456781234567e"));
+  EZBENCH2("strlen_swar 17", donothing, strlen_pure_("123456781234567e"));
+  EZBENCH2("strlen_sse  34", donothing,
+           strlen_("123456781234567e123456781234567ee"));
+  EZBENCH2("strlen_swar 34", donothing,
+           strlen_pure_("123456781234567e123456781234567ee"));
+  EZBENCH2("strlen_sse  68", donothing,
+           strlen_("123456781234567e123456781234567ee123456781234567e1234567812"
+                   "34567eee"));
+  EZBENCH2("strlen_swar 68", donothing,
+           strlen_pure_("123456781234567e123456781234567ee123456781234567e12345"
+                        "6781234567eee"));
+  EZBENCH2("strlen_sse  256", donothing, strlen_(d));
+  EZBENCH2("strlen_swar 256", donothing, strlen_pure_(d));
+  EZBENCH2("strlen_sse  512", donothing, strlen_(c));
+  EZBENCH2("strlen_swar 512", donothing, strlen_pure_(c));
+  EZBENCH2("strlen_sse  2048", donothing, strlen_(b));
+  EZBENCH2("strlen_swar 2048", donothing, strlen_pure_(b));
 }

tool/net/redbean.c

@@ -2024,8 +2024,7 @@ static char *RedirectSlash(void) {
 static char *ServeIndex(const char *path, size_t pathlen) {
   size_t i, n;
   char *p, *q;
-  p = NULL;
+  for (p = 0, i = 0; !p && i < ARRAYLEN(kIndexPaths); ++i) {
-  for (i = 0; !p && i < ARRAYLEN(kIndexPaths); ++i) {
     q = MergePaths(path, pathlen, kIndexPaths[i], strlen(kIndexPaths[i]), &n);
     p = RoutePath(q, n);
     free(q);
@@ -4093,7 +4092,7 @@ static char *HandleRequest(void) {
       !IsAcceptableHost(url.host.p, url.host.n) ||
       !IsAcceptablePort(url.port.p, url.port.n)) {
     LockInc(&shared->c.urisrefused);
-    return ServeFailure(400, "Bad Request");
+    return ServeFailure(400, "Bad URI");
   }
   LOGF("RECEIVED %s HTTP%02d %.*s %s %`'.*s %`'.*s", DescribeClient(),
        msg.version, msg.xmethod.b - msg.xmethod.a, inbuf.p + msg.xmethod.a,