From 794d048bf212074d4bf26c41e2297698c1dc8a39 Mon Sep 17 00:00:00 2001 From: "Markus F.X.J. Oberhumer" Date: Thu, 4 Jan 2001 15:30:45 +0000 Subject: [PATCH] Moved the actual filter implementations into the new filter directory. committer: mfx 978622245 +0000 --- src/fcto_ml.ch | 125 ------ src/filter/ct.h | 390 ++++++++++++++++ src/{fcto_ml3.ch => filter/ctjo.h} | 8 +- src/{fcto_ml2.ch => filter/cto.h} | 8 +- src/filter/ctsw.h | 173 ++++++++ src/filter/sw.h | 188 ++++++++ src/filteri.cpp | 684 ++--------------------------- 7 files changed, 798 insertions(+), 778 deletions(-) delete mode 100644 src/fcto_ml.ch create mode 100644 src/filter/ct.h rename src/{fcto_ml3.ch => filter/ctjo.h} (98%) rename src/{fcto_ml2.ch => filter/cto.h} (98%) create mode 100644 src/filter/ctsw.h create mode 100644 src/filter/sw.h diff --git a/src/fcto_ml.ch b/src/fcto_ml.ch deleted file mode 100644 index 12eb8200..00000000 --- a/src/fcto_ml.ch +++ /dev/null @@ -1,125 +0,0 @@ -/* fcto_ml.ch -- filter CTO implementation - - This file is part of the UPX executable compressor. - - Copyright (C) 1996-2001 Markus Franz Xaver Johannes Oberhumer - Copyright (C) 1996-2001 Laszlo Molnar - 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@jk.uni-linz.ac.at ml1050@cdata.tvnet.hu - */ - - - -/************************************************************************* -// these are not implemented here -**************************************************************************/ - -// filter: e8, e9, e8e9 -#define f_cto32_e8 NULL -#define f_cto32_e9 NULL -#define f_cto32_e8e9 NULL - -// unfilter: e8, e9, e8e9 -#define u_cto32_e8 NULL -#define u_cto32_e9 NULL -#define u_cto32_e8e9 NULL - -// scan: e8, e9, e8e9 -#define s_cto32_e8 NULL -#define s_cto32_e9 NULL -#define s_cto32_e8e9 NULL - -// filter: e8, e9, e8e9 with bswap be->le -#define f_cto32_e8_bswap_be NULL -#define f_cto32_e9_bswap_be NULL -#define f_cto32_e8e9_bswap_be NULL - -// unfilter: e8, e9, e8e9 with bswap be->le -#define u_cto32_e8_bswap_be NULL -#define u_cto32_e9_bswap_be NULL -#define u_cto32_e8e9_bswap_be NULL - -// scan: e8, e9, e8e9 with bswap be->le -#define s_cto32_e8_bswap_be NULL -#define s_cto32_e9_bswap_be NULL -#define s_cto32_e8e9_bswap_be NULL - - -/************************************************************************* -// -**************************************************************************/ - -#define COND(b,x) (b[x] == 0xe8) -#define F f_cto32_e8_bswap_le -#define U u_cto32_e8_bswap_le -#include "fcto_ml2.ch" -#undef U -#undef F -#define F s_cto32_e8_bswap_le -#include "fcto_ml2.ch" -#undef F -#undef COND - -#define COND(b,x) (b[x] == 0xe9) -#define F f_cto32_e9_bswap_le -#define U u_cto32_e9_bswap_le -#include "fcto_ml2.ch" -#undef U -#undef F -#define F s_cto32_e9_bswap_le -#include "fcto_ml2.ch" -#undef F -#undef COND - -#define COND(b,x) (b[x] == 0xe8 || b[x] == 0xe9) -#define F f_cto32_e8e9_bswap_le -#define U u_cto32_e8e9_bswap_le -#include "fcto_ml2.ch" -#undef U -#undef F -#define F s_cto32_e8e9_bswap_le -#include "fcto_ml2.ch" -#undef F -#undef COND - - -/************************************************************************* -// -**************************************************************************/ - -#define COND(b,x,lastcall) \ - (b[x] == 0xe8 || b[x] == 0xe9 \ - || (lastcall!=(x) && 0xf==b[(x)-1] && 0x80<=b[x] && b[x]<=0x8f) ) -#define F f_ctjo32_e8e9_bswap_le -#define U u_ctjo32_e8e9_bswap_le -#include "fcto_ml3.ch" -#undef U -#undef F -#define F s_ctjo32_e8e9_bswap_le -#include "fcto_ml3.ch" -#undef F -#undef COND - - - -/* -vi:ts=4:et -*/ - diff --git a/src/filter/ct.h b/src/filter/ct.h new file mode 100644 index 00000000..807c92d7 --- /dev/null +++ b/src/filter/ct.h @@ -0,0 +1,390 @@ +/* ct.h -- calltrick filter + + This file is part of the UPX executable compressor. + + Copyright (C) 1996-2001 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 1996-2001 Laszlo Molnar + 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@jk.uni-linz.ac.at ml1050@cdata.tvnet.hu + */ + + + +/************************************************************************* +// 16-bit calltrick ("naive") +**************************************************************************/ + +#define CT16(f, cond, addvalue, get, set) \ + upx_byte *b = f->buf; \ + upx_byte *b_end = b + f->buf_len - 3; \ + do { \ + if (cond) \ + { \ + b += 1; \ + unsigned a = (unsigned) (b - f->buf); \ + f->lastcall = a; \ + set(b, get(b) + (addvalue)); \ + f->calls++; \ + b += 2 - 1; \ + } \ + } while (++b < b_end); \ + if (f->lastcall) f->lastcall += 2; \ + return 0; + + + +// filter: e8, e9, e8e9 +static int f_ct16_e8(Filter *f) +{ + CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_le16) +} + +static int f_ct16_e9(Filter *f) +{ + CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_le16) +} + +static int f_ct16_e8e9(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_le16) +} + + +// unfilter: e8, e9, e8e9 +static int u_ct16_e8(Filter *f) +{ + CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_le16, set_le16) +} + +static int u_ct16_e9(Filter *f) +{ + CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_le16, set_le16) +} + +static int u_ct16_e8e9(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le16, set_le16) +} + + +// scan: e8, e9, e8e9 +static int s_ct16_e8(Filter *f) +{ + CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_dummy) +} + +static int s_ct16_e9(Filter *f) +{ + CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_dummy) +} + +static int s_ct16_e8e9(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_dummy) +} + + +// filter: e8, e9, e8e9 with bswap le->be +static int f_ct16_e8_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_be16) +} + +static int f_ct16_e9_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_be16) +} + +static int f_ct16_e8e9_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_be16) +} + + +// unfilter: e8, e9, e8e9 with bswap le->be +static int u_ct16_e8_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_be16, set_le16) +} + +static int u_ct16_e9_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16) +} + +static int u_ct16_e8e9_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16) +} + + +// scan: e8, e9, e8e9 with bswap le->be +static int s_ct16_e8_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe8), a + f->addvalue, get_be16, set_dummy) +} + +static int s_ct16_e9_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe9), a + f->addvalue, get_be16, set_dummy) +} + +static int s_ct16_e8e9_bswap_le(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be16, set_dummy) +} + + +// filter: e8, e9, e8e9 with bswap be->le +static int f_ct16_e8_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe8), a + f->addvalue, get_be16, set_le16) +} + +static int f_ct16_e9_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe9), a + f->addvalue, get_be16, set_le16) +} + +static int f_ct16_e8e9_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be16, set_le16) +} + + +// unfilter: e8, e9, e8e9 with bswap be->le +static int u_ct16_e8_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_le16, set_be16) +} + +static int u_ct16_e9_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_le16, set_be16) +} + +static int u_ct16_e8e9_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le16, set_be16) +} + + +// scan: e8, e9, e8e9 with bswap be->le +static int s_ct16_e8_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_dummy) +} + +static int s_ct16_e9_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_dummy) +} + +static int s_ct16_e8e9_bswap_be(Filter *f) +{ + CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_dummy) +} + + +#undef CT16 + + +/************************************************************************* +// 32-bit calltrick ("naive") +**************************************************************************/ + +#define CT32(f, cond, addvalue, get, set) \ + upx_byte *b = f->buf; \ + upx_byte *b_end = b + f->buf_len - 5; \ + do { \ + if (cond) \ + { \ + b += 1; \ + unsigned a = (unsigned) (b - f->buf); \ + f->lastcall = a; \ + set(b, get(b) + (addvalue)); \ + f->calls++; \ + b += 4 - 1; \ + } \ + } while (++b < b_end); \ + if (f->lastcall) f->lastcall += 4; \ + return 0; + + +// filter: e8, e9, e8e9 +static int f_ct32_e8(Filter *f) +{ + CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_le32) +} + +static int f_ct32_e9(Filter *f) +{ + CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_le32) +} + +static int f_ct32_e8e9(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_le32) +} + + +// unfilter: e8, e9, e8e9 +static int u_ct32_e8(Filter *f) +{ + CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_le32, set_le32) +} + +static int u_ct32_e9(Filter *f) +{ + CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_le32, set_le32) +} + +static int u_ct32_e8e9(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le32, set_le32) +} + + +// scan: e8, e9, e8e9 +static int s_ct32_e8(Filter *f) +{ + CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_dummy) +} + +static int s_ct32_e9(Filter *f) +{ + CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_dummy) +} + +static int s_ct32_e8e9(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_dummy) +} + + +// filter: e8, e9, e8e9 with bswap le->be +static int f_ct32_e8_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_be32) +} + +static int f_ct32_e9_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_be32) +} + +static int f_ct32_e8e9_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_be32) +} + + +// unfilter: e8, e9, e8e9 with bswap le->be +static int u_ct32_e8_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_be32, set_le32) +} + +static int u_ct32_e9_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32) +} + +static int u_ct32_e8e9_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32) +} + + +// scan: e8, e9, e8e9 with bswap le->be +static int s_ct32_e8_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe8), a + f->addvalue, get_be32, set_dummy) +} + +static int s_ct32_e9_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe9), a + f->addvalue, get_be32, set_dummy) +} + +static int s_ct32_e8e9_bswap_le(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be32, set_dummy) +} + + +// filter: e8, e9, e8e9 with bswap be->le +static int f_ct32_e8_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe8), a + f->addvalue, get_be32, set_le32) +} + +static int f_ct32_e9_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe9), a + f->addvalue, get_be32, set_le32) +} + +static int f_ct32_e8e9_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be32, set_le32) +} + + +// unfilter: e8, e9, e8e9 with bswap be->le +static int u_ct32_e8_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_le32, set_be32) +} + +static int u_ct32_e9_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_le32, set_be32) +} + +static int u_ct32_e8e9_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le32, set_be32) +} + + +// scan: e8, e9, e8e9 with bswap be->le +static int s_ct32_e8_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_dummy) +} + +static int s_ct32_e9_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_dummy) +} + +static int s_ct32_e8e9_bswap_be(Filter *f) +{ + CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_dummy) +} + + +#undef CT32 + + +/* +vi:ts=4:et:nowrap +*/ + diff --git a/src/fcto_ml3.ch b/src/filter/ctjo.h similarity index 98% rename from src/fcto_ml3.ch rename to src/filter/ctjo.h index b213d5af..f77fd168 100644 --- a/src/fcto_ml3.ch +++ b/src/filter/ctjo.h @@ -1,4 +1,4 @@ -/* fctl_ml3.ch -- filter CTO implementation +/* ctjo.h -- filter CTO implementation This file is part of the UPX executable compressor. @@ -188,7 +188,11 @@ static int U(Filter *f) #endif +#undef F +#undef U + + /* -vi:ts=4:et +vi:ts=4:et:nowrap */ diff --git a/src/fcto_ml2.ch b/src/filter/cto.h similarity index 98% rename from src/fcto_ml2.ch rename to src/filter/cto.h index e088f42c..37f6f53a 100644 --- a/src/fcto_ml2.ch +++ b/src/filter/cto.h @@ -1,4 +1,4 @@ -/* fctl_ml2.ch -- filter CTO implementation +/* cto.h -- calltrick filter This file is part of the UPX executable compressor. @@ -186,7 +186,11 @@ static int U(Filter *f) #endif +#undef F +#undef U + + /* -vi:ts=4:et +vi:ts=4:et:nowrap */ diff --git a/src/filter/ctsw.h b/src/filter/ctsw.h new file mode 100644 index 00000000..3d386599 --- /dev/null +++ b/src/filter/ctsw.h @@ -0,0 +1,173 @@ +/* ctsw.h -- call-/swaptrick filter + + This file is part of the UPX executable compressor. + + Copyright (C) 1996-2001 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 1996-2001 Laszlo Molnar + 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@jk.uni-linz.ac.at ml1050@cdata.tvnet.hu + */ + + + +/************************************************************************* +// 16-bit call-/swaptrick ("naive") +**************************************************************************/ + +#define CTSW16(f, cond1, cond2, addvalue, get, set) \ + upx_byte *b = f->buf; \ + upx_byte *b_end = b + f->buf_len - 3; \ + do { \ + if (cond1) \ + { \ + b += 1; \ + unsigned a = (unsigned) (b - f->buf); \ + f->lastcall = a; \ + set(b, get(b) + (addvalue)); \ + f->calls++; \ + b += 2 - 1; \ + } \ + else if (cond2) \ + { \ + b += 1; \ + unsigned a = (unsigned) (b - f->buf); \ + f->lastcall = a; \ + set(b, get(b)); \ + f->calls++; \ + b += 2 - 1; \ + } \ + } while (++b < b_end); \ + if (f->lastcall) f->lastcall += 2; \ + return 0; + + +// filter +static int f_ctsw16_e8_e9(Filter *f) +{ + CTSW16(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le16, set_be16) +} + +static int f_ctsw16_e9_e8(Filter *f) +{ + CTSW16(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le16, set_be16) +} + + +// unfilter +static int u_ctsw16_e8_e9(Filter *f) +{ + CTSW16(f, (*b == 0xe8), (*b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16) +} + +static int u_ctsw16_e9_e8(Filter *f) +{ + CTSW16(f, (*b == 0xe9), (*b == 0xe8), 0 - a - f->addvalue, get_be16, set_le16) +} + + +// scan +static int s_ctsw16_e8_e9(Filter *f) +{ + CTSW16(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le16, set_dummy) +} + +static int s_ctsw16_e9_e8(Filter *f) +{ + CTSW16(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le16, set_dummy) +} + + +#undef CTSW16 + + +/************************************************************************* +// 32-bit call-/swaptrick ("naive") +**************************************************************************/ + +#define CTSW32(f, cond1, cond2, addvalue, get, set) \ + upx_byte *b = f->buf; \ + upx_byte *b_end = b + f->buf_len - 5; \ + do { \ + if (cond1) \ + { \ + b += 1; \ + unsigned a = (unsigned) (b - f->buf); \ + f->lastcall = a; \ + set(b, get(b) + (addvalue)); \ + f->calls++; \ + b += 4 - 1; \ + } \ + else if (cond2) \ + { \ + b += 1; \ + unsigned a = (unsigned) (b - f->buf); \ + f->lastcall = a; \ + set(b, get(b)); \ + f->calls++; \ + b += 4 - 1; \ + } \ + } while (++b < b_end); \ + if (f->lastcall) f->lastcall += 4; \ + return 0; + + +// filter +static int f_ctsw32_e8_e9(Filter *f) +{ + CTSW32(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le32, set_be32) +} + +static int f_ctsw32_e9_e8(Filter *f) +{ + CTSW32(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le32, set_be32) +} + + +// unfilter +static int u_ctsw32_e8_e9(Filter *f) +{ + CTSW32(f, (*b == 0xe8), (*b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32) +} + +static int u_ctsw32_e9_e8(Filter *f) +{ + CTSW32(f, (*b == 0xe9), (*b == 0xe8), 0 - a - f->addvalue, get_be32, set_le32) +} + + +// scan +static int s_ctsw32_e8_e9(Filter *f) +{ + CTSW32(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le32, set_dummy) +} + +static int s_ctsw32_e9_e8(Filter *f) +{ + CTSW32(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le32, set_dummy) +} + + +#undef CTSW32 + + +/* +vi:ts=4:et:nowrap +*/ + diff --git a/src/filter/sw.h b/src/filter/sw.h new file mode 100644 index 00000000..5bb9f934 --- /dev/null +++ b/src/filter/sw.h @@ -0,0 +1,188 @@ +/* sw.h -- swaptrick filter + + This file is part of the UPX executable compressor. + + Copyright (C) 1996-2001 Markus Franz Xaver Johannes Oberhumer + Copyright (C) 1996-2001 Laszlo Molnar + 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@jk.uni-linz.ac.at ml1050@cdata.tvnet.hu + */ + + + +/************************************************************************* +// 16-bit swaptrick ("naive") +**************************************************************************/ + +#define SW16(f, cond, get, set) \ + upx_byte *b = f->buf; \ + upx_byte *b_end = b + f->buf_len - 3; \ + do { \ + if (cond) \ + { \ + b += 1; \ + unsigned a = (unsigned) (b - f->buf); \ + f->lastcall = a; \ + set(b, get(b)); \ + f->calls++; \ + b += 2 - 1; \ + } \ + } while (++b < b_end); \ + if (f->lastcall) f->lastcall += 2; \ + return 0; + + +// filter +static int f_sw16_e8(Filter *f) +{ + SW16(f, (*b == 0xe8), get_le16, set_be16) +} + +static int f_sw16_e9(Filter *f) +{ + SW16(f, (*b == 0xe9), get_le16, set_be16) +} + +static int f_sw16_e8e9(Filter *f) +{ + SW16(f, (*b == 0xe8 || *b == 0xe9), get_le16, set_be16) +} + + +// unfilter +static int u_sw16_e8(Filter *f) +{ + SW16(f, (*b == 0xe8), get_be16, set_le16) +} + +static int u_sw16_e9(Filter *f) +{ + SW16(f, (*b == 0xe9), get_be16, set_le16) +} + +static int u_sw16_e8e9(Filter *f) +{ + SW16(f, (*b == 0xe8 || *b == 0xe9), get_be16, set_le16) +} + + +// scan +static int s_sw16_e8(Filter *f) +{ + SW16(f, (*b == 0xe8), get_le16, set_dummy) +} + +static int s_sw16_e9(Filter *f) +{ + SW16(f, (*b == 0xe9), get_le16, set_dummy) +} + +static int s_sw16_e8e9(Filter *f) +{ + SW16(f, (*b == 0xe8 || *b == 0xe9), get_le16, set_dummy) +} + + +#undef SW16 + + + + +/************************************************************************* +// 32-bit swaptrick ("naive") +**************************************************************************/ + +#define SW32(f, cond, get, set) \ + upx_byte *b = f->buf; \ + upx_byte *b_end = b + f->buf_len - 5; \ + do { \ + if (cond) \ + { \ + b += 1; \ + unsigned a = (unsigned) (b - f->buf); \ + f->lastcall = a; \ + set(b, get(b)); \ + f->calls++; \ + b += 4 - 1; \ + } \ + } while (++b < b_end); \ + if (f->lastcall) f->lastcall += 4; \ + return 0; + + +// filter +static int f_sw32_e8(Filter *f) +{ + SW32(f, (*b == 0xe8), get_le32, set_be32) +} + +static int f_sw32_e9(Filter *f) +{ + SW32(f, (*b == 0xe9), get_le32, set_be32) +} + +static int f_sw32_e8e9(Filter *f) +{ + SW32(f, (*b == 0xe8 || *b == 0xe9), get_le32, set_be32) +} + + +// unfilter +static int u_sw32_e8(Filter *f) +{ + SW32(f, (*b == 0xe8), get_be32, set_le32) +} + +static int u_sw32_e9(Filter *f) +{ + SW32(f, (*b == 0xe9), get_be32, set_le32) +} + +static int u_sw32_e8e9(Filter *f) +{ + SW32(f, (*b == 0xe8 || *b == 0xe9), get_be32, set_le32) +} + + +// scan +static int s_sw32_e8(Filter *f) +{ + SW32(f, (*b == 0xe8), get_le32, set_dummy) +} + +static int s_sw32_e9(Filter *f) +{ + SW32(f, (*b == 0xe9), get_le32, set_dummy) +} + +static int s_sw32_e8e9(Filter *f) +{ + SW32(f, (*b == 0xe8 || *b == 0xe9), get_le32, set_dummy) +} + + +#undef SW32 + + + +/* +vi:ts=4:et:nowrap +*/ + diff --git a/src/filteri.cpp b/src/filteri.cpp index 8e3c4180..8d18393e 100644 --- a/src/filteri.cpp +++ b/src/filteri.cpp @@ -34,664 +34,56 @@ /************************************************************************* -// 16-bit calltrick ("naive") +// calltrick / swaptrick **************************************************************************/ -#define CT16(f, cond, addvalue, get, set) \ - upx_byte *b = f->buf; \ - upx_byte *b_end = b + f->buf_len - 3; \ - do { \ - if (cond) \ - { \ - b += 1; \ - unsigned a = (unsigned) (b - f->buf); \ - f->lastcall = a; \ - set(b, get(b) + (addvalue)); \ - f->calls++; \ - b += 2 - 1; \ - } \ - } while (++b < b_end); \ - if (f->lastcall) f->lastcall += 2; \ - return 0; - - - -// filter: e8, e9, e8e9 -static int f_ct16_e8(Filter *f) -{ - CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_le16) -} - -static int f_ct16_e9(Filter *f) -{ - CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_le16) -} - -static int f_ct16_e8e9(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_le16) -} - - -// unfilter: e8, e9, e8e9 -static int u_ct16_e8(Filter *f) -{ - CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_le16, set_le16) -} - -static int u_ct16_e9(Filter *f) -{ - CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_le16, set_le16) -} - -static int u_ct16_e8e9(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le16, set_le16) -} - - -// scan: e8, e9, e8e9 -static int s_ct16_e8(Filter *f) -{ - CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_dummy) -} - -static int s_ct16_e9(Filter *f) -{ - CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_dummy) -} - -static int s_ct16_e8e9(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_dummy) -} - - -// filter: e8, e9, e8e9 with bswap le->be -static int f_ct16_e8_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_be16) -} - -static int f_ct16_e9_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_be16) -} - -static int f_ct16_e8e9_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_be16) -} - - -// unfilter: e8, e9, e8e9 with bswap le->be -static int u_ct16_e8_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_be16, set_le16) -} - -static int u_ct16_e9_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16) -} - -static int u_ct16_e8e9_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16) -} - - -// scan: e8, e9, e8e9 with bswap le->be -static int s_ct16_e8_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe8), a + f->addvalue, get_be16, set_dummy) -} - -static int s_ct16_e9_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe9), a + f->addvalue, get_be16, set_dummy) -} - -static int s_ct16_e8e9_bswap_le(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be16, set_dummy) -} - - -// filter: e8, e9, e8e9 with bswap be->le -static int f_ct16_e8_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe8), a + f->addvalue, get_be16, set_le16) -} - -static int f_ct16_e9_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe9), a + f->addvalue, get_be16, set_le16) -} - -static int f_ct16_e8e9_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be16, set_le16) -} - - -// unfilter: e8, e9, e8e9 with bswap be->le -static int u_ct16_e8_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_le16, set_be16) -} - -static int u_ct16_e9_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_le16, set_be16) -} - -static int u_ct16_e8e9_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le16, set_be16) -} - - -// scan: e8, e9, e8e9 with bswap be->le -static int s_ct16_e8_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_dummy) -} - -static int s_ct16_e9_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_dummy) -} - -static int s_ct16_e8e9_bswap_be(Filter *f) -{ - CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_dummy) -} - - -#undef CT16 +#include "filter/ct.h" +#include "filter/sw.h" +#include "filter/ctsw.h" /************************************************************************* -// 16-bit swaptrick ("naive") +// cto "clever" calltrick **************************************************************************/ -#define SW16(f, cond, get, set) \ - upx_byte *b = f->buf; \ - upx_byte *b_end = b + f->buf_len - 3; \ - do { \ - if (cond) \ - { \ - b += 1; \ - unsigned a = (unsigned) (b - f->buf); \ - f->lastcall = a; \ - set(b, get(b)); \ - f->calls++; \ - b += 2 - 1; \ - } \ - } while (++b < b_end); \ - if (f->lastcall) f->lastcall += 2; \ - return 0; +#define COND(b,x) (b[x] == 0xe8) +#define F f_cto32_e8_bswap_le +#define U u_cto32_e8_bswap_le +#include "filter/cto.h" +#define F s_cto32_e8_bswap_le +#include "filter/cto.h" +#undef COND +#define COND(b,x) (b[x] == 0xe9) +#define F f_cto32_e9_bswap_le +#define U u_cto32_e9_bswap_le +#include "filter/cto.h" +#define F s_cto32_e9_bswap_le +#include "filter/cto.h" +#undef COND -// filter -static int f_sw16_e8(Filter *f) -{ - SW16(f, (*b == 0xe8), get_le16, set_be16) -} - -static int f_sw16_e9(Filter *f) -{ - SW16(f, (*b == 0xe9), get_le16, set_be16) -} - -static int f_sw16_e8e9(Filter *f) -{ - SW16(f, (*b == 0xe8 || *b == 0xe9), get_le16, set_be16) -} - - -// unfilter -static int u_sw16_e8(Filter *f) -{ - SW16(f, (*b == 0xe8), get_be16, set_le16) -} - -static int u_sw16_e9(Filter *f) -{ - SW16(f, (*b == 0xe9), get_be16, set_le16) -} - -static int u_sw16_e8e9(Filter *f) -{ - SW16(f, (*b == 0xe8 || *b == 0xe9), get_be16, set_le16) -} - - -// scan -static int s_sw16_e8(Filter *f) -{ - SW16(f, (*b == 0xe8), get_le16, set_dummy) -} - -static int s_sw16_e9(Filter *f) -{ - SW16(f, (*b == 0xe9), get_le16, set_dummy) -} - -static int s_sw16_e8e9(Filter *f) -{ - SW16(f, (*b == 0xe8 || *b == 0xe9), get_le16, set_dummy) -} - - -#undef SW16 +#define COND(b,x) (b[x] == 0xe8 || b[x] == 0xe9) +#define F f_cto32_e8e9_bswap_le +#define U u_cto32_e8e9_bswap_le +#include "filter/cto.h" +#define F s_cto32_e8e9_bswap_le +#include "filter/cto.h" +#undef COND /************************************************************************* -// 16-bit call-/swaptrick ("naive") -**************************************************************************/ - -#define CTSW16(f, cond1, cond2, addvalue, get, set) \ - upx_byte *b = f->buf; \ - upx_byte *b_end = b + f->buf_len - 3; \ - do { \ - if (cond1) \ - { \ - b += 1; \ - unsigned a = (unsigned) (b - f->buf); \ - f->lastcall = a; \ - set(b, get(b) + (addvalue)); \ - f->calls++; \ - b += 2 - 1; \ - } \ - else if (cond2) \ - { \ - b += 1; \ - unsigned a = (unsigned) (b - f->buf); \ - f->lastcall = a; \ - set(b, get(b)); \ - f->calls++; \ - b += 2 - 1; \ - } \ - } while (++b < b_end); \ - if (f->lastcall) f->lastcall += 2; \ - return 0; - - -// filter -static int f_ctsw16_e8_e9(Filter *f) -{ - CTSW16(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le16, set_be16) -} - -static int f_ctsw16_e9_e8(Filter *f) -{ - CTSW16(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le16, set_be16) -} - - -// unfilter -static int u_ctsw16_e8_e9(Filter *f) -{ - CTSW16(f, (*b == 0xe8), (*b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16) -} - -static int u_ctsw16_e9_e8(Filter *f) -{ - CTSW16(f, (*b == 0xe9), (*b == 0xe8), 0 - a - f->addvalue, get_be16, set_le16) -} - - -// scan -static int s_ctsw16_e8_e9(Filter *f) -{ - CTSW16(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le16, set_dummy) -} - -static int s_ctsw16_e9_e8(Filter *f) -{ - CTSW16(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le16, set_dummy) -} - - -#undef CTSW16 - - -/************************************************************************* -// 32-bit calltrick ("naive") -**************************************************************************/ - -#define CT32(f, cond, addvalue, get, set) \ - upx_byte *b = f->buf; \ - upx_byte *b_end = b + f->buf_len - 5; \ - do { \ - if (cond) \ - { \ - b += 1; \ - unsigned a = (unsigned) (b - f->buf); \ - f->lastcall = a; \ - set(b, get(b) + (addvalue)); \ - f->calls++; \ - b += 4 - 1; \ - } \ - } while (++b < b_end); \ - if (f->lastcall) f->lastcall += 4; \ - return 0; - - -// filter: e8, e9, e8e9 -static int f_ct32_e8(Filter *f) -{ - CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_le32) -} - -static int f_ct32_e9(Filter *f) -{ - CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_le32) -} - -static int f_ct32_e8e9(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_le32) -} - - -// unfilter: e8, e9, e8e9 -static int u_ct32_e8(Filter *f) -{ - CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_le32, set_le32) -} - -static int u_ct32_e9(Filter *f) -{ - CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_le32, set_le32) -} - -static int u_ct32_e8e9(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le32, set_le32) -} - - -// scan: e8, e9, e8e9 -static int s_ct32_e8(Filter *f) -{ - CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_dummy) -} - -static int s_ct32_e9(Filter *f) -{ - CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_dummy) -} - -static int s_ct32_e8e9(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_dummy) -} - - -// filter: e8, e9, e8e9 with bswap le->be -static int f_ct32_e8_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_be32) -} - -static int f_ct32_e9_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_be32) -} - -static int f_ct32_e8e9_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_be32) -} - - -// unfilter: e8, e9, e8e9 with bswap le->be -static int u_ct32_e8_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_be32, set_le32) -} - -static int u_ct32_e9_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32) -} - -static int u_ct32_e8e9_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32) -} - - -// scan: e8, e9, e8e9 with bswap le->be -static int s_ct32_e8_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe8), a + f->addvalue, get_be32, set_dummy) -} - -static int s_ct32_e9_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe9), a + f->addvalue, get_be32, set_dummy) -} - -static int s_ct32_e8e9_bswap_le(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be32, set_dummy) -} - - -// filter: e8, e9, e8e9 with bswap be->le -static int f_ct32_e8_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe8), a + f->addvalue, get_be32, set_le32) -} - -static int f_ct32_e9_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe9), a + f->addvalue, get_be32, set_le32) -} - -static int f_ct32_e8e9_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be32, set_le32) -} - - -// unfilter: e8, e9, e8e9 with bswap be->le -static int u_ct32_e8_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_le32, set_be32) -} - -static int u_ct32_e9_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_le32, set_be32) -} - -static int u_ct32_e8e9_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le32, set_be32) -} - - -// scan: e8, e9, e8e9 with bswap be->le -static int s_ct32_e8_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_dummy) -} - -static int s_ct32_e9_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_dummy) -} - -static int s_ct32_e8e9_bswap_be(Filter *f) -{ - CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_dummy) -} - - -#undef CT32 - - -/************************************************************************* -// 32-bit swaptrick ("naive") -**************************************************************************/ - -#define SW32(f, cond, get, set) \ - upx_byte *b = f->buf; \ - upx_byte *b_end = b + f->buf_len - 5; \ - do { \ - if (cond) \ - { \ - b += 1; \ - unsigned a = (unsigned) (b - f->buf); \ - f->lastcall = a; \ - set(b, get(b)); \ - f->calls++; \ - b += 4 - 1; \ - } \ - } while (++b < b_end); \ - if (f->lastcall) f->lastcall += 4; \ - return 0; - - -// filter -static int f_sw32_e8(Filter *f) -{ - SW32(f, (*b == 0xe8), get_le32, set_be32) -} - -static int f_sw32_e9(Filter *f) -{ - SW32(f, (*b == 0xe9), get_le32, set_be32) -} - -static int f_sw32_e8e9(Filter *f) -{ - SW32(f, (*b == 0xe8 || *b == 0xe9), get_le32, set_be32) -} - - -// unfilter -static int u_sw32_e8(Filter *f) -{ - SW32(f, (*b == 0xe8), get_be32, set_le32) -} - -static int u_sw32_e9(Filter *f) -{ - SW32(f, (*b == 0xe9), get_be32, set_le32) -} - -static int u_sw32_e8e9(Filter *f) -{ - SW32(f, (*b == 0xe8 || *b == 0xe9), get_be32, set_le32) -} - - -// scan -static int s_sw32_e8(Filter *f) -{ - SW32(f, (*b == 0xe8), get_le32, set_dummy) -} - -static int s_sw32_e9(Filter *f) -{ - SW32(f, (*b == 0xe9), get_le32, set_dummy) -} - -static int s_sw32_e8e9(Filter *f) -{ - SW32(f, (*b == 0xe8 || *b == 0xe9), get_le32, set_dummy) -} - - -#undef SW32 - - -/************************************************************************* -// 32-bit call-/swaptrick ("naive") -**************************************************************************/ - -#define CTSW32(f, cond1, cond2, addvalue, get, set) \ - upx_byte *b = f->buf; \ - upx_byte *b_end = b + f->buf_len - 5; \ - do { \ - if (cond1) \ - { \ - b += 1; \ - unsigned a = (unsigned) (b - f->buf); \ - f->lastcall = a; \ - set(b, get(b) + (addvalue)); \ - f->calls++; \ - b += 4 - 1; \ - } \ - else if (cond2) \ - { \ - b += 1; \ - unsigned a = (unsigned) (b - f->buf); \ - f->lastcall = a; \ - set(b, get(b)); \ - f->calls++; \ - b += 4 - 1; \ - } \ - } while (++b < b_end); \ - if (f->lastcall) f->lastcall += 4; \ - return 0; - - -// filter -static int f_ctsw32_e8_e9(Filter *f) -{ - CTSW32(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le32, set_be32) -} - -static int f_ctsw32_e9_e8(Filter *f) -{ - CTSW32(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le32, set_be32) -} - - -// unfilter -static int u_ctsw32_e8_e9(Filter *f) -{ - CTSW32(f, (*b == 0xe8), (*b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32) -} - -static int u_ctsw32_e9_e8(Filter *f) -{ - CTSW32(f, (*b == 0xe9), (*b == 0xe8), 0 - a - f->addvalue, get_be32, set_le32) -} - - -// scan -static int s_ctsw32_e8_e9(Filter *f) -{ - CTSW32(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le32, set_dummy) -} - -static int s_ctsw32_e9_e8(Filter *f) -{ - CTSW32(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le32, set_dummy) -} - - -#undef CTSW32 - - -/************************************************************************* -// 32-bit calltrick with cto ("clever") // -// This version is more sophisticated because it only -// tries to change actual calls and/or jumps. **************************************************************************/ -#undef set_dummy - -#include "fcto_ml.ch" +#define COND(b,x,lastcall) \ + (b[x] == 0xe8 || b[x] == 0xe9 \ + || (lastcall!=(x) && 0xf==b[(x)-1] && 0x80<=b[x] && b[x]<=0x8f) ) +#define F f_ctjo32_e8e9_bswap_le +#define U u_ctjo32_e8e9_bswap_le +#include "filter/ctjo.h" +#define F s_ctjo32_e8e9_bswap_le +#include "filter/ctjo.h" +#undef COND /************************************************************************* @@ -736,15 +128,9 @@ const FilterImp::FilterEntry FilterImp::filters[] = { { 0x1d, 6, 0, f_ctsw32_e8_e9, u_ctsw32_e8_e9, s_ctsw32_e8_e9 }, { 0x1e, 6, 0, f_ctsw32_e9_e8, u_ctsw32_e9_e8, s_ctsw32_e9_e8 }, // 32-bit cto calltrick - { 0x21, 6, 0x00ffffff, f_cto32_e8, u_cto32_e8, s_cto32_e8 }, - { 0x22, 6, 0x00ffffff, f_cto32_e9, u_cto32_e9, s_cto32_e9 }, - { 0x23, 6, 0x00ffffff, f_cto32_e8e9, u_cto32_e8e9, s_cto32_e8e9 }, { 0x24, 6, 0x00ffffff, f_cto32_e8_bswap_le, u_cto32_e8_bswap_le, s_cto32_e8_bswap_le }, { 0x25, 6, 0x00ffffff, f_cto32_e9_bswap_le, u_cto32_e9_bswap_le, s_cto32_e9_bswap_le }, { 0x26, 6, 0x00ffffff, f_cto32_e8e9_bswap_le, u_cto32_e8e9_bswap_le, s_cto32_e8e9_bswap_le }, - { 0x27, 6, 0x00ffffff, f_cto32_e8_bswap_be, u_cto32_e8_bswap_be, s_cto32_e8_bswap_be }, - { 0x28, 6, 0x00ffffff, f_cto32_e9_bswap_be, u_cto32_e9_bswap_be, s_cto32_e9_bswap_be }, - { 0x29, 6, 0x00ffffff, f_cto32_e8e9_bswap_be, u_cto32_e8e9_bswap_be, s_cto32_e8e9_bswap_be }, // 32-bit cto calltrick + jmp { 0x36, 6, 0x00ffffff, f_ctjo32_e8e9_bswap_le, u_ctjo32_e8e9_bswap_le, s_ctjo32_e8e9_bswap_le }, };