CI updates

.github/workflows/ci.yml

@@ -633,9 +633,9 @@ jobs:
           - { zig_target: x86_64-windows-gnu }
     name: ${{ format('zigcc {0} {1}', matrix.zig_target, matrix.zig_pic) }}
     runs-on: ubuntu-latest
-    container: ${{ matrix.container || 'alpine:3.22' }}
+    container: ${{ matrix.container || 'alpine:3.23' }}
     env:
-      container: ${{ matrix.container || 'alpine:3.22' }}
+      container: ${{ matrix.container || 'alpine:3.23' }}
       UPX_CONFIG_HAVE_WORKING_BUILD_RPATH: ''
       # for zig-cc wrapper scripts (see below):
       ZIG_CPPFLAGS: -DUPX_DOCTEST_CONFIG_MULTITHREADING

src/pefile.cpp

@@ -1736,9 +1736,7 @@ PeFile::Resource::upx_rnode *PeFile::Resource::convert(const void *rnode, upx_rn
     branch->name = nullptr;
     branch->parent = parent;
     branch->nc = ic;
-    branch->children = New(upx_rnode *, ic);
+    branch->children = New0(upx_rnode *, ic);
-    // NOLINTNEXTLINE(bugprone-multi-level-implicit-pointer-conversion)
-    memset(branch->children, 0, sizeof(upx_rnode *) * ic);
     branch->data = *node;
     if (!root)         // first one
         root = branch; // prevent leak if xcheck throws (hacked unpack or test)

src/util/cxxlib.h

@@ -623,10 +623,10 @@ struct TriBool final {
     static constexpr bool is_third_true = IsThirdTrue;
     // types
     typedef T underlying_type;
-    static_assert(std::is_integral_v<underlying_type>);
     typedef decltype(T(0) + T(0)) promoted_type;
-    static_assert(std::is_integral_v<promoted_type>);
     enum value_type : underlying_type { False = 0, True = 1, Third = 2 };
+    static_assert(std::is_integral_v<underlying_type>);
+    static_assert(std::is_integral_v<promoted_type>);
     static_assert(sizeof(value_type) == sizeof(underlying_type));
     static_assert(sizeof(underlying_type) <= sizeof(promoted_type));
     // constructors

src/util/util.cpp

@@ -71,7 +71,7 @@ bool mem_size_valid(upx_uint64_t element_size, upx_uint64_t n, upx_uint64_t extr
 }
 
 upx_rsize_t mem_size(upx_uint64_t element_size, upx_uint64_t n, upx_uint64_t extra1,
-                     upx_uint64_t extra2) {
+                     upx_uint64_t extra2) may_throw {
     assert(element_size > 0);
     if very_unlikely (element_size == 0 || element_size > UPX_RSIZE_MAX)
         throwCantPack("mem_size 1; take care");
@@ -144,7 +144,8 @@ TEST_CASE("ptr_diff") {
 }
 
 // check that 2 buffers do not overlap; will throw on error
-void ptraddr_check_no_overlap(upx_ptraddr_t a, size_t a_size, upx_ptraddr_t b, size_t b_size) {
+void ptraddr_check_no_overlap(upx_ptraddr_t a, size_t a_size, upx_ptraddr_t b, size_t b_size)
+    may_throw {
     if very_unlikely (a == 0 || b == 0)
         throwCantPack("ptr_check_no_overlap-nullptr");
     upx_ptraddr_t a_end = a + mem_size(1, a_size);
@@ -160,7 +161,7 @@ void ptraddr_check_no_overlap(upx_ptraddr_t a, size_t a_size, upx_ptraddr_t b, s
 
 // check that 3 buffers do not overlap; will throw on error
 void ptraddr_check_no_overlap(upx_ptraddr_t a, size_t a_size, upx_ptraddr_t b, size_t b_size,
-                              upx_ptraddr_t c, size_t c_size) {
+                              upx_ptraddr_t c, size_t c_size) may_throw {
     if very_unlikely (a == 0 || b == 0 || c == 0)
         throwCantPack("ptr_check_no_overlap-nullptr");
     upx_ptraddr_t a_end = a + mem_size(1, a_size);
@@ -253,6 +254,14 @@ TEST_CASE("ptr_check_no_overlap 3") {
 // stdlib
 **************************************************************************/
 
+void *upx_calloc(size_t n, size_t element_size) may_throw {
+    const upx_rsize_t bytes = mem_size(element_size, n); // assert size
+    void *p = ::malloc(bytes);
+    if (p != nullptr && bytes > 0)
+        memset(p, 0, bytes);
+    return p;
+}
+
 const char *upx_getenv(const char *envvar) noexcept {
     if (envvar != nullptr && envvar[0])
         return ::getenv(envvar);
@@ -282,14 +291,6 @@ void upx_rand_init() noexcept {
     ::srand(seed);
 }
 
-void *upx_calloc(size_t n, size_t element_size) may_throw {
-    size_t bytes = mem_size(element_size, n); // assert size
-    void *p = ::malloc(bytes);
-    if (p != nullptr)
-        memset(p, 0, bytes);
-    return p;
-}
-
 // simple unoptimized memswap()
 // TODO later: CHERI clang-14 bug/miscompilation with upx_memswap(); or
 //   maybe caused by tagged-memory issues ???

src/util/util.h

@@ -67,13 +67,12 @@ inline void mem_size_assert(upx_uint64_t element_size, upx_uint64_t n) may_throw
 }
 
 // "new" with asserted size; will throw on invalid size
-#if DEBUG
 template <class T>
-T *NewArray(upx_uint64_t n) may_throw {
+inline T *NewT(upx_uint64_t n) may_throw {
     COMPILE_TIME_ASSERT(std::is_standard_layout<T>::value)
     COMPILE_TIME_ASSERT(std::is_trivially_copyable<T>::value)
     COMPILE_TIME_ASSERT(std::is_trivially_default_constructible<T>::value)
-    upx_rsize_t bytes = mem_size(sizeof(T), n); // assert size
+    const upx_rsize_t bytes = mem_size(sizeof(T), n); // assert size
     T *array = new T[size_t(n)];
 #if !defined(__SANITIZE_MEMORY__)
     if (array != nullptr && bytes > 0) {
@@ -84,11 +83,25 @@ T *NewArray(upx_uint64_t n) may_throw {
     UNUSED(bytes);
     return array;
 }
-#define New(type, n) (NewArray<type>((n)))
+#if DEBUG || 1
+#define New(type, n) (NewT<type>((n)))
 #else
 #define New(type, n) new type[mem_size_get_n(sizeof(type), (n))]
 #endif
 
+template <class T>
+inline T *New0T(upx_uint64_t n) may_throw {
+    COMPILE_TIME_ASSERT(std::is_standard_layout<T>::value)
+    COMPILE_TIME_ASSERT(std::is_trivially_copyable<T>::value)
+    COMPILE_TIME_ASSERT(std::is_trivially_default_constructible<T>::value)
+    const upx_rsize_t bytes = mem_size(sizeof(T), n); // assert size
+    T *array = new T[size_t(n)];
+    if (array != nullptr && bytes > 0)
+        memset(array, 0, bytes); // NOLINT(bugprone-multi-level-implicit-pointer-conversion)
+    return array;
+}
+#define New0(type, n) (New0T<type>((n)))
+
 /*************************************************************************
 // ptr util
 **************************************************************************/