Merge branch 'busybox' into merge

10 files changed, 430 insertions, 337 deletions

diff --git a/archival/libarchive/bz/blocksort.c b/archival/libarchive/bz/blocksort.c
index e600cb7a7..92d6d8251 100644
--- a/archival/libarchive/bz/blocksort.c
+++ b/archival/libarchive/bz/blocksort.c
@@ -113,9 +113,8 @@ void fallbackQSort3(uint32_t* fmap,
                 int32_t   loSt,
                 int32_t   hiSt)
 {
-        int32_t unLo, unHi, ltLo, gtHi, n, m;
-        int32_t sp, lo, hi;
-        uint32_t med, r, r3;
+        int32_t sp;
+        uint32_t r;
         int32_t stackLo[FALLBACK_QSORT_STACK_SIZE];
         int32_t stackHi[FALLBACK_QSORT_STACK_SIZE];
 
@@ -125,6 +124,11 @@ void fallbackQSort3(uint32_t* fmap,
         fpush(loSt, hiSt);
 
         while (sp > 0) {
+                int32_t unLo, unHi, ltLo, gtHi, n, m;
+                int32_t lo, hi;
+                uint32_t med;
+                uint32_t r3;
+
                 AssertH(sp < FALLBACK_QSORT_STACK_SIZE - 1, 1004);
 
                 fpop(lo, hi);
@@ -161,7 +165,7 @@ void fallbackQSort3(uint32_t* fmap,
                                         ltLo++;
                                         unLo++;
                                         continue;
-                                };
+                                }
                                 if (n > 0) break;
                                 unLo++;
                         }
@@ -172,7 +176,7 @@ void fallbackQSort3(uint32_t* fmap,
                                         mswap(fmap[unHi], fmap[gtHi]);
                                         gtHi--; unHi--;
                                         continue;
-                                };
+                                }
                                 if (n < 0) break;
                                 unHi--;
                         }
@@ -227,17 +231,19 @@ void fallbackQSort3(uint32_t* fmap,
 #define UNALIGNED_BH(zz)  ((zz) & 0x01f)
 
 static
-void fallbackSort(uint32_t* fmap,
-                uint32_t* eclass,
-                uint32_t* bhtab,
-                int32_t   nblock)
+void fallbackSort(EState* state)
 {
         int32_t ftab[257];
         int32_t ftabCopy[256];
         int32_t H, i, j, k, l, r, cc, cc1;
         int32_t nNotDone;
         int32_t nBhtab;
-        uint8_t* eclass8 = (uint8_t*)eclass;
+        /* params */
+        uint32_t *const fmap    = state->arr1;
+        uint32_t *const eclass  = state->arr2;
+#define eclass8 ((uint8_t*)eclass)
+        uint32_t *const bhtab   = state->ftab;
+        const int32_t   nblock  = state->nblock;
 
         /*
          * Initial 1-char radix sort to generate
@@ -326,7 +332,7 @@ void fallbackSort(uint32_t* fmap,
                                         if (cc != cc1) {
                                                 SET_BH(i);
                                                 cc = cc1;
-                                        };
+                                        }
                                 }
                         }
                 }
@@ -349,6 +355,7 @@ void fallbackSort(uint32_t* fmap,
                 eclass8[fmap[i]] = (uint8_t)j;
         }
         AssertH(j < 256, 1005);
+#undef eclass8
 }
 
 #undef       SET_BH
@@ -367,25 +374,25 @@ void fallbackSort(uint32_t* fmap,
 /*---------------------------------------------*/
 static
 NOINLINE
-int mainGtU(
+int mainGtU(EState* state,
                 uint32_t  i1,
-                uint32_t  i2,
-                uint8_t*  block,
-                uint16_t* quadrant,
-                uint32_t  nblock,
-                int32_t*  budget)
+                uint32_t  i2)
 {
         int32_t  k;
         uint8_t  c1, c2;
         uint16_t s1, s2;
 
+        uint8_t  *const block    = state->block;
+        uint16_t *const quadrant = state->quadrant;
+        const int32_t   nblock   = state->nblock;
+
 /* Loop unrolling here is actually very useful
  * (generated code is much simpler),
  * code size increase is only 270 bytes (i386)
  * but speeds up compression 10% overall
  */
 
-#if CONFIG_BZIP2_FAST >= 1
+#if BZIP2_SPEED >= 1
 
 #define TIMES_8(code) \
         code; code; code; code; \
@@ -435,7 +442,7 @@ int mainGtU(
                 if (i1 >= nblock) i1 -= nblock;
                 if (i2 >= nblock) i2 -= nblock;
 
-                (*budget)--;
+                state->budget--;
                 k -= 8;
         } while (k >= 0);
 
@@ -452,42 +459,45 @@ int mainGtU(
  * usually small, typically <= 20.
  */
 static
-const int32_t incs[14] = {
+const uint32_t incs[14] = {
         1, 4, 13, 40, 121, 364, 1093, 3280,
         9841, 29524, 88573, 265720,
         797161, 2391484
 };
 
 static
-void mainSimpleSort(uint32_t* ptr,
-                uint8_t*  block,
-                uint16_t* quadrant,
-                int32_t   nblock,
+void mainSimpleSort(EState* state,
                 int32_t   lo,
                 int32_t   hi,
-                int32_t   d,
-                int32_t*  budget)
+                int32_t   d)
 {
-        int32_t i, j, h, bigN, hp;
-        uint32_t v;
-
-        bigN = hi - lo + 1;
-        if (bigN < 2) return;
+        uint32_t *const ptr = state->ptr;
 
-        hp = 0;
-        while (incs[hp] < bigN) hp++;
-        hp--;
+        /* At which increment to start? */
+        int hp = 0;
+        {
+                int bigN = hi - lo;
+                if (bigN <= 0)
+                        return;
+                while (incs[hp] <= bigN)
+                        hp++;
+                hp--;
+        }
 
         for (; hp >= 0; hp--) {
-                h = incs[hp];
+                int32_t i;
+                unsigned h;
 
+                h = incs[hp];
                 i = lo + h;
                 while (1) {
-                        /*-- copy 1 --*/
+                        unsigned j;
+                        unsigned v;
+
                         if (i > hi) break;
                         v = ptr[i];
                         j = i;
-                        while (mainGtU(ptr[j-h]+d, v+d, block, quadrant, nblock, budget)) {
+                        while (mainGtU(state, ptr[j-h]+d, v+d)) {
                                 ptr[j] = ptr[j-h];
                                 j = j - h;
                                 if (j <= (lo + h - 1)) break;
@@ -496,24 +506,23 @@ void mainSimpleSort(uint32_t* ptr,
                         i++;
 
 /* 1.5% overall speedup, +290 bytes */
-#if CONFIG_BZIP2_FAST >= 3
+#if BZIP2_SPEED >= 3
                         /*-- copy 2 --*/
                         if (i > hi) break;
                         v = ptr[i];
                         j = i;
-                        while (mainGtU(ptr[j-h]+d, v+d, block, quadrant, nblock, budget)) {
+                        while (mainGtU(state, ptr[j-h]+d, v+d)) {
                                 ptr[j] = ptr[j-h];
                                 j = j - h;
                                 if (j <= (lo + h - 1)) break;
                         }
                         ptr[j] = v;
                         i++;
-
                         /*-- copy 3 --*/
                         if (i > hi) break;
                         v = ptr[i];
                         j = i;
-                        while (mainGtU(ptr[j-h]+d, v+d, block, quadrant, nblock, budget)) {
+                        while (mainGtU(state, ptr[j-h]+d, v+d)) {
                                 ptr[j] = ptr[j-h];
                                 j = j - h;
                                 if (j <= (lo + h - 1)) break;
@@ -521,7 +530,7 @@ void mainSimpleSort(uint32_t* ptr,
                         ptr[j] = v;
                         i++;
 #endif
-                        if (*budget < 0) return;
+                        if (state->budget < 0) return;
                 }
         }
 }
@@ -545,7 +554,7 @@ uint8_t mmed3(uint8_t a, uint8_t b, uint8_t c)
                 t = a;
                 a = b;
                 b = t;
-        };
+        }
         /* here b >= a */
         if (b > c) {
                 b = c;
@@ -586,15 +595,12 @@ uint8_t mmed3(uint8_t a, uint8_t b, uint8_t c)
 #define MAIN_QSORT_STACK_SIZE   100
 
 static NOINLINE
-void mainQSort3(uint32_t* ptr,
-                uint8_t*  block,
-                uint16_t* quadrant,
-                int32_t   nblock,
+void mainQSort3(EState* state,
                 int32_t   loSt,
-                int32_t   hiSt,
-                int32_t   dSt,
-                int32_t*  budget)
+                int32_t   hiSt
+                /*int32_t dSt*/)
 {
+        enum { dSt = BZ_N_RADIX };
         int32_t unLo, unHi, ltLo, gtHi, n, m, med;
         int32_t sp, lo, hi, d;
 
@@ -606,6 +612,9 @@ void mainQSort3(uint32_t* ptr,
         int32_t nextHi[3];
         int32_t nextD [3];
 
+        uint32_t *const ptr   = state->ptr;
+        uint8_t  *const block = state->block;
+
         sp = 0;
         mpush(loSt, hiSt, dSt);
 
@@ -616,8 +625,8 @@ void mainQSort3(uint32_t* ptr,
                 if (hi - lo < MAIN_QSORT_SMALL_THRESH
                  || d > MAIN_QSORT_DEPTH_THRESH
                 ) {
-                        mainSimpleSort(ptr, block, quadrant, nblock, lo, hi, d, budget);
-                        if (*budget < 0)
+                        mainSimpleSort(state, lo, hi, d);
+                        if (state->budget < 0)
                                 return;
                         continue;
                 }
@@ -638,8 +647,8 @@ void mainQSort3(uint32_t* ptr,
                                         ltLo++;
                                         unLo++;
                                         continue;
-                                };
-                                if (n >  0) break;
+                                }
+                                if (n > 0) break;
                                 unLo++;
                         }
                         while (1) {
@@ -651,8 +660,8 @@ void mainQSort3(uint32_t* ptr,
                                         gtHi--;
                                         unHi--;
                                         continue;
-                                };
-                                if (n <  0) break;
+                                }
+                                if (n < 0) break;
                                 unHi--;
                         }
                         if (unLo > unHi)
@@ -721,28 +730,24 @@ void mainQSort3(uint32_t* ptr,
 #define CLEARMASK (~(SETMASK))
 
 static NOINLINE
-void mainSort(EState* state,
-                uint32_t* ptr,
-                uint8_t*  block,
-                uint16_t* quadrant,
-                uint32_t* ftab,
-                int32_t   nblock,
-                int32_t*  budget)
+void mainSort(EState* state)
 {
-        int32_t  i, j, k, ss, sb;
-        uint8_t  c1;
-        int32_t  numQSorted;
-        uint16_t s;
+        int32_t  i, j;
         Bool     bigDone[256];
+        uint8_t  runningOrder[256];
         /* bbox: moved to EState to save stack
-        int32_t  runningOrder[256];
         int32_t  copyStart[256];
         int32_t  copyEnd  [256];
         */
-#define runningOrder (state->mainSort__runningOrder)
 #define copyStart    (state->mainSort__copyStart)
 #define copyEnd      (state->mainSort__copyEnd)
 
+        uint32_t *const ptr      = state->ptr;
+        uint8_t  *const block    = state->block;
+        uint32_t *const ftab     = state->ftab;
+        const int32_t   nblock   = state->nblock;
+        uint16_t *const quadrant = state->quadrant;
+
         /*-- set up the 2-byte frequency table --*/
         /* was: for (i = 65536; i >= 0; i--) ftab[i] = 0; */
         memset(ftab, 0, 65537 * sizeof(ftab[0]));
@@ -750,25 +755,25 @@ void mainSort(EState* state,
         j = block[0] << 8;
         i = nblock - 1;
 /* 3%, +300 bytes */
-#if CONFIG_BZIP2_FAST >= 2
+#if BZIP2_SPEED >= 2
         for (; i >= 3; i -= 4) {
                 quadrant[i] = 0;
-                j = (j >> 8) | (((uint16_t)block[i]) << 8);
+                j = (j >> 8) | (((unsigned)block[i]) << 8);
                 ftab[j]++;
                 quadrant[i-1] = 0;
-                j = (j >> 8) | (((uint16_t)block[i-1]) << 8);
+                j = (j >> 8) | (((unsigned)block[i-1]) << 8);
                 ftab[j]++;
                 quadrant[i-2] = 0;
-                j = (j >> 8) | (((uint16_t)block[i-2]) << 8);
+                j = (j >> 8) | (((unsigned)block[i-2]) << 8);
                 ftab[j]++;
                 quadrant[i-3] = 0;
-                j = (j >> 8) | (((uint16_t)block[i-3]) << 8);
+                j = (j >> 8) | (((unsigned)block[i-3]) << 8);
                 ftab[j]++;
         }
 #endif
         for (; i >= 0; i--) {
                 quadrant[i] = 0;
-                j = (j >> 8) | (((uint16_t)block[i]) << 8);
+                j = (j >> 8) | (((unsigned)block[i]) << 8);
                 ftab[j]++;
         }
 
@@ -785,33 +790,36 @@ void mainSort(EState* state,
                 ftab[i] = j;
         }
 
-        s = block[0] << 8;
-        i = nblock - 1;
-#if CONFIG_BZIP2_FAST >= 2
-        for (; i >= 3; i -= 4) {
-                s = (s >> 8) | (block[i] << 8);
-                j = ftab[s] - 1;
-                ftab[s] = j;
-                ptr[j] = i;
-                s = (s >> 8) | (block[i-1] << 8);
-                j = ftab[s] - 1;
-                ftab[s] = j;
-                ptr[j] = i-1;
-                s = (s >> 8) | (block[i-2] << 8);
-                j = ftab[s] - 1;
-                ftab[s] = j;
-                ptr[j] = i-2;
-                s = (s >> 8) | (block[i-3] << 8);
-                j = ftab[s] - 1;
-                ftab[s] = j;
-                ptr[j] = i-3;
-        }
+        {
+                unsigned s;
+                s = block[0] << 8;
+                i = nblock - 1;
+#if BZIP2_SPEED >= 2
+                for (; i >= 3; i -= 4) {
+                        s = (s >> 8) | (block[i] << 8);
+                        j = ftab[s] - 1;
+                        ftab[s] = j;
+                        ptr[j] = i;
+                        s = (s >> 8) | (block[i-1] << 8);
+                        j = ftab[s] - 1;
+                        ftab[s] = j;
+                        ptr[j] = i-1;
+                        s = (s >> 8) | (block[i-2] << 8);
+                        j = ftab[s] - 1;
+                        ftab[s] = j;
+                        ptr[j] = i-2;
+                        s = (s >> 8) | (block[i-3] << 8);
+                        j = ftab[s] - 1;
+                        ftab[s] = j;
+                        ptr[j] = i-3;
+                }
 #endif
-        for (; i >= 0; i--) {
-                s = (s >> 8) | (block[i] << 8);
-                j = ftab[s] - 1;
-                ftab[s] = j;
-                ptr[j] = i;
+                for (; i >= 0; i--) {
+                        s = (s >> 8) | (block[i] << 8);
+                        j = ftab[s] - 1;
+                        ftab[s] = j;
+                        ptr[j] = i;
+                }
         }
 
         /*
@@ -825,24 +833,23 @@ void mainSort(EState* state,
         }
 
         {
-                int32_t vv;
                 /* bbox: was: int32_t h = 1; */
                 /* do h = 3 * h + 1; while (h <= 256); */
-                uint32_t h = 364;
+                unsigned h = 364;
 
                 do {
                         /*h = h / 3;*/
                         h = (h * 171) >> 9; /* bbox: fast h/3 */
                         for (i = h; i <= 255; i++) {
-                                vv = runningOrder[i];
+                                unsigned vv, jh;
+                                vv = runningOrder[i]; /* uint8[] */
                                 j = i;
-                                while (BIGFREQ(runningOrder[j-h]) > BIGFREQ(vv)) {
-                                        runningOrder[j] = runningOrder[j-h];
-                                        j = j - h;
-                                        if (j <= (h - 1))
-                                                goto zero;
+                                while (jh = j - h, BIGFREQ(runningOrder[jh]) > BIGFREQ(vv)) {
+                                        runningOrder[j] = runningOrder[jh];
+                                        j = jh;
+                                        if (j < h)
+                                                break;
                                 }
- zero:
                                 runningOrder[j] = vv;
                         }
                 } while (h != 1);
@@ -852,9 +859,8 @@ void mainSort(EState* state,
          * The main sorting loop.
          */
 
-        numQSorted = 0;
-
-        for (i = 0; i <= 255; i++) {
+        for (i = 0; /*i <= 255*/; i++) {
+                unsigned ss;
 
                 /*
                  * Process big buckets, starting with the least full.
@@ -874,17 +880,14 @@ void mainSort(EState* state,
                  */
                 for (j = 0; j <= 255; j++) {
                         if (j != ss) {
+                                unsigned sb;
                                 sb = (ss << 8) + j;
                                 if (!(ftab[sb] & SETMASK)) {
-                                        int32_t lo =  ftab[sb]   & CLEARMASK;
+                                        int32_t lo =  ftab[sb] /*& CLEARMASK (redundant)*/;
                                         int32_t hi = (ftab[sb+1] & CLEARMASK) - 1;
                                         if (hi > lo) {
-                                                mainQSort3(
-                                                        ptr, block, quadrant, nblock,
-                                                        lo, hi, BZ_N_RADIX, budget
-                                                );
-                                                if (*budget < 0) return;
-                                                numQSorted += (hi - lo + 1);
+                                                mainQSort3(state, lo, hi /*,BZ_N_RADIX*/);
+                                                if (state->budget < 0) return;
                                         }
                                 }
                                 ftab[sb] |= SETMASK;
@@ -906,6 +909,8 @@ void mainSort(EState* state,
                                 copyEnd  [j] = (ftab[(j << 8) + ss + 1] & CLEARMASK) - 1;
                         }
                         for (j = ftab[ss << 8] & CLEARMASK; j < copyStart[ss]; j++) {
+                                unsigned c1;
+                                int32_t k;
                                 k = ptr[j] - 1;
                                 if (k < 0)
                                         k += nblock;
@@ -914,6 +919,8 @@ void mainSort(EState* state,
                                         ptr[copyStart[c1]++] = k;
                         }
                         for (j = (ftab[(ss+1) << 8] & CLEARMASK) - 1; j > copyEnd[ss]; j--) {
+                                unsigned c1;
+                                int32_t k;
                                 k = ptr[j]-1;
                                 if (k < 0)
                                         k += nblock;
@@ -933,6 +940,9 @@ void mainSort(EState* state,
                 for (j = 0; j <= 255; j++)
                         ftab[(j << 8) + ss] |= SETMASK;
 
+                if (i == 255)
+                        break;
+
                 /*
                  * Step 3:
                  * The [ss] big bucket is now done.  Record this fact,
@@ -974,15 +984,15 @@ void mainSort(EState* state,
                  */
                 bigDone[ss] = True;
 
-                if (i < 255) {
-                        int32_t bbStart = ftab[ss << 8] & CLEARMASK;
-                        int32_t bbSize  = (ftab[(ss+1) << 8] & CLEARMASK) - bbStart;
-                        int32_t shifts  = 0;
+                {
+                        unsigned bbStart = ftab[ss << 8] & CLEARMASK;
+                        unsigned bbSize  = (ftab[(ss+1) << 8] & CLEARMASK) - bbStart;
+                        unsigned shifts  = 0;
 
                         while ((bbSize >> shifts) > 65534) shifts++;
 
                         for (j = bbSize-1; j >= 0; j--) {
-                                int32_t a2update   = ptr[bbStart + j];
+                                unsigned a2update  = ptr[bbStart + j]; /* uint32[] */
                                 uint16_t qVal      = (uint16_t)(j >> shifts);
                                 quadrant[a2update] = qVal;
                                 if (a2update < BZ_N_OVERSHOOT)
@@ -1015,31 +1025,24 @@ void mainSort(EState* state,
  *      arr1[0 .. nblock-1] holds sorted order
  */
 static NOINLINE
-void BZ2_blockSort(EState* s)
+int32_t BZ2_blockSort(EState* state)
 {
         /* In original bzip2 1.0.4, it's a parameter, but 30
          * (which was the default) should work ok. */
         enum { wfact = 30 };
+        unsigned i;
+        int32_t origPtr = origPtr;
 
-        uint32_t* ptr    = s->ptr;
-        uint8_t*  block  = s->block;
-        uint32_t* ftab   = s->ftab;
-        int32_t   nblock = s->nblock;
-        uint16_t* quadrant;
-        int32_t   budget;
-        int32_t   i;
-
-        if (nblock < 10000) {
-                fallbackSort(s->arr1, s->arr2, ftab, nblock);
-        } else {
+        if (state->nblock >= 10000) {
                 /* Calculate the location for quadrant, remembering to get
                  * the alignment right.  Assumes that &(block[0]) is at least
                  * 2-byte aligned -- this should be ok since block is really
                  * the first section of arr2.
                  */
-                i = nblock + BZ_N_OVERSHOOT;
-                if (i & 1) i++;
-                quadrant = (uint16_t*)(&(block[i]));
+                i = state->nblock + BZ_N_OVERSHOOT;
+                if (i & 1)
+                        i++;
+                state->quadrant = (uint16_t*) &(state->block[i]);
 
                 /* (wfact-1) / 3 puts the default-factor-30
                  * transition point at very roughly the same place as
@@ -1048,22 +1051,26 @@ void BZ2_blockSort(EState* s)
                  * resulting compressed stream is now the same regardless
                  * of whether or not we use the main sort or fallback sort.
                  */
-                budget = nblock * ((wfact-1) / 3);
-
-                mainSort(s, ptr, block, quadrant, ftab, nblock, &budget);
-                if (budget < 0) {
-                        fallbackSort(s->arr1, s->arr2, ftab, nblock);
-                }
+                state->budget = state->nblock * ((wfact-1) / 3);
+                mainSort(state);
+                if (state->budget >= 0)
+                        goto good;
         }
+        fallbackSort(state);
+ good:
 
-        s->origPtr = -1;
-        for (i = 0; i < s->nblock; i++)
-                if (ptr[i] == 0) {
-                        s->origPtr = i;
+#if BZ_LIGHT_DEBUG
+        origPtr = -1;
+#endif
+        for (i = 0; i < state->nblock; i++) {
+                if (state->ptr[i] == 0) {
+                        origPtr = i;
                         break;
-                };
+                }
+        }
 
-        AssertH(s->origPtr != -1, 1003);
+        AssertH(origPtr != -1, 1003);
+        return origPtr;
 }
 
 
diff --git a/archival/libarchive/bz/bzlib.c b/archival/libarchive/bz/bzlib.c
index 5f7db747a..9af2f026d 100644
--- a/archival/libarchive/bz/bzlib.c
+++ b/archival/libarchive/bz/bzlib.c
@@ -55,8 +55,9 @@ void prepare_new_block(EState* s)
 {
         int i;
         s->nblock = 0;
-        s->numZ = 0;
-        s->state_out_pos = 0;
+        //indexes into s->zbits[], initialzation moved to init of s->zbits
+        //s->posZ = s->zbits; // was: s->numZ = 0;
+        //s->state_out_pos = s->zbits;
         BZ_INITIALISE_CRC(s->blockCRC);
         /* inlined memset would be nice to have here */
         for (i = 0; i < 256; i++)
@@ -86,7 +87,7 @@ int isempty_RL(EState* s)
 static
 void BZ2_bzCompressInit(bz_stream *strm, int blockSize100k)
 {
-        int32_t n;
+        unsigned n;
         EState* s;
 
         s = xzalloc(sizeof(EState));
@@ -237,11 +238,10 @@ void /*Bool*/ copy_output_until_stop(EState* s)
                 if (s->strm->avail_out == 0) break;
 
                 /*-- block done? --*/
-                if (s->state_out_pos >= s->numZ) break;
+                if (s->state_out_pos >= s->posZ) break;
 
                 /*progress_out = True;*/
-                *(s->strm->next_out) = s->zbits[s->state_out_pos];
-                s->state_out_pos++;
+                *(s->strm->next_out) = *s->state_out_pos++;
                 s->strm->avail_out--;
                 s->strm->next_out++;
                 s->strm->total_out++;
@@ -261,7 +261,7 @@ void /*Bool*/ handle_compress(bz_stream *strm)
         while (1) {
                 if (s->state == BZ_S_OUTPUT) {
                         /*progress_out |=*/ copy_output_until_stop(s);
-                        if (s->state_out_pos < s->numZ) break;
+                        if (s->state_out_pos < s->posZ) break;
                         if (s->mode == BZ_M_FINISHING
                         //# && s->avail_in_expect == 0
                          && s->strm->avail_in == 0
@@ -336,7 +336,7 @@ int BZ2_bzCompress(bz_stream *strm, int action)
                         /*if (s->avail_in_expect != s->strm->avail_in)
                                 return BZ_SEQUENCE_ERROR;*/
                         /*progress =*/ handle_compress(strm);
-                        if (s->avail_in_expect > 0 || !isempty_RL(s) || s->state_out_pos < s->numZ)
+                        if (s->avail_in_expect > 0 || !isempty_RL(s) || s->state_out_pos < s->posZ)
                                 return BZ_FLUSH_OK;
                         s->mode = BZ_M_RUNNING;
                         return BZ_RUN_OK;
@@ -349,9 +349,9 @@ int BZ2_bzCompress(bz_stream *strm, int action)
                                 return BZ_SEQUENCE_ERROR;*/
                         /*progress =*/ handle_compress(strm);
                         /*if (!progress) return BZ_SEQUENCE_ERROR;*/
-                        //#if (s->avail_in_expect > 0 || !isempty_RL(s) || s->state_out_pos < s->numZ)
+                        //#if (s->avail_in_expect > 0 || !isempty_RL(s) || s->state_out_pos < s->posZ)
                         //#     return BZ_FINISH_OK;
-                        if (s->strm->avail_in > 0 || !isempty_RL(s) || s->state_out_pos < s->numZ)
+                        if (s->strm->avail_in > 0 || !isempty_RL(s) || s->state_out_pos < s->posZ)
                                 return BZ_FINISH_OK;
                         /*s->mode = BZ_M_IDLE;*/
                         return BZ_STREAM_END;
diff --git a/archival/libarchive/bz/bzlib_private.h b/archival/libarchive/bz/bzlib_private.h
index 43e674bec..ea0f29b7c 100644
--- a/archival/libarchive/bz/bzlib_private.h
+++ b/archival/libarchive/bz/bzlib_private.h
@@ -120,8 +120,11 @@ typedef struct EState {
 
         /* mode this stream is in, and whether inputting */
         /* or outputting data */
-        int32_t  mode;
-        int32_t  state;
+        uint8_t mode;
+        uint8_t state;
+
+        /* misc administratium */
+        uint8_t blockSize100k;
 
         /* remembers avail_in when flush/finish requested */
 /* bbox: not needed, strm->avail_in always has the same value */
@@ -129,20 +132,19 @@ typedef struct EState {
         /* uint32_t avail_in_expect; */
 
         /* for doing the block sorting */
-        int32_t  origPtr;
         uint32_t *arr1;
         uint32_t *arr2;
         uint32_t *ftab;
 
+        uint16_t *quadrant;
+        int32_t  budget;
+
         /* aliases for arr1 and arr2 */
         uint32_t *ptr;
         uint8_t  *block;
         uint16_t *mtfv;
         uint8_t  *zbits;
 
-        /* guess what */
-        uint32_t *crc32table;
-
         /* run-length-encoding of the input */
         uint32_t state_in_ch;
         int32_t  state_in_len;
@@ -150,20 +152,23 @@ typedef struct EState {
         /* input and output limits and current posns */
         int32_t  nblock;
         int32_t  nblockMAX;
-        int32_t  numZ;
-        int32_t  state_out_pos;
+        //int32_t  numZ; // index into s->zbits[], replaced by pointer:
+        uint8_t  *posZ;
+        uint8_t  *state_out_pos;
 
         /* the buffer for bit stream creation */
         uint32_t bsBuff;
         int32_t  bsLive;
 
+        /* guess what */
+        uint32_t *crc32table;
+
         /* block and combined CRCs */
         uint32_t blockCRC;
         uint32_t combinedCRC;
 
         /* misc administratium */
         int32_t  blockNo;
-        int32_t  blockSize100k;
 
         /* stuff for coding the MTF values */
         int32_t  nMTF;
@@ -183,7 +188,7 @@ typedef struct EState {
         /* stack-saving measures: these can be local, but they are too big */
         int32_t  sendMTFValues__code [BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
         int32_t  sendMTFValues__rfreq[BZ_N_GROUPS][BZ_MAX_ALPHA_SIZE];
-#if CONFIG_BZIP2_FAST >= 5
+#if BZIP2_SPEED >= 5
         /* second dimension: only 3 needed; 4 makes index calculations faster */
         uint32_t sendMTFValues__len_pack[BZ_MAX_ALPHA_SIZE][4];
 #endif
@@ -191,7 +196,6 @@ typedef struct EState {
         int32_t  BZ2_hbMakeCodeLengths__weight[BZ_MAX_ALPHA_SIZE * 2];
         int32_t  BZ2_hbMakeCodeLengths__parent[BZ_MAX_ALPHA_SIZE * 2];
 
-        int32_t  mainSort__runningOrder[256];
         int32_t  mainSort__copyStart[256];
         int32_t  mainSort__copyEnd[256];
 } EState;
@@ -199,7 +203,7 @@ typedef struct EState {
 
 /*-- compression. --*/
 
-static void
+static int32_t
 BZ2_blockSort(EState*);
 
 static void
diff --git a/archival/libarchive/bz/compress.c b/archival/libarchive/bz/compress.c
index 2d994685c..539ab927e 100644
--- a/archival/libarchive/bz/compress.c
+++ b/archival/libarchive/bz/compress.c
@@ -32,6 +32,12 @@ in the file LICENSE.
 
 /* #include "bzlib_private.h" */
 
+#if BZIP2_SPEED >= 5
+# define ALWAYS_INLINE_5 ALWAYS_INLINE
+#else
+# define ALWAYS_INLINE_5 /*nothing*/
+#endif
+
 /*---------------------------------------------------*/
 /*--- Bit stream I/O                              ---*/
 /*---------------------------------------------------*/
@@ -50,8 +56,7 @@ static NOINLINE
 void bsFinishWrite(EState* s)
 {
         while (s->bsLive > 0) {
-                s->zbits[s->numZ] = (uint8_t)(s->bsBuff >> 24);
-                s->numZ++;
+                *s->posZ++ = (uint8_t)(s->bsBuff >> 24);
                 s->bsBuff <<= 8;
                 s->bsLive -= 8;
         }
@@ -61,39 +66,74 @@ void bsFinishWrite(EState* s)
 /*---------------------------------------------------*/
 static
 /* Helps only on level 5, on other levels hurts. ? */
-#if CONFIG_BZIP2_FAST >= 5
-ALWAYS_INLINE
-#endif
+ALWAYS_INLINE_5
 void bsW(EState* s, int32_t n, uint32_t v)
 {
         while (s->bsLive >= 8) {
-                s->zbits[s->numZ] = (uint8_t)(s->bsBuff >> 24);
-                s->numZ++;
+                *s->posZ++ = (uint8_t)(s->bsBuff >> 24);
                 s->bsBuff <<= 8;
                 s->bsLive -= 8;
         }
         s->bsBuff |= (v << (32 - s->bsLive - n));
         s->bsLive += n;
 }
+/* Same with n == 16: */
+static
+ALWAYS_INLINE_5
+void bsW16(EState* s, uint32_t v)
+{
+        while (s->bsLive >= 8) {
+                *s->posZ++ = (uint8_t)(s->bsBuff >> 24);
+                s->bsBuff <<= 8;
+                s->bsLive -= 8;
+        }
+        s->bsBuff |= (v << (16 - s->bsLive));
+        s->bsLive += 16;
+}
+/* Same with n == 1: */
+static
+ALWAYS_INLINE /* one callsite */
+void bsW1_1(EState* s)
+{
+        /* need space for only 1 bit, no need for loop freeing > 8 bits */
+        if (s->bsLive >= 8) {
+                *s->posZ++ = (uint8_t)(s->bsBuff >> 24);
+                s->bsBuff <<= 8;
+                s->bsLive -= 8;
+        }
+        s->bsBuff |= (1 << (31 - s->bsLive));
+        s->bsLive += 1;
+}
+static
+ALWAYS_INLINE_5
+void bsW1_0(EState* s)
+{
+        /* need space for only 1 bit, no need for loop freeing > 8 bits */
+        if (s->bsLive >= 8) {
+                *s->posZ++ = (uint8_t)(s->bsBuff >> 24);
+                s->bsBuff <<= 8;
+                s->bsLive -= 8;
+        }
+        //s->bsBuff |= (0 << (31 - s->bsLive));
+        s->bsLive += 1;
+}
 
 
 /*---------------------------------------------------*/
-static
-void bsPutU32(EState* s, unsigned u)
+static ALWAYS_INLINE
+void bsPutU16(EState* s, unsigned u)
 {
-        bsW(s, 8, (u >> 24) & 0xff);
-        bsW(s, 8, (u >> 16) & 0xff);
-        bsW(s, 8, (u >>  8) & 0xff);
-        bsW(s, 8,  u        & 0xff);
+        bsW16(s, u);
 }
 
 
 /*---------------------------------------------------*/
 static
-void bsPutU16(EState* s, unsigned u)
+void bsPutU32(EState* s, unsigned u)
 {
-        bsW(s, 8, (u >>  8) & 0xff);
-        bsW(s, 8,  u        & 0xff);
+        //bsW(s, 32, u); // can't use: may try "uint32 << -n"
+        bsW16(s, (u >> 16) & 0xffff);
+        bsW16(s, u         & 0xffff);
 }
 
 
@@ -106,25 +146,57 @@ static
 void makeMaps_e(EState* s)
 {
         int i;
-        s->nInUse = 0;
+        unsigned cnt = 0;
         for (i = 0; i < 256; i++) {
                 if (s->inUse[i]) {
-                        s->unseqToSeq[i] = s->nInUse;
-                        s->nInUse++;
+                        s->unseqToSeq[i] = cnt;
+                        cnt++;
                 }
         }
+        s->nInUse = cnt;
 }
 
 
 /*---------------------------------------------------*/
+/*
+ * This bit of code is performance-critical.
+ * On 32bit x86, gcc-6.3.0 was observed to spill ryy_j to stack,
+ * resulting in abysmal performance (x3 slowdown).
+ * Forcing it into a separate function alleviates register pressure,
+ * and spillage no longer happens.
+ * Other versions of gcc do not exhibit this problem, but out-of-line code
+ * seems to be helping them too (code is both smaller and faster).
+ * Therefore NOINLINE is enabled for the entire 32bit x86 arch for now,
+ * without a check for gcc version.
+ */
+static
+#if defined __i386__
+NOINLINE
+#endif
+int inner_loop(uint8_t *yy, uint8_t ll_i)
+{
+        register uint8_t  rtmp;
+        register uint8_t* ryy_j;
+        rtmp  = yy[1];
+        yy[1] = yy[0];
+        ryy_j = &(yy[1]);
+        while (ll_i != rtmp) {
+                register uint8_t rtmp2;
+                ryy_j++;
+                rtmp2  = rtmp;
+                rtmp   = *ryy_j;
+                *ryy_j = rtmp2;
+        }
+        yy[0] = rtmp;
+        return ryy_j - &(yy[0]);
+}
 static NOINLINE
 void generateMTFValues(EState* s)
 {
         uint8_t yy[256];
-        int32_t i, j;
-        int32_t zPend;
+        int i;
+        int zPend;
         int32_t wr;
-        int32_t EOB;
 
         /*
          * After sorting (eg, here),
@@ -148,95 +220,74 @@ void generateMTFValues(EState* s)
          * compressBlock().
          */
         uint32_t* ptr   = s->ptr;
-        uint8_t*  block = s->block;
-        uint16_t* mtfv  = s->mtfv;
 
         makeMaps_e(s);
-        EOB = s->nInUse+1;
-
-        for (i = 0; i <= EOB; i++)
-                s->mtfFreq[i] = 0;
 
         wr = 0;
         zPend = 0;
+        for (i = 0; i <= s->nInUse+1; i++)
+                s->mtfFreq[i] = 0;
+
         for (i = 0; i < s->nInUse; i++)
                 yy[i] = (uint8_t) i;
 
         for (i = 0; i < s->nblock; i++) {
-                uint8_t ll_i;
+                uint8_t ll_i = ll_i; /* gcc 4.3.1 thinks it may be used w/o init */
+                int32_t j;
+
                 AssertD(wr <= i, "generateMTFValues(1)");
                 j = ptr[i] - 1;
                 if (j < 0)
                         j += s->nblock;
-                ll_i = s->unseqToSeq[block[j]];
+                ll_i = s->unseqToSeq[s->block[j]];
                 AssertD(ll_i < s->nInUse, "generateMTFValues(2a)");
 
                 if (yy[0] == ll_i) {
                         zPend++;
-                } else {
-                        if (zPend > 0) {
-                                zPend--;
-                                while (1) {
-                                        if (zPend & 1) {
-                                                mtfv[wr] = BZ_RUNB; wr++;
-                                                s->mtfFreq[BZ_RUNB]++;
-                                        } else {
-                                                mtfv[wr] = BZ_RUNA; wr++;
-                                                s->mtfFreq[BZ_RUNA]++;
-                                        }
-                                        if (zPend < 2) break;
-                                        zPend = (uint32_t)(zPend - 2) / 2;
-                                        /* bbox: unsigned div is easier */
-                                };
-                                zPend = 0;
-                        }
-                        {
-                                register uint8_t  rtmp;
-                                register uint8_t* ryy_j;
-                                register uint8_t  rll_i;
-                                rtmp  = yy[1];
-                                yy[1] = yy[0];
-                                ryy_j = &(yy[1]);
-                                rll_i = ll_i;
-                                while (rll_i != rtmp) {
-                                        register uint8_t rtmp2;
-                                        ryy_j++;
-                                        rtmp2  = rtmp;
-                                        rtmp   = *ryy_j;
-                                        *ryy_j = rtmp2;
-                                };
-                                yy[0] = rtmp;
-                                j = ryy_j - &(yy[0]);
-                                mtfv[wr] = j+1;
-                                wr++;
-                                s->mtfFreq[j+1]++;
-                        }
+                        continue;
                 }
-        }
 
-        if (zPend > 0) {
-                zPend--;
-                while (1) {
-                        if (zPend & 1) {
-                                mtfv[wr] = BZ_RUNB;
-                                wr++;
-                                s->mtfFreq[BZ_RUNB]++;
-                        } else {
-                                mtfv[wr] = BZ_RUNA;
+                if (zPend > 0) {
+ process_zPend:
+                        zPend--;
+                        while (1) {
+#if 0
+                                if (zPend & 1) {
+                                        s->mtfv[wr] = BZ_RUNB; wr++;
+                                        s->mtfFreq[BZ_RUNB]++;
+                                } else {
+                                        s->mtfv[wr] = BZ_RUNA; wr++;
+                                        s->mtfFreq[BZ_RUNA]++;
+                                }
+#else /* same as above, since BZ_RUNA is 0 and BZ_RUNB is 1 */
+                                unsigned run = zPend & 1;
+                                s->mtfv[wr] = run;
                                 wr++;
-                                s->mtfFreq[BZ_RUNA]++;
+                                s->mtfFreq[run]++;
+#endif
+                                zPend -= 2;
+                                if (zPend < 0)
+                                        break;
+                                zPend = (unsigned)zPend / 2;
+                                /* bbox: unsigned div is easier */
                         }
-                        if (zPend < 2)
-                                break;
-                        zPend = (uint32_t)(zPend - 2) / 2;
-                        /* bbox: unsigned div is easier */
-                };
-                zPend = 0;
+                        if (i < 0) /* came via "goto process_zPend"? exit */
+                                goto end;
+                        zPend = 0;
+                }
+                j = inner_loop(yy, ll_i);
+                s->mtfv[wr] = j+1;
+                wr++;
+                s->mtfFreq[j+1]++;
         }
 
-        mtfv[wr] = EOB;
+        i = -1;
+        if (zPend > 0)
+                goto process_zPend; /* "process it and come back here" */
+ end:
+        s->mtfv[wr] = s->nInUse+1;
         wr++;
-        s->mtfFreq[EOB]++;
+        s->mtfFreq[s->nInUse+1]++;
 
         s->nMTF = wr;
 }
@@ -249,8 +300,11 @@ void generateMTFValues(EState* s)
 static NOINLINE
 void sendMTFValues(EState* s)
 {
-        int32_t v, t, i, j, gs, ge, bt, bc, iter;
-        int32_t nSelectors, alphaSize, minLen, maxLen, selCtr;
+        int32_t t, i;
+        unsigned iter;
+        unsigned gs;
+        int32_t alphaSize;
+        unsigned nSelectors, selCtr;
         int32_t nGroups;
 
         /*
@@ -266,39 +320,49 @@ void sendMTFValues(EState* s)
 #define rfreq    sendMTFValues__rfreq
 #define len_pack sendMTFValues__len_pack
 
-        uint16_t cost[BZ_N_GROUPS];
-        int32_t  fave[BZ_N_GROUPS];
+        unsigned /*uint16_t*/ cost[BZ_N_GROUPS];
 
         uint16_t* mtfv = s->mtfv;
 
         alphaSize = s->nInUse + 2;
-        for (t = 0; t < BZ_N_GROUPS; t++)
+        for (t = 0; t < BZ_N_GROUPS; t++) {
+                unsigned v;
                 for (v = 0; v < alphaSize; v++)
                         s->len[t][v] = BZ_GREATER_ICOST;
+        }
 
         /*--- Decide how many coding tables to use ---*/
         AssertH(s->nMTF > 0, 3001);
-        if (s->nMTF < 200)  nGroups = 2; else
-        if (s->nMTF < 600)  nGroups = 3; else
-        if (s->nMTF < 1200) nGroups = 4; else
-        if (s->nMTF < 2400) nGroups = 5; else
-        nGroups = 6;
+        // 1..199 = 2
+        // 200..599 = 3
+        // 600..1199 = 4
+        // 1200..2399 = 5
+        // 2400..99999 = 6
+        nGroups = 2;
+        nGroups += (s->nMTF >= 200);
+        nGroups += (s->nMTF >= 600);
+        nGroups += (s->nMTF >= 1200);
+        nGroups += (s->nMTF >= 2400);
 
         /*--- Generate an initial set of coding tables ---*/
         {
-                int32_t nPart, remF, tFreq, aFreq;
+                unsigned nPart, remF;
 
                 nPart = nGroups;
                 remF  = s->nMTF;
                 gs = 0;
                 while (nPart > 0) {
+                        unsigned v;
+                        unsigned ge;
+                        unsigned tFreq, aFreq;
+
                         tFreq = remF / nPart;
-                        ge = gs - 1;
+                        ge = gs;
                         aFreq = 0;
-                        while (aFreq < tFreq && ge < alphaSize-1) {
-                                ge++;
-                                aFreq += s->mtfFreq[ge];
+                        while (aFreq < tFreq && ge < alphaSize) {
+                                aFreq += s->mtfFreq[ge++];
                         }
+                        ge--;
 
                         if (ge > gs
                          && nPart != nGroups && nPart != 1
@@ -324,19 +388,19 @@ void sendMTFValues(EState* s)
          * Iterate up to BZ_N_ITERS times to improve the tables.
          */
         for (iter = 0; iter < BZ_N_ITERS; iter++) {
-                for (t = 0; t < nGroups; t++)
-                        fave[t] = 0;
-
-                for (t = 0; t < nGroups; t++)
+                for (t = 0; t < nGroups; t++) {
+                        unsigned v;
                         for (v = 0; v < alphaSize; v++)
                                 s->rfreq[t][v] = 0;
+                }
 
-#if CONFIG_BZIP2_FAST >= 5
+#if BZIP2_SPEED >= 5
                 /*
                  * Set up an auxiliary length table which is used to fast-track
                  * the common case (nGroups == 6).
                  */
                 if (nGroups == 6) {
+                        unsigned v;
                         for (v = 0; v < alphaSize; v++) {
                                 s->len_pack[v][0] = (s->len[1][v] << 16) | s->len[0][v];
                                 s->len_pack[v][1] = (s->len[3][v] << 16) | s->len[2][v];
@@ -347,6 +411,9 @@ void sendMTFValues(EState* s)
                 nSelectors = 0;
                 gs = 0;
                 while (1) {
+                        unsigned ge;
+                        unsigned bt, bc;
+
                         /*--- Set group start & end marks. --*/
                         if (gs >= s->nMTF)
                                 break;
@@ -360,7 +427,7 @@ void sendMTFValues(EState* s)
                          */
                         for (t = 0; t < nGroups; t++)
                                 cost[t] = 0;
-#if CONFIG_BZIP2_FAST >= 5
+#if BZIP2_SPEED >= 5
                         if (nGroups == 6 && 50 == ge-gs+1) {
                                 /*--- fast track the common case ---*/
                                 register uint32_t cost01, cost23, cost45;
@@ -390,7 +457,7 @@ void sendMTFValues(EState* s)
                         {
                                 /*--- slow version which correctly handles all situations ---*/
                                 for (i = gs; i <= ge; i++) {
-                                        uint16_t icv = mtfv[i];
+                                        unsigned /*uint16_t*/ icv = mtfv[i];
                                         for (t = 0; t < nGroups; t++)
                                                 cost[t] += s->len[t][icv];
                                 }
@@ -409,7 +476,6 @@ void sendMTFValues(EState* s)
                                         bt = t;
                                 }
                         }
-                        fave[bt]++;
                         s->selector[nSelectors] = bt;
                         nSelectors++;
 
@@ -417,7 +483,7 @@ void sendMTFValues(EState* s)
                          * Increment the symbol frequencies for the selected table.
                          */
 /* 1% faster compress. +800 bytes */
-#if CONFIG_BZIP2_FAST >= 4
+#if BZIP2_SPEED >= 4
                         if (nGroups == 6 && 50 == ge-gs+1) {
                                 /*--- fast track the common case ---*/
 #define BZ_ITUR(nn) s->rfreq[bt][mtfv[gs + (nn)]]++
@@ -464,6 +530,7 @@ void sendMTFValues(EState* s)
                 for (i = 0; i < nGroups; i++)
                         pos[i] = i;
                 for (i = 0; i < nSelectors; i++) {
+                        unsigned j;
                         ll_i = s->selector[i];
                         j = 0;
                         tmp = pos[j];
@@ -472,16 +539,16 @@ void sendMTFValues(EState* s)
                                 tmp2 = tmp;
                                 tmp = pos[j];
                                 pos[j] = tmp2;
-                        };
+                        }
                         pos[0] = tmp;
                         s->selectorMtf[i] = j;
                 }
-        };
+        }
 
         /*--- Assign actual codes for the tables. --*/
         for (t = 0; t < nGroups; t++) {
-                minLen = 32;
-                maxLen = 0;
+                unsigned minLen = 32; //todo: s->len[t][0];
+                unsigned maxLen = 0;  //todo: s->len[t][0];
                 for (i = 0; i < alphaSize; i++) {
                         if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
                         if (s->len[t][i] < minLen) minLen = s->len[t][i];
@@ -509,15 +576,16 @@ void sendMTFValues(EState* s)
                         }
                 }
 
-                bsW(s, 16, inUse16);
+                bsW16(s, inUse16);
 
                 inUse16 <<= (sizeof(int)*8 - 16); /* move 15th bit into sign bit */
                 for (i = 0; i < 16; i++) {
                         if (inUse16 < 0) {
                                 unsigned v16 = 0;
+                                unsigned j;
                                 for (j = 0; j < 16; j++)
                                         v16 = v16*2 + s->inUse[i * 16 + j];
-                                bsW(s, 16, v16);
+                                bsW16(s, v16);
                         }
                         inUse16 <<= 1;
                 }
@@ -527,19 +595,20 @@ void sendMTFValues(EState* s)
         bsW(s, 3, nGroups);
         bsW(s, 15, nSelectors);
         for (i = 0; i < nSelectors; i++) {
+                unsigned j;
                 for (j = 0; j < s->selectorMtf[i]; j++)
-                        bsW(s, 1, 1);
-                bsW(s, 1, 0);
+                        bsW1_1(s);
+                bsW1_0(s);
         }
 
         /*--- Now the coding tables. ---*/
         for (t = 0; t < nGroups; t++) {
-                int32_t curr = s->len[t][0];
+                unsigned curr = s->len[t][0];
                 bsW(s, 5, curr);
                 for (i = 0; i < alphaSize; i++) {
-                        while (curr < s->len[t][i]) { bsW(s, 2, 2); curr++; /* 10 */ };
-                        while (curr > s->len[t][i]) { bsW(s, 2, 3); curr--; /* 11 */ };
-                        bsW(s, 1, 0);
+                        while (curr < s->len[t][i]) { bsW(s, 2, 2); curr++; /* 10 */ }
+                        while (curr > s->len[t][i]) { bsW(s, 2, 3); curr--; /* 11 */ }
+                        bsW1_0(s);
                 }
         }
 
@@ -547,6 +616,8 @@ void sendMTFValues(EState* s)
         selCtr = 0;
         gs = 0;
         while (1) {
+                unsigned ge;
+
                 if (gs >= s->nMTF)
                         break;
                 ge = gs + BZ_G_SIZE - 1;
@@ -605,17 +676,21 @@ void sendMTFValues(EState* s)
 static
 void BZ2_compressBlock(EState* s, int is_last_block)
 {
+        int32_t origPtr = origPtr;
+
         if (s->nblock > 0) {
                 BZ_FINALISE_CRC(s->blockCRC);
                 s->combinedCRC = (s->combinedCRC << 1) | (s->combinedCRC >> 31);
                 s->combinedCRC ^= s->blockCRC;
                 if (s->blockNo > 1)
-                        s->numZ = 0;
+                        s->posZ = s->zbits; // was: s->numZ = 0;
 
-                BZ2_blockSort(s);
+                origPtr = BZ2_blockSort(s);
         }
 
         s->zbits = &((uint8_t*)s->arr2)[s->nblock];
+        s->posZ = s->zbits;
+        s->state_out_pos = s->zbits;
 
         /*-- If this is the first block, create the stream header. --*/
         if (s->blockNo == 1) {
@@ -649,9 +724,9 @@ void BZ2_compressBlock(EState* s, int is_last_block)
                  * so as to maintain backwards compatibility with
                  * older versions of bzip2.
                  */
-                bsW(s, 1, 0);
+                bsW1_0(s);
 
-                bsW(s, 24, s->origPtr);
+                bsW(s, 24, origPtr);
                 generateMTFValues(s);
                 sendMTFValues(s);
         }
diff --git a/archival/libarchive/bz/huffman.c b/archival/libarchive/bz/huffman.c
index bbec11adb..dc851cd3f 100644
--- a/archival/libarchive/bz/huffman.c
+++ b/archival/libarchive/bz/huffman.c
@@ -48,7 +48,7 @@ in the file LICENSE.
 
 
 /* 90 bytes, 0.3% of overall compress speed */
-#if CONFIG_BZIP2_FAST >= 1
+#if BZIP2_SPEED >= 1
 
 /* macro works better than inline (gcc 4.2.1) */
 #define DOWNHEAP1(heap, weight, Heap) \
@@ -217,7 +217,7 @@ void BZ2_hbAssignCodes(int32_t *code,
                         if (length[i] == n) {
                                 code[i] = vec;
                                 vec++;
-                        };
+                        }
                 }
                 vec <<= 1;
         }
diff --git a/archival/libarchive/decompress_gunzip.c b/archival/libarchive/decompress_gunzip.c
index 14a901792..7483a2cea 100644
--- a/archival/libarchive/decompress_gunzip.c
+++ b/archival/libarchive/decompress_gunzip.c
@@ -280,8 +280,8 @@ static unsigned fill_bitbuffer(STATE_PARAM unsigned bitbuffer, unsigned *current
 /* Given a list of code lengths and a maximum table size, make a set of
  * tables to decode that set of codes.  Return zero on success, one if
  * the given code set is incomplete (the tables are still built in this
- * case), two if the input is invalid (all zero length codes or an
- * oversubscribed set of lengths) - in this case stores NULL in *t.
+ * case), two if the input is invalid (an oversubscribed set of lengths)
+ * - in this case stores NULL in *t.
  *
  * b:   code lengths in bits (all assumed <= BMAX)
  * n:   number of codes (assumed <= N_MAX)
@@ -330,8 +330,15 @@ static int huft_build(const unsigned *b, const unsigned n,
                 p++;     /* can't combine with above line (Solaris bug) */
         } while (--i);
         if (c[0] == n) {  /* null input - all zero length codes */
-                *m = 0;
-                return 2;
+                q = xzalloc(3 * sizeof(*q));
+                //q[0].v.t = NULL;
+                q[1].e = 99;    /* invalid code marker */
+                q[1].b = 1;
+                q[2].e = 99;    /* invalid code marker */
+                q[2].b = 1;
+                *t = q + 1;
+                *m = 1;
+                return 0;
         }
 
         /* Find minimum and maximum length, bound *m by those */
@@ -1000,7 +1007,7 @@ inflate_unzip_internal(STATE_PARAM transformer_state_t *xstate)
         gunzip_bb = 0;
 
         /* Create the crc table */
-        gunzip_crc_table = crc32_filltable(NULL, 0);
+        gunzip_crc_table = crc32_new_table_le();
         gunzip_crc = ~0;
 
         error_msg = "corrupted data";
diff --git a/archival/libarchive/decompress_unxz.c b/archival/libarchive/decompress_unxz.c
index 0be85500c..8ae7a275b 100644
--- a/archival/libarchive/decompress_unxz.c
+++ b/archival/libarchive/decompress_unxz.c
@@ -52,7 +52,7 @@ unpack_xz_stream(transformer_state_t *xstate)
         IF_DESKTOP(long long) int total = 0;
 
         if (!global_crc32_table)
-                global_crc32_table = crc32_filltable(NULL, /*endian:*/ 0);
+                global_crc32_new_table_le();
 
         memset(&iobuf, 0, sizeof(iobuf));
         membuf = xmalloc(2 * BUFSIZ);
diff --git a/archival/libarchive/get_header_ar.c b/archival/libarchive/get_header_ar.c
index 1809ec396..93e071c9f 100644
--- a/archival/libarchive/get_header_ar.c
+++ b/archival/libarchive/get_header_ar.c
@@ -83,7 +83,7 @@ char FAST_FUNC get_header_ar(archive_handle_t *archive_handle)
                          */
                         ar_long_name_size = size;
                         free(ar_long_names);
-                        ar_long_names = xmalloc(size);
+                        ar_long_names = xzalloc(size + 1);
                         xread(archive_handle->src_fd, ar_long_names, size);
                         archive_handle->offset += size;
                         /* Return next header */
@@ -107,7 +107,7 @@ char FAST_FUNC get_header_ar(archive_handle_t *archive_handle)
                 unsigned long_offset;
 
                 /* The number after the '/' indicates the offset in the ar data section
-                 * (saved in ar_long_names) that conatains the real filename */
+                 * (saved in ar_long_names) that contains the real filename */
                 long_offset = read_num(&ar.formatted.name[1], 10,
                                        sizeof(ar.formatted.name) - 1);
                 if (long_offset >= ar_long_name_size) {
diff --git a/archival/libarchive/get_header_tar.c b/archival/libarchive/get_header_tar.c
index aeb54190f..5c495e14e 100644
--- a/archival/libarchive/get_header_tar.c
+++ b/archival/libarchive/get_header_tar.c
@@ -152,6 +152,7 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
         file_header_t *file_header = archive_handle->file_header;
         struct tar_header_t tar;
         char *cp;
+        int tar_typeflag; /* can be "char", "int" seems give smaller code */
         int i, sum_u, sum;
 #if ENABLE_FEATURE_TAR_OLDSUN_COMPATIBILITY
         int sum_s;
@@ -253,10 +254,10 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
          * POSIX says that checksum is done on unsigned bytes, but
          * Sun and HP-UX gets it wrong... more details in
          * GNU tar source. */
+        sum_u = ' ' * sizeof(tar.chksum);
 #if ENABLE_FEATURE_TAR_OLDSUN_COMPATIBILITY
-        sum_s = ' ' * sizeof(tar.chksum);
+        sum_s = sum_u;
 #endif
-        sum_u = ' ' * sizeof(tar.chksum);
         for (i = 0; i < 148; i++) {
                 sum_u += ((unsigned char*)&tar)[i];
 #if ENABLE_FEATURE_TAR_OLDSUN_COMPATIBILITY
@@ -269,27 +270,22 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
                 sum_s += ((signed char*)&tar)[i];
 #endif
         }
-        /* This field does not need special treatment (getOctal) */
-        {
-                char *endp; /* gcc likes temp var for &endp */
-                sum = strtoul(tar.chksum, &endp, 8);
-                if ((*endp != '\0' && *endp != ' ')
-                 || (sum_u != sum IF_FEATURE_TAR_OLDSUN_COMPATIBILITY(&& sum_s != sum))
-                ) {
-                        bb_error_msg_and_die("invalid tar header checksum");
-                }
-        }
-        /* don't use xstrtoul, tar.chksum may have leading spaces */
-        sum = strtoul(tar.chksum, NULL, 8);
-        if (sum_u != sum IF_FEATURE_TAR_OLDSUN_COMPATIBILITY(&& sum_s != sum)) {
+        /* Most tarfiles have tar.chksum NUL or space terminated, but
+         * github.com decided to be "special" and have unterminated field:
+         * 0090: 30343300 30303031 33323731 30000000 |043.000132710...|
+         *                                                ^^^^^^^^|
+         * Need to use GET_OCTAL. This overwrites tar.typeflag ---+
+         * (the '0' char immediately after chksum in example above) with NUL.
+         */
+        tar_typeflag = (uint8_t)tar.typeflag; /* save it */
+        sum = GET_OCTAL(tar.chksum);
+        if (sum_u != sum
+            IF_FEATURE_TAR_OLDSUN_COMPATIBILITY(&& sum_s != sum)
+        ) {
                 bb_error_msg_and_die("invalid tar header checksum");
         }
 
-        /* 0 is reserved for high perf file, treat as normal file */
-        if (!tar.typeflag) tar.typeflag = '0';
-        parse_names = (tar.typeflag >= '0' && tar.typeflag <= '7');
-
-        /* getOctal trashes subsequent field, therefore we call it
+        /* GET_OCTAL trashes subsequent field, therefore we call it
          * on fields in reverse order */
         if (tar.devmajor[0]) {
                 char t = tar.prefix[0];
@@ -299,6 +295,11 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
                 file_header->device = makedev(major, minor);
                 tar.prefix[0] = t;
         }
+
+        /* 0 is reserved for high perf file, treat as normal file */
+        if (tar_typeflag == '\0') tar_typeflag = '0';
+        parse_names = (tar_typeflag >= '0' && tar_typeflag <= '7');
+
         file_header->link_target = NULL;
         if (!p_linkname && parse_names && tar.linkname[0]) {
                 file_header->link_target = xstrndup(tar.linkname, sizeof(tar.linkname));
@@ -332,7 +333,7 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
 
         /* Set bits 12-15 of the files mode */
         /* (typeflag was not trashed because chksum does not use getOctal) */
-        switch (tar.typeflag) {
+        switch (tar_typeflag) {
         case '1': /* hardlink */
                 /* we mark hardlinks as regular files with zero size and a link name */
                 file_header->mode |= S_IFREG;
@@ -381,7 +382,7 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
         case 'x': {     /* pax extended header */
                 if ((uoff_t)file_header->size > 0xfffff) /* paranoia */
                         goto skip_ext_hdr;
-                process_pax_hdr(archive_handle, file_header->size, (tar.typeflag == 'g'));
+                process_pax_hdr(archive_handle, file_header->size, (tar_typeflag == 'g'));
                 goto again_after_align;
 #if ENABLE_FEATURE_TAR_GNU_EXTENSIONS
 /* See http://www.gnu.org/software/tar/manual/html_node/Extensions.html */
@@ -419,7 +420,7 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
  skip_ext_hdr:
         {
                 off_t sz;
-                bb_error_msg("warning: skipping header '%c'", tar.typeflag);
+                bb_error_msg("warning: skipping header '%c'", tar_typeflag);
                 sz = (file_header->size + 511) & ~(off_t)511;
                 archive_handle->offset += sz;
                 sz >>= 9; /* sz /= 512 but w/o contortions for signed div */
@@ -429,7 +430,7 @@ char FAST_FUNC get_header_tar(archive_handle_t *archive_handle)
                 goto again_after_align;
         }
         default:
-                bb_error_msg_and_die("unknown typeflag: 0x%x", tar.typeflag);
+                bb_error_msg_and_die("unknown typeflag: 0x%x", tar_typeflag);
         }
 
 #if ENABLE_FEATURE_TAR_GNU_EXTENSIONS
diff --git a/archival/libarchive/lzo1x_d.c b/archival/libarchive/lzo1x_d.c
index 40b167e68..43cf4a04e 100644
--- a/archival/libarchive/lzo1x_d.c
+++ b/archival/libarchive/lzo1x_d.c
@@ -31,8 +31,7 @@
 ************************************************************************/
 /* safe decompression with overrun testing */
 int lzo1x_decompress_safe(const uint8_t* in, unsigned in_len,
-                uint8_t* out, unsigned* out_len,
-                void* wrkmem UNUSED_PARAM)
+                uint8_t* out, unsigned* out_len /*, void* wrkmem */)
 {
         register uint8_t* op;
         register const uint8_t* ip;