Markus F.X.J. Oberhumer
307 lines
11 KiB
C++
307 lines
11 KiB
C++
/* ctojr.h -- filter CTO implementation; renumber destinations MRU
|
|
|
|
This file is part of the UPX executable compressor.
|
|
|
|
Copyright (C) 1996-2023 Markus Franz Xaver Johannes Oberhumer
|
|
Copyright (C) 1996-2023 Laszlo Molnar
|
|
Copyright (C) 2000-2023 John F. Reiser
|
|
All Rights Reserved.
|
|
|
|
UPX and the UCL library are free software; you can redistribute them
|
|
and/or modify them under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of
|
|
the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; see the file COPYING.
|
|
If not, write to the Free Software Foundation, Inc.,
|
|
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
Markus F.X.J. Oberhumer Laszlo Molnar
|
|
<markus@oberhumer.com> <ezerotven+github@gmail.com>
|
|
|
|
John F. Reiser
|
|
<jreiser@users.sourceforge.net>
|
|
*/
|
|
|
|
#if (ACC_CC_MSC && (_MSC_VER >= 1000 && _MSC_VER < 1300))
|
|
#pragma warning(disable : 4702) // W4: unreachable code
|
|
#endif
|
|
|
|
/*************************************************************************
|
|
// filter / scan
|
|
**************************************************************************/
|
|
|
|
#ifdef U //{
|
|
#define NOFILT 0 // no filter
|
|
#define FNOMRU 1 // filter, but not using mru
|
|
#define MRUFLT 2 // mru filter
|
|
|
|
static unsigned f80_call(Filter const *f) { return (1 + (0x0f & f->id)) % 3; }
|
|
|
|
static unsigned f80_jmp1(Filter const *f) { return ((1 + (0x0f & f->id)) / 3) % 3; }
|
|
|
|
static unsigned f80_jcc2(Filter const *f) { return f80_jmp1(f); }
|
|
|
|
#define N_MRU 32 // does not have to be a power of 2
|
|
|
|
// Adaptively remember recent destinations.
|
|
static void update_mru(const unsigned jc, // destination address
|
|
const int kh, // mru[kh] is slot where found
|
|
unsigned mru[N_MRU], // circular buffer of most recent destinations
|
|
int &hand, // mru[hand] is most recent destination
|
|
int &tail // mru[tail] is beyond oldest destination ("cold cache" startup)
|
|
) {
|
|
if (0 > --hand) {
|
|
hand = N_MRU - 1;
|
|
}
|
|
const unsigned t = mru[hand]; // entry which will be overwritten by jc
|
|
if (0 != t) { // have seen at least N_MRU destinations
|
|
mru[kh] = t;
|
|
} else { // "cold cache": keep active region contiguous
|
|
if (0 > --tail) {
|
|
tail = N_MRU - 1;
|
|
}
|
|
const unsigned t2 = mru[tail];
|
|
mru[tail] = 0;
|
|
mru[kh] = t2;
|
|
}
|
|
mru[hand] = jc;
|
|
}
|
|
#endif //}
|
|
|
|
static int F(Filter *f) {
|
|
#ifdef U
|
|
// filter
|
|
byte *const b = f->buf;
|
|
#else
|
|
// scan
|
|
const byte *b = f->buf;
|
|
#endif
|
|
const unsigned size = f->buf_len;
|
|
|
|
unsigned ic, jc, kc;
|
|
unsigned calls = 0, noncalls = 0, noncalls2 = 0;
|
|
unsigned lastnoncall = size, lastcall = 0;
|
|
unsigned wtally[3];
|
|
memset(wtally, 0, sizeof(wtally));
|
|
|
|
#ifdef U //{
|
|
const unsigned f_call = f80_call(f);
|
|
const unsigned f_jmp1 = f80_jmp1(f);
|
|
const unsigned f_jcc2 = f80_jcc2(f);
|
|
|
|
int hand = 0, tail = 0;
|
|
unsigned mru[N_MRU];
|
|
memset(&mru[0], 0, sizeof(mru));
|
|
assert(N_MRU <= 256);
|
|
f->n_mru = (MRUFLT == f_call || MRUFLT == f_jmp1 || MRUFLT == f_jcc2) ? N_MRU : 0;
|
|
#endif //}
|
|
|
|
// FIXME: We must fit into 8 MiB because we steal one bit.
|
|
// find a 16 MiB large empty address space
|
|
{
|
|
int which;
|
|
unsigned char buf[256];
|
|
memset(buf, 0, 256);
|
|
|
|
for (ic = 0; ic < size - 5; ic++)
|
|
if (CONDF(which, b, ic, lastcall) && get_le32(b + ic + 1) + ic + 1 >= size) {
|
|
buf[b[ic + 1]] |= 1;
|
|
}
|
|
UNUSED(which);
|
|
|
|
if (getcto(f, buf) < 0)
|
|
return -1;
|
|
}
|
|
const unsigned char cto8 = f->cto;
|
|
#ifdef U
|
|
const unsigned cto = (unsigned) f->cto << 24;
|
|
#endif
|
|
|
|
for (ic = 0; ic < size - 5; ic++) {
|
|
int which;
|
|
int f_on = 0;
|
|
if (!CONDF(which, b, ic, lastcall))
|
|
continue;
|
|
++wtally[which];
|
|
jc = get_le32(b + ic + 1) + ic + 1;
|
|
// try to detect 'real' calls only
|
|
if (jc < size) {
|
|
#ifdef U
|
|
if (2 == which && NOFILT != f_jcc2) { // 6-byte Jcc <disp32>
|
|
// Prefix 0x0f is constant, but opcode condition 0x80..0x8f
|
|
// varies. Because we store the destination (or its mru index)
|
|
// in be32 big endian format, the low-addressed bytes
|
|
// will tend to be constant. Swap prefix and opcode
|
|
// so that constants are together for better compression.
|
|
unsigned char const t = b[ic - 1];
|
|
b[ic - 1] = b[ic];
|
|
b[ic] = t;
|
|
}
|
|
// FIXME [?]: Extend to 8 bytes if "ADD ESP, byte 4*n" follows CALL.
|
|
// This will require two related cto's (consecutive, or otherwise).
|
|
if ((0 == which && MRUFLT == f_call) || (1 == which && MRUFLT == f_jmp1) ||
|
|
(2 == which && MRUFLT == f_jcc2)) {
|
|
f_on = 1;
|
|
// Recode the destination: narrower mru indices
|
|
// should compress better than wider addresses.
|
|
// (But not when offset of match is unlimited?)
|
|
int k;
|
|
for (k = 0; k < N_MRU; ++k) {
|
|
int kh = hand + k;
|
|
if (N_MRU <= kh) {
|
|
kh -= N_MRU;
|
|
}
|
|
if (mru[kh] == jc) { // destination was seen recently
|
|
set_be32(b + ic + 1, ((k << 1) | 0) + cto);
|
|
update_mru(jc, kh, mru, hand, tail);
|
|
break;
|
|
}
|
|
}
|
|
if (k == N_MRU) { // loop failed; jc is not in mru[]
|
|
set_be32(b + ic + 1, ((jc << 1) | 1) + cto);
|
|
// Adaptively remember recent destinations.
|
|
if (0 > --hand) {
|
|
hand = N_MRU - 1;
|
|
}
|
|
mru[hand] = jc;
|
|
}
|
|
} else if ((0 == which && NOFILT != f_call) || (1 == which && NOFILT != f_jmp1) ||
|
|
(2 == which && NOFILT != f_jcc2)) {
|
|
f_on = 1;
|
|
set_be32(b + ic + 1, jc + cto);
|
|
}
|
|
#endif
|
|
if (f_on) {
|
|
if (ic - lastnoncall < 5) {
|
|
// check the last 4 bytes before this call
|
|
for (kc = 4; kc; kc--)
|
|
if (CONDF(which, b, ic - kc, lastcall) && b[ic - kc + 1] == cto8)
|
|
break;
|
|
if (kc) {
|
|
#ifdef U
|
|
// restore original
|
|
if (2 == which) {
|
|
// Unswap prefix and opcode for 6-byte Jcc <disp32>
|
|
unsigned char const t = b[ic - 1];
|
|
b[ic - 1] = b[ic];
|
|
b[ic] = t;
|
|
}
|
|
set_le32(b + ic + 1, jc - ic - 1);
|
|
#endif
|
|
if (b[ic + 1] == cto8)
|
|
return 1; // fail - buffer not restored
|
|
lastnoncall = ic;
|
|
noncalls2++;
|
|
continue;
|
|
}
|
|
}
|
|
calls++;
|
|
ic += 4;
|
|
lastcall = ic + 1;
|
|
}
|
|
} else {
|
|
assert(b[ic + 1] != cto8); // this should not happen
|
|
lastnoncall = ic;
|
|
noncalls++;
|
|
}
|
|
}
|
|
|
|
f->calls = calls;
|
|
f->noncalls = noncalls;
|
|
f->lastcall = lastcall;
|
|
|
|
#if 0 || defined(TESTING)
|
|
printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",
|
|
calls,noncalls,noncalls2,size,cto8);
|
|
printf("CALL/JMP/JCC %d %d %d\n",wtally[0],wtally[1],wtally[2]);
|
|
#endif
|
|
UNUSED(noncalls2);
|
|
return 0;
|
|
}
|
|
|
|
/*************************************************************************
|
|
// unfilter
|
|
**************************************************************************/
|
|
|
|
#ifdef U
|
|
static int U(Filter *f) {
|
|
unsigned ic, jc;
|
|
|
|
byte *const b = f->buf;
|
|
const unsigned size5 = f->buf_len - 5;
|
|
const unsigned cto = (unsigned) f->cto << 24;
|
|
unsigned lastcall = 0;
|
|
int hand = 0, tail = 0;
|
|
const unsigned f_call = f80_call(f);
|
|
const unsigned f_jmp1 = f80_jmp1(f);
|
|
const unsigned f_jcc2 = f80_jcc2(f);
|
|
|
|
unsigned mru[N_MRU];
|
|
memset(&mru[0], 0, sizeof(mru));
|
|
|
|
for (ic = 0; ic < size5; ic++) {
|
|
int which;
|
|
if (CONDU(which, b, ic, lastcall)) {
|
|
unsigned f_on = 0;
|
|
jc = get_be32(b + ic + 1) - cto;
|
|
if (b[ic + 1] == f->cto) {
|
|
if ((0 == which && MRUFLT == f_call) || (1 == which && MRUFLT == f_jmp1) ||
|
|
(2 == which && MRUFLT == f_jcc2)) {
|
|
f_on = 1;
|
|
if (1 & jc) { // 1st time at this destination
|
|
jc >>= 1;
|
|
if (0 > --hand) {
|
|
hand = N_MRU - 1;
|
|
}
|
|
mru[hand] = jc;
|
|
} else { // not 1st time at this destination
|
|
jc >>= 1;
|
|
if (N_MRU <= jc) {
|
|
throwCompressedDataViolation();
|
|
}
|
|
int kh = jc + hand;
|
|
if (N_MRU <= kh) {
|
|
kh -= N_MRU;
|
|
}
|
|
jc = mru[kh];
|
|
update_mru(jc, kh, mru, hand, tail);
|
|
}
|
|
set_le32(b + ic + 1, jc - ic - 1);
|
|
} else if ((0 == which && NOFILT != f_call) || (1 == which && NOFILT != f_jmp1) ||
|
|
(2 == which && NOFILT != f_jcc2)) {
|
|
f_on = 1;
|
|
set_le32(b + ic + 1, jc - ic - 1);
|
|
}
|
|
if (2 == which && NOFILT != f_jcc2) {
|
|
// Unswap prefix and opcode for 6-byte Jcc <disp32>
|
|
unsigned char const t = b[ic - 1];
|
|
b[ic - 1] = b[ic];
|
|
b[ic] = t;
|
|
}
|
|
|
|
if (f_on) {
|
|
f->calls++;
|
|
ic += 4;
|
|
f->lastcall = lastcall = ic + 1;
|
|
}
|
|
} else
|
|
f->noncalls++;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#undef N_MRU
|
|
#undef F
|
|
#undef U
|
|
|
|
/* vim:set ts=4 sw=4 et: */
|