9 files changed, 293 insertions, 131 deletions

diff --git a/libbb/c_escape.c b/libbb/c_escape.c
new file mode 100644
index 000000000..6c109f2e0
--- /dev/null
+++ b/libbb/c_escape.c
@@ -0,0 +1,20 @@
+/* vi: set sw=4 ts=4: */
+/*
+ * Copyright (C) 2025 by Denys Vlasenko <vda.linux@googlemail.com>
+ *
+ * Licensed under GPLv2, see file LICENSE in this source tree.
+ */
+//kbuild:lib-y += c_escape.o
+
+#include "libbb.h"
+
+const char c_escape_conv_str00[] ALIGN1 =
+        "\\""0""\0" // [0]:00
+        "\\""a""\0" // [1]:07
+        "\\""b""\0" // [2]:08
+        "\\""t""\0" // [3]:09
+        "\\""n""\0" // [4]:0a
+        "\\""v""\0" // [5]:0b
+        "\\""f""\0" // [6]:0c
+        "\\""r"     // [7]:0d
+        ;
diff --git a/libbb/concat_path_file.c b/libbb/concat_path_file.c
index 5b4b7f113..aefb84f45 100644
--- a/libbb/concat_path_file.c
+++ b/libbb/concat_path_file.c
@@ -17,6 +17,7 @@
 
 char* FAST_FUNC concat_path_file(const char *path, const char *filename)
 {
+#if 0
         char *lc;
 
         if (!path)
@@ -25,4 +26,78 @@ char* FAST_FUNC concat_path_file(const char *path, const char *filename)
         while (*filename == '/')
                 filename++;
         return xasprintf("%s%s%s", path, (lc==NULL ? "/" : ""), filename);
+#else
+/* ^^^^^^^^^^^ timing of xasprintf-based code above:
+ * real 7.074s
+ * user 0.156s <<<
+ * sys  6.394s
+ *      "rm -rf" of a Linux kernel tree from tmpfs (run time still dominated by in-kernel work, though)
+ * real 6.989s
+ * user 0.055s <<< 3 times less CPU used
+ * sys  6.450s
+ * vvvvvvvvvvv timing of open-coded malloc+memcpy code below (+59 bytes):
+ */
+        char *buf, *p;
+        size_t n1, n2, n3;
+
+        while (*filename == '/')
+                filename++;
+
+        if (!path || !path[0])
+                return xstrdup(filename);
+
+        n1 = strlen(path);
+        n2 = (path[n1 - 1] != '/'); /* 1: "path has no trailing slash" */
+        n3 = strlen(filename) + 1;
+
+        buf = xmalloc(n1 + n2 + n3);
+        p = mempcpy(buf, path, n1);
+        if (n2)
+                *p++ = '/';
+        memcpy(p, filename, n3);
+        return buf;
+#endif
+}
+
+/* If second component comes from struct dirent,
+ * it's possible to eliminate one strlen() by using name length
+ * provided by kernel in struct dirent. See below.
+ * However, the win seems to be insignificant.
+ */
+
+#if 0
+
+/* Extract d_namlen from struct dirent */
+static size_t get_d_namlen(const struct dirent *de)
+{
+#if defined(_DIRENT_HAVE_D_NAMLEN)
+        return de->d_namlen;
+#elif defined(_DIRENT_HAVE_D_RECLEN)
+        const size_t prefix_sz = offsetof(struct dirent, d_name);
+        return de->d_reclen - prefix_sz;
+#else
+        return strlen(de->d_name);
+#endif
+}
+
+char* FAST_FUNC concat_path_dirent(const char *path, const struct dirent *de)
+{
+        char *buf, *p;
+        size_t n1, n2, n3;
+
+        if (!path || !path[0])
+                return xstrdup(de->d_name);
+
+        n1 = strlen(path);
+        n2 = (path[n1 - 1] != '/');
+        n3 = get_d_namlen(de) + 1;
+
+        buf = xmalloc(n1 + n2 + n3);
+        p = mempcpy(buf, path, n1);
+        if (n2)
+                *p++ = '/';
+        memcpy(p, de->d_name, n3);
+        return buf;
 }
+
+#endif
diff --git a/libbb/dump.c b/libbb/dump.c
index ac5d47d9e..d34094576 100644
--- a/libbb/dump.c
+++ b/libbb/dump.c
@@ -478,37 +478,52 @@ static void bpad(PR *pr)
                 continue;
 }
 
-static const char conv_str[] ALIGN1 =
-        "\0"  "\\""0""\0"
-        "\007""\\""a""\0"
-        "\b"  "\\""b""\0"
-        "\f"  "\\""f""\0"
-        "\n"  "\\""n""\0"
-        "\r"  "\\""r""\0"
-        "\t"  "\\""t""\0"
-        "\v"  "\\""v""\0"
-        ;
-
 static void conv_c(PR *pr, unsigned char *p)
 {
-        const char *str = conv_str;
-
-        do {
-                if (*p == *str) {
-                        ++str;
-                        goto strpr; /* map e.g. '\n' to "\\n" */
-                }
-                str += 4;
-        } while (*str);
+        const char *str;
+        unsigned char ch;
+
+        ch = *p;
+        if (ch == 0 || (ch -= 6, (signed char)ch > 0 && ch <= 7)) {
+                /* map chars 0,7..13 to "\0","\{a,b,t,n,v,f,r}" */
+                str = c_escape_conv_str00 + 3 * ch;
+                goto strpr;
+        }
 
         if (isprint_asciionly(*p)) {
                 *pr->cchar = 'c';
                 printf(pr->fmt, *p);
         } else {
+#if defined(__i386__) || defined(__x86_64__)
+                /* Abuse partial register operations */
+                uint32_t buf;
+                unsigned n = *p;
+                asm (           //00000000 00000000 00000000 aabbbccc
+"\n             shll $10,%%eax" //00000000 000000aa bbbccc00 00000000
+"\n             shrw $5,%%ax"   //00000000 000000aa 00000bbb ccc00000
+"\n             shrb $5,%%al"   //00000000 000000aa 00000bbb 00000ccc
+"\n             shll $8,%%eax"  //000000aa 00000bbb 00000ccc 00000000
+"\n             bswapl %%eax"   //00000000 00000ccc 00000bbb 000000aa
+"\n             addl $0x303030,%%eax"
+"\n"            : "=a" (n)
+                : "0" (n)
+                );
+                buf = n;
+                str = (void*)&buf;
+#elif 1
                 char buf[4];
                 /* gcc-8.0.1 needs lots of casts to shut up */
                 sprintf(buf, "%03o", (unsigned)(uint8_t)*p);
                 str = buf;
+#else // use faster version? +20 bytes of code relative to sprintf() method
+                char buf[4];
+                buf[3] = '\0';
+                ch = *p;
+                buf[2] = '0' + (ch & 7); ch >>= 3;
+                buf[1] = '0' + (ch & 7); ch >>= 3;
+                buf[0] = '0' + ch;
+                str = buf;
+#endif
  strpr:
                 *pr->cchar = 's';
                 printf(pr->fmt, str);
diff --git a/libbb/getopt32.c b/libbb/getopt32.c
index b5efa19ac..4c05dcb97 100644
--- a/libbb/getopt32.c
+++ b/libbb/getopt32.c
@@ -530,6 +530,7 @@ vgetopt32(char **argv, const char *applet_opts, const char *applet_long_options,
          * "fake" short options, like this one:
          * wget $'-\203' "Test: test" http://kernel.org/
          * (supposed to act as --header, but doesn't) */
+ next_opt:
 #if ENABLE_LONG_OPTS
         while ((c = getopt_long(argc, argv, applet_opts,
                         long_options, NULL)) != -1) {
@@ -544,8 +545,16 @@ vgetopt32(char **argv, const char *applet_opts, const char *applet_long_options,
                          * but we construct long opts so that flag
                          * is always NULL (see above) */
                         if (on_off->opt_char == '\0' /* && c != '\0' */) {
-                                /* c is probably '?' - "bad option" */
-                                goto error;
+                                /* We reached the end of complementary[] and did not find -c */
+                                if (c == '?') /* getopt says: "bad option, or option has no required argument" */
+                                        goto error;
+                                /* if there were options beyond 32 bits (example: ls),
+                                 * they got no complementary[] slot, and no result bit.
+                                 * IOW: they must be "accept but ignore" options.
+                                 * For them, we end up here.
+                                 */
+                                //bb_error_msg("ignored option '%c', skipping", c);
+                                goto next_opt;
                         }
                 }
                 if (flags & on_off->incongruously)
diff --git a/libbb/hash_md5_sha.c b/libbb/hash_md5_sha.c
index 75a61c32c..9ebda232a 100644
--- a/libbb/hash_md5_sha.c
+++ b/libbb/hash_md5_sha.c
@@ -11,7 +11,7 @@
 #define STR1(s) #s
 #define STR(s) STR1(s)
 
-#define NEED_SHA512 (ENABLE_SHA512SUM || ENABLE_USE_BB_CRYPT_SHA)
+#define NEED_SHA512 (ENABLE_SHA512SUM || ENABLE_SHA384SUM || ENABLE_USE_BB_CRYPT_SHA)
 
 #if ENABLE_SHA1_HWACCEL || ENABLE_SHA256_HWACCEL
 # if defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__))
@@ -1032,7 +1032,7 @@ static const sha_K_int sha_K[] ALIGN8 = {
         K(0x84c87814a1f0ab72ULL), K(0x8cc702081a6439ecULL),
         K(0x90befffa23631e28ULL), K(0xa4506cebde82bde9ULL),
         K(0xbef9a3f7b2c67915ULL), K(0xc67178f2e372532bULL),
-#if NEED_SHA512  /* [64]+ are used for sha512 only */
+#if NEED_SHA512  /* [64]+ are used for sha384 and sha512 only */
         K(0xca273eceea26619cULL), K(0xd186b8c721c0c207ULL),
         K(0xeada7dd6cde0eb1eULL), K(0xf57d4f7fee6ed178ULL),
         K(0x06f067aa72176fbaULL), K(0x0a637dc5a2c898a6ULL),
@@ -1229,11 +1229,20 @@ static const uint32_t init512_lo[] ALIGN4 = {
         0x137e2179,
 };
 #endif /* NEED_SHA512 */
-
-// Note: SHA-384 is identical to SHA-512, except that initial hash values are
-// 0xcbbb9d5dc1059ed8, 0x629a292a367cd507, 0x9159015a3070dd17, 0x152fecd8f70e5939,
-// 0x67332667ffc00b31, 0x8eb44a8768581511, 0xdb0c2e0d64f98fa7, 0x47b5481dbefa4fa4,
-// and the output is constructed by omitting last two 64-bit words of it.
+#if ENABLE_SHA384SUM
+static const uint64_t init384[] ALIGN8 = {
+        0,
+        0,
+        0xcbbb9d5dc1059ed8,
+        0x629a292a367cd507,
+        0x9159015a3070dd17,
+        0x152fecd8f70e5939,
+        0x67332667ffc00b31,
+        0x8eb44a8768581511,
+        0xdb0c2e0d64f98fa7,
+        0x47b5481dbefa4fa4,
+};
+#endif
 
 /* Initialize structure containing state of computation.
    (FIPS 180-2:5.3.2)  */
@@ -1255,9 +1264,19 @@ void FAST_FUNC sha256_begin(sha256_ctx_t *ctx)
 #endif
 }
 
-#if NEED_SHA512
+#if ENABLE_SHA384SUM
 /* Initialize structure containing state of computation.
    (FIPS 180-2:5.3.3)  */
+void FAST_FUNC sha384_begin(sha512_ctx_t *ctx)
+{
+        memcpy(&ctx->total64, init384, sizeof(init384));
+        /*ctx->total64[0] = ctx->total64[1] = 0; - already done */
+}
+#endif
+
+#if NEED_SHA512
+/* Initialize structure containing state of computation.
+   (FIPS 180-2:5.3.4)  */
 void FAST_FUNC sha512_begin(sha512_ctx_t *ctx)
 {
         int i;
@@ -1332,7 +1351,7 @@ unsigned FAST_FUNC sha1_end(sha1_ctx_t *ctx, void *resbuf)
 }
 
 #if NEED_SHA512
-unsigned FAST_FUNC sha512_end(sha512_ctx_t *ctx, void *resbuf)
+static unsigned FAST_FUNC sha512384_end(sha512_ctx_t *ctx, void *resbuf, unsigned outsize)
 {
         unsigned bufpos = ctx->total64[0] & 127;
 
@@ -1363,11 +1382,21 @@ unsigned FAST_FUNC sha512_end(sha512_ctx_t *ctx, void *resbuf)
                 for (i = 0; i < ARRAY_SIZE(ctx->hash); ++i)
                         ctx->hash[i] = SWAP_BE64(ctx->hash[i]);
         }
-        memcpy(resbuf, ctx->hash, sizeof(ctx->hash));
-        return sizeof(ctx->hash);
+        memcpy(resbuf, ctx->hash, outsize);
+        return outsize;
+}
+unsigned FAST_FUNC sha512_end(sha384_ctx_t *ctx, void *resbuf)
+{
+        return sha512384_end(ctx, resbuf, SHA512_OUTSIZE);
 }
 #endif /* NEED_SHA512 */
 
+#if ENABLE_SHA384SUM
+unsigned FAST_FUNC sha384_end(sha384_ctx_t *ctx, void *resbuf)
+{
+        return sha512384_end(ctx, resbuf, SHA384_OUTSIZE);
+}
+#endif
 
 /*
  * The Keccak sponge function, designed by Guido Bertoni, Joan Daemen,
@@ -1904,6 +1933,8 @@ void FAST_FUNC sha3_hash(sha3_ctx_t *ctx, const void *buffer, size_t len)
 
 unsigned FAST_FUNC sha3_end(sha3_ctx_t *ctx, void *resbuf)
 {
+        unsigned hash_len;
+
         /* Padding */
         uint8_t *buf = (uint8_t*)ctx->state;
         /*
@@ -1926,6 +1957,7 @@ unsigned FAST_FUNC sha3_end(sha3_ctx_t *ctx, void *resbuf)
         sha3_process_block72(ctx->state);
 
         /* Output */
-        memcpy(resbuf, ctx->state, 64);
-        return 64;
+        hash_len = (1600/8 - ctx->input_block_bytes) / 2;
+        memcpy(resbuf, ctx->state, hash_len);
+        return hash_len;
 }
diff --git a/libbb/lineedit.c b/libbb/lineedit.c
index 43d1da35c..10cc0433b 100644
--- a/libbb/lineedit.c
+++ b/libbb/lineedit.c
@@ -1564,7 +1564,7 @@ void FAST_FUNC save_history(line_input_t *st)
         FILE *fp;
 
         /* bash compat: HISTFILE="" disables history saving */
-        if (!st || !st->hist_file || !state->hist_file[0])
+        if (!st || !st->hist_file || !st->hist_file[0])
                 return;
         if (st->cnt_history <= st->cnt_history_in_file)
                 return; /* no new entries were added */
diff --git a/libbb/procps.c b/libbb/procps.c
index f56b71b21..fc31c075d 100644
--- a/libbb/procps.c
+++ b/libbb/procps.c
@@ -109,7 +109,7 @@ void FAST_FUNC free_procps_scan(procps_status_t* sp)
 }
 
 #if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
-static unsigned long long fast_strtoull_16(char **endptr)
+unsigned long long FAST_FUNC fast_strtoull_16(char **endptr)
 {
         unsigned char c;
         char *str = *endptr;
@@ -130,7 +130,7 @@ static unsigned long long fast_strtoull_16(char **endptr)
 
 #if ENABLE_FEATURE_FAST_TOP || ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
 /* We cut a lot of corners here for speed */
-static unsigned long fast_strtoul_10(char **endptr)
+unsigned long FAST_FUNC fast_strtoul_10(char **endptr)
 {
         unsigned char c;
         char *str = *endptr;
@@ -143,6 +143,24 @@ static unsigned long fast_strtoul_10(char **endptr)
         *endptr = str + 1; /* We skip trailing space! */
         return n;
 }
+# if LONG_MAX < LLONG_MAX
+/* For VSZ, which can be very large */
+static unsigned long long fast_strtoull_10(char **endptr)
+{
+        unsigned char c;
+        char *str = *endptr;
+        unsigned long long n = *str - '0';
+
+        /* Need to stop on both ' ' and '\n' */
+        while ((c = *++str) > ' ')
+                n = n*10 + (c - '0');
+
+        *endptr = str + 1; /* We skip trailing space! */
+        return n;
+}
+# else
+#  define fast_strtoull_10(endptr) fast_strtoul_10(endptr)
+# endif
 
 # if ENABLE_FEATURE_FAST_TOP
 static long fast_strtol_10(char **endptr)
@@ -155,7 +173,7 @@ static long fast_strtol_10(char **endptr)
 }
 # endif
 
-static char *skip_fields(char *str, int count)
+char* FAST_FUNC skip_fields(char *str, int count)
 {
         do {
                 while (*str++ != ' ')
@@ -166,35 +184,25 @@ static char *skip_fields(char *str, int count)
 }
 #endif
 
-#if ENABLE_FEATURE_TOPMEM || ENABLE_PMAP
-static char* skip_whitespace_if_prefixed_with(char *buf, const char *prefix)
+#if ENABLE_FEATURE_TOPMEM
+static NOINLINE void procps_read_smaps(pid_t pid, procps_status_t *sp)
 {
-        char *tp = is_prefixed_with(buf, prefix);
-        if (tp) {
-                tp = skip_whitespace(tp);
-        }
-        return tp;
-}
+        // There is A LOT of /proc/PID/smaps data on a big system.
+        // Optimize this for speed, makes "top -m" faster.
+//TODO large speedup:
+//read /proc/PID/smaps_rollup (cumulative stats of all mappings, much faster)
+//and  /proc/PID/maps         to get mapped_ro and mapped_rw (IOW: VSZ,VSZRW)
 
-int FAST_FUNC procps_read_smaps(pid_t pid, struct smaprec *total,
-                void (*cb)(struct smaprec *, void *), void *data)
-{
         FILE *file;
-        struct smaprec currec;
         char filename[sizeof("/proc/%u/smaps") + sizeof(int)*3];
         char buf[PROCPS_BUFSIZE];
-#if !ENABLE_PMAP
-        void (*cb)(struct smaprec *, void *) = NULL;
-        void *data = NULL;
-#endif
 
         sprintf(filename, "/proc/%u/smaps", (int)pid);
 
         file = fopen_for_read(filename);
         if (!file)
-                return 1;
+                return;
 
-        memset(&currec, 0, sizeof(currec));
         while (fgets(buf, PROCPS_BUFSIZE, file)) {
                 // Each mapping datum has this form:
                 // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
@@ -202,80 +210,53 @@ int FAST_FUNC procps_read_smaps(pid_t pid, struct smaprec *total,
                 // Rss:                 nnn kB
                 // .....
 
-                char *tp, *p;
+                char *tp;
 
+                if (buf[0] == 'S' || buf[0] == 'P') {
 #define SCAN(S, X) \
-                if ((tp = skip_whitespace_if_prefixed_with(buf, S)) != NULL) { \
-                        total->X += currec.X = fast_strtoul_10(&tp); \
-                        continue;                                    \
-                }
-                if (cb) {
-                        SCAN("Pss:"  , smap_pss     );
-                        SCAN("Swap:" , smap_swap    );
-                }
-                SCAN("Private_Dirty:", private_dirty);
-                SCAN("Private_Clean:", private_clean);
-                SCAN("Shared_Dirty:" , shared_dirty );
-                SCAN("Shared_Clean:" , shared_clean );
+                        if (memcmp(buf, S, sizeof(S)-1) == 0) { \
+                                tp = skip_whitespace(buf + sizeof(S)-1); \
+                                sp->X += fast_strtoul_10(&tp); \
+                                continue; \
+                        }
+                        SCAN("Private_Dirty:", private_dirty)
+                        SCAN("Private_Clean:", private_clean)
+                        SCAN("Shared_Dirty:" , shared_dirty )
+                        SCAN("Shared_Clean:" , shared_clean )
 #undef SCAN
+                }
                 tp = strchr(buf, '-');
                 if (tp) {
                         // We reached next mapping - the line of this form:
                         // f7d29000-f7d39000 rw-s FILEOFS M:m INODE FILENAME
 
-                        if (cb) {
-                                /* If we have a previous record, there's nothing more
-                                 * for it, call the callback and clear currec
-                                 */
-                                if (currec.smap_size)
-                                        cb(&currec, data);
-                                free(currec.smap_name);
-                        }
-                        memset(&currec, 0, sizeof(currec));
+                        char *rwx;
+                        unsigned long sz;
 
                         *tp = ' ';
                         tp = buf;
-                        currec.smap_start = fast_strtoull_16(&tp);
-                        currec.smap_size = (fast_strtoull_16(&tp) - currec.smap_start) >> 10;
-
-                        strncpy(currec.smap_mode, tp, sizeof(currec.smap_mode)-1);
-
+                        sz = fast_strtoull_16(&tp); // start
+                        sz = (fast_strtoull_16(&tp) - sz) >> 10; // end - start
+                        // tp -> "rw-s" string
+                        rwx = tp;
                         // skipping "rw-s FILEOFS M:m INODE "
                         tp = skip_whitespace(skip_fields(tp, 4));
-                        // filter out /dev/something (something != zero)
-                        if (!is_prefixed_with(tp, "/dev/") || strcmp(tp, "/dev/zero\n") == 0) {
-                                if (currec.smap_mode[1] == 'w') {
-                                        currec.mapped_rw = currec.smap_size;
-                                        total->mapped_rw += currec.smap_size;
-                                } else if (currec.smap_mode[1] == '-') {
-                                        currec.mapped_ro = currec.smap_size;
-                                        total->mapped_ro += currec.smap_size;
-                                }
+                        // if not a device memory mapped...
+                        if (memcmp(tp, "/dev/", 5) != 0    // not "/dev/something"
+                         || strcmp(tp + 5, "zero\n") == 0  // or is "/dev/zero" (which isn't a device)
+                        ) {
+                                if (rwx[1] == 'w')
+                                        sp->mapped_rw += sz;
+                                else if (rwx[0] == 'r' || rwx[2] == 'x')
+                                        sp->mapped_ro += sz;
+                                // else: seen "---p" mappings (mmap guard gaps?),
+                                // do NOT account these as VSZ, they aren't really
                         }
-
                         if (strcmp(tp, "[stack]\n") == 0)
-                                total->stack += currec.smap_size;
-                        if (cb) {
-                                p = skip_non_whitespace(tp);
-                                if (p == tp) {
-                                        currec.smap_name = xstrdup("  [ anon ]");
-                                } else {
-                                        *p = '\0';
-                                        currec.smap_name = xstrdup(tp);
-                                }
-                        }
-                        total->smap_size += currec.smap_size;
+                                sp->stack += sz;
                 }
         }
         fclose(file);
-
-        if (cb) {
-                if (currec.smap_size)
-                        cb(&currec, data);
-                free(currec.smap_name);
-        }
-
-        return 0;
 }
 #endif
 
@@ -370,7 +351,8 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
                         char *cp, *comm1;
                         int tty;
 #if !ENABLE_FEATURE_FAST_TOP
-                        unsigned long vsz, rss;
+                        unsigned long long vsz;
+                        unsigned long rss;
 #endif
                         /* see proc(5) for some details on this */
                         strcpy(filename_tail, "stat");
@@ -396,7 +378,7 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
                                 "%ld "                 /* nice */
                                 "%*s %*s "             /* timeout, it_real_value */
                                 "%lu "                 /* start_time */
-                                "%lu "                 /* vsize */
+                                "%llu "                /* vsize - can be very large */
                                 "%lu "                 /* rss */
 # if ENABLE_FEATURE_TOP_SMP_PROCESS
                                 "%*s %*s %*s %*s %*s %*s " /*rss_rlim, start_code, end_code, start_stack, kstk_esp, kstk_eip */
@@ -449,7 +431,7 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
                         cp = skip_fields(cp, 2); /* timeout, it_real_value */
                         sp->start_time = fast_strtoul_10(&cp);
                         /* vsz is in bytes and we want kb */
-                        sp->vsz = fast_strtoul_10(&cp) >> 10;
+                        sp->vsz = fast_strtoull_10(&cp) >> 10;
                         /* vsz is in bytes but rss is in *PAGES*! Can you believe that? */
                         sp->rss = fast_strtoul_10(&cp) << sp->shift_pages_to_kb;
 # if ENABLE_FEATURE_TOP_SMP_PROCESS
@@ -483,7 +465,7 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
 
 #if ENABLE_FEATURE_TOPMEM
                 if (flags & PSSCAN_SMAPS)
-                        procps_read_smaps(pid, &sp->smaps, NULL, NULL);
+                        procps_read_smaps(pid, sp);
 #endif /* TOPMEM */
 #if ENABLE_FEATURE_PS_ADDITIONAL_COLUMNS
                 if (flags & PSSCAN_RUIDGID) {
@@ -566,36 +548,45 @@ procps_status_t* FAST_FUNC procps_scan(procps_status_t* sp, int flags)
         return sp;
 }
 
-void FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
+int FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
 {
         int sz;
         char filename[sizeof("/proc/%u/cmdline") + sizeof(int)*3];
 
         sprintf(filename, "/proc/%u/cmdline", pid);
         sz = open_read_close(filename, buf, col - 1);
+        if (sz < 0)
+                return sz;
         if (sz > 0) {
-                const char *base;
+                const char *program_basename;
                 int comm_len;
 
                 buf[sz] = '\0';
                 while (--sz >= 0 && buf[sz] == '\0')
                         continue;
-                /* Prevent basename("process foo/bar") = "bar" */
-                strchrnul(buf, ' ')[0] = '\0';
-                base = bb_basename(buf); /* before we replace argv0's NUL with space */
+
+                /* Find "program" in "[-][/PATH/TO/]program" */
+                strchrnul(buf, ' ')[0] = '\0'; /* prevent basename("program foo/bar") = "bar" */
+                program_basename = bb_basename(buf[0] == '-' ? buf + 1 : buf);
+                /* ^^^ note: must do it *before* replacing argv0's NUL with space */
+
+                /* Prevent stuff like this:
+                 *  echo 'sleep 999; exit' >`printf '\ec'`; sh ?c
+                 * messing up top and ps output (or worse).
+                 * This also replaces NULs with spaces, converting
+                 * list of NUL-strings into one string.
+                 */
                 while (sz >= 0) {
                         if ((unsigned char)(buf[sz]) < ' ')
                                 buf[sz] = ' ';
                         sz--;
                 }
-                if (base[0] == '-') /* "-sh" (login shell)? */
-                        base++;
 
                 /* If comm differs from argv0, prepend "{comm} ".
                  * It allows to see thread names set by prctl(PR_SET_NAME).
                  */
                 if (!comm)
-                        return;
+                        return 0;
                 comm_len = strlen(comm);
                 /* Why compare up to comm_len, not COMM_LEN-1?
                  * Well, some processes rewrite argv, and use _spaces_ there
@@ -603,19 +594,20 @@ void FAST_FUNC read_cmdline(char *buf, int col, unsigned pid, const char *comm)
                  * I prefer to still treat argv0 "process foo bar"
                  * as 'equal' to comm "process".
                  */
-                if (strncmp(base, comm, comm_len) != 0) {
+                if (strncmp(program_basename, comm, comm_len) != 0) {
                         comm_len += 3;
                         if (col > comm_len)
                                 memmove(buf + comm_len, buf, col - comm_len);
                         snprintf(buf, col, "{%s}", comm);
                         if (col <= comm_len)
-                                return;
+                                return 0;
                         buf[comm_len - 1] = ' ';
                         buf[col - 1] = '\0';
                 }
         } else {
                 snprintf(buf, col, "[%s]", comm ? comm : "?");
         }
+        return 0;
 }
 
 /* from kernel:
diff --git a/libbb/replace.c b/libbb/replace.c
index 6183d3e6f..bc26b04cc 100644
--- a/libbb/replace.c
+++ b/libbb/replace.c
@@ -46,3 +46,17 @@ char* FAST_FUNC xmalloc_substitute_string(const char *src, int count, const char
         //dbg_msg("subst9:'%s'", buf);
         return buf;
 }
+
+#if 0 /* inlined in libbb.h */
+/* Returns strlen as a bonus */
+size_t FAST_FUNC replace_char(char *str, char from, char to)
+{
+        char *p = str;
+        while (*p) {
+                if (*p == from)
+                        *p = to;
+                p++;
+        }
+        return p - str;
+}
+#endif
diff --git a/libbb/yescrypt/alg-sha256.c b/libbb/yescrypt/alg-sha256.c
index 20e8d1ee4..dc748c968 100644
--- a/libbb/yescrypt/alg-sha256.c
+++ b/libbb/yescrypt/alg-sha256.c
@@ -47,9 +47,12 @@ PBKDF2_SHA256(const uint8_t *passwd, size_t passwdlen,
 
         /* Iterate through the blocks. */
         for (i = 0; dkLen != 0; ) {
-                uint64_t U[32 / 8];
-                uint64_t T[32 / 8];
-                uint64_t j;
+                long U[32 / sizeof(long)];
+                long T[32 / sizeof(long)];
+// Do not make these ^^ uint64_t[]. Keep them long[].
+// Even though the XORing loop below is optimized out,
+// gcc is not smart enough to realize that 64-bit alignment of the stack
+// is no longer useful, and generates ~50 more bytes of code on i386...
                 uint32_t ivec;
                 size_t clen;
                 int k;
@@ -64,13 +67,15 @@ PBKDF2_SHA256(const uint8_t *passwd, size_t passwdlen,
 //does libbb need a non-vararg version with just one (buf,len)?
 
                 if (c > 1) {
+//in yescrypt, c is always 1, so this if() branch is optimized out
+                        uint64_t j;
                         /* T_i = U_1 ... */
                         memcpy(U, T, 32);
                         for (j = 2; j <= c; j++) {
                                 /* Compute U_j. */
                                 hmac_peek_hash(&Phctx, (void*)U, U, 32, NULL);
                                 /* ... xor U_j ... */
-                                for (k = 0; k < 32 / 8; k++)
+                                for (k = 0; k < 32 / sizeof(long); k++)
                                         T[k] ^= U[k];
                                 //TODO: xorbuf32_aligned_long(T, U);
                         }