Mirror
/
upx
mirror of https://github.com/upx/upx.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Various cosmetic updates and refactors. NFCI.

This commit is contained in:
Markus F.X.J. Oberhumer 2021-01-04 17:20:57 +01:00
parent adcd569852
commit f962afe146
20 changed files with 92 additions and 284 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.github/workflows/ci.yml vendored
View File

@ -122,7 +122,7 @@ jobs:
export BUILD_LOCAL_UCL=1 export BUILD_LOCAL_UCL=1
bash ./.github/travis_build.sh bash ./.github/travis_build.sh
- name: 'Run test suite' - name: 'Run test suite using Wine'
run: | run: |
export C=${{matrix.C}} B=${{matrix.B}} T=${{matrix.T}} X=${{matrix.X}} TRAVIS_OS_NAME=linux export C=${{matrix.C}} B=${{matrix.B}} T=${{matrix.T}} X=${{matrix.X}} TRAVIS_OS_NAME=linux
export CROSS=${{matrix.CROSS}} export CROSS=${{matrix.CROSS}}
@ -195,7 +195,7 @@ jobs:
set s=%H%\upx\src set s=%H%\upx\src
cat .GITREV.txt cat .GITREV.txt
set /p GITREV=<.GITREV.txt set /p GITREV=<.GITREV.txt
cl -MT -EHsc -J -O2 -W4 -WX -DUPX_VERSION_GITREV="""%GITREV%""" %DEFS% -DUCL_NO_ASM -I%s%\lzma-sdk -I%H%\deps\ucl-1.03\include -I%H%\deps\zlib-1.2.11 -Feupx.exe %s%\*.cpp %BDIR%\ucl-1.03\ucl.lib %BDIR%\zlib-1.2.11\zlib.lib cl -MT -EHsc -J -O2 -W4 -WX -DUPX_VERSION_GITREV="""%GITREV%""" %DEFS% -I%s%\lzma-sdk -I%H%\deps\ucl-1.03\include -I%H%\deps\zlib-1.2.11 -Feupx.exe %s%\*.cpp %BDIR%\ucl-1.03\ucl.lib %BDIR%\zlib-1.2.11\zlib.lib
- name: 'Basic tests' - name: 'Basic tests'
shell: cmd shell: cmd

129
src/bele.h
View File

@ -31,8 +31,8 @@
// BE - Big Endian // BE - Big Endian
// LE - Little Endian // LE - Little Endian
// NE - Native Endiannes (aka host endianness) // NE - Native Endianness (aka host endianness)
// TE - Target Endiannes // TE - Target Endianness (not used here, see various packers)
/************************************************************************* /*************************************************************************
// core - NE // core - NE
@ -103,7 +103,7 @@ __acc_static_forceinline upx_uint64_t bswap64(upx_uint64_t v)
__acc_static_forceinline constexpr unsigned bswap16(unsigned v) __acc_static_forceinline constexpr unsigned bswap16(unsigned v)
{ {
//return __builtin_bswap16((upx_uint16_t) v); //return __builtin_bswap16((upx_uint16_t) (v & 0xffff));
//return (unsigned) __builtin_bswap64((upx_uint64_t) v << 48); //return (unsigned) __builtin_bswap64((upx_uint64_t) v << 48);
return __builtin_bswap32(v << 16); return __builtin_bswap32(v << 16);
} }
@ -161,56 +161,56 @@ inline unsigned get_be16(const void *p)
return ne16_to_be16(get_ne16(p)); return ne16_to_be16(get_ne16(p));
} }
inline void set_be16(void *p, unsigned v)
{
set_ne16(p, ne16_to_be16(v));
}
inline unsigned get_be32(const void *p) inline unsigned get_be32(const void *p)
{ {
return ne32_to_be32(get_ne32(p)); return ne32_to_be32(get_ne32(p));
} }
inline void set_be32(void *p, unsigned v)
{
set_ne32(p, ne32_to_be32(v));
}
inline upx_uint64_t get_be64(const void *p) inline upx_uint64_t get_be64(const void *p)
{ {
return ne64_to_be64(get_ne64(p)); return ne64_to_be64(get_ne64(p));
} }
inline void set_be64(void *p, upx_uint64_t v)
{
set_ne64(p, ne64_to_be64(v));
}
inline unsigned get_le16(const void *p) inline unsigned get_le16(const void *p)
{ {
return ne16_to_le16(get_ne16(p)); return ne16_to_le16(get_ne16(p));
} }
inline void set_le16(void *p, unsigned v)
{
set_ne16(p, ne16_to_le16(v));
}
inline unsigned get_le32(const void *p) inline unsigned get_le32(const void *p)
{ {
return ne32_to_le32(get_ne32(p)); return ne32_to_le32(get_ne32(p));
} }
inline void set_le32(void *p, unsigned v)
{
set_ne32(p, ne32_to_le32(v));
}
inline upx_uint64_t get_le64(const void *p) inline upx_uint64_t get_le64(const void *p)
{ {
return ne64_to_le64(get_ne64(p)); return ne64_to_le64(get_ne64(p));
} }
inline void set_be16(void *p, unsigned v)
{
set_ne16(p, ne16_to_be16(v));
}
inline void set_be32(void *p, unsigned v)
{
set_ne32(p, ne32_to_be32(v));
}
inline void set_be64(void *p, upx_uint64_t v)
{
set_ne64(p, ne64_to_be64(v));
}
inline void set_le16(void *p, unsigned v)
{
set_ne16(p, ne16_to_le16(v));
}
inline void set_le32(void *p, unsigned v)
{
set_ne32(p, ne32_to_le32(v));
}
inline void set_le64(void *p, upx_uint64_t v) inline void set_le64(void *p, upx_uint64_t v)
{ {
set_ne64(p, ne64_to_le64(v)); set_ne64(p, ne64_to_le64(v));
@ -227,6 +227,12 @@ inline unsigned get_be24(const void *p)
return (b[0] << 16) | (b[1] << 8) | (b[2] << 0); return (b[0] << 16) | (b[1] << 8) | (b[2] << 0);
} }
inline unsigned get_le24(const void *p)
{
const unsigned char *b = ACC_CCAST(const unsigned char *, p);
return (b[0] << 0) | (b[1] << 8) | (b[2] << 16);
}
inline void set_be24(void *p, unsigned v) inline void set_be24(void *p, unsigned v)
{ {
unsigned char *b = ACC_PCAST(unsigned char *, p); unsigned char *b = ACC_PCAST(unsigned char *, p);
@ -235,12 +241,6 @@ inline void set_be24(void *p, unsigned v)
b[2] = ACC_ICONV(unsigned char, (v >> 0) & 0xff); b[2] = ACC_ICONV(unsigned char, (v >> 0) & 0xff);
} }
inline unsigned get_le24(const void *p)
{
const unsigned char *b = ACC_CCAST(const unsigned char *, p);
return (b[0] << 0) | (b[1] << 8) | (b[2] << 16);
}
inline void set_le24(void *p, unsigned v) inline void set_le24(void *p, unsigned v)
{ {
unsigned char *b = ACC_PCAST(unsigned char *, p); unsigned char *b = ACC_PCAST(unsigned char *, p);
@ -258,20 +258,17 @@ inline unsigned get_le26(const void *p)
inline void set_le26(void *p, unsigned v) inline void set_le26(void *p, unsigned v)
{ {
// preserve the top 6 bits // preserve the top 6 bits
#if 0 //set_le32(p, (get_le32(p) & 0xfc000000) | (v & 0x03ffffff));
set_le32(p, (get_le32(p) & 0xfc000000) | (v & 0x03ffffff)); // optimized version, saving a runtime bswap32
#else set_ne32(p, (get_ne32(p) & ne32_to_le32(0xfc000000)) | (ne32_to_le32(v) & ne32_to_le32(0x03ffffff)));
// optimized version, saving a bswap32
set_ne32(p, (get_ne32(p) & ne32_to_le32(0xfc000000)) | ne32_to_le32(v & 0x03ffffff));
#endif
} }
/************************************************************************* /*************************************************************************
// get signed values, i.e. sign-extend // get signed values
**************************************************************************/ **************************************************************************/
inline int sign_extend(unsigned v, unsigned bits) __acc_static_forceinline int sign_extend(unsigned v, unsigned bits)
{ {
const unsigned sign_bit = 1u << (bits - 1); const unsigned sign_bit = 1u << (bits - 1);
v &= sign_bit | (sign_bit - 1); v &= sign_bit | (sign_bit - 1);
@ -279,7 +276,7 @@ inline int sign_extend(unsigned v, unsigned bits)
return ACC_ICAST(int, v); return ACC_ICAST(int, v);
} }
inline upx_int64_t sign_extend(upx_uint64_t v, unsigned bits) __acc_static_forceinline upx_int64_t sign_extend(upx_uint64_t v, unsigned bits)
{ {
const upx_uint64_t sign_bit = UPX_UINT64_C(1) << (bits - 1); const upx_uint64_t sign_bit = UPX_UINT64_C(1) << (bits - 1);
v &= sign_bit | (sign_bit - 1); v &= sign_bit | (sign_bit - 1);
@ -455,6 +452,7 @@ __packed_struct(LE64)
__packed_struct_end() __packed_struct_end()
// native types
#if (ACC_ABI_BIG_ENDIAN) #if (ACC_ABI_BIG_ENDIAN)
typedef BE16 NE16; typedef BE16 NE16;
typedef BE32 NE32; typedef BE32 NE32;
@ -467,45 +465,27 @@ typedef LE64 NE64;
/************************************************************************* /*************************************************************************
// global operators // global operators (pointer addition/subtraction)
**************************************************************************/ **************************************************************************/
template <class T> template <class T> inline T* operator + (T* ptr, const BE16& v) { return ptr + (unsigned) v; }
inline T* operator + (T* ptr, const BE16& v) { return ptr + (unsigned) v; } template <class T> inline T* operator - (T* ptr, const BE16& v) { return ptr - (unsigned) v; }
template <class T>
inline T* operator + (const BE16& v, T* ptr) { return ptr + (unsigned) v; }
template <class T>
inline T* operator - (T* ptr, const BE16& v) { return ptr - (unsigned) v; }
template <class T> template <class T> inline T* operator + (T* ptr, const BE32& v) { return ptr + (unsigned) v; }
inline T* operator + (T* ptr, const BE32& v) { return ptr + (unsigned) v; } template <class T> inline T* operator - (T* ptr, const BE32& v) { return ptr - (unsigned) v; }
template <class T>
inline T* operator + (const BE32& v, T* ptr) { return ptr + (unsigned) v; }
template <class T>
inline T* operator - (T* ptr, const BE32& v) { return ptr - (unsigned) v; }
// these are not implemented on purpose and will cause link-time errors // these are not implemented on purpose and will cause link-time errors
template <class T> T* operator + (T* ptr, const BE64& v); template <class T> T* operator + (T* ptr, const BE64& v);
template <class T> T* operator + (const BE64& v, T* ptr);
template <class T> T* operator - (T* ptr, const BE64& v); template <class T> T* operator - (T* ptr, const BE64& v);
template <class T> template <class T> inline T* operator + (T* ptr, const LE16& v) { return ptr + (unsigned) v; }
inline T* operator + (T* ptr, const LE16& v) { return ptr + (unsigned) v; } template <class T> inline T* operator - (T* ptr, const LE16& v) { return ptr - (unsigned) v; }
template <class T>
inline T* operator + (const LE16& v, T* ptr) { return ptr + (unsigned) v; }
template <class T>
inline T* operator - (T* ptr, const LE16& v) { return ptr - (unsigned) v; }
template <class T> template <class T> inline T* operator + (T* ptr, const LE32& v) { return ptr + (unsigned) v; }
inline T* operator + (T* ptr, const LE32& v) { return ptr + (unsigned) v; } template <class T> inline T* operator - (T* ptr, const LE32& v) { return ptr - (unsigned) v; }
template <class T>
inline T* operator + (const LE32& v, T* ptr) { return ptr + (unsigned) v; }
template <class T>
inline T* operator - (T* ptr, const LE32& v) { return ptr - (unsigned) v; }
// these are not implemented on purpose and will cause link-time errors // these are not implemented on purpose and will cause link-time errors
template <class T> T* operator + (T* ptr, const LE64& v); template <class T> T* operator + (T* ptr, const LE64& v);
template <class T> T* operator + (const LE64& v, T* ptr);
template <class T> T* operator - (T* ptr, const LE64& v); template <class T> T* operator - (T* ptr, const LE64& v);
@ -545,7 +525,7 @@ inline unsigned UPX_MIN(const LE32& a, unsigned b) { return UPX_MIN((unsigned
/************************************************************************* /*************************************************************************
// misc // misc support
**************************************************************************/ **************************************************************************/
// for use with qsort() // for use with qsort()
@ -591,22 +571,23 @@ extern const BEPolicy be_policy;
extern const LEPolicy le_policy; extern const LEPolicy le_policy;
} }
// implementation
namespace N_BELE_CTP { namespace N_BELE_CTP {
#define BELE_CTP 1 #define BELE_CTP 1
#include "bele_policy.h" #include "bele_policy.h"
#undef BELE_CTP #undef BELE_CTP
} }
namespace N_BELE_RTP { namespace N_BELE_RTP {
#define BELE_RTP 1 #define BELE_RTP 1
#include "bele_policy.h" #include "bele_policy.h"
#undef BELE_RTP #undef BELE_RTP
} }
// util
namespace N_BELE_CTP { namespace N_BELE_CTP {
inline const N_BELE_RTP::AbstractPolicy* getRTP(const BEPolicy*) inline const N_BELE_RTP::AbstractPolicy* getRTP(const BEPolicy * /*dummy*/)
{ return &N_BELE_RTP::be_policy; } { return &N_BELE_RTP::be_policy; }
inline const N_BELE_RTP::AbstractPolicy* getRTP(const LEPolicy*) inline const N_BELE_RTP::AbstractPolicy* getRTP(const LEPolicy * /*dummy*/)
{ return &N_BELE_RTP::le_policy; } { return &N_BELE_RTP::le_policy; }
} }

7
src/bele_policy.h
View File

@ -84,7 +84,7 @@ struct AbstractPolicy
S u64_compare_signed(const void *a, const void *b) C = 0; S u64_compare_signed(const void *a, const void *b) C = 0;
// disable dynamic allocation // disable dynamic allocation
DISABLE_NEW_DELETE ACC_CXX_DISABLE_NEW_DELETE
}; };
#endif #endif
@ -162,7 +162,7 @@ struct BEPolicy
} }
// disable dynamic allocation // disable dynamic allocation
DISABLE_NEW_DELETE ACC_CXX_DISABLE_NEW_DELETE
}; };
@ -239,10 +239,11 @@ struct LEPolicy
} }
// disable dynamic allocation // disable dynamic allocation
DISABLE_NEW_DELETE ACC_CXX_DISABLE_NEW_DELETE
}; };
// native policy (aka host policy)
#if (ACC_ABI_BIG_ENDIAN) #if (ACC_ABI_BIG_ENDIAN)
typedef BEPolicy HostPolicy; typedef BEPolicy HostPolicy;
#elif (ACC_ABI_LITTLE_ENDIAN) #elif (ACC_ABI_LITTLE_ENDIAN)

2
src/bptr.h
View File

@ -97,7 +97,7 @@ private:
// disable copy // disable copy
BoundedPtr(const BoundedPtr&) = delete; BoundedPtr(const BoundedPtr&) = delete;
// disable dynamic allocation // disable dynamic allocation
DISABLE_NEW_DELETE ACC_CXX_DISABLE_NEW_DELETE
}; };

30
src/compress_ucl.cpp
View File

@ -28,34 +28,6 @@
#include "conf.h" #include "conf.h"
#include "compress.h" #include "compress.h"
#if !(WITH_UCL)
extern int compress_ucl_dummy;
int compress_ucl_dummy = 0;
#else
#if 1 && !(UCL_USE_ASM) && (ACC_ARCH_I386)
# if (ACC_CC_CLANG || ACC_CC_GNUC || ACC_CC_INTELC || ACC_CC_MSC || ACC_CC_WATCOMC)
# define UCL_USE_ASM 1
# endif
#endif
#if (UCL_NO_ASM)
# undef UCL_USE_ASM
#endif
#if (ACC_CFG_NO_UNALIGNED)
# undef UCL_USE_ASM
#endif
#if 1 && (UCL_USE_ASM)
# include <ucl/ucl_asm.h>
# define ucl_nrv2b_decompress_safe_8 ucl_nrv2b_decompress_asm_safe_8
# define ucl_nrv2b_decompress_safe_le16 ucl_nrv2b_decompress_asm_safe_le16
# define ucl_nrv2b_decompress_safe_le32 ucl_nrv2b_decompress_asm_safe_le32
# define ucl_nrv2d_decompress_safe_8 ucl_nrv2d_decompress_asm_safe_8
# define ucl_nrv2d_decompress_safe_le16 ucl_nrv2d_decompress_asm_safe_le16
# define ucl_nrv2d_decompress_safe_le32 ucl_nrv2d_decompress_asm_safe_le32
# define ucl_nrv2e_decompress_safe_8 ucl_nrv2e_decompress_asm_safe_8
# define ucl_nrv2e_decompress_safe_le16 ucl_nrv2e_decompress_asm_safe_le16
# define ucl_nrv2e_decompress_safe_le32 ucl_nrv2e_decompress_asm_safe_le32
#endif
/************************************************************************* /*************************************************************************
@ -315,6 +287,4 @@ unsigned upx_ucl_crc32(const void *buf, unsigned len, unsigned crc)
} }
#endif #endif
#endif /* WITH_UCL */
/* vim:set ts=4 sw=4 et: */ /* vim:set ts=4 sw=4 et: */

11
src/compress_zlib.cpp
View File

@ -29,6 +29,7 @@
#include "conf.h" #include "conf.h"
#include "compress.h" #include "compress.h"
#include "mem.h" #include "mem.h"
#include <zlib.h>
void zlib_compress_config_t::reset() void zlib_compress_config_t::reset()
@ -41,14 +42,6 @@ void zlib_compress_config_t::reset()
} }
#if !(WITH_ZLIB)
extern int compress_zlib_dummy;
int compress_zlib_dummy = 0;
#else
#include <zlib.h>
static int convert_errno_from_zlib(int zr) static int convert_errno_from_zlib(int zr)
{ {
switch (zr) switch (zr)
@ -251,6 +244,4 @@ unsigned upx_zlib_crc32(const void *buf, unsigned len, unsigned crc)
#endif #endif
#endif /* WITH_ZLIB */
/* vim:set ts=4 sw=4 et: */ /* vim:set ts=4 sw=4 et: */

37
src/conf.h
View File

@ -76,6 +76,7 @@ ACC_COMPILE_TIME_ASSERT_HEADER(((int)(1u << 31)) >> 31 == -1) // arithmetic righ
ACC_COMPILE_TIME_ASSERT_HEADER(CHAR_MAX == 255) // -funsigned-char ACC_COMPILE_TIME_ASSERT_HEADER(CHAR_MAX == 255) // -funsigned-char
ACC_COMPILE_TIME_ASSERT_HEADER((char)(-1) > 0) // -funsigned-char ACC_COMPILE_TIME_ASSERT_HEADER((char)(-1) > 0) // -funsigned-char
// enable/disable some warnings
#if (ACC_CC_GNUC >= 0x040700) #if (ACC_CC_GNUC >= 0x040700)
# pragma GCC diagnostic error "-Wzero-as-null-pointer-constant" # pragma GCC diagnostic error "-Wzero-as-null-pointer-constant"
#endif #endif
@ -89,14 +90,6 @@ ACC_COMPILE_TIME_ASSERT_HEADER((char)(-1) > 0) // -funsigned-char
# pragma warning(disable: 4820) // padding added after data member # pragma warning(disable: 4820) // padding added after data member
#endif #endif
// FIXME - quick hack for arm-wince-gcc-3.4 (Debian pocketpc-*.deb packages)
#if 1 && (ACC_ARCH_ARM) && defined(__pe__) && !defined(__CEGCC__) && !defined(_WIN32)
# undef HAVE_CHMOD
# undef HAVE_CHOWN
# undef HAVE_LSTAT
# undef HAVE_UTIME
#endif
#define ACC_WANT_ACC_INCD_H 1 #define ACC_WANT_ACC_INCD_H 1
#define ACC_WANT_ACC_INCE_H 1 #define ACC_WANT_ACC_INCE_H 1
#define ACC_WANT_ACC_LIB_H 1 #define ACC_WANT_ACC_LIB_H 1
@ -457,12 +450,6 @@ private:
#define UPX_F_VMLINUX_PPC64 141 #define UPX_F_VMLINUX_PPC64 141
#define UPX_F_DYLIB_PPC64 142 #define UPX_F_DYLIB_PPC64 142
// compression methods
#define M_ALL (-1)
#define M_END (-2)
#define M_NONE (-3)
#define M_SKIP (-4)
#define M_ULTRA_BRUTE (-5)
// compression methods - DO NOT CHANGE // compression methods - DO NOT CHANGE
#define M_NRV2B_LE32 2 #define M_NRV2B_LE32 2
#define M_NRV2B_8 3 #define M_NRV2B_8 3
@ -478,6 +465,12 @@ private:
//#define M_CL1B_LE16 13 //#define M_CL1B_LE16 13
#define M_LZMA 14 #define M_LZMA 14
#define M_DEFLATE 15 /* zlib */ #define M_DEFLATE 15 /* zlib */
// compression methods internal usage
#define M_ALL (-1)
#define M_END (-2)
#define M_NONE (-3)
#define M_SKIP (-4)
#define M_ULTRA_BRUTE (-5)
#define M_IS_NRV2B(x) ((x) >= M_NRV2B_LE32 && (x) <= M_NRV2B_LE16) #define M_IS_NRV2B(x) ((x) >= M_NRV2B_LE32 && (x) <= M_NRV2B_LE16)
#define M_IS_NRV2D(x) ((x) >= M_NRV2D_LE32 && (x) <= M_NRV2D_LE16) #define M_IS_NRV2D(x) ((x) >= M_NRV2D_LE32 && (x) <= M_NRV2D_LE16)
@ -670,13 +663,11 @@ struct upx_compress_result_t
**************************************************************************/ **************************************************************************/
#include "snprintf.h" // must get included first! #include "snprintf.h" // must get included first!
#include "stdcxx.h"
#include "options.h"
#include "except.h"
#include "bele.h"
#include "util.h"
#include "console.h"
#include <exception>
#include <new>
#include <type_traits>
#include <typeinfo>
ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<short, upx_int16_t>::value)) ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<short, upx_int16_t>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<unsigned short, upx_uint16_t>::value)) ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<unsigned short, upx_uint16_t>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<int, upx_int32_t>::value)) ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<int, upx_int32_t>::value))
@ -684,6 +675,12 @@ ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<unsigned, upx_uint32_t>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<long long, upx_int64_t>::value)) ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<long long, upx_int64_t>::value))
ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<unsigned long long, upx_uint64_t>::value)) ACC_COMPILE_TIME_ASSERT_HEADER((std::is_same<unsigned long long, upx_uint64_t>::value))
#include "options.h"
#include "except.h"
#include "bele.h"
#include "util.h"
#include "console.h"
// classes // classes
class ElfLinker; class ElfLinker;

2
src/except.h
View File

@ -59,7 +59,7 @@ private:
// disable assignment // disable assignment
Throwable& operator= (const Throwable &); Throwable& operator= (const Throwable &);
// disable dynamic allocation // disable dynamic allocation
DISABLE_NEW_DELETE ACC_CXX_DISABLE_NEW_DELETE
private: private:
static unsigned long counter; // for debugging static unsigned long counter; // for debugging

4
src/main.cpp
View File

@ -1404,7 +1404,7 @@ void upx_compiler_sanity_check(void)
} }
{ {
unsigned dd; unsigned dd;
void *d = &dd; void * const d = &dd;
dd = ne32_to_le32(0xf7f6f5f4); dd = ne32_to_le32(0xf7f6f5f4);
assert(get_le26(d) == 0x03f6f5f4); assert(get_le26(d) == 0x03f6f5f4);
set_le26(d, 0); set_le26(d, 0);
@ -1423,7 +1423,7 @@ void upx_compiler_sanity_check(void)
assert(testNoAliasing(&u.v_short, &u.l32)); assert(testNoAliasing(&u.v_short, &u.l32));
assert(testNoAliasing(&u.v_int, &u.b64)); assert(testNoAliasing(&u.v_int, &u.b64));
assert(testNoAliasing(&u.v_int, &u.l64)); assert(testNoAliasing(&u.v_int, &u.l64));
#if 0 #if 1
// check working -fno-strict-aliasing // check working -fno-strict-aliasing
assert(testNoAliasing(&u.v_short, &u.v_int)); assert(testNoAliasing(&u.v_short, &u.v_int));
assert(testNoAliasing(&u.v_int, &u.v_long)); assert(testNoAliasing(&u.v_int, &u.v_long));

2
src/mem.h
View File

@ -80,7 +80,7 @@ private:
MemBuffer& operator= (const MemBuffer &) = delete; MemBuffer& operator= (const MemBuffer &) = delete;
// disable dynamic allocation // disable dynamic allocation
DISABLE_NEW_DELETE ACC_CXX_DISABLE_NEW_DELETE
}; };
#endif /* already included */ #endif /* already included */

2
src/packer.cpp
View File

@ -753,7 +753,7 @@ bool Packer::getPackHeader(void *b, int blen, bool allow_incompressible)
bool Packer::readPackHeader(int len, bool allow_incompressible) bool Packer::readPackHeader(int len, bool allow_incompressible)
{ {
assert((int)len > 0); assert(len > 0);
MemBuffer buf(len); MemBuffer buf(len);
len = fi->read(buf, len); len = fi->read(buf, len);
if (len <= 0) if (len <= 0)

2
src/packer.h
View File

@ -49,7 +49,7 @@ class PackHeader
friend class Packer; friend class Packer;
private: private:
// these are strictly private to Packer and not accessible in subclasses: // these are strictly private to Packer and not accessible in subclasses
PackHeader(); PackHeader();
void putPackHeader(upx_bytep p); void putPackHeader(upx_bytep p);

7
src/packer_c.cpp
View File

@ -38,13 +38,8 @@
bool Packer::isValidCompressionMethod(int method) bool Packer::isValidCompressionMethod(int method)
{ {
if (M_IS_LZMA(method)) { if (M_IS_LZMA(method))
#if !(WITH_LZMA)
assert(0 && "Internal error - LZMA not compiled in");
#else
return true; return true;
#endif
}
return (method >= M_NRV2B_LE32 && method <= M_LZMA); return (method >= M_NRV2B_LE32 && method <= M_LZMA);
} }

2
src/snprintf.cpp
View File

@ -900,7 +900,7 @@ int main(void)
"%d", "%d",
nullptr nullptr
}; };
const long int_nums[] = { -1, 134, 91340, 341, 0203, 0 }; const int int_nums[] = { -1, 134, 91340, 341, 0203, 0 };
const char *str_fmt[] = { const char *str_fmt[] = {
"10.5s", "10.5s",
"5.10s", "5.10s",

2
src/snprintf.h
View File

@ -70,7 +70,7 @@ inline int strcasecmp(const unsigned char *s1, const unsigned char *s2) {
return strcasecmp((const char *) s1, (const char *) s2); return strcasecmp((const char *) s1, (const char *) s2);
} }
inline size_t strlen(const unsigned char *s) { return strlen((const char *) s); } inline upx_rsize_t upx_strlen(const unsigned char *s) { return upx_strlen((const char *) s); }
#endif /* already included */ #endif /* already included */

46
src/stdcxx.cpp
View File

@ -1,46 +0,0 @@
/* stdcxx.cpp --
This file is part of the UPX executable compressor.
Copyright (C) 1996-2021 Markus Franz Xaver Johannes Oberhumer
Copyright (C) 1996-2021 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.com> <ezerotven+github@gmail.com>
*/
#include "conf.h"
#include "stdcxx.h"
#if 1 && defined(__linux__) && (ACC_CC_GNUC >= 0x030400)
/* this is used by __gnu_cxx::__verbose_terminate_handler() */
extern "C" {
char *__attribute__((__weak__)) __cxa_demangle(const char *, char *, size_t *, int *);
char *__cxa_demangle(const char *mangled_name, char *buf, size_t *n, int *status) {
UNUSED(mangled_name);
UNUSED(buf);
UNUSED(n);
if (status)
*status = -1; /* memory_allocation_failure */
return nullptr;
}
} /* extern "C" */
#endif
/* vim:set ts=4 sw=4 et: */

56
src/stdcxx.h
View File

@ -1,56 +0,0 @@
/* stdcxx.h --
This file is part of the UPX executable compressor.
Copyright (C) 1996-2021 Markus Franz Xaver Johannes Oberhumer
Copyright (C) 1996-2021 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.com> <ezerotven+github@gmail.com>
*/
#ifndef __UPX_STDCXX_H
#define __UPX_STDCXX_H 1
#ifdef __cplusplus
#define DISABLE_NEW_DELETE ACC_CXX_DISABLE_NEW_DELETE
/*************************************************************************
// exceptions & RTTI
**************************************************************************/
#include <exception>
#include <new>
#include <type_traits>
#include <typeinfo>
/*************************************************************************
// STL
**************************************************************************/
#ifdef WANT_STL
#error "WANT_STL"
#endif /* WANT_STL */
#endif /* __cplusplus */
#endif /* already included */
/* vim:set ts=4 sw=4 et: */

2
src/ui.cpp
View File

@ -1,4 +1,4 @@
/* ui.cpp -- /* ui.cpp -- User Interface
This file is part of the UPX executable compressor. This file is part of the UPX executable compressor.

3
src/ui.h
View File

@ -1,4 +1,4 @@
/* ui.h -- /* ui.h -- User Interface
This file is part of the UPX executable compressor. This file is part of the UPX executable compressor.
@ -51,7 +51,6 @@ public:
static void uiTestTotal(); static void uiTestTotal();
static void uiFileInfoTotal(); static void uiFileInfoTotal();
public:
virtual void uiPackStart(const OutputFile *fo); virtual void uiPackStart(const OutputFile *fo);
virtual void uiPackEnd(const OutputFile *fo); virtual void uiPackEnd(const OutputFile *fo);
virtual void uiUnpackStart(const OutputFile *fo); virtual void uiUnpackStart(const OutputFile *fo);

26
src/util.cpp
View File

@ -46,6 +46,7 @@
/************************************************************************* /*************************************************************************
// assert sane memory buffer sizes to protect against integer overflows // assert sane memory buffer sizes to protect against integer overflows
// and malicious header fields // and malicious header fields
// see C 11 standard, Annex K
**************************************************************************/ **************************************************************************/
ACC_COMPILE_TIME_ASSERT_HEADER(UPX_RSIZE_MAX_MEM == UPX_RSIZE_MAX) ACC_COMPILE_TIME_ASSERT_HEADER(UPX_RSIZE_MAX_MEM == UPX_RSIZE_MAX)
@ -517,29 +518,4 @@ unsigned get_ratio(upx_uint64_t u_len, upx_uint64_t c_len) {
return ACC_ICONV(unsigned, x); return ACC_ICONV(unsigned, x);
} }
/*************************************************************************
// Don't link these functions from libc ==> save xxx bytes
**************************************************************************/
extern "C" {
// FIXME - quick hack for arm-wince-gcc-3.4 (Debian pocketpc-*.deb packages)
#if 1 && (ACC_ARCH_ARM) && defined(__pe__) && !defined(__CEGCC__) && !defined(_WIN32)
int dup(int fd) {
UNUSED(fd);
return -1;
}
#endif
#if (ACC_OS_DOS32) && defined(__DJGPP__)
// int _is_executable(const char *, int, const char *) { return 0; }
// FIXME: something wants to link in ctime.o
// time_t mktime(struct tm *) { return 0; }
// time_t time(time_t *t) { if (t) *t = 0; return 0; }
#endif
} // extern "C"
/* vim:set ts=4 sw=4 et: */ /* vim:set ts=4 sw=4 et: */