/* ctojr.h -- filter CTO implementation; renumber destinations MRU

   This file is part of the UPX executable compressor.

   Copyright (C) 1996-2025 Markus Franz Xaver Johannes Oberhumer
   Copyright (C) 1996-2025 Laszlo Molnar
   Copyright (C) 2000-2025 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: */
