jory/upx
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

CI updates

Browse Source
This commit is contained in:
Markus F.X.J. Oberhumer 2025-11-29 15:12:15 +01:00
parent 7a46365296
commit e39f2b2b2f
3 changed files with 184 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -485,7 +485,7 @@ jobs:
export upx_testsuite_SRCDIR="$(readlink -en ../deps/upx-testsuite)"
env -C build/release/Release upx_exe=./upx.exe bash "$PWD"/misc/testsuite/upx_testsuite_1.sh
job-windows-toolchains: # build "by hand" using cmd.exe
job-windows-bh-toolchains: # build "by hand" using cmd.exe
if: github.repository_owner == 'upx'
needs: [ job-rebuild-and-verify-stubs ]
strategy:

198
src/util/membuffer.cpp
View File

@ -87,6 +87,7 @@ MemBuffer::~MemBuffer() noexcept { this->dealloc(); }
// skip == offset, take == size_in_bytes
void *MemBuffer::subref_impl(const char *errfmt, size_t skip, size_t take) {
debug_set(debug.last_return_address_subref, upx_return_address());
checkState();
// check overrun and wrap-around
if (skip + take > size_in_bytes || skip + take < skip) {
char buf[100];
@ -134,13 +135,13 @@ void MemBuffer::allocForDecompression(unsigned uncompressed_size, unsigned extra
debug_set(debug.last_return_address_alloc, upx_return_address());
}
void MemBuffer::fill(unsigned off, unsigned len, int value) {
void MemBuffer::fill(size_t off, size_t bytes, int value) {
debug_set(debug.last_return_address_fill, upx_return_address());
checkState();
if (off > size_in_bytes || len > size_in_bytes || off + len > size_in_bytes)
if (off > size_in_bytes || bytes > size_in_bytes || off + bytes > size_in_bytes)
throwCantPack("MemBuffer::fill out of range; take care!");
if (len > 0)
memset(ptr + off, value, len);
if (bytes > 0)
memset(ptr + off, value, bytes);
}
/*************************************************************************
@ -249,6 +250,17 @@ void MemBuffer::dealloc() noexcept {
//
**************************************************************************/
TEST_CASE("MemBuffer unused 1") {
MemBuffer mb;
(void) mb;
}
TEST_CASE("MemBuffer unused 2") {
MemBuffer mb;
CHECK(mb.raw_ptr() == nullptr);
CHECK(mb.raw_size_in_bytes() == 0);
}
TEST_CASE("MemBuffer core") {
constexpr size_t N = 64;
MemBuffer mb;
@ -292,6 +304,7 @@ TEST_CASE("MemBuffer core") {
}
TEST_CASE("MemBuffer global overloads") {
{
MemBuffer mb1(1);
MemBuffer mb4(4);
mb1.clear();
@ -304,50 +317,145 @@ TEST_CASE("MemBuffer global overloads") {
CHECK_NOTHROW(memset(mb1, 255, 1));
CHECK_THROWS(memset(mb1, 254, 2));
CHECK(mb1[0] == 255);
CHECK_THROWS(get_ne16(mb1));
CHECK_THROWS(get_ne24(mb1));
CHECK_THROWS(get_ne32(mb1));
CHECK_THROWS(get_ne64(mb1));
CHECK_THROWS(get_be16(mb1));
CHECK_THROWS(get_be24(mb1));
CHECK_THROWS(get_be32(mb1));
CHECK_THROWS(get_be64(mb1));
CHECK_THROWS(get_le16(mb1));
CHECK_THROWS(get_le24(mb1));
CHECK_THROWS(get_le32(mb1));
CHECK_THROWS(get_le64(mb1));
CHECK_NOTHROW(get_ne16(mb4));
CHECK_NOTHROW(get_ne24(mb4));
CHECK_NOTHROW(get_ne32(mb4));
CHECK_THROWS(get_ne64(mb4));
CHECK_NOTHROW(get_be16(mb4));
CHECK_NOTHROW(get_be24(mb4));
CHECK_NOTHROW(get_be32(mb4));
CHECK_THROWS(get_be64(mb4));
CHECK_NOTHROW(get_le16(mb4));
CHECK_NOTHROW(get_le24(mb4));
CHECK_NOTHROW(get_le32(mb4));
CHECK_THROWS(get_le64(mb4));
CHECK_NOTHROW(set_ne32(mb4, 0));
CHECK_THROWS(set_ne64(mb4, 0));
CHECK_NOTHROW(set_be32(mb4, 0));
CHECK_THROWS(set_be64(mb4, 0));
CHECK_NOTHROW(set_le32(mb4, 0));
CHECK_THROWS(set_le64(mb4, 0));
}
TEST_CASE("MemBuffer unused 1") {
MemBuffer mb;
(void) mb;
#if DEBUG || 0
for (size_t i = 1; i <= 16; i++) {
MemBuffer mb(i);
mb.clear();
if (i < 2) {
CHECK_THROWS(get_ne16(mb));
CHECK_THROWS(get_be16(mb));
CHECK_THROWS(get_le16(mb));
CHECK_THROWS(set_ne16(mb, 0));
CHECK_THROWS(set_be16(mb, 0));
CHECK_THROWS(set_le16(mb, 0));
} else {
CHECK_NOTHROW(get_ne16(mb));
CHECK_NOTHROW(get_be16(mb));
CHECK_NOTHROW(get_le16(mb));
CHECK_NOTHROW(set_ne16(mb, 0));
CHECK_NOTHROW(set_be16(mb, 0));
CHECK_NOTHROW(set_le16(mb, 0));
}
TEST_CASE("MemBuffer unused 2") {
MemBuffer mb;
CHECK(mb.raw_ptr() == nullptr);
CHECK(mb.raw_size_in_bytes() == 0);
if (i < 3) {
CHECK_THROWS(get_ne24(mb));
CHECK_THROWS(get_be24(mb));
CHECK_THROWS(get_le24(mb));
CHECK_THROWS(set_ne24(mb, 0));
CHECK_THROWS(set_be24(mb, 0));
CHECK_THROWS(set_le24(mb, 0));
} else {
CHECK_NOTHROW(get_ne24(mb));
CHECK_NOTHROW(get_be24(mb));
CHECK_NOTHROW(get_le24(mb));
CHECK_NOTHROW(set_ne24(mb, 0));
CHECK_NOTHROW(set_be24(mb, 0));
CHECK_NOTHROW(set_le24(mb, 0));
}
if (i < 4) {
CHECK_THROWS(get_ne32(mb));
CHECK_THROWS(get_be32(mb));
CHECK_THROWS(get_le32(mb));
CHECK_THROWS(set_ne32(mb, 0));
CHECK_THROWS(set_be32(mb, 0));
CHECK_THROWS(set_le32(mb, 0));
} else {
CHECK_NOTHROW(get_ne32(mb));
CHECK_NOTHROW(get_be32(mb));
CHECK_NOTHROW(get_le32(mb));
CHECK_NOTHROW(set_ne32(mb, 0));
CHECK_NOTHROW(set_be32(mb, 0));
CHECK_NOTHROW(set_le32(mb, 0));
}
if (i < 8) {
CHECK_THROWS(get_ne64(mb));
CHECK_THROWS(get_be64(mb));
CHECK_THROWS(get_le64(mb));
CHECK_THROWS(set_ne64(mb, 0));
CHECK_THROWS(set_be64(mb, 0));
CHECK_THROWS(set_le64(mb, 0));
} else {
CHECK_NOTHROW(get_ne64(mb));
CHECK_NOTHROW(get_be64(mb));
CHECK_NOTHROW(get_le64(mb));
CHECK_NOTHROW(set_ne64(mb, 0));
CHECK_NOTHROW(set_be64(mb, 0));
CHECK_NOTHROW(set_le64(mb, 0));
}
//
CHECK_NOTHROW(mb.subref("", 0, 0));
CHECK_NOTHROW(mb.subref("", 0, i));
CHECK_NOTHROW(mb.subref("", i, 0));
CHECK_NOTHROW(mb.subref("", i - 1, 1));
CHECK_THROWS(mb.subref("", 0, i + 1));
CHECK_THROWS(mb.subref("", i + 1, 0));
CHECK_THROWS(mb.subref("", i, 1));
CHECK_THROWS(mb.subref("", (size_t) -1, 0));
CHECK_THROWS(mb.subref("", (size_t) -1, i));
//
if (i < 2) {
CHECK_THROWS(mb.subref("", 0, sizeof(NE16)));
CHECK_THROWS(mb.subref("", 0, sizeof(BE16)));
CHECK_THROWS(mb.subref("", 0, sizeof(LE16)));
} else {
CHECK_NOTHROW(mb.subref("", 0, sizeof(NE16)));
CHECK_NOTHROW(mb.subref("", 0, sizeof(BE16)));
CHECK_NOTHROW(mb.subref("", 0, sizeof(LE16)));
}
if (i < 4) {
CHECK_THROWS(mb.subref("", 0, sizeof(NE32)));
CHECK_THROWS(mb.subref("", 0, sizeof(BE32)));
CHECK_THROWS(mb.subref("", 0, sizeof(LE32)));
} else {
CHECK_NOTHROW(mb.subref("", 0, sizeof(NE32)));
CHECK_NOTHROW(mb.subref("", 0, sizeof(BE32)));
CHECK_NOTHROW(mb.subref("", 0, sizeof(LE32)));
}
if (i < 8) {
CHECK_THROWS(mb.subref("", 0, sizeof(NE64)));
CHECK_THROWS(mb.subref("", 0, sizeof(BE64)));
CHECK_THROWS(mb.subref("", 0, sizeof(LE64)));
} else {
CHECK_NOTHROW(mb.subref("", 0, sizeof(NE64)));
CHECK_NOTHROW(mb.subref("", 0, sizeof(BE64)));
CHECK_NOTHROW(mb.subref("", 0, sizeof(LE64)));
}
//
CHECK_NOTHROW(mb.subref_u<byte *>("", 0));
CHECK_NOTHROW(mb.subref_u<byte *>("", i - 1));
CHECK_THROWS(mb.subref_u<byte *>("", i));
CHECK_THROWS(mb.subref_u<byte *>("", (size_t) -1));
//
if (i < 2) {
CHECK_THROWS(mb.subref_u<NE16 *>("", 0));
CHECK_THROWS(mb.subref_u<BE16 *>("", 0));
CHECK_THROWS(mb.subref_u<LE16 *>("", 0));
} else {
CHECK_NOTHROW(mb.subref_u<NE16 *>("", 0));
CHECK_NOTHROW(mb.subref_u<BE16 *>("", 0));
CHECK_NOTHROW(mb.subref_u<LE16 *>("", 0));
}
if (i < 4) {
CHECK_THROWS(mb.subref_u<NE32 *>("", 0));
CHECK_THROWS(mb.subref_u<BE32 *>("", 0));
CHECK_THROWS(mb.subref_u<LE32 *>("", 0));
} else {
CHECK_NOTHROW(mb.subref_u<NE32 *>("", 0));
CHECK_NOTHROW(mb.subref_u<BE32 *>("", 0));
CHECK_NOTHROW(mb.subref_u<LE32 *>("", 0));
}
if (i < 8) {
CHECK_THROWS(mb.subref_u<NE64 *>("", 0));
CHECK_THROWS(mb.subref_u<BE64 *>("", 0));
CHECK_THROWS(mb.subref_u<LE64 *>("", 0));
} else {
CHECK_NOTHROW(mb.subref_u<NE64 *>("", 0));
CHECK_NOTHROW(mb.subref_u<BE64 *>("", 0));
CHECK_NOTHROW(mb.subref_u<LE64 *>("", 0));
}
}
#endif
}
TEST_CASE("MemBuffer array access") {

22
src/util/membuffer.h
View File

@ -41,9 +41,9 @@ public:
typedef T element_type;
typedef typename std::add_lvalue_reference<T>::type reference;
typedef typename std::add_pointer<T>::type pointer;
typedef unsigned size_type; // limited by UPX_RSIZE_MAX
typedef pointer iterator;
typedef typename std::add_pointer<const T>::type const_iterator;
typedef unsigned size_type; // limited by UPX_RSIZE_MAX
protected:
static const size_t element_size = sizeof(element_type);
@ -194,11 +194,11 @@ public:
static unsigned getSizeForDecompression(unsigned uncompressed_size, unsigned extra = 0)
may_throw;
void alloc(upx_uint64_t bytes) may_throw;
noinline void alloc(upx_uint64_t bytes) may_throw;
void allocForCompression(unsigned uncompressed_size, unsigned extra = 0) may_throw;
void allocForDecompression(unsigned uncompressed_size, unsigned extra = 0) may_throw;
void dealloc() noexcept;
noinline void dealloc() noexcept;
void checkState() const may_throw;
// explicit conversion
@ -208,8 +208,8 @@ public:
unsigned getSize() const noexcept { return size_in_bytes; } // note: element_size == 1
// util
noinline void fill(unsigned off, unsigned len, int value) may_throw;
forceinline void clear(unsigned off, unsigned len) may_throw { fill(off, len, 0); }
noinline void fill(size_t off, size_t bytes, int value) may_throw;
forceinline void clear(size_t off, size_t bytes) may_throw { fill(off, bytes, 0); }
forceinline void clear() may_throw { fill(0, size_in_bytes, 0); }
// If the entire range [skip, skip+take) is inside the buffer,
@ -219,9 +219,19 @@ public:
forceinline pointer subref(const char *errfmt, size_t skip, size_t take) may_throw {
return (pointer) subref_impl(errfmt, skip, take);
}
template <class U>
forceinline U subref_u(const char *errfmt, size_t skip) may_throw {
COMPILE_TIME_ASSERT(std::is_pointer<U>::value)
return (U) subref_impl(errfmt, skip, sizeof(typename std::remove_pointer<U>::type));
}
template <class U>
forceinline U subref_u(const char *errfmt, size_t skip, size_t take) may_throw {
COMPILE_TIME_ASSERT(std::is_pointer<U>::value)
return (U) subref_impl(errfmt, skip, take);
}
private:
void *subref_impl(const char *errfmt, size_t skip, size_t take) may_throw;
noinline void *subref_impl(const char *errfmt, size_t skip, size_t take) may_throw;
// static debug stats
struct Stats {