all: final tweaks for release

clarify GPLv2+ COPYING

.clang-format

@@ -0,0 +1,28 @@
+# "Gofmt's style is nobody's favourite, but gofmt is everybody's favourite." --Rob Pike
+#
+# for clang-format-10.0.1 from https://github.com/upx/upx-stubtools/releases
+---
+BasedOnStyle: LLVM
+AccessModifierOffset: -4
+#AlignConsecutiveAssignments: true
+AlwaysBreakTemplateDeclarations: true
+ColumnLimit: 100
+IndentWidth: 4
+SortIncludes: false
+SpaceAfterCStyleCast: true
+Standard: Cpp03
+StatementMacros: [
+  ACCCHK_ASSERT,
+  ACCCHK_ASSERT_IS_SIGNED_T,
+  ACCCHK_ASSERT_IS_UNSIGNED_T,
+  ACCCHK_ASSERT_SIGN_T,
+  ACC_COMPILE_TIME_ASSERT,
+  ACC_COMPILE_TIME_ASSERT_HEADER,
+  ACC_CXX_DISABLE_NEW_DELETE,
+  ACC_CXX_TRIGGER_FUNCTION,
+  ACC_CXX_TRIGGER_FUNCTION_IMPL,
+  CLANG_FORMAT_DUMMY_STATEMENT,
+  COMPILE_TIME_ASSERT,
+  COMPILE_TIME_ASSERT_ALIGNED1,
+]
+...

.editorconfig

@@ -0,0 +1,21 @@
+# see https://editorconfig.org/
+
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_size = 4
+indent_style = space
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[{GNUmakefile*,MMakefile*,Makefile*,Makevars*,*.mk}]
+indent_size = 8
+indent_style = tab
+
+[*.S]
+indent_size = 8
+
+[*.yml]
+indent_size = 2

.gitattributes

@@ -0,0 +1,10 @@
+# make GitHub language detection more accurate, see https://github.com/github/linguist
+
+src/*.h linguist-language=C++
+src/*/*.h linguist-language=C++
+
+src/stub/**/*.ash linguist-language=Assembly
+src/stub/**/*.asm linguist-language=Assembly
+src/stub/**/*.S linguist-language=Assembly
+
+src/stub/tmp/** linguist-vendored

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,45 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+This issue tracker is **ONLY** used for reporting bugs.
+Please use [stackoverflow](https://stackoverflow.com) for supporting issues.
+
+<!---
+
+IF YOU REMOVE THIS TEMPLATE WE WILL CLOSE YOUR ISSUE WITHOUT RESPONSE.
+Just read it and fill in the details we're asking, it saves so much of our time. Thanks!
+
+-->
+
+## What's the problem (or question)?
+<!--- If describing a bug, tell us what happens instead of the expected behavior -->
+<!--- If suggesting a change/improvement, explain the difference from current behavior -->
+
+## What should have happened?
+<!--- If you're describing a bug, tell us what should happen -->
+<!--- If you're suggesting a change/improvement, tell us how it should work -->
+
+## Do you have an idea for a solution?
+<!--- Not obligatory, but suggest a fix/reason for the bug, -->
+<!--- or ideas how to implement the addition or change -->
+
+## How can we reproduce the issue?
+<!--- Provide unambiguous set of steps to reproduce this bug. Include code to reproduce, if relevant -->
+1.
+2.
+3.
+4.
+
+## Please tell us details about your environment.
+<!--- Include as many relevant details about the environment you experienced the bug in -->
+* UPX version used (`upx --version`):
+* Host Operating System and version:
+* Host CPU architecture:
+* Target Operating System and version:
+* Target CPU architecture:

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1 @@
+blank_issues_enabled: false

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,45 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+This issue tracker is **ONLY** used for requesting sensible features.
+Please use [stackoverflow](https://stackoverflow.com) for supporting issues.
+
+<!---
+
+IF YOU REMOVE THIS TEMPLATE WE WILL CLOSE YOUR ISSUE WITHOUT RESPONSE.
+Just read it and fill in the details we're asking, it saves so much of our time. Thanks!
+
+-->
+
+## What's the problem (or question)?
+<!--- If describing a bug, tell us what happens instead of the expected behavior -->
+<!--- If suggesting a change/improvement, explain the difference from current behavior -->
+
+## What should have happened?
+<!--- If you're describing a bug, tell us what should happen -->
+<!--- If you're suggesting a change/improvement, tell us how it should work -->
+
+## Do you have an idea for a solution?
+<!--- Not obligatory, but suggest a fix/reason for the bug, -->
+<!--- or ideas how to implement the addition or change -->
+
+## How can we reproduce the issue?
+<!--- Provide unambiguous set of steps to reproduce this bug. Include code to reproduce, if relevant -->
+1.
+2.
+3.
+4.
+
+## Please tell us details about your environment.
+<!--- Include as many relevant details about the environment you experienced the bug in -->
+* UPX version used (`upx --version`):
+* Host Operating System and version:
+* Host CPU architecture:
+* Target Operating System and version:
+* Target CPU architecture:

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      # Check for updates to GitHub Actions every weekday
+      interval: 'daily'

.github/pull_request_template.md

@@ -0,0 +1,14 @@
+UPX PULL REQUEST NOTES
+======================
+
+Handling pull requests is actually quite time consuming, so please
+
+- if you want to contribute **a real C++ code bug-fix** then open an issue
+on the main UPX issue tracker first
+
+- if you want to contribute **a new feature** then by all means open an issue
+on the main UPX issue tracker first before starting any coding!
+
+- please refuse the temptation to "improve" the docs, scripts, CI, makefiles,
+cmake build system, spelling errors, etc - we will NOT merge this; only open
+an issue if you're sure there is a **real bug**

.github/security.md

@@ -0,0 +1,15 @@
+# Security Context
+
+IMPORTANT NOTE: UPX inherits the security context of any files it handles.
+
+This means that packing, unpacking, or even testing or listing a file requires
+the same security considerations as actually executing the file.
+
+Use UPX on trusted files only!
+
+## Supported Versions
+
+| Version   | Supported          |
+| --------- | ------------------ |
+| git HEAD  | :white_check_mark: |
+| any other | :x:                |

.github/travis_build.sh

@@ -0,0 +1,93 @@
+#! /bin/bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+# ...lots of outdated/unneeded stuff from the old Travis/Circle/AppVeyor CI days...
+
+if [[ $TRAVIS_OS_NAME == osx ]]; then
+    argv0=$0; argv0abs=$(greadlink -en -- "$0"); argv0dir=$(dirname "$argv0abs")
+else
+    argv0=$0; argv0abs=$(readlink -en -- "$0"); argv0dir=$(dirname "$argv0abs")
+fi
+source "$argv0dir/travis_init.sh" || exit 1
+
+# create dirs
+cd / || exit 1
+mkbuilddirs $upx_BUILDDIR $ucl_BUILDDIR $upx_testsuite_BUILDDIR $zlib_BUILDDIR
+cd / && cd "$upx_SRCDIR" || exit 1
+
+echo
+print_settings
+echo
+echo "$CC --version"; $CC --version
+echo "$CXX --version"; $CXX --version
+echo
+
+# check whitespace
+if [[ $TRAVIS_OS_NAME == linux ]]; then
+    cd / && cd $upx_SRCDIR || exit 1
+    echo "Checking source code for whitespace violations..."
+    bash ./misc/scripts/check_whitespace.sh || exit 1
+    echo "  Passed."
+fi # linux
+
+set -x
+
+#
+# rebuild UPX stubs (needs upx-stubtools)
+#
+
+if [[ $BM_X =~ (^|\+)rebuild-stubs($|\+) ]]; then
+    if [[ -f "$HOME/local/bin/bin-upx/upx-stubtools-check-version" ]]; then
+        bin_upx=$(readlink -en -- "$HOME/local/bin/bin-upx")
+    elif [[ -f "$HOME/.local/bin/bin-upx/upx-stubtools-check-version" ]]; then
+        bin_upx=$(readlink -en -- "$HOME/.local/bin/bin-upx")
+    else
+        bin_upx=$(readlink -en -- "$upx_SRCDIR/../deps/bin-upx-20210104")
+    fi
+    cd / && cd "$upx_SRCDIR" || exit 1
+    extra_subdirs=()
+    extra_subdirs+=( src/stub/src/arch/amd64 )
+    extra_subdirs+=( src/stub/src/arch/arm/v4a )
+    extra_subdirs+=( src/stub/src/arch/arm/v4t )
+    extra_subdirs+=( src/stub/src/arch/arm64/v8 )
+    extra_subdirs+=( src/stub/src/arch/i386 )
+    extra_subdirs+=( src/stub/src/arch/m68k/m68000 )
+    extra_subdirs+=( src/stub/src/arch/m68k/m68020 )
+    extra_subdirs+=( src/stub/src/arch/mips/r3000 )
+    extra_subdirs+=( src/stub/src/arch/powerpc/32 )
+    extra_subdirs+=( src/stub/src/arch/powerpc/64 )
+    extra_subdirs+=( src/stub/src/arch/powerpc/64le )
+    make -C src/stub maintainer-clean
+    for d in ${extra_subdirs[@]}; do
+        make -C $d -f Makefile.extra maintainer-clean
+        git status $d || true
+    done
+    git status src/stub/src || true
+    git status || true
+    failed=0
+    for d in ${extra_subdirs[@]}; do
+        PATH="$bin_upx:$PATH" make -C $d -f Makefile.extra || failed=1
+    done
+    PATH="$bin_upx:$PATH" make -C src/stub all || failed=1
+    if [[ $failed != 0 ]]; then
+        echo "UPX-ERROR: FATAL: rebuild-stubs failed"
+        exit 1
+    fi
+    if ! git diff --quiet; then
+        git status || true
+        git diff || true
+        echo "UPX-ERROR: FATAL: rebuild-stubs git status mismatch. See log file."
+        exit 1
+    fi
+    git status
+    if [[ $BM_X == rebuild-stubs ]]; then
+        echo "X=rebuild-stubs done. Exiting."
+        exit 0
+    fi
+    unset bin_upx extra_subdirs d failed
+fi
+
+exit 1

.github/travis_init.sh

@@ -0,0 +1,273 @@
+## vim:set ts=4 sw=4 et:
+
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+# ...lots of outdated/unneeded stuff from the old Travis/Circle/AppVeyor CI days...
+
+#set -x # debug
+umask 022
+export GIT_PAGER=
+
+# rename short variables to more readable Build-Matrix BM_ names
+#   C is COMPILER
+#   B is BUILD_OPTIONS
+#   T is TESTSUITE_OPTIONS
+#   X is EXTRA_OPTIONS
+BM_CROSS=$CROSS; BM_C=$C; BM_B=$B; BM_T=$T; BM_X=$X
+unset CROSS C B T X
+[[ -z $BM_C ]] && BM_C=gcc
+[[ -z $BM_B ]] && BM_B=release
+
+# just in case, unset variable for passing extra UPX options
+export UPX=
+# un-export some vars
+declare +x UPX_AUTOMATIC_BUILDS_SSL_KEY UPX_AUTOMATIC_BUILDS_SSL_IV
+
+# compatibility wrappers
+if [[ $TRAVIS_OS_NAME == osx ]]; then
+# use GNU coreutils ("brew install coreutils")
+chmod() {
+    gchmod "$@"
+}
+date() {
+    gdate "$@"
+}
+readlink() {
+    greadlink "$@"
+}
+sha256sum() {
+    gsha256sum "$@"
+}
+fi
+if [[ -n $APPVEYOR_JOB_ID ]]; then
+openssl() {
+    /usr/bin/openssl "$@"
+}
+sort() {
+    /usr/bin/sort "$@"
+}
+fi
+
+# set CC and CXX from BM_C and BM_CROSS
+if [[ -z $CC_OVERRIDE ]]; then
+CC=false CXX=false SCAN_BUILD=false
+AR=ar SIZE=size
+if [[ -n $APPVEYOR_JOB_ID ]]; then
+    BUILD_LOCAL_UCL=1
+    BUILD_LOCAL_ZLIB=1
+    if [[ $BM_C =~ (^|\-)(clang|gcc)($|\-) ]]; then
+        export upx_EXTRA_LDFLAGS="-static-libgcc -static-libstdc++"
+    fi
+    upx_exeext=.exe
+    # dir c:\cygwin
+    case $BM_C in
+        gcc-m32 | gcc-4.9-m32)
+            x=i686-w64-mingw32; AR="$x-ar"; CC="$x-gcc -m32"; CXX="$x-g++ -m32" ;;
+        gcc-m64 | gcc-4.9-m64)
+            x=x86_64-w64-mingw32; AR="$x-ar"; CC="$x-gcc -m64"; CXX="$x-g++ -m64" ;;
+        msvc | msvc-*)
+            AR="link -lib"; CC="cl"; CXX="cl" ;; # standard system compiler
+    esac
+fi # APPVEYOR_JOB_ID
+if [[ -n $BM_CROSS ]]; then
+    BUILD_LOCAL_UCL=1
+    BUILD_LOCAL_ZLIB=1
+    if [[ $BM_C =~ (^|\-)(clang|gcc)($|\-) ]]; then
+        export upx_EXTRA_LDFLAGS="-static-libgcc -static-libstdc++"
+    fi
+    cat /etc/os-release || true
+    if grep -E -q '^PRETTY_NAME="?Ubuntu .*12\.04' /etc/os-release; then
+        case $BM_CROSS-$BM_C in
+            arm-linux-gnueabi-gcc | arm-linux-gnueabi-gcc-4.6)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-arm -L /usr/arm-linux-gnueabi"
+                x=arm-linux-gnueabi; AR="$x-ar"; CC="$x-gcc"; CXX="$x-g++" ;;
+            arm-linux-gnueabihf-gcc | arm-linux-gnueabihf-gcc-4.6)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-arm -L /usr/arm-linux-gnueabihf"
+                x=arm-linux-gnueabihf; AR="$x-ar"; CC="$x-gcc"; CXX="$x-g++" ;;
+            i[36]86-w64-mingw32-gcc | i[36]86-w64-mingw32-gcc-4.6)
+                upx_exeext=.exe
+                [[ -z $upx_wine ]] && upx_wine="wine"
+                x=i686-w64-mingw32; AR="$x-ar"; CC="$x-gcc -m32"; CXX="$x-g++ -m32" ;;
+            x86_64-w64-mingw32-gcc | x86_64-w64-mingw32-gcc-4.6)
+                upx_exeext=.exe
+                [[ -z $upx_wine ]] && upx_wine="wine"
+                x=x86_64-w64-mingw32; AR="$x-ar"; CC="$x-gcc -m64"; CXX="$x-g++ -m64" ;;
+        esac
+    elif grep -E -q '^PRETTY_NAME="?Ubuntu 16\.04' /etc/os-release; then
+        case $BM_CROSS-$BM_C in
+            aarch64-linux-gnu-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-aarch64 -L /usr/aarch64-linux-gnu"
+                x=aarch64-linux-gnu; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            arm-linux-gnueabi-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-arm -L /usr/arm-linux-gnueabi"
+                x=arm-linux-gnueabi; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            arm-linux-gnueabihf-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-arm -L /usr/arm-linux-gnueabihf"
+                x=arm-linux-gnueabihf; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            i[36]86-w64-mingw32-gcc-5)
+                upx_exeext=.exe
+                [[ -z $upx_wine ]] && upx_wine="wine"
+                x=i686-w64-mingw32; AR="$x-ar"; CC="$x-gcc -m32"; CXX="$x-g++ -m32" ;;
+            mips-linux-gnu-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-mips -L /usr/mips-linux-gnu"
+                x=mips-linux-gnu; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            mipsel-linux-gnu-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-mipsel -L /usr/mipsel-linux-gnu"
+                x=mipsel-linux-gnu; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            powerpc-linux-gnu-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-ppc -L /usr/powerpc-linux-gnu"
+                x=powerpc-linux-gnu; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            powerpc64-linux-gnu-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-ppc64 -L /usr/powerpc64-linux-gnu"
+                x=powerpc64-linux-gnu; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            powerpc64le-linux-gnu-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-ppc64le -L /usr/powerpc64le-linux-gnu"
+                x=powerpc64le-linux-gnu; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            s390x-linux-gnu-gcc-5)
+                [[ -z $upx_qemu ]] && upx_qemu="qemu-s390x -L /usr/s390x-linux-gnu"
+                x=s390x-linux-gnu; AR="$x-ar"; CC="$x-gcc-5"; CXX="$x-g++-5" ;;
+            x86_64-w64-mingw32-gcc-5)
+                upx_exeext=.exe
+                [[ -z $upx_wine ]] && upx_wine="wine"
+                x=x86_64-w64-mingw32; AR="$x-ar"; CC="$x-gcc -m64"; CXX="$x-g++ -m64" ;;
+        esac
+    elif grep -E -q '^PRETTY_NAME="?Ubuntu 20\.04' /etc/os-release; then
+        case $BM_CROSS-$BM_C in
+            x86_64-w64-mingw32-gcc-9)
+                export upx_EXTRA_CPPFLAGS="-D__USE_MINGW_ANSI_STDIO=1"
+                export upx_EXTRA_LDFLAGS="-static"
+                upx_exeext=.exe
+                [[ -z $upx_wine ]] && upx_wine="wine64"
+                x=x86_64-w64-mingw32; AR="$x-ar"; CC="$x-gcc -m64"; CXX="$x-g++ -m64" ;;
+        esac
+    fi
+fi # BM_CROSS
+if [[ $CC == "false" ]]; then # generic
+if [[ -z $BM_CROSS ]]; then
+    if [[ $TRAVIS_OS_NAME == osx ]]; then
+        case $BM_C in
+            clang | clang-m?? | clang-[6789][0-9][0-9]-m?? | clang-1[0-1][0-9][0-9]-m??)
+                CC="clang"; CXX="clang++" ;; # standard system compiler
+        esac
+    else
+        case $BM_C in
+            clang | clang-m?? | clang-3.4-m??)
+                CC="clang"; CXX="clang++" ;; # standard system compiler
+            clang-[3456].[0-9]-m??)
+                v=${BM_C:6:3}; CC="clang-$v"; CXX="clang++-$v"; SCAN_BUILD="scan-build-$v" ;;
+            clang-[789]-m??)
+                v=${BM_C:6:1}; CC="clang-$v"; CXX="clang++-$v"; SCAN_BUILD="scan-build-$v" ;;
+            clang-1[0-9]-m??)
+                v=${BM_C:6:2}; CC="clang-$v"; CXX="clang++-$v"; SCAN_BUILD="scan-build-$v" ;;
+            gcc | gcc-m?? | gcc-mx32)
+                CC="gcc"; CXX="g++" ;; # standard system compiler
+            gcc-[34].[0-9]-m?? | gcc-[34].[0-9]-mx32)
+                v=${BM_C:4:3}; CC="gcc-$v"; CXX="g++-$v" ;;
+            gcc-[56789]-m?? | gcc-[56789]-mx32)
+                v=${BM_C:4:1}; CC="gcc-$v"; CXX="g++-$v" ;;
+            gcc-1[0-9]-m?? | gcc-1[0-9]-mx32)
+                v=${BM_C:4:2}; CC="gcc-$v"; CXX="g++-$v" ;;
+        esac
+    fi
+fi
+fi # generic
+case $BM_C in
+    clang*-m32) CC="$CC -m32";  CXX="$CXX -m32" ;;
+    clang*-m64) CC="$CC -m64";  CXX="$CXX -m64" ;;
+    gcc*-m32)   CC="$CC -m32";  CXX="$CXX -m32" ;;
+    gcc*-m64)   CC="$CC -m64";  CXX="$CXX -m64" ;;
+    gcc*-mx32)  CC="$CC -mx32"; CXX="$CXX -mx32"; BUILD_LOCAL_UCL=1; BUILD_LOCAL_ZLIB=1 ;;
+esac
+if [[ $BM_C =~ (^|\-)(clang|gcc)($|\-) ]]; then
+    CC="$CC -std=gnu89"
+fi
+unset v x
+export AR CC CXX
+fi # CC_OVERRIDE
+
+# source dirs
+[[ -z $upx_SRCDIR ]] && upx_SRCDIR=$(readlink -mn -- $argv0dir/..)
+[[ -z $ucl_SRCDIR ]] && ucl_SRCDIR=$(readlink -mn -- $upx_SRCDIR/../deps/ucl-1.03)
+[[ -z $upx_testsuite_SRCDIR ]] && upx_testsuite_SRCDIR=$(readlink -mn -- $upx_SRCDIR/../deps/upx-testsuite)
+[[ -z $zlib_SRCDIR ]] && zlib_SRCDIR=$(readlink -mn -- $upx_SRCDIR/../deps/zlib-1.2.11)
+
+# build dirs
+mkbuilddirs() {
+    local d
+    for d in "$@"; do
+        mkdir -p -v "$d" || exit 1
+        [[ -f "$d/.mfxnobackup" ]] || touch "$d/.mfxnobackup"
+    done
+}
+# search for an existing $toptop_builddir
+if [[ -z $toptop_builddir ]]; then
+    for d in . ..; do
+        for subdir in "local" appveyor circle github gitlab travis .; do
+            dd=$d/build/$subdir
+            if [[ -d $dd ]]; then
+                toptop_builddir=$(readlink -en -- "$dd")
+                break 2
+            fi
+        done
+    done
+    unset d subdir dd
+fi
+[[ -z $toptop_builddir ]] && toptop_builddir=$(readlink -mn -- ./build)
+[[ -z $toptop_bdir ]] && toptop_bdir=$(readlink -mn -- "$toptop_builddir/${BM_CROSS:+$BM_CROSS-}$BM_C/$BM_B")
+[[ -z $upx_BUILDDIR ]] && upx_BUILDDIR=$(readlink -mn -- "$toptop_bdir/upx")
+[[ -z $ucl_BUILDDIR ]] && ucl_BUILDDIR=$(readlink -mn -- "$toptop_bdir/ucl-1.03")
+[[ -z $upx_testsuite_BUILDDIR ]] && upx_testsuite_BUILDDIR=$(readlink -mn -- "$toptop_bdir/upx-testsuite")
+[[ -z $zlib_BUILDDIR ]] && zlib_BUILDDIR=$(readlink -mn -- "$toptop_bdir/zlib-1.2.11")
+[[ -z $lcov_OUTPUTDIR ]] && lcov_OUTPUTDIR=$(readlink -mn -- "$toptop_bdir/.lcov-results")
+unset toptop_builddir toptop_bdir
+
+# ensure absolute directories
+make_absolute() {
+    local d
+    while [[ $# -gt 0 ]]; do
+        if [[ -n ${!1} ]]; then
+            d=$(readlink -mn -- "${!1}")
+            eval $1="$d"
+        fi
+        shift
+    done
+}
+for var_prefix in ucl upx upx_testsuite zlib; do
+    for var_suffix in _BUILDDIR _SRCDIR; do
+        make_absolute ${var_prefix}${var_suffix}
+    done
+done
+make_absolute lcov_OUTPUTDIR
+unset var_prefix var_suffix
+
+print_header() {
+    local x="==========="; x="$x$x$x$x$x$x$x"
+    echo -e "\n${x}\n${1}\n${x}\n"
+}
+
+print_settings() {
+    local v var_prefix var_suffix
+    # Build Matrix
+    for v in TRAVIS_OS_NAME BM_CROSS BM_C BM_B BM_T; do
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+    done
+    # BM_C related
+    for v in AR CC CXX CPPFLAGS CFLAGS CXXFLAGS LDFLAGS LIBS SCAN_BUILD; do
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+        v=EXTRA_${v}
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+    done
+    # directories and other info
+    for v in TRAVIS_XCODE_SDK UPX_UCLDIR lcov_OUTPUTDIR; do
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+    done
+    for var_prefix in ucl upx upx_testsuite zlib; do
+    for var_suffix in _BUILDDIR _SRCDIR; do
+        v=${var_prefix}${var_suffix}
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+    done
+    done
+    ##env | LC_ALL=C sort
+}
+
+true

.github/travis_testsuite_1-expected_sha256sums.sh

@@ -0,0 +1,209 @@
+########## begin .sha256sums.recreate
+expected_sha256sums__t010_decompressed="\
+24158f78c34c4ef94bb7773a6dda7231d289be76c2f5f60e8b9ddb3f800c100e *amd64-linux.elf/upx-3.91
+24808d572483f4cd713d66894b3da406755038737007a78b076528e6407e3132 *amd64-linux.elf/upx-3.95
+d88eaad0528bcecec9f51cbe015a117c8cf350a3f6d8308f2b0517d4fd19d189 *amd64-win64.pe/upx-3.95.exe
+f7279729eb975e4238f8b8ee56fefa41ccbeb35ef0ffe4c34f8047baab78fff5 *arm-linux.elf/upx-3.95
+e09df2a69f88c692138447f274ba7f99cdd11f8696c71ac8d3761606c95ab5c5 *arm-wince.pe/upx-3.91.exe
+ce81113f8a4ff1cd806811cb80ab8bea5c9c6fbced47451c7f07e50700f9817b *arm64-linux.elf/upx-3.95
+b1c1c38d50007616aaf8e942839648c80a6111023e0b411e5fa7a06c543aeb4a *armeb-linux.elf/upx-3.91
+84b90eb0d617571fe4885639925b35ca6a61060cb2616bb5bf729b4d701653e4 *armeb-linux.elf/upx-3.95
+bcac77a287289301a45fde9a75e4e6c9ad7f8d57856bae6eafaae12ae4445a34 *i386-dos32.djgpp2.coff/upx-3.91.exe
+7d331e508449497f64cd47abdd3f00f70307f508ad3fd692d333feb97beccead *i386-dos32.djgpp2.coff/upx-3.95.exe
+730a513b72a094697f827e4ac1a4f8ef58a614fc7a7ad448fa58d60cd89af7ed *i386-linux.elf/upx-3.91
+a1f3e5ffa7b2cfebe1e475ac1f4c7683b1b8b4e292aa0d04386cc0314dd162c9 *i386-linux.elf/upx-3.95
+e90fb09a808334c2674996760d42c82f8352e3f671f6b66c11481e772785c4d2 *i386-win32.pe/upx-3.91.exe
+07bd50c1d80f6ff651228e6fc0ba3a583a472915772244f232696b34156a9d27 *i386-win32.pe/upx-3.95.exe
+8e5333ea040f5594d3e67d5b09e005d52b3a52ef55099a7c11d7e39ead38e66d *m68k-atari.tos/upx-3.91.ttp
+8902f38ec3d95d8e077e3ab5fdbb5bad408859913a35deb87041f4f053cd6605 *mips-linux.elf/upx-3.95
+c3f44b4d00a87384c03a6f9e7aec809c1addfe3e271244d38a474f296603088c *mipsel-linux.elf/upx-3.91
+dd1496bc4e9c32a5d5dd47e3eaabf7b134ca001d48807eebfd3d5e28c8a2ab58 *mipsel-linux.elf/upx-3.95
+b8c35fa2956da17ca505956e9f5017bb5f3a746322647e24ccb8ff28059cafa4 *powerpc-linux.elf/upx-3.91
+2bc00a51daa0bada19a8fa1bd2c227a8596844fa1b0aa3611087f195072700e2 *powerpc-linux.elf/upx-3.95
+a0950546dc17fca9437219431d8ddb0249ce5b08e899e0c799a87ac982adee70 *powerpc64le-linux.elf/upx-3.95
+"
+expected_sha256sums__t020_canonicalized="\
+24158f78c34c4ef94bb7773a6dda7231d289be76c2f5f60e8b9ddb3f800c100e *amd64-linux.elf/upx-3.91
+24808d572483f4cd713d66894b3da406755038737007a78b076528e6407e3132 *amd64-linux.elf/upx-3.95
+d88eaad0528bcecec9f51cbe015a117c8cf350a3f6d8308f2b0517d4fd19d189 *amd64-win64.pe/upx-3.95.exe
+f7279729eb975e4238f8b8ee56fefa41ccbeb35ef0ffe4c34f8047baab78fff5 *arm-linux.elf/upx-3.95
+e09df2a69f88c692138447f274ba7f99cdd11f8696c71ac8d3761606c95ab5c5 *arm-wince.pe/upx-3.91.exe
+ce81113f8a4ff1cd806811cb80ab8bea5c9c6fbced47451c7f07e50700f9817b *arm64-linux.elf/upx-3.95
+b1c1c38d50007616aaf8e942839648c80a6111023e0b411e5fa7a06c543aeb4a *armeb-linux.elf/upx-3.91
+84b90eb0d617571fe4885639925b35ca6a61060cb2616bb5bf729b4d701653e4 *armeb-linux.elf/upx-3.95
+bcac77a287289301a45fde9a75e4e6c9ad7f8d57856bae6eafaae12ae4445a34 *i386-dos32.djgpp2.coff/upx-3.91.exe
+7d331e508449497f64cd47abdd3f00f70307f508ad3fd692d333feb97beccead *i386-dos32.djgpp2.coff/upx-3.95.exe
+730a513b72a094697f827e4ac1a4f8ef58a614fc7a7ad448fa58d60cd89af7ed *i386-linux.elf/upx-3.91
+a1f3e5ffa7b2cfebe1e475ac1f4c7683b1b8b4e292aa0d04386cc0314dd162c9 *i386-linux.elf/upx-3.95
+e90fb09a808334c2674996760d42c82f8352e3f671f6b66c11481e772785c4d2 *i386-win32.pe/upx-3.91.exe
+07bd50c1d80f6ff651228e6fc0ba3a583a472915772244f232696b34156a9d27 *i386-win32.pe/upx-3.95.exe
+8e5333ea040f5594d3e67d5b09e005d52b3a52ef55099a7c11d7e39ead38e66d *m68k-atari.tos/upx-3.91.ttp
+8902f38ec3d95d8e077e3ab5fdbb5bad408859913a35deb87041f4f053cd6605 *mips-linux.elf/upx-3.95
+c3f44b4d00a87384c03a6f9e7aec809c1addfe3e271244d38a474f296603088c *mipsel-linux.elf/upx-3.91
+dd1496bc4e9c32a5d5dd47e3eaabf7b134ca001d48807eebfd3d5e28c8a2ab58 *mipsel-linux.elf/upx-3.95
+b8c35fa2956da17ca505956e9f5017bb5f3a746322647e24ccb8ff28059cafa4 *powerpc-linux.elf/upx-3.91
+2bc00a51daa0bada19a8fa1bd2c227a8596844fa1b0aa3611087f195072700e2 *powerpc-linux.elf/upx-3.95
+a0950546dc17fca9437219431d8ddb0249ce5b08e899e0c799a87ac982adee70 *powerpc64le-linux.elf/upx-3.95
+"
+expected_sha256sums__t110_compress_ucl_nrv2b_3_no_filter="\
+d8e9cb72d6d63b64b68c44a380b0f700a2c2a127bb128cf16bf003e5fe7b112f *amd64-linux.elf/upx-3.91
+71c2a5e4b1fd131c7d94c646394228e577e33a90620e6f04ed8ce71bf9419dd6 *amd64-linux.elf/upx-3.95
+7ef188bb0071bf5ad92edc0ff2cca7798ab2f084bad5d244162bafdd4dd99a03 *amd64-win64.pe/upx-3.95.exe
+cb458bf41edcac0b50648c15ac538048fd9e57da03c3588f0fa3e524d7e9b856 *arm-linux.elf/upx-3.95
+5d86c92a039dbe374ff69d1ee160eee849ed7a43aabe21a427482d4f050b98be *arm-wince.pe/upx-3.91.exe
+9436568081d9bb519cf0c7ad1f9497026e2e74fd29009d4829a05a742c649142 *arm64-linux.elf/upx-3.95
+e68f0929566ff9a8c978c9203c07bde9bc9ecc57fb3b3664f7ce4cd84ca82d26 *armeb-linux.elf/upx-3.91
+8fe7b9bcf5db78b3f5585555526ee9aa640e40e97052226431c2f4e2dcd8d26a *armeb-linux.elf/upx-3.95
+899a2af496235848b333d49645c9b08638170fc05899b55673900e5962d70a2a *i386-dos32.djgpp2.coff/upx-3.91.exe
+41048de2b63e0703a78c222efeca6b99225fad8e0c8758775f5fb6e63edde3e9 *i386-dos32.djgpp2.coff/upx-3.95.exe
+4e7bb9e52a5f8085e9882eff1007b7f401a7fbdfc82e5342ef604e4feb4ccf15 *i386-linux.elf/upx-3.91
+72fba7c493de49b2ee152629e9083b83d6e732c99eefc7d59641d091c64f171e *i386-linux.elf/upx-3.95
+38fbad083a8eaa4ed7cb379f21a5277a703baaa77d4e6d9e145d2bb4838513b5 *i386-win32.pe/upx-3.91.exe
+a27abdb7d9888b7d1e79aa90cdb6a1500e0a3abdc64ee9fbe7db7ce4423ffc79 *i386-win32.pe/upx-3.95.exe
+a8e11176946ec68f4c2e40e0a585eb70f589560117bef2a98315c454b2fe1f13 *m68k-atari.tos/upx-3.91.ttp
+a80d40f6ae66effe0ce9dfcbcc306e59c61118a3653eba304b6120c3cb4bd951 *mips-linux.elf/upx-3.95
+8aab2896c689c9b9eae5d205e8dbf3e9896989f212181f666dece91e893314e9 *mipsel-linux.elf/upx-3.91
+00dbb8a83349fff83374b5a716ae953943b003991e1808e5d773f3e2aa3176bb *mipsel-linux.elf/upx-3.95
+174a1e090a254cefff98bc23235a3feea9e23c3be0a4c007c44c89a999e62567 *powerpc-linux.elf/upx-3.91
+f133e103c0d02927311593f6f25ea0c4803fe648919e154a5b2a527964b6a9fb *powerpc-linux.elf/upx-3.95
+996c63e6717ced59c7dfd4573482ef54d2715dc04bc106e6a86e0317443cb960 *powerpc64le-linux.elf/upx-3.95
+"
+expected_sha256sums__t120_compress_ucl_nrv2d_3_no_filter="\
+e5fce664c1ed5e4d5ced5186c5b88be8ef14b378b911e2e70bc8e7a331f8e3ff *amd64-linux.elf/upx-3.91
+86437aa77c0c1c5f55ef8d15ae2ba69d9d48034330faccc025f03a2a7d54ef12 *amd64-linux.elf/upx-3.95
+761629a404ac155b3f856ff6bedf66266e1c75dcf389b56aee7692f420872653 *amd64-win64.pe/upx-3.95.exe
+7dc22a271fd568f2ec7db5360ae08d2ed0dc6ceb14901bf8d3a49f6a239506be *arm-linux.elf/upx-3.95
+58259c38274532baf60932569a4006ceb762a381ac3b257e9af648af24422660 *arm-wince.pe/upx-3.91.exe
+f626c4131c1b70a880e6431c41842093dad4a2fff921304727306e699c6e6ceb *arm64-linux.elf/upx-3.95
+6f870fe4f7a92cd244bc0b209082264ffdf68d023dc1d697f5111ce5f4a168ca *armeb-linux.elf/upx-3.91
+ed554bbf0d531740a2cb408a5408b7fb67fef32173531bae21b15829e4465b92 *armeb-linux.elf/upx-3.95
+6e5b040dd59e0bf3491da6947fd3c576fd1b090b1fa7f278b147dd33b0a561a4 *i386-dos32.djgpp2.coff/upx-3.91.exe
+f27ef0ce4ca0c7557dfd4c0c3a7e5443523f82dd9f4d354fb80ad0e001ede485 *i386-dos32.djgpp2.coff/upx-3.95.exe
+8e6d5979658e8a00b567ddd214abd5565fc4c356b3e84941038c16aff9b3fb23 *i386-linux.elf/upx-3.91
+7d7cc62ec7f8e71e526687cde53d5b49e5f688787c3aef533a8aa9f302e51bea *i386-linux.elf/upx-3.95
+f81ed2a88589df18a735bebc1b42d638d3eb0bebbaea70758c762348103adde1 *i386-win32.pe/upx-3.91.exe
+d5533151370ea42679c94036b8d61239f90fd930fca5d3cedbbca9c959756294 *i386-win32.pe/upx-3.95.exe
+5361b1f369a4b42f9063f448bdcda31f97bd610c659d2fe3c89d3e479a84cbc9 *m68k-atari.tos/upx-3.91.ttp
+ac4233c2d342375bd2fb5cf871cfd47b58863fbcac7693937e1d15d23f09f96e *mips-linux.elf/upx-3.95
+9bcae27b631736ff226d45fc143c61c55b1bbb127b77b9612ad2d123dc96d45d *mipsel-linux.elf/upx-3.91
+bf735a042c3406897f1cba6a62f8f7ea631bd15f15f21a56165decfe39323c52 *mipsel-linux.elf/upx-3.95
+215c0694962ab6f4ead91448722a6ddce8471abce0742e148a6626cdbdf904fa *powerpc-linux.elf/upx-3.91
+82857404a03d2a21c4bff152c8da78ae3cdcdb71ad0c847256c370ce510a4f1b *powerpc-linux.elf/upx-3.95
+ee860ecf8fafb5ca6a7f9c6baf316dba1c3b55553aa02f4dc254d54b32e0a61a *powerpc64le-linux.elf/upx-3.95
+"
+expected_sha256sums__t130_compress_ucl_nrv2e_3_no_filter="\
+d43e28f8724cdb76deaca6581b698bd77c06a94ea37c8cf730eb38f82ce62cce *amd64-linux.elf/upx-3.91
+05c7ced28df8fa967385aa85adb479a9d9928112cb28884e8382421ee7aed062 *amd64-linux.elf/upx-3.95
+405399cb91cde3dfeed89bfe14ff65301fcb9a6925ffb55bdac8c60e164fec9f *amd64-win64.pe/upx-3.95.exe
+48a0983b24a0dc0e29df24ee30470ce228f4c978a3e965e27a6b12d8977807bd *arm-linux.elf/upx-3.95
+9b460ce1edeb2557661526bdd0d195f5d4c7c5f261c2886fe47691ce5b2d20c5 *arm-wince.pe/upx-3.91.exe
+391afe58edcbbedadde8c9ec4cd693c4c169bd6f6fefa9f63c41f4d7529246c9 *arm64-linux.elf/upx-3.95
+05943cb6189f8230a6a6cc8ffb9ae9b6f3ecb1ef222181522833dc8373c77211 *armeb-linux.elf/upx-3.91
+0f1cdc18d24c03d3e56256721ba9fdddf7809eeaeefacf4f677120903c9544e4 *armeb-linux.elf/upx-3.95
+ee2918a9bf26aebcb5547684f2d4f9c24ac516597c208a478e5bc3f36b59291e *i386-dos32.djgpp2.coff/upx-3.91.exe
+f24770536216fa29a7d3624f6e676a54244be0a7ab1213d29d21a146639a1b83 *i386-dos32.djgpp2.coff/upx-3.95.exe
+2ea7702d4398d03ea46502f5179b2eaa209926ad0d105e81663b3c87c2e7acb7 *i386-linux.elf/upx-3.91
+74df9d74515b51839272c5c84572880d58ea85a16cbed5549b2af182149dad24 *i386-linux.elf/upx-3.95
+11401986fe43ee57cb0170099d3a6228238e2eff8244ad81cc647420314c98ee *i386-win32.pe/upx-3.91.exe
+3ee3b313f0cf6c891c5895343ff304aa34e3017aac45022f7bbd0cfd7d80dc25 *i386-win32.pe/upx-3.95.exe
+e9659acb2dc14f60e8f3d71b6024ec9c768ee11233ec9dad5e1bd252cd259381 *m68k-atari.tos/upx-3.91.ttp
+0796aa39c6a069f5c940ee07442c22d864fdca7f6fe083d51debabab077c413f *mips-linux.elf/upx-3.95
+98d370c61692de7249aa51f3befc3ebefa705f172a1ebf0dd092ea07b9776158 *mipsel-linux.elf/upx-3.91
+7bb3afac05c13ef34721facf4c81621791a45a40cceab2cc1bb7306a747c5df5 *mipsel-linux.elf/upx-3.95
+eb292cd7c95fcd597431a8e6c9f13f0b64bbda3423611a43ceeca418a3979554 *powerpc-linux.elf/upx-3.91
+6a45c2734fc2aa82a0e2b9331c545e1bb04d02797c59ab00a8250d052603b8a2 *powerpc-linux.elf/upx-3.95
+9c6dc09daf5901983625e8f9f2f45f66a10fcf9841ae3e9788bb3ae075db5307 *powerpc64le-linux.elf/upx-3.95
+"
+expected_sha256sums__t140_compress_lzma_2_no_filter="\
+8f08ea0a86c3f49c7b2a90aca17b5739a91e39ef6542365e7395d1325fdcfc2b *amd64-linux.elf/upx-3.91
+9f7c9d0432baaf21977ca4bd827f7cdf7c39296f77e122689cc57945856e7b39 *amd64-linux.elf/upx-3.95
+86e277047c1b8c1884bf5ceb4f628410b011fae761e8cf7031f0b8b3058adac6 *amd64-win64.pe/upx-3.95.exe
+80a8f4d0df27d32d8f20bfd838f6c876026f84d6c54bb5c1a920340031eb22e8 *arm-linux.elf/upx-3.95
+c059993735be23726fd74a5d0c5165f4c6581cc90513b2a6f82cb0f8d113ca6a *arm-wince.pe/upx-3.91.exe
+3b8298af00f656d071187fc219bbb9a131a412f7489dc7a164fa7c6a78c96c85 *arm64-linux.elf/upx-3.95
+83d0c4dc17bbb9391d904c85c6382fee5b8f76baf664f14c8f7c3c0b31bc8079 *armeb-linux.elf/upx-3.91
+f939c8365f00d486573f9b969d42d1b43e49fc8c5f59b3a72eb229482de3938e *armeb-linux.elf/upx-3.95
+467cead4f4418d1a581ac61cac5526afdbb6ebe8887749c3b8b25a45bb686e22 *i386-dos32.djgpp2.coff/upx-3.91.exe
+c35eb28139afcea4b03e7fabf993e9927486b53e0ca20d78e61a274358934ad3 *i386-dos32.djgpp2.coff/upx-3.95.exe
+6898de07c4d250dfdd9be431a59562e87f49e2c69112d034352d1ec62c6e99dd *i386-linux.elf/upx-3.91
+400f08c53c7b3d81e99c85f9aa86443616d884a366627f61dce3f1d0c46c67ba *i386-linux.elf/upx-3.95
+2530b702024091f71405e5a8b4b0ebc235a8e12bcb66867590d1a6741c905b9d *i386-win32.pe/upx-3.91.exe
+2a854af2416d459b7bdf8345cae374800cf471d9e945a170fa38046221e7b462 *i386-win32.pe/upx-3.95.exe
+74ac6483e4a98a4173330ad43203f04354af0bc1ce046e6c94e5759d68ce992f *m68k-atari.tos/upx-3.91.ttp
+118fd0c794402cf96c4c97533c2a3292afdc87632bac6a25978f0baae248e375 *mips-linux.elf/upx-3.95
+4b26db733fab84d8032dd4c6cc345f3da50ac3fe581706b1676ebe19d099c693 *mipsel-linux.elf/upx-3.91
+a016e09a4aa299dd176a6e5eccde98db8781c509e7605504c316a77bf55fe1a1 *mipsel-linux.elf/upx-3.95
+db75012b5177ef021fb9365c3828aba39ea7feff0783e737a4625c0066de8ef1 *powerpc-linux.elf/upx-3.91
+168931dfcecc39019fa86eb2e27dfc2e8239160c3b826b76fd53f39f13f986da *powerpc-linux.elf/upx-3.95
+e58fb39928d60ec18add81e3dcc62b5a82cfa8c9c19f89ade0a7388ac88342f5 *powerpc64le-linux.elf/upx-3.95
+"
+expected_sha256sums__t150_compress_ucl_2_all_filters="\
+c329512f59d065b20698c49ff7d710c7bb0cf099b8a4b8fe5ecd1121a12eb175 *amd64-linux.elf/upx-3.91
+8cf09664da89c51453e23c4ac76e8d619814dbd576580f408ebf95078dc67474 *amd64-linux.elf/upx-3.95
+8af657df3b6a0f7d586f38960a592827921a914f923db4ab87fbb93094f1096d *amd64-win64.pe/upx-3.95.exe
+055f5fd681f872e2e308a59402196bb3f33fdb0ef34ddee4031f7d676e6ac364 *arm-linux.elf/upx-3.95
+eae07f1e169d0b89ec80fac5f61ce41af9c697d48ddb45495806f9e3103dd0ac *arm-wince.pe/upx-3.91.exe
+b1bfa0d71d8dfd3edd772d1d92f76695155ba9cbcdc572c68efa8cd6e500b0b6 *arm64-linux.elf/upx-3.95
+12af497fbc9d06199fa623744a31778ee78fe142e5958162f0e683809ca58435 *armeb-linux.elf/upx-3.91
+b497a7fb0b12fb75a4444f0c137e174fe059b973f5f2425b1eedb04855dfb130 *armeb-linux.elf/upx-3.95
+1c7d4abe5aa21da343399e2cff642f04bf0904bbac2df97d5e10b2e9087806fd *i386-dos32.djgpp2.coff/upx-3.91.exe
+70ae2c3a58b22dbf1aefb145705c00855be241e6b2cc45fe18cd90bf93fa3802 *i386-dos32.djgpp2.coff/upx-3.95.exe
+f332cba5e96fa04377a127c2c7f45822ccf1f12dd990fca5bf73499902082c3b *i386-linux.elf/upx-3.91
+15f1238bd48835d850c4eb9bb51515738d69237b6c81bd7148aefb0a0e4556e6 *i386-linux.elf/upx-3.95
+1c00860e202116b199fa76b4b508f27d7ec28510d8287557d04688c93be4e624 *i386-win32.pe/upx-3.91.exe
+12e1ac68a55bae0c2f82149b133e21224e37168e9915ef97bd40d38455723a53 *i386-win32.pe/upx-3.95.exe
+ae43a71d76b0bc2f1af2e9b5ec90d6cc0337dbd603d124dfac8c68893bd8fb5f *m68k-atari.tos/upx-3.91.ttp
+e0c0dd0e41b3d0f059d373bbc81c35fdb843657d496614fd090aa2d89ed5da27 *mips-linux.elf/upx-3.95
+558780a870830f5fbb14f5cd00db576fa37c8fcd72f7f22491ca2279aaf85757 *mipsel-linux.elf/upx-3.91
+7d85974f25e3daa3f21c11496683bee6c22d1c6086f29ed5b410637cb9c66f2e *mipsel-linux.elf/upx-3.95
+cb3c36ee3ade39e4cb1c2d5bb20548f1f4560bf1853c315b5c2b3fca533c75ec *powerpc-linux.elf/upx-3.91
+faaf09644ef9eb51a5f48a34971bb6ab363cb85fb79fdba8ad9eb1aecd7d5a7e *powerpc-linux.elf/upx-3.95
+c714496c2027d81cd16431cc27dc105761aae98d71099cecae84bd1d269e9dba *powerpc64le-linux.elf/upx-3.95
+"
+expected_sha256sums__t160_compress_all_methods_1_no_filter="\
+08a685a5869892597aa82264e8796a6d0e663f61426b683cfb47a51c5f4e1f37 *amd64-linux.elf/upx-3.91
+ea0ef4eed5ecfa14f5e713bae4a7559adcd8dc5bf26a6bc035d771063cf325eb *amd64-linux.elf/upx-3.95
+d5cbc1908d75808afffaa503584588aa33ef3ce36692273c0d7ae628fe649fc6 *amd64-win64.pe/upx-3.95.exe
+a90a668fb46aa1ae1ebe875383930f016ea3ca9985f8a6d0d09bcef179cee7ab *arm-linux.elf/upx-3.95
+ad3d1c557d82f8d4d54a462b5e720705b51df064141b0fd3f81d54de685f51d6 *arm-wince.pe/upx-3.91.exe
+1b2f673515ca9b67c7af0a9381d4e2b7f23b709e97ae969cf1dedcfda8b254ef *arm64-linux.elf/upx-3.95
+ef2ce0aace6ea8c6994232c93b73d2b0fda6ccc2b108bfca6a0f4d4dbacc36d0 *armeb-linux.elf/upx-3.91
+2bfdc5e22932b32d405611d51940d7a79b851e3776b8cdb05db5112a195cc624 *armeb-linux.elf/upx-3.95
+a9b09a6118386855e0b326e337f72c8dd369b3cadfb4e1d35a08c197a71ec0f6 *i386-dos32.djgpp2.coff/upx-3.91.exe
+4cedba26f462707805fef1810d720e09b25040f97344444d93c0af36923e8089 *i386-dos32.djgpp2.coff/upx-3.95.exe
+7fdf110134d120d6cec0aea13c1a7b861770cecb4f516cd1ab595a4d3d26936f *i386-linux.elf/upx-3.91
+deb15af9198da2d8e2d95b5f5e64bd8639cb97d4cfe2484eabdcd6385288b964 *i386-linux.elf/upx-3.95
+40fcff57d7859f37d349b907a4564bf3e9ba7223cc163e770f8353a8bfa51c73 *i386-win32.pe/upx-3.91.exe
+fae3dc1dc8eac23f6e610a1e01c20d4779026511a091672f7c150c402ae1c552 *i386-win32.pe/upx-3.95.exe
+f9663e80b6d0f69cc916ae137f6df9cd8c10bfff9c1562959efd32e91b02e1a8 *m68k-atari.tos/upx-3.91.ttp
+50b71e6090c7964bb704849584c7c75d8ee5aaa5bfab26482d3879bc01d17841 *mips-linux.elf/upx-3.95
+cb7d16ae50a2eb464c1f864f1b9052cc66f52545b82d636e48b2105e797e31f7 *mipsel-linux.elf/upx-3.91
+a1052f7425c434ce0f92dbb292d6511c8af1698a2e88352f7a463711ef8115c6 *mipsel-linux.elf/upx-3.95
+5fcc6323a8cd37d83e9a9136d7d2511a3e5c59216ceab50d4f386a2ae1a6c842 *powerpc-linux.elf/upx-3.91
+a905cb39a96982ab08e2663be690cd400bd54646b50ee50790de51b322d09830 *powerpc-linux.elf/upx-3.95
+071b42a5ae7bf3d25f01e436473433470b97311ac2aff834884a0d3d240d0291 *powerpc64le-linux.elf/upx-3.95
+"
+expected_sha256sums__t170_compress_all_methods_no_lzma_5_no_filter="\
+c5ed17847125467790aa635c926075768925ab88c3a6baa57b3bf2877c6b9001 *amd64-linux.elf/upx-3.91
+a17594fae504de512492ef822675cf6faac74e48c7803ac119626148ea9adb89 *amd64-linux.elf/upx-3.95
+1ea4c9aedd3591f62cd6902986c1df39d3ef7fc624abc78bde61300e87627d20 *amd64-win64.pe/upx-3.95.exe
+319e96fc0a6dbaa3aa7214100176957d4d0e84b7d0ee849a1f60c34ba5a22947 *arm-linux.elf/upx-3.95
+a3f2144754b44700b4aacb39ab5f5b818fda7caa0a934090eeacee7dafb6ba7b *arm-wince.pe/upx-3.91.exe
+5cb0a03d3305ddd5bc77990538b49ce3f14dcd03ad76d272d45005aa86dd5f7d *arm64-linux.elf/upx-3.95
+f5061f76060445a72edb898e9919400e81423bde6dad566a5bb5bdf1407ef6dc *armeb-linux.elf/upx-3.91
+337e4776b2f1afec7eb6d54c34d68f166af63ce5b4e2fb7ac48eeb5b83582c28 *armeb-linux.elf/upx-3.95
+46223cc5aea67b275cc5621eec79f97d4f543edecfdac37a0f2407583f881fc9 *i386-dos32.djgpp2.coff/upx-3.91.exe
+228c9007c5395fc9eef93a23d781e7daab01efa1ee86a4d4f6a46b9b7f7aeb8b *i386-dos32.djgpp2.coff/upx-3.95.exe
+089693d8059d8580ea3bf326d038ffb51f258721833ad96c05f20c321ab8df13 *i386-linux.elf/upx-3.91
+d4995b5b5c46eef7f8f1673c629f427d19b5dbda495c2b3f157acf4046b72123 *i386-linux.elf/upx-3.95
+dd70e8fde421a35692f26147c3eba392f57adb332d0e5025fa0039a2673c10cb *i386-win32.pe/upx-3.91.exe
+3fa365f39199afc7a259ba8ad8ae50cd026ef3f0a37d3fd570d42cba8bc5e0e7 *i386-win32.pe/upx-3.95.exe
+1b2f9a97731805dafef6961656bd29d7e983320a5626fe88ba987bf267bef32a *m68k-atari.tos/upx-3.91.ttp
+21febba6606d89c4a0f72a7f07f55d90268da48b97c65d23647c021c2e26b7c4 *mips-linux.elf/upx-3.95
+7a0892428e07493578d59f16adc0e6f5959f3d5a437e818375ff9fbf8ba42d2f *mipsel-linux.elf/upx-3.91
+ecf7d97388e48f2ad27a06ab8f4027e165e5a34f577f7b4fec3928a946557d60 *mipsel-linux.elf/upx-3.95
+171393e34d004f04040067080b4b48d08030708bd30bcea593f554ed13b4ddb8 *powerpc-linux.elf/upx-3.91
+0b97ff1ed48d19e64120cd4fac5f4e76da6ea6f3ec1fda5cada11aa2142d045a *powerpc-linux.elf/upx-3.95
+0c825675a076c7b9f73ae0292527e3d569b5c0b33298b9f48b7bdd3084115c69 *powerpc64le-linux.elf/upx-3.95
+"
+########## end .sha256sums.recreate

.github/travis_testsuite_1.sh

@@ -0,0 +1,287 @@
+#! /bin/bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+#
+# very first version of the upx-testsuite
+#
+
+if [[ $TRAVIS_OS_NAME == osx ]]; then
+    argv0=$0; argv0abs=$(greadlink -en -- "$0"); argv0dir=$(dirname "$argv0abs")
+else
+    argv0=$0; argv0abs=$(readlink -en -- "$0"); argv0dir=$(dirname "$argv0abs")
+fi
+source "$argv0dir/travis_init.sh" || exit 1
+
+if [[ $BM_T =~ (^|\+)SKIP($|\+) ]]; then
+    echo "UPX testsuite SKIPPED."
+    exit 0
+fi
+if [[ $BM_X == rebuild-stubs ]]; then
+    exit 0
+fi
+
+# convenience
+[[ -f $upx_exe ]] && upx_exe=$(readlink -en -- "$upx_exe")
+
+# create dirs
+cd / || exit 1
+if [[ ! -d "$upx_testsuite_SRCDIR/files/packed" ]]; then
+    echo 'invalid or missing $upx_testsuite_SRCDIR:'
+    echo '  please git clone https://github.com/upx/upx-testsuite'
+    echo '  and set (export) the envvar upx_testsuite_SRCDIR to the local file path'
+    exit 1
+fi
+mkbuilddirs "$upx_testsuite_BUILDDIR"
+cd / && cd "$upx_testsuite_BUILDDIR" || exit 1
+
+# /***********************************************************************
+# // support functions
+# ************************************************************************/
+
+testsuite_header() {
+    print_header "$1"
+}
+
+testsuite_split_f() {
+    fd=$(dirname "$1")
+    fb=$(basename "$1")
+    fsubdir=$(basename "$fd")
+    # sanity checks
+    if [[ ! -f $1 || -z $fsubdir || -z $fb ]]; then
+        fd= fb= fsubdir=
+    fi
+}
+
+testsuite_check_sha() {
+    (cd "$1" && sha256sum -b */* | LC_ALL=C sort -k2) > $1/.sha256sums.current
+    echo
+    cat $1/.sha256sums.current
+    if ! cmp -s $1/.sha256sums.expected $1/.sha256sums.current; then
+        echo "UPX-ERROR: $1 FAILED: checksum mismatch"
+        diff -u $1/.sha256sums.expected $1/.sha256sums.current || true
+        exit_code=99
+        let num_errors+=1 || true
+        all_errors="${all_errors} $1"
+        #exit 99
+    fi
+    echo
+}
+
+testsuite_check_sha_decompressed() {
+    (cd "$1" && sha256sum -b */* | LC_ALL=C sort -k2) > $1/.sha256sums.current
+    if ! cmp -s $1/.sha256sums.expected $1/.sha256sums.current; then
+        cat $1/.sha256sums.current
+        echo "UPX-ERROR: FATAL: $1 FAILED: decompressed checksum mismatch"
+        diff -u $1/.sha256sums.expected $1/.sha256sums.current || true
+        exit 98
+    fi
+}
+
+testsuite_use_canonicalized=1
+testsuite_run_compress() {
+    testsuite_header $testdir
+    local files f
+    if [[ $testsuite_use_canonicalized == 1 ]]; then
+        files=t020_canonicalized/*/*
+    else
+        files=t010_decompressed/*/*
+    fi
+    for f in $files; do
+        testsuite_split_f $f
+        [[ -z $fb ]] && continue
+        echo "# $f"
+        mkdir -p $testdir/$fsubdir $testdir/.decompressed/$fsubdir
+        $upx_run -qq --prefer-ucl "$@" $f -o $testdir/$fsubdir/$fb
+        $upx_run -qq -d $testdir/$fsubdir/$fb -o $testdir/.decompressed/$fsubdir/$fb
+    done
+    testsuite_check_sha $testdir
+    $upx_run -qq -l $testdir/*/*
+    $upx_run -qq --file-info $testdir/*/*
+    $upx_run -q -t $testdir/*/*
+    if [[ $testsuite_use_canonicalized == 1 ]]; then
+        # check that after decompression the file matches the canonicalized version
+        cp t020_canonicalized/.sha256sums.expected $testdir/.decompressed/
+        testsuite_check_sha_decompressed $testdir/.decompressed
+        rm -rf "./$testdir/.decompressed"
+    fi
+}
+
+# /***********************************************************************
+# // expected checksums
+# //
+# // To ease maintenance of this script in case of updates this section
+# // can be automatically re-created from the current checksums -
+# // see call of function recreate_expected_sha256sums below.
+# ************************************************************************/
+
+recreate_expected_sha256sums() {
+    local o=$1
+    local files f d
+    echo "########## begin .sha256sums.recreate" > "$o"
+    files=*/.sha256sums.current
+    for f in $files; do
+        d=$(dirname "$f")
+        echo "expected_sha256sums__${d}="'"\' >> "$o"
+        cat "$f" >> "$o"
+        echo '"' >> "$o"
+    done
+    echo "########## end .sha256sums.recreate" >> "$o"
+}
+
+source "$argv0dir/travis_testsuite_1-expected_sha256sums.sh" || exit 1
+
+# /***********************************************************************
+# // init
+# ************************************************************************/
+
+#set -x # debug
+exit_code=0
+num_errors=0
+all_errors=
+
+if [[ $BM_T =~ (^|\+)ALLOW_FAIL($|\+) ]]; then
+    echo "ALLOW_FAIL"
+    set +e
+fi
+
+[[ -z $upx_exe && -f $upx_BUILDDIR/upx.out ]] && upx_exe=$upx_BUILDDIR/upx.out
+[[ -z $upx_exe && -f $upx_BUILDDIR/upx.exe ]] && upx_exe=$upx_BUILDDIR/upx.exe
+if [[ -z $upx_exe ]]; then exit 1; fi
+upx_run=$upx_exe
+if [[ $BM_T =~ (^|\+)qemu($|\+) && -n $upx_qemu ]]; then
+    upx_run="$upx_qemu $upx_qemu_flags -- $upx_exe"
+fi
+if [[ $BM_T =~ (^|\+)wine($|\+) && -n $upx_wine ]]; then
+    upx_run="$upx_wine $upx_wine_flags $upx_exe"
+fi
+if [[ $BM_T =~ (^|\+)valgrind($|\+) ]]; then
+    if [[ -z $upx_valgrind ]]; then
+        upx_valgrind="valgrind"
+    fi
+    if [[ -z $upx_valgrind_flags ]]; then
+        #upx_valgrind_flags="--leak-check=full --show-reachable=yes"
+        #upx_valgrind_flags="-q --leak-check=no --error-exitcode=1"
+        upx_valgrind_flags="--leak-check=no --error-exitcode=1"
+    fi
+    upx_run="$upx_valgrind $upx_valgrind_flags $upx_exe"
+fi
+
+if [[ $BM_B =~ (^|\+)coverage($|\+) ]]; then
+    (cd / && cd "$upx_BUILDDIR" && lcov -d . --zerocounters)
+fi
+
+export UPX="--prefer-ucl --no-color --no-progress"
+export UPX_DEBUG_DISABLE_GITREV_WARNING=1
+export UPX_DEBUG_DOCTEST_VERBOSE=0
+
+# let's go
+if ! $upx_run --version-short;    then echo "UPX-ERROR: FATAL: upx --version-short FAILED"; exit 1; fi
+if ! $upx_run -L >/dev/null 2>&1; then echo "UPX-ERROR: FATAL: upx -L FAILED"; exit 1; fi
+if ! $upx_run --help >/dev/null;  then echo "UPX-ERROR: FATAL: upx --help FAILED"; exit 1; fi
+rm -rf ./testsuite_1
+mkbuilddirs testsuite_1
+cd testsuite_1 || exit 1
+
+# /***********************************************************************
+# // decompression tests
+# ************************************************************************/
+
+testdir=t010_decompressed
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+
+testsuite_header $testdir
+for f in $upx_testsuite_SRCDIR/files/packed/*/upx-3.9[15]*; do
+    testsuite_split_f $f
+    [[ -z $fb ]] && continue
+    echo "# $f"
+    mkdir -p $testdir/$fsubdir
+    $upx_run -qq -d $f -o $testdir/$fsubdir/$fb
+done
+testsuite_check_sha $testdir
+
+# run one pack+unpack step to canonicalize the files
+testdir=t020_canonicalized
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+
+testsuite_header $testdir
+for f in t010_decompressed/*/*; do
+    testsuite_split_f $f
+    [[ -z $fb ]] && continue
+    echo "# $f"
+    mkdir -p $testdir/$fsubdir/.packed
+    $upx_run -qq --prefer-ucl -1 $f -o $testdir/$fsubdir/.packed/$fb
+    $upx_run -qq -d $testdir/$fsubdir/.packed/$fb -o $testdir/$fsubdir/$fb
+done
+testsuite_check_sha $testdir
+
+# /***********************************************************************
+# // compression tests
+# // info: we use fast compression levels because we want to
+# //   test UPX and not the compression libraries
+# ************************************************************************/
+
+testdir=t110_compress_ucl_nrv2b_3_no_filter
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+time testsuite_run_compress --nrv2b -3 --no-filter
+
+testdir=t120_compress_ucl_nrv2d_3_no_filter
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+time testsuite_run_compress --nrv2d -3 --no-filter
+
+testdir=t130_compress_ucl_nrv2e_3_no_filter
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+time testsuite_run_compress --nrv2e -3 --no-filter
+
+testdir=t140_compress_lzma_2_no_filter
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+time testsuite_run_compress --lzma -2 --no-filter
+
+testdir=t150_compress_ucl_2_all_filters
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+time testsuite_run_compress -2 --all-filters
+
+testdir=t160_compress_all_methods_1_no_filter
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+time testsuite_run_compress --all-methods -1 --no-filter
+
+testdir=t170_compress_all_methods_no_lzma_5_no_filter
+mkdir $testdir; v=expected_sha256sums__$testdir; echo -n "${!v}" >$testdir/.sha256sums.expected
+time testsuite_run_compress --all-methods --no-lzma -5 --no-filter
+
+# /***********************************************************************
+# // summary
+# ************************************************************************/
+
+# recreate checksums from current version for an easy update in case of changes
+recreate_expected_sha256sums .sha256sums.recreate
+
+testsuite_header "UPX testsuite summary"
+if ! $upx_run --version-short; then
+    echo "UPX-ERROR: upx --version-short FAILED"
+    exit 1
+fi
+echo
+echo "upx_exe='$upx_exe'"
+if [[ $upx_run != "$upx_exe" ]]; then
+    echo "upx_run='$upx_run'"
+fi
+if [[ -f $upx_exe ]]; then
+    ls -l "$upx_exe"
+    file "$upx_exe" || true
+fi
+echo "upx_testsuite_SRCDIR='$upx_testsuite_SRCDIR'"
+echo "upx_testsuite_BUILDDIR='$upx_testsuite_BUILDDIR'"
+echo ".sha256sums.{expected,current}:"
+cat */.sha256sums.expected | LC_ALL=C sort | wc
+cat */.sha256sums.current  | LC_ALL=C sort | wc
+echo
+if [[ $exit_code == 0 ]]; then
+    echo "UPX testsuite passed. All done."
+else
+    echo "UPX-ERROR: UPX testsuite FAILED:${all_errors}"
+    echo "UPX-ERROR: UPX testsuite FAILED with $num_errors error(s). See log file."
+fi
+exit $exit_code

.github/workflows/ci.yml

@@ -0,0 +1,271 @@
+# Support for GitHub Actions -- https://github.com/features/actions
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+# note: GitHub Actions runner images are frequently updated, and
+# unfortunately this sometimes breaks builds in mysterious ways...
+# see https://github.com/actions/runner-images.git
+
+name: 'CI'
+
+on:
+  push:
+    branches:
+      - '*'
+      - '!appveyor*'
+      - '!gitlab*'
+      - '!travis*'
+  workflow_dispatch:
+
+env:
+  UPX_CMAKE_BUILD_FLAGS: --verbose
+
+jobs:
+  job-rebuild-and-verify-stubs:
+    name: 'Rebuild stubs'
+    runs-on: ubuntu-20.04
+    steps:
+      - name: 'Install extra packages'
+        run: |
+          uname -a; pwd; id; umask
+          cd ..; mkdir -p deps; cd deps; mkdir packages
+          # for ubuntu-22.04: install python2
+          ##export DEBIAN_FRONTEND=noninteractive
+          ##sudo apt-get install -y --no-install-recommends python2-minimal
+          # manually install compat libs from Ubuntu 16.04
+          wget -q 'http://mirror.enzu.com/ubuntu/pool/main/g/gmp/libgmp10_6.1.0+dfsg-2_amd64.deb'
+          wget -q 'http://mirror.enzu.com/ubuntu/pool/main/m/mpfr4/libmpfr4_3.1.4-1_amd64.deb'
+          for f in *.deb; do dpkg -x $f ./packages; done
+          sudo mv -v -n ./packages/usr/lib/x86_64-linux-gnu/lib* /usr/lib/x86_64-linux-gnu/
+          sudo ldconfig
+          wget -q -O - https://github.com/upx/upx-stubtools/releases/download/v20210104/bin-upx-20210104.tar.xz | tar -xJ
+      - name: 'Check out code'
+        uses: actions/checkout@v3
+        with: { submodules: true }
+      - name: 'Rebuild and verify stubs'
+        run: |
+          env C=gcc X=rebuild-stubs TRAVIS_OS_NAME=linux bash ./.github/travis_build.sh
+      - name: 'Check source code formatting'
+        run: |
+          bash ./misc/scripts/check_whitespace_git.sh
+          env UPX_CLANG_FORMAT="$PWD/../deps/bin-upx-20210104/clang-format-10.0.1" make -C src clang-format
+          if ! git diff --quiet; then git diff; exit 1; fi
+
+  job-linux-cmake:
+    needs: [ job-rebuild-and-verify-stubs ]
+    name: ${{ format('{0} cmake', matrix.os) }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: ubuntu-20.04 }
+          - { os: ubuntu-22.04 }
+    steps:
+      - name: 'Check out code'
+        uses: actions/checkout@v3
+        with: { submodules: true }
+      - name: 'Build cmake debug-gcc'
+        run:   'make build/debug-gcc'
+      - name: 'Build cmake release-gcc'
+        run:   'make build/release-gcc'
+      - name: 'Build cmake debug-clang'
+        run:   'make build/debug-clang'
+      - name: 'Build cmake release-clang'
+        run:   'make build/release-clang'
+      - name: 'Make artifact'
+        run: |
+          N=upx-${GITHUB_REF_NAME}-${GITHUB_SHA:0:7}-${{ matrix.os }}
+          mkdir -p "tmp/artifact/$N"
+          (cd build && cp -ai --parents */upx "../tmp/artifact/$N")
+          (cd tmp/artifact && tar --sort=name -czf "$N.tar.gz" "$N" && rm -rf "./$N")
+          # GitHub Actions magic: set "artifact_name" environment value for use in next step
+          echo "artifact_name=$N" >> $GITHUB_ENV
+      - name: ${{ format('Upload artifact {0}', env.artifact_name) }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ env.artifact_name }}
+          path: tmp/artifact
+      - name: 'Run basic tests'
+        run: |
+          make -C build/debug-gcc test
+          make -C build/release-gcc test
+          make -C build/debug-clang test
+          make -C build/release-clang test
+
+  job-macos-cmake:
+    needs: [ job-rebuild-and-verify-stubs ]
+    name: ${{ format('{0} cmake', matrix.os) }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { os: macos-11, gcc: gcc-10, gxx: 'g++-10' }
+          # { os: macos-12, gcc: gcc-11, gxx: 'g++-11' } # disable gcc - XCode 14.0 ld bug
+          - { os: macos-12 }
+    steps:
+      - name: 'Check out code'
+        uses: actions/checkout@v3
+        with: { submodules: true }
+      - name: 'Build cmake debug-gcc'
+        if: ${{ matrix.gcc != '' }}
+        run:   'make build/debug-gcc CC=${{ matrix.gcc }} CXX=${{ matrix.gxx }}'
+      - name: 'Build cmake release-gcc'
+        if: ${{ matrix.gcc != '' }}
+        run:   'make build/release-gcc CC=${{ matrix.gcc }} CXX=${{ matrix.gxx }}'
+      - name: 'Build cmake debug-clang'
+        run:   'make build/debug-clang'
+      - name: 'Build cmake release-clang'
+        run:   'make build/release-clang'
+      - name: 'Make artifact'
+        run: |
+          N=upx-${GITHUB_REF_NAME}-${GITHUB_SHA:0:7}-${{ matrix.os }}
+          mkdir -p "tmp/artifact/$N"
+          (cd build && rsync -R -a */upx "../tmp/artifact/$N/")
+          (cd tmp/artifact && gtar --sort=name -czf "$N.tar.gz" "$N" && rm -rf "./$N")
+          # GitHub Actions magic: set "artifact_name" environment value for use in next step
+          echo "artifact_name=$N" >> $GITHUB_ENV
+      - name: ${{ format('Upload artifact {0}', env.artifact_name) }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ env.artifact_name }}
+          path: tmp/artifact
+      - name: 'Run basic tests'
+        run: |
+          make -C build/debug-clang test
+          make -C build/release-clang test
+
+  job-windows-cmake:
+    needs: [ job-rebuild-and-verify-stubs ]
+    name: ${{ format('{0} cmake', matrix.os) }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # windows-2019 used to work but got broken with the 20220821.1
+          # runner-image update; disable for now
+          # see https://github.com/actions/runner-images.git
+          ####- { os: windows-2019 }
+          - { os: windows-2022 }
+    steps:
+      - name: 'Check out code'
+        uses: actions/checkout@v3
+        with: { submodules: true }
+      - name: 'Inspect runner-image settings'
+        # see https://github.com/actions/runner-images.git
+        if: ${{ false }}
+        run: |
+          Get-Command bash; Get-Command cmake; Get-Command make
+          bash --version; cmake --version; make --version
+          Get-Command cl -ErrorAction SilentlyContinue
+      - name: 'Build cmake debug'
+        run:   'make build/debug'
+      - name: 'Build cmake release'
+        run:   'make build/release'
+      - name: 'Make artifact'
+        shell: bash
+        run: |
+          N=upx-${GITHUB_REF_NAME}-${GITHUB_SHA:0:7}-${{ matrix.os }}
+          mkdir -p "tmp/artifact/$N"
+          (cd build && cp -ai --parents */*/upx.exe "../tmp/artifact/$N")
+          # GitHub Actions magic: set "artifact_name" environment value for use in next step
+          echo "artifact_name=$N" >> $GITHUB_ENV
+      - name: ${{ format('Upload artifact {0}', env.artifact_name) }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ env.artifact_name }}
+          path: tmp/artifact
+      - name: 'Run basic tests'
+        run: |
+          cmake --build build/debug   --config Debug   --target RUN_TESTS
+          cmake --build build/release --config Release --target RUN_TESTS
+
+  job-windows-toolchains:
+    needs: [ job-rebuild-and-verify-stubs ]
+    name: ${{ matrix.name }}
+    runs-on: ${{ matrix.os }}
+    env:
+      C: ${{ matrix.C }}
+      B: release
+      H: 'd:\a\upx'
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { name: amd64-win64-msvc-14.2, os: windows-2019, C: msvc-14.2-x64, A: x64 }
+          - { name: amd64-win64-msvc-14.3, os: windows-2022, C: msvc-14.3-x64, A: x64 }
+          - { name: i386-win32-msvc-14.2,  os: windows-2019, C: msvc-14.2-x86, A: x86 }
+          - { name: i386-win32-msvc-14.3,  os: windows-2022, C: msvc-14.3-x86, A: x86 }
+    steps:
+      - name: 'Check out code'
+        uses: actions/checkout@v3
+        with: { submodules: true }
+      - name: 'Prepare sources'
+        shell: cmd
+        run: |
+          where bash & where cat & where chmod & where cmp & where cp & where curl & where date & where file & where git & where gzip & where mkdir & where mv & where openssl & where readlink & where rm & where rmdir & where sed & where sha256sum & where sort & where ssh & where ssh-add & where ssh-agent & where ssh-keyscan & where tar & where touch
+          git config --global core.autocrlf input
+          git --version & bash --version
+          cd %H%
+          md build build\%C% deps
+          cd deps
+          git clone --depth=1 https://github.com/upx/upx-testsuite
+      - name: 'Set up Developer Command Prompt'
+        uses: ilammy/msvc-dev-cmd@v1
+        with:
+          arch: ${{ matrix.A }}
+      - name: 'Build'
+        shell: cmd
+        run: |
+          @REM setup directories following the VPATH build in travis_build.sh
+          where cl & where link
+          set BDIR=%H%\build\%C%\%B%
+          md %BDIR% %BDIR%\ucl %BDIR%\upx %BDIR%\upx-testsuite %BDIR%\zlib
+          set DEFS=-D_CRT_NONSTDC_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS
+          git rev-parse --short=12 HEAD > %BDIR%\upx\.GITREV.txt
+          @REM ===== build UCL =====
+          cd %BDIR%\ucl
+          set s=%H%\upx\vendor\ucl
+          cl -MT -J -O2 -W4 %DEFS% -I%s%\include -I%s% -c %s%\src\*.c
+          link -lib -out:ucl.lib *.obj
+          @REM ===== build zlib =====
+          cd %BDIR%\zlib
+          cl -MT -J -O2 -W3 %DEFS% -c %H%\upx\vendor\zlib\*.c
+          link -lib -out:zlib.lib *.obj
+          @REM ===== build UPX =====
+          cd %BDIR%\upx
+          set s=%H%\upx\src
+          cat .GITREV.txt
+          set /p GITREV=<.GITREV.txt
+          cl -MT -EHsc -J -O2 -W4 -WX -DUPX_VERSION_GITREV="""%GITREV%""" %DEFS% -I%H%\upx\vendor -Feupx.exe %s%\*.cpp %s%\util\*.cpp %BDIR%\ucl\ucl.lib %BDIR%\zlib\zlib.lib /link setargv.obj
+      - name: 'Make artifact'
+        shell: bash
+        run: |
+          N=upx-${GITHUB_REF_NAME}-${GITHUB_SHA:0:7}-${{ matrix.name }}
+          mkdir -p "tmp/artifact/$N/$B"
+          cp -ai ../build/$C/$B/upx/upx*.exe "tmp/artifact/$N/$B"
+          # GitHub Actions magic: set "artifact_name" environment value for use in next step
+          echo "artifact_name=$N" >> $GITHUB_ENV
+      - name: ${{ format('Upload artifact {0}', env.artifact_name) }}
+        uses: actions/upload-artifact@v3
+        with:
+          name: ${{ env.artifact_name }}
+          path: tmp/artifact
+      - name: 'Run basic tests'
+        run: |
+          $ErrorActionPreference = 'stop'
+          $ErrorView = 'NormalView'
+          cd $Env:H\build\$Env:C\$Env:B\upx
+          $Env:UPX = "--no-color --no-progress"
+          .\upx.exe --version
+          .\upx.exe upx.exe -o upx_packed.exe
+          dir *.exe
+          .\upx.exe -l upx_packed.exe
+          .\upx.exe -t upx_packed.exe
+          .\upx_packed.exe --version
+      - name: 'Run test suite'
+        run: |
+          bash ./.github/travis_testsuite_1.sh
+
+# vim:set ts=2 sw=2 et:

.github/workflows/close-stale-issues.yml

@@ -0,0 +1,35 @@
+# see https://docs.github.com/en/actions/managing-issues-and-pull-requests/closing-inactive-issues
+# see https://github.com/actions/stale
+
+# Automatically closing issues is far from perfect, but then we only have
+# limited resources and this approach favors issues that people
+# actually care about.
+#
+# also see:
+#   "Should I Stale or Should I Close? An Analysis of a Bot that Closes
+#    Abandoned Issues and Pull Request".
+#   https://igorwiese.com/images/papers/Paper_BotSE_19.pdf
+
+name: 'Close inactive issues'
+on:
+  schedule:
+    - cron: "30 6 * * 4"
+  workflow_dispatch:
+jobs:
+  close-issues:
+    name: 'Close inactive issues'
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      - uses: actions/stale@v6
+        with:
+#         operations-per-run: 300
+          days-before-stale: 60
+          days-before-close: 30
+          stale-issue-message: 'This issue is stale because it has been open 60 days with no activity. Please remove the stale label or add a comment or this issue will be closed in 30 days.'
+          stale-pr-message:       'This PR is stale because it has been open 60 days with no activity. Please remove the stale label or add a comment or this PR will be closed in 30 days.'
+          close-issue-message: 'This issue was closed because it has been stalled for 30 days with no activity. Please feel free to reopen.'
+          close-pr-message:       'This PR was closed because it has been stalled for 30 days with no activity. Please feel free to reopen.'
+          repo-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,38 @@
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "devel", "devel4", "devel5", "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "devel", "devel4", "devel5" ]
+  schedule:
+    - cron: '20 1 * * 3'
+  workflow_dispatch:
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'cpp' ]
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+      with: { submodules: true }
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2

.github/workflows/nopr.yml

@@ -0,0 +1,16 @@
+name: 'Close pull requests'
+on:
+  #pull_request:
+  workflow_dispatch:
+jobs:
+  close-pull-requests:
+    name: 'Close pull requests'
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: write
+    steps:
+      - name: 'Close pull requests'
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          gh pr list --repo='${{ github.repository }}' --state=open --json=number | jq '.[].number' | xargs -r -n1 -- gh pr close --repo='${{ github.repository }}'

.gitignore

@@ -0,0 +1,49 @@
+/.hg*
+/.vscode*
+/Makevars.global*
+/build*
+/maint*
+/vendor*
+
+.depend
+GNUmakefile
+MMakefile
+Makevars.local*
+tmp-testsuite*
+
+*.a
+*.d
+*.dll
+*.exe
+*.lib
+*.map
+*.o
+*.obj
+*.out
+*.py[cdo]
+*.so
+*.swp
+*.ttp
+
+doc/*.man
+doc/*.ps
+doc/*.tex
+
+src/stub/**/.*-stamp
+src/stub/**/MMakefile
+src/stub/tmp*/*.bin
+src/stub/tmp*/*.bin.bindump
+src/stub/tmp*/*.bin.disasm
+src/stub/tmp*/*.d
+src/stub/tmp*/*.o
+src/stub/tmp*/*.o.disasm
+src/stub/tmp*/mips.r3000-*.[is]
+src/stub/tmp*/mipsel.r3000-*.[is]
+src/stub/src/**/tmp*/*
+
+src/stub/tools/armpe/armpe_tester.exe
+src/stub/tools/armpe/armpe_tester.out
+
+src/stub/tools/sstrip/amd64-linux-sstrip
+src/stub/tools/sstrip/i386-linux-sstrip
+src/stub/tools/sstrip/sstrip

.gitmodules

@@ -0,0 +1,20 @@
+[submodule "vendor/doctest"]
+    path = vendor/doctest
+    url = https://github.com/upx/upx-vendor-doctest.git
+    branch = upx-vendor
+    shallow = true
+[submodule "vendor/lzma-sdk"]
+    path = vendor/lzma-sdk
+    url = https://github.com/upx/upx-vendor-lzma-sdk.git
+    branch = upx-vendor
+    shallow = true
+[submodule "vendor/ucl"]
+    path = vendor/ucl
+    url = https://github.com/upx/upx-vendor-ucl.git
+    branch = upx-vendor
+    shallow = true
+[submodule "vendor/zlib"]
+    path = vendor/zlib
+    url = https://github.com/upx/upx-vendor-zlib.git
+    branch = upx-vendor
+    shallow = true

.hgignore

@@ -1,48 +0,0 @@
-syntax: regexp
-
-^\.bzr
-^ChangeLog
-^build
-^maint
-
-syntax: glob
-
-*.a
-*.dll
-*.lib
-*.py[cdo]
-*.so
-*.swp
-
-doc/*.1
-doc/*.doc
-doc/*.html
-doc/*.man
-doc/*.ps
-doc/*.tex
-
-src/GNUmakefile
-src/MMakefile
-src/compress_nrv*
-src/*.mft
-src/*.rc
-
-src/*.d
-src/*.exe
-src/*.map
-src/*.o
-src/*.obj
-src/*.out
-src/*.res
-src/*.ttp
-
-stub/**MMakefile
-stub/**.*-stamp
-stub/tmp*/*
-stub/**/tmp*/*
-
-stub/tools/armpe/armpe_tester
-
-stub/tools/sstrip/amd64-linux-sstrip
-stub/tools/sstrip/i386-linux-sstrip
-stub/tools/sstrip/sstrip

.hgtags

@@ -1,11 +0,0 @@
-140415ffbcef86a42b4d672249927364430d3d38 RELEASE_111
-223ac5b23f9731ceac9ff8d65167df4900776e36 RELEASE_190
-2c753c5bf38e7322715e2a5c6c5381111bd7a61a RELEASE_194
-2ee65b77f9117651e2e5517b2edede23698d73ca RELEASE_196
-70402aeee6e0e4fc2889658ed8cee44461c0b0a8 RELEASE_200
-a916a2fe22de45167d25abcb40008315f415221c RELEASE_201
-a935d577fc7dd9c2c87761c9c702805da6ce1e51 RELEASE_193
-b0353253b0b3d062eb5adb50d4b665a96620da45 RELEASE_195
-c2e0cd4d621b047f254f2def42132a03683ff52c RELEASE_192
-eb1ce56dce7dd1835964362470610925963b9043 RELEASE_110
-ed96891ef795bceec6b7ff3ca1ca7764431bfb39 RELEASE_191

CMakeLists.txt

@@ -0,0 +1,234 @@
+cmake_minimum_required(VERSION 3.10 FATAL_ERROR)
+
+# config options
+option(UPX_CONFIG_DISABLE_GITREV   "Do not compile with default Git version info.")
+option(UPX_CONFIG_DISABLE_SANITIZE "Do not compile with default sanitize options.")
+option(UPX_CONFIG_DISABLE_WERROR   "Do not compile with default -Werror option.")
+
+#***********************************************************************
+# init
+#***********************************************************************
+
+# Disallow in-source builds. Note that you will still have to manually
+# clean up a few files if you accidentally try an in-source build.
+set(CMAKE_DISABLE_IN_SOURCE_BUILD ON)
+set(CMAKE_DISABLE_SOURCE_CHANGES  ON)
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+if(",${CMAKE_SOURCE_DIR}," STREQUAL ",${CMAKE_BINARY_DIR},")
+    message(FATAL_ERROR "ERROR: In-source builds are not allowed, please use an extra build dir.")
+endif()
+
+# determine git revision
+set(GITREV_SHORT "")
+set(GITREV_PLUS "")
+find_package(Git)
+if(GIT_FOUND AND NOT UPX_CONFIG_DISABLE_GITREV)
+    execute_process(
+        RESULT_VARIABLE result
+        COMMAND "${GIT_EXECUTABLE}" rev-parse --short=12 HEAD
+        ERROR_QUIET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        OUTPUT_VARIABLE GITREV_SHORT
+    )
+    string(LENGTH "${GITREV_SHORT}" l)
+    if(${result} EQUAL 0 AND ${l} EQUAL 12)
+        execute_process(RESULT_VARIABLE result COMMAND "${GIT_EXECUTABLE}" diff --quiet)
+        if(NOT ${result} EQUAL 0)
+            set(GITREV_PLUS "+")
+        endif()
+    else()
+        set(GITREV_SHORT "")
+    endif()
+endif()
+if(NOT IS_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/.git") # extra check
+    set(GITREV_SHORT "")
+endif()
+if(GITREV_SHORT)
+    message(STATUS "UPX_VERSION_GITREV = \"${GITREV_SHORT}${GITREV_PLUS}\"")
+else()
+    message(STATUS "UPX_VERSION_GITREV: not set")
+endif()
+
+project(upx VERSION 4.0.0 LANGUAGES C CXX)
+
+# set default build type to "Release"
+get_property(is_multi_config GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(is_multi_config)
+    set(c "${CMAKE_CONFIGURATION_TYPES}")
+    list(INSERT c 0 "Release")
+    list(INSERT c 1 "Debug")
+    if (CMAKE_BUILD_TYPE)
+        list(INSERT c 0 "${CMAKE_BUILD_TYPE}")
+    endif()
+    list(REMOVE_DUPLICATES c)
+    set(CMAKE_CONFIGURATION_TYPES "${c}" CACHE STRING "List of supported configuration types." FORCE)
+elseif(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build." FORCE)
+endif()
+
+#***********************************************************************
+# targets and compilation flags
+#***********************************************************************
+
+file(GLOB ucl_SOURCES "vendor/ucl/src/*.c")
+list(SORT ucl_SOURCES)
+add_library(upx_vendor_ucl STATIC ${ucl_SOURCES})
+set_property(TARGET upx_vendor_ucl PROPERTY C_STANDARD 11)
+
+file(GLOB zlib_SOURCES "vendor/zlib/*.c")
+list(SORT zlib_SOURCES)
+add_library(upx_vendor_zlib STATIC ${zlib_SOURCES})
+set_property(TARGET upx_vendor_zlib PROPERTY C_STANDARD 11)
+
+file(GLOB upx_SOURCES "src/*.cpp" "src/util/*.cpp")
+list(SORT upx_SOURCES)
+add_executable(upx ${upx_SOURCES})
+set_property(TARGET upx PROPERTY CXX_STANDARD 14)
+target_link_libraries(upx upx_vendor_ucl upx_vendor_zlib)
+
+if(UPX_CONFIG_DISABLE_WERROR)
+    set(warn_Werror "")
+    set(warn_WX "")
+else()
+    set(warn_Werror -Werror)
+    set(warn_WX -WX)
+endif()
+
+if(NOT MSVC)
+    # use -O2 instead of -O3 to reduce code size
+    string(REGEX REPLACE "(^| )-O3( |$$)" "\\1-O2\\2" a "${CMAKE_C_FLAGS_RELEASE}")
+    string(REGEX REPLACE "(^| )-O3( |$$)" "\\1-O2\\2" b "${CMAKE_CXX_FLAGS_RELEASE}")
+    set(CMAKE_C_FLAGS_RELEASE "${a}" CACHE STRING "Flags used by the C compiler during RELEASE builds." FORCE)
+    set(CMAKE_CXX_FLAGS_RELEASE "${b}" CACHE STRING "Flags used by the CXX compiler during RELEASE builds." FORCE)
+endif()
+
+if(MSVC)
+    # disable silly warnings about using "deprecated" POSIX functions like fopen()
+    add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
+    add_definitions(-D_CRT_NONSTDC_NO_WARNINGS)
+    add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+    add_definitions(-D_CRT_SECURE_NO_WARNINGS)
+else()
+    # protect against security threats caused by misguided compiler "optimizations"
+    if (CMAKE_C_COMPILER_ID STREQUAL "GNU")
+        add_definitions(-fno-delete-null-pointer-checks)
+    endif()
+    add_definitions(-fno-strict-aliasing -fno-strict-overflow -funsigned-char)
+    # disable overambitious auto-vectorization until this actually gains something
+    add_definitions(-fno-tree-vectorize)
+endif()
+
+set(t upx_vendor_ucl)
+target_include_directories(${t} PRIVATE vendor/ucl/include vendor/ucl)
+if(MSVC)
+    target_compile_options(${t} PRIVATE -J -W4 ${warn_WX})
+else()
+    target_compile_options(${t} PRIVATE -Wall -Wextra -Wvla ${warn_Werror})
+endif()
+
+set(t upx_vendor_zlib)
+if(MSVC)
+    target_compile_options(${t} PRIVATE -DHAVE_STDARG_H -DHAVE_VSNPRINTF -J -W3 ${warn_WX})
+else()
+    target_compile_options(${t} PRIVATE -DHAVE_STDARG_H -DHAVE_UNISTD_H -DHAVE_VSNPRINTF)
+    # clang-15: -Wno-strict-prototypes is needed to silence the new -Wdeprecated-non-prototype warning
+    target_compile_options(${t} PRIVATE -Wall -Wextra -Wvla -Wno-strict-prototypes ${warn_Werror})
+endif()
+
+set(t upx)
+target_include_directories(${t} PRIVATE vendor)
+target_compile_definitions(${t} PRIVATE $<$<CONFIG:Debug>:DEBUG=1>)
+if(GITREV_SHORT)
+    target_compile_definitions(${t} PRIVATE UPX_VERSION_GITREV="${GITREV_SHORT}${GITREV_PLUS}")
+endif()
+if(NOT UPX_CONFIG_DISABLE_SANITIZE AND NOT MSVC)
+    # default sanitizer for Debug builds
+    target_compile_options(${t} PRIVATE $<$<CONFIG:Debug>:-fsanitize=undefined -fsanitize-undefined-trap-on-error -fstack-protector-all>)
+    # default sanitizer for Release builds
+    target_compile_options(${t} PRIVATE $<$<CONFIG:Release>:-fstack-protector>)
+endif()
+if(MSVC)
+    target_compile_options(${t} PRIVATE -EHsc -J -W4 ${warn_WX})
+else()
+    target_compile_options(${t} PRIVATE
+        -Wall -Wextra -Wcast-align -Wcast-qual -Wmissing-declarations -Wpointer-arith
+        -Wshadow -Wvla -Wwrite-strings ${warn_Werror}
+    )
+endif()
+
+#***********************************************************************
+# "make test"
+#***********************************************************************
+
+if(NOT CMAKE_CROSSCOMPILING)
+    include(CTest)
+    set(exe ${CMAKE_EXECUTABLE_SUFFIX})
+    set(upx_self_exe "$<TARGET_FILE:upx>")
+    add_test(NAME upx-test-cleanup COMMAND rm -f ./upx.packed${exe} ./upx.unpacked${exe})
+    add_test(NAME upx-version      COMMAND upx --version)
+    add_test(NAME upx-help         COMMAND upx --help)
+    add_test(NAME upx-self-pack    COMMAND upx -3 ${upx_self_exe} -o upx.packed${exe})
+    add_test(NAME upx-list         COMMAND upx -l upx.packed${exe})
+    add_test(NAME upx-fileinfo     COMMAND upx --fileinfo upx.packed${exe})
+    add_test(NAME upx-test         COMMAND upx -t upx.packed${exe})
+    add_test(NAME upx-unpack       COMMAND upx -d upx.packed${exe} -o upx.unpacked${exe})
+    add_test(NAME upx-run-unpacked COMMAND ./upx.unpacked${exe} --version)
+    add_test(NAME upx-run-packed   COMMAND ./upx.packed${exe} --version)
+endif()
+
+# TODO: could add some more explicit test programs; but then, the integrated
+# "doctest" is quite convenient and already covers a number of basic
+# checks - and more complex cases better should be handled by an
+# external test suite.
+
+#***********************************************************************
+# "make install"
+#***********************************************************************
+
+# installation prefix and directories
+if(NOT CMAKE_INSTALL_PREFIX)
+    message(FATAL_ERROR "ERROR: CMAKE_INSTALL_PREFIX is not defined.")
+endif()
+include(GNUInstallDirs)
+
+if(DEFINED CMAKE_INSTALL_FULL_BINDIR)
+    install(TARGETS upx DESTINATION "${CMAKE_INSTALL_FULL_BINDIR}")
+    install(FILES
+        COPYING LICENSE NEWS README doc/upx-doc.html doc/upx-doc.txt
+        DESTINATION "${CMAKE_INSTALL_FULL_DOCDIR}"
+    )
+    install(FILES doc/upx.1 DESTINATION "${CMAKE_INSTALL_FULL_MANDIR}/man1")
+endif()
+
+#***********************************************************************
+# finally print some info about the build configuration
+#***********************************************************************
+
+if(EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/maint/src/CMakeLists.extra.txt")
+include("${CMAKE_CURRENT_SOURCE_DIR}/maint/src/CMakeLists.extra.txt")
+endif()
+
+function(print_var v)
+    if(${v})
+        message(STATUS "${v} = ${${v}}")
+    endif()
+endfunction()
+print_var(CMAKE_BUILD_TYPE)
+print_var(CMAKE_CONFIGURATION_TYPES)
+print_var(CMAKE_INSTALL_PREFIX)
+print_var(CMAKE_CROSSCOMPILING)
+print_var(CMAKE_C_COMPILER_ID)
+print_var(CMAKE_C_COMPILER_VERSION)
+print_var(CMAKE_C_COMPILER_ARCHITECTURE_ID)
+print_var(CMAKE_C_PLATFORM_ID)
+print_var(CMAKE_C_COMPILER_ABI)
+print_var(CMAKE_CXX_COMPILER_ID)
+print_var(CMAKE_CXX_COMPILER_VERSION)
+print_var(CMAKE_CXX_COMPILER_ARCHITECTURE_ID)
+print_var(CMAKE_CXX_PLATFORM_ID)
+print_var(CMAKE_CXX_COMPILER_ABI)
+if (CMAKE_BUILD_TYPE AND NOT CMAKE_BUILD_TYPE MATCHES "^(Debug|Release)$")
+    message(WARNING "WARNING: unsupported CMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}; please use \"Debug\" or \"Release\"")
+endif()
+
+# vim:set ft=cmake ts=4 sw=4 tw=0 et:

COPYING

@@ -1,8 +1,8 @@
                     GNU GENERAL PUBLIC LICENSE
                        Version 2, June 1991
 
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -15,7 +15,7 @@ software--to make sure the software is free for all its users.  This
 General Public License applies to most of the Free Software
 Foundation's software and to any other program whose authors commit to
 using it.  (Some other Free Software Foundation software is covered by
-the GNU Library General Public License instead.)  You can apply it to
+the GNU Lesser General Public License instead.)  You can apply it to
 your programs, too.
 
   When we speak of free software, we are referring to freedom, not
@@ -55,7 +55,7 @@ patent must be licensed for everyone's free use or not licensed at all.
 
   The precise terms and conditions for copying, distribution and
 modification follow.
-
+
                     GNU GENERAL PUBLIC LICENSE
    TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
 
@@ -110,7 +110,7 @@ above, provided that you also meet all of these conditions:
     License.  (Exception: if the Program itself is interactive but
     does not normally print such an announcement, your work based on
     the Program is not required to print an announcement.)
-
+
 These requirements apply to the modified work as a whole.  If
 identifiable sections of that work are not derived from the Program,
 and can be reasonably considered independent and separate works in
@@ -168,7 +168,7 @@ access to copy from a designated place, then offering equivalent
 access to copy the source code from the same place counts as
 distribution of the source code, even though third parties are not
 compelled to copy the source along with the object code.
-
+
   4. You may not copy, modify, sublicense, or distribute the Program
 except as expressly provided under this License.  Any attempt
 otherwise to copy, modify, sublicense or distribute the Program is
@@ -225,7 +225,7 @@ impose that choice.
 
 This section is intended to make thoroughly clear what is believed to
 be a consequence of the rest of this License.
-
+
   8. If the distribution and/or use of the Program is restricted in
 certain countries either by patents or by copyrighted interfaces, the
 original copyright holder who places the Program under this License
@@ -278,7 +278,7 @@ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGES.
 
                      END OF TERMS AND CONDITIONS
-
+
             How to Apply These Terms to Your New Programs
 
   If you develop a new program, and you want it to be of the greatest
@@ -291,7 +291,7 @@ convey the exclusion of warranty; and each file should have at least
 the "copyright" line and a pointer to where the full notice is found.
 
     <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) 19yy  <name of author>
+    Copyright (C) <year>  <name of author>
 
     This program is free software; you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -303,17 +303,16 @@ the "copyright" line and a pointer to where the full notice is found.
     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
+    You should have received a copy of the GNU General Public License along
-    along with this program; if not, write to the Free Software
+    with this program; if not, write to the Free Software Foundation, Inc.,
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
 
 Also add information on how to contact you by electronic and paper mail.
 
 If the program is interactive, make it output a short notice like this
 when it starts in an interactive mode:
 
-    Gnomovision version 69, Copyright (C) 19yy name of author
+    Gnomovision version 69, Copyright (C) year name of author
     Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
     This is free software, and you are welcome to redistribute it
     under certain conditions; type `show c' for details.
@@ -336,5 +335,5 @@ necessary.  Here is a sample; alter the names:
 This General Public License does not permit incorporating your program into
 proprietary programs.  If your program is a subroutine library, you may
 consider it more useful to permit linking proprietary applications with the
-library.  If this is what you want to do, use the GNU Library General
+library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.

Makefile

@@ -1,47 +1,85 @@
 #
-# UPX toplevel Makefile - needs GNU make 3.80 or better
+# UPX top-level Makefile - needs GNU make and CMake >= 3.13
 #
 
-MAKEFLAGS += -rR
+# NOTE: if you only have CMake 3.10 then you can invoke cmake manually like this:
-.SUFFIXES:
+#   mkdir -p build/release
-export SHELL = /bin/sh
+#   cd build/release
+#   cmake ../..
+#   cmake --build .
 
-srcdir = .
+CMAKE = cmake
-top_srcdir = .
+UPX_CMAKE_BUILD_FLAGS += --parallel
-
+ifneq ($(VERBOSE),)
-
+  UPX_CMAKE_BUILD_FLAGS += --verbose
-# info: src/stub needs GNU make 3.81 and special build tools
-BUILD_STUB = 0
-ifneq ($(wildcard $(HOME)/local/bin/bin-upx/.),)
-BUILD_STUB = 1
-endif
-ifneq ($(wildcard $(HOME)/bin/bin-upx/.),)
-BUILD_STUB = 1
-endif
-ifneq ($(findstring $(firstword $(MAKE_VERSION)),3.79 3.79.1 3.80),)
-BUILD_STUB = 0
 endif
 
-
+# check git submodules
-default:
+ifeq ($(wildcard ./vendor/doctest/doctest/.),)
-	@echo "UPX info: please choose a target for 'make'"
+  $(error ERROR: missing git submodule; run 'git submodule update --init')
-
-all mostlyclean clean distclean maintainer-clean:
-ifeq ($(BUILD_STUB),1)
-	$(MAKE) -C src/stub $@
 endif
-	$(MAKE) -C src $@
+ifeq ($(wildcard ./vendor/lzma-sdk/C/.),)
-	$(MAKE) -C doc $@
+  $(error ERROR: missing git submodule; run 'git submodule update --init')
-
+endif
-# automatically generate ChangeLog from Mercurial repo
+ifeq ($(wildcard ./vendor/ucl/include/.),)
-ChangeLog:
+  $(error ERROR: missing git submodule; run 'git submodule update --init')
-ifneq ($(wildcard .hg/data/.),)
+endif
-	hg log --style=changelog > $@
+ifeq ($(wildcard ./vendor/zlib/crc32.c),)
-else
+  $(error ERROR: missing git submodule; run 'git submodule update --init')
-	@echo "UPX info: no hg repo found"
 endif
 
+#***********************************************************************
+# default
+#***********************************************************************
 
-.PHONY: default all mostlyclean clean distclean maintainer-clean
+__check_cache = $(if $(wildcard $1/CMakeCache.txt),@true,)
-.PHONY: ChangeLog
+run_config = $(call __check_cache,$1) $(CMAKE) -S . -B $1 $(UPX_CMAKE_CONFIG_FLAGS) -DCMAKE_BUILD_TYPE=$2
+run_build  =                          $(CMAKE) --build $1 $(UPX_CMAKE_BUILD_FLAGS) --config $2
 
+default: build/release
+
+build/debug: PHONY
+	$(call run_config,$@,Debug)
+	$(call run_build,$@,Debug)
+
+build/release: PHONY
+	$(call run_config,$@,Release)
+	$(call run_build,$@,Release)
+
+#***********************************************************************
+# some pre-defined build configurations
+#***********************************************************************
+
+# force building with gcc/g++
+build/%-gcc: export CC=gcc
+build/%-gcc: export CXX=g++
+build/debug-gcc: PHONY
+	$(call run_config,$@,Debug)
+	$(call run_build,$@,Debug)
+build/release-gcc: PHONY
+	$(call run_config,$@,Release)
+	$(call run_build,$@,Release)
+
+# force building with clang/clang++
+build/%-clang: export CC=clang
+build/%-clang: export CXX=clang++
+build/debug-clang: PHONY
+	$(call run_config,$@,Debug)
+	$(call run_build,$@,Debug)
+build/release-clang: PHONY
+	$(call run_config,$@,Release)
+	$(call run_build,$@,Release)
+
+# cross compiler: Windows mingw-w64
+build/%-cross-mingw64: export CC=x86_64-w64-mingw32-gcc
+build/%-cross-mingw64: export CXX=x86_64-w64-mingw32-g++
+#   disable sanitize to avoid link errors on GitHub CI
+build/%-cross-mingw64: UPX_CMAKE_CONFIG_FLAGS += -DUPX_CONFIG_DISABLE_SANITIZE=1
+build/debug-cross-mingw64: PHONY
+	$(call run_config,$@,Debug)
+	$(call run_build,$@,Debug)
+build/release-cross-mingw64: PHONY
+	$(call run_config,$@,Release)
+	$(call run_build,$@,Release)
+
+.PHONY: default PHONY

NEWS

@@ -2,22 +2,170 @@
 User visible changes for UPX
 ==================================================================
 
-Changes in 2.90 (08 Oct 2006):
+Changes in 3.99 (27 Oct 2022):
+  * NOTE: this is a pre-release with known regressions for some ELF formats;
+    please help testing and reporting bugs, and see our GitHub Actions CI
+    page for up-to-date pre-built binaries ("Artifacts")
+    https://github.com/upx/upx/actions/workflows/ci.yml
+  * SECURITY NOTES: emphasize the security context in the docs
+  * Support easy building from source code with CMake
+  * Add support for EFI files (PE x86; Kornel Pal)
+  * bug fixes - see https://github.com/upx/upx/milestone/6
+
+Changes in 3.96 (23 Jan 2020):
+  * bug fixes - see https://github.com/upx/upx/milestone/5
+
+Changes in 3.95 (26 Aug 2018):
+  * Flag --android-shlib to work around bad design in Android
+  * Flag --force-pie when ET_DYN main program is not marked as DF_1_PIE
+  * Better compatibility with varying layout of address space on Linux
+  * Support for 4 PT_LOAD layout in ELF generated by binutils-2.31
+  * bug fixes, particularly better diagnosis of malformed input
+  * bug fixes - see https://github.com/upx/upx/milestone/4
+
+Changes in 3.94 (12 May 2017):
+  * Add support for arm64-linux (aka "aarch64").
+  * Add support for --lzma compression on 64-bit PowerPC (Thierry Fauck).
+  * For Mach, "upx -d" will unpack a prefix of the file (and warn).
+  * Various improvements to the ELF formats.
+  * bug fixes - see https://github.com/upx/upx/milestone/3
+
+Changes in 3.93 (29 Jan 2017):
+  * Fixed some win32/pe and win64/pe regressions introduced in 3.92
+  * bug fixes - see https://github.com/upx/upx/milestone/2
+
+Changes in 3.92 (11 Dec 2016):
+  * INFO: UPX has moved to GitHub - the new home page is https://upx.github.io
+  * IMPORTANT: all PE formats: internal changes: reunited the diverged source
+    files - please report all regressions into the bug tracker and try UPX 3.91
+    in case of problems.
+  * Support Apple MacOS 10.12 "Sierra", including more-robust de-compression.
+  * Explicitly diagnose Go-language bad PT_LOAD; recommend hemfix.c.
+    https://sourceforge.net/p/upx/bugs/195/   https://github.com/pwaller/goupx
+  * Fix CERT-FI Case 829767 UPX command line tools segfaults.
+    Received by UPX Team on 2015-May-08; originally reported
+    by Codenomicon to NCSC-FI on 2015-01-08.
+    The vulnerabilities were discovered by Joonas Kuorilehto and
+    Antti Häyrynen from Codenomicon.
+  * bug fixes - see https://github.com/upx/upx/milestone/1
+
+Changes in 3.91 (30 Sep 2013):
+  * Added experimental support for Windows 64-bit PE files, based on
+    work by Stefan Widmann. Please use for testing only!
+  * bug fixes
+
+==================================================================
+
+Changes in 3.09 (18 Feb 2013):
+  * New option --preserve-build-id for GNU ELF.
+  * Allow for code signing and LC_UUID on Mac OS X executables.
+  * Allow non-contiguous LC_SEGMENTs and 0==.vmsize for Mach-O.
+  * Allow zero-filled final page in PackUnix::canUnpack().
+  * bug fixes
+
+Changes in 3.08 (12 Dec 2011):
+  * Fix allocation in runtime stub for darwin.macho-entry (i386 and amd64).
+  * Compress shared library on ELF i386 only [ld.so threatens even this case].
+  * Attempt to support ELF on QNX 6.3.0 for armel (experimental).
+  * Better diagnostic when ELF -fPIC is needed.
+  * PT_NOTE improvements for *BSD.
+  * Preserve more ELF .e_flags on ARM.
+  * Minor code improvements for ELF stubs.
+  * Defend against another flavor of corrupt PE header.
+  * bug fixes
+
+Changes in 3.07 (08 Sep 2010):
+  * win32/pe: fixed relocation handling for files with *no* TLS callbacks
+    [severe bug introduced in 3.06]
+
+Changes in 3.06 (04 Sep 2010):
+  * win32/pe: TLS callback support contributed by Stefan Widmann. Thanks!
+  * bug fixes
+
+Changes in 3.05 (27 Apr 2010):
+  * i386-linux and amd64-linux support shared libraries (DT_INIT must
+    exist, all info needed by runtime loader must be first in .text, etc.)
+  * Linux /proc/self/exe now is preserved by default, by leaving behind
+    one page.  New compress-time option --unmap-all-pages is available.
+  * Withdraw support for shared libraries on Darwin (Apple Mac OS X)
+    because upx does not understand enough about .dylib.
+  * bug fixes
+
+Changes in 3.04 (27 Sep 2009):
+  * new format Mach/AMD64 supports 64-bit programs on Apple Macintosh.
+  * new formats Dylib/i386 and Dylib/ppc32 support shared libraries
+    [such as browser plugins] on Darwin (Apple Macintosh).  An existing
+    -init function (LC_ROUTINES command) is required.
+  * new format vmlinuz/armel for Debian NSLU2 (etc.) linux kernel
+  * bvmlinuz boot protocol 2.08 for 386 Linux kernel
+  * Extended ABI version 4 for armel-eabi ARM Linux ELF
+  * bug fixes
+
+Changes in 3.03 (27 Apr 2008):
+  * implement cache flushing for PowerPC (esp. model 440)
+  * fix cache flushing on MIPS (>3 MiB compressed, or with holes)
+  * fix MIPS big-endian
+  * bug fixes
+
+Changes in 3.02 (16 Dec 2007):
+  * fix unmapping on arm-linux.elf
+  * fix error checking in mmap for i386-linux.elf [triggered by -fPIE]
+  * bug fixes
+
+Changes in 3.01 (31 Jul 2007):
+  * new options --no-mode, --no-owner and --no-time to disable preservation
+    of mode (file permissions), file ownership and timestamps.
+  * dos/exe: fixed an incorrect error message caused by a bug in
+    relocation handling
+  * new format linux/mipsel supports ELF on [32-bit] R3000
+  * fix argv[0] on PowerPC with --lzma
+  * bug fixes
+
+Changes in 3.00 (27 Apr 2007):
+  * watcom/le & tmt/adam: fixed a problem when using certain filters
+
+Changes in 2.93 beta (08 Mar 2007):
+  * new formats Mach/i386 and Mach/fat support Mac OS X i686 and
+    Universal binaries [i686 and PowerPC only]
+  * dos/exe: LZMA is now also supported for 16-bit dos/exe. Please note that
+    you have to explicitly use '--lzma' even for '--ultra-brute' here
+    because runtime decompression is about 30 times slower than NRV -
+    which is really noticeable on old machines.
+  * dos/exe: fixed a rarely occurring bug in relocation handling
+  * win32/pe & arm/pe: better icon compression handling
+
+Changes in 2.92 beta (23 Jan 2007):
+  * new option '--ultra-brute' which tries even more variants
+  * slightly improved compression ratio for some files when
+    using '--brute' or '--ultra-brute'
+  * bug fixes
+
+Changes in 2.91 beta (29 Nov 2006):
+  * assorted bug fixes
+  * arm/pe: fix "missing" icon & version info resource problem for wince 5
+  * win32/pe & arm/pe: added option --compress-icons=3 to compress all icons
+
+Changes in 2.90 beta (08 Oct 2006):
   * LZMA algorithm support for most of the 32-bit and 64-bit file formats;
     use new option '--lzma' to enable
   * new format: BSD/elf386 supporting FreeBSD, NetBSD and OpenBSD
     via auto-detection of PT_NOTE or EI_OSABI
   * arm/pe: all the NRV compression methods are now supported
     (only NRV2D is missing in thumb mode)
-  * linux/elf386, linux/ElfAMD remember /proc/self/exe in environment
+  * linux/elf386, linux/ElfAMD: remember /proc/self/exe in environment
-  * vmlinuz/386: fixed zlib uncompression problem on dos
+  * major source code changes: the runtime decompression stubs are now
-  * major source code change: the runtime decompression stubs are now
     built from internal ELF objects
 
+==================================================================
+
+Changes in 2.03 (07 Nov 2006):
+  * bvmlinuz/386: fix for kernels not at 0x100000; also allow x86_64
+  * linux/elf386: work around Linux kernel bug (0-length .bss needs PF_W)
+
 Changes in 2.02 (13 Aug 2006):
   * linux/386: work around Linux kernel bug (".bss" requires PF_W)
   * linux/ppc32, mach/ppc32: compressed programs now work on a 405 CPU
-  * vmlinuz/386: fixed zlib uncompression problem on dos
+  * vmlinuz/386: fixed zlib uncompression problem on DOS
 
 Changes in 2.01 (06 Jun 2006):
   * arm/pe: better DLL support
@@ -286,8 +434,8 @@ Changes in 0.80 (03 Aug 1999)
   * win32/pe: even better TLS support
   * win32/pe: versioninfo works on NT
   * win32/pe: import by ordinal from kernel32.dll works
-  * win32/pe: other import improvements: importing a nonexistant DLL
+  * win32/pe: other import improvements: importing a nonexistent DLL
-    results in a usual Windows message, importing a nonexistant function
+    results in a usual Windows message, importing a nonexistent function
     results in program exit (instead of crash ;-)
   * win32/pe: new option: '--compress-resources=0'
   * win32/pe: reduced memory requirement during uncompression, some
@@ -339,7 +487,7 @@ Changes in 0.60 (06 Mar 1999)
   * win32/pe: fixed file corruption when the size of the export data is invalid
   * win32/pe: fixed a problem with empty resource data
   * win32/pe: compressed file alignment set to minimum value
-  * win32/pe: made all compressed sections writeable
+  * win32/pe: made all compressed sections writable
   * fixed some other win32/pe bugs
   * fixed an address optimization problem for some not Watcom LE files
   * fixed a bug which could make UPX hang when an exe header contained
@@ -380,3 +528,5 @@ Changes in 0.20 (05 Jul 1998)
 Changes in 0.05 (26 May 1998)
   * first public beta release
 
+
+# vim:set syntax=off tw=0 ts=4 sw=4 et: -*- coding: utf-8 -*-

PROJECTS

@@ -1,88 +0,0 @@
-                 ooooo     ooo ooooooooo.   ooooooo  ooooo
-                 `888'     `8' `888   `Y88.  `8888    d8'
-                  888       8   888   .d88'    Y888..8P
-                  888       8   888ooo88P'      `8888'
-                  888       8   888            .8PY888.
-                  `88.    .8'   888           d8'  `888b
-                    `YbodP'    o888o        o888o  o88888o
-
-
-                    The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2006 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
-
-
-Here are some possible projects from which you can choose if you'd like to
-contribute to UPX. Be sure to get in touch with us first to avoid
-duplicate efforts.
-
-
-User interface:
----------------
-
- - Write a nifty Win32 GUI (in C++), but try to keep the size of the
-   final executable small. Compression should be in a separate
-   thread that calls do_one_file() [see src/work.cpp].
-
- - Draw a nice UPX icon.
-
-
-More formats:
--------------
-
- - Amiga
-
- - BeOS
-
- - C64
-
- - elks/8086 (this is a 16-bit linux-8086 kernel)
-   See http://www.elks.ecs.soton.ac.uk/
-
- - freebsd/386 (generic), freebsd/elf386 (specialized).
-   Probably could share most of the linux code.
-
- - add support for self-extracting HTML pages using a Javascript stub
-   (like the AlgART HTML Packer "AHP")
-
-
-Existing formats:
------------------
-
- - djgpp2/coff: add support for DLX dynamic loading
-     (see SEAL http://www.home.sk/public/seal/ )
-
- - dos/com: add support for very long files - convert to exe if necessary
-
- - dos/exe: implement filter support
-
- - linux/i386:
-     - use the new assembly preprocessor stuff (ie. process the file
-       headers internally)
-     - UPX uncompressor daemon
-     - rewrite the stub in assembly (not sure if this is a good idea...)
-
- - watcom/le: add support for per section compression, LX support, VXD
-
- - win32/pe: display a nice dialog box in the stub in case
-     of problems (like importing a DLL or function fails)
- - win32/pe: per section compression
-
-
-Compression ratio:
-------------------
-
- - invent more effective filters
-
- - I (Markus) will continue to work on better compression algorithms,
-   so be sure to do better than me if you plan working on this ;-)
-
-
-Other:
-------
-
- - anything else you think that could improve UPX...
-
-
-Thanks for your contribution.
-

README

@@ -8,8 +8,8 @@
 
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2006 Markus Oberhumer, Laszlo Molnar & John Reiser
+   Copyright (c) 1996-2022 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
+                           https://upx.github.io
 
 
 
@@ -18,10 +18,8 @@ WELCOME
 
 Welcome to UPX !
 
-Please don't forget to read the file LICENSE - UPX is distributed
+UPX is a free, secure, portable, extendable, high-performance
-under the GNU General Public License (GPL) with special exceptions
+executable packer for several executable formats.
-allowing the distribution of all compressed executables, including
-commercial programs.
 
 
 INTRODUCTION
@@ -37,106 +35,88 @@ and run exactly as before, with no runtime or memory penalty for most
 of the supported formats.
 
 UPX supports a number of different executable formats, including
-Windows 95/98/ME/NT/2000/XP/CE programs and DLLs, DOS programs,
+Windows programs and DLLs, macOS apps and Linux executables.
-and Linux executables and kernels.
 
 UPX is free software distributed under the term of the GNU General
 Public License. Full source code is available.
 
 UPX may be distributed and used freely, even with commercial applications.
-See the UPX License Agreement for details.
+See the UPX License Agreements for details.
 
-UPX is rated number one in the well known Archive Comparison Test. Visit
-http://compression.ca/ .
 
-UPX aims to be Commercial Quality Freeware.
+SECURITY CONTEXT
+================
+
+IMPORTANT NOTE: UPX inherits the security context of any files it handles.
+
+This means that packing, unpacking, or even testing or listing a file requires
+the same security considerations as actually executing the file.
+
+Use UPX on trusted files only!
 
 
 SHORT DOCUMENTATION
 ===================
 
 'upx program.exe' will compress a program or DLL. For best compression
-results try 'upx --brute program.exe'.
+results try 'upx --best program.exe' or 'upx --brute program.exe'.
 
 Please see the file UPX.DOC for the full documentation. The files
 NEWS and BUGS also contain various tidbits of information.
 
 
-DISCLAIMER
-==========
-
-UPX comes with ABSOLUTELY NO WARRANTY; for details see the file LICENSE.
-
-Having said that, we think that UPX is quite stable now. Indeed we
-have compressed lots of files without any problems. Also, the
-current version has undergone several months of beta testing -
-actually it's almost 8 years since our first public beta.
-
-This is the first production quality release, and we plan that future
-releases will be backward compatible with this version.
-
-Please report all problems or suggestions to the authors. Thanks.
-
-
 THE FUTURE
 ==========
 
-  - We'd really love to support handheld systems like the PalmPilot because
+  - Stay up-to-date with ongoing OS and executable format changes.
-    compression makes a lot of sense here. And - because of the atari/tos
-    format - we already have a working decompressor in 68000 assembly.
-    Unfortunately we know next to nothing about the operating system
-    architecture of such handhelds, so we need some information from
-    an expert. Please contact us if you think you can help.
 
-  - The Linux approach could probably get ported to a lot of other Unix
+  - RISC-V 64 for Linux.
-    variants, at least for other i386 architectures it shouldn't be too
-    much work. If someone sends me a fresh hard disk and an official
-    FreeBSD/OpenBSD/NetBSD/Solaris/BeOS... CD I might take a look at it ;-)
 
   - We will *NOT* add any sort of protection and/or encryption.
     This only gives people a false feeling of security because
-    by definition all protectors/compressors can be broken.
+    all "protectors" can be broken by definition.
-    And don't trust any advertisment of authors of other executable
-    compressors about this topic - just do a websearch on "unpackers"...
 
-  - Fix all remaining bugs - keep your reports coming ;-)
+  - Fix all remaining bugs - please report any issues
-
+    https://github.com/upx/upx/issues
-  - See the file PROJECTS in the source code distribution if you want
-    to contribute.
 
 
 COPYRIGHT
 =========
 
-Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-Copyright (C) 1996-2006 Laszlo Molnar
+Copyright (C) 1996-2022 Laszlo Molnar
-Copyright (C) 2000-2006 John F. Reiser
+Copyright (C) 2000-2022 John F. Reiser
 
 This program may be used freely, and you are welcome to
 redistribute it under certain conditions.
 
 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
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-UPX License Agreement for more details.
 
-You should have received a copy of the UPX License Agreement along
+UPX is distributed with full source code under the terms of the
-with this program; see the file LICENSE. If not, visit the UPX home page.
+GNU General Public License v2+;
+either under the pure GPLv2+ (see the file COPYING),
+or (at your option) under the GPLv+2 with special exceptions and
+restrictions granting the free usage for commercial
+programs (see the file LICENSE).
+
+You should have received a copy of the UPX License Agreements along
+with this program; see the files COPYING and LICENSE. If not,
+visit the UPX home page.
 
 
 Share and enjoy,
-Markus & Laszlo
+Markus & Laszlo & John
 
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   markus@oberhumer.com                      ml1050@users.sourceforge.net
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
+   John F. Reiser
+   <jreiser@BitWagon.com>
 
 
 [ The term UPX is a shorthand for the Ultimate Packer for eXecutables
   and holds no connection with potential owners of registered trademarks
   or other rights. ]
-
-[ Feel free to contact us if you have commercial compression requirements
-  or interesting job offers. ]
-

README.1ST

@@ -1,31 +0,0 @@
-                 ooooo     ooo ooooooooo.   ooooooo  ooooo
-                 `888'     `8' `888   `Y88.  `8888    d8'
-                  888       8   888   .d88'    Y888..8P
-                  888       8   888ooo88P'      `8888'
-                  888       8   888            .8PY888.
-                  `88.    .8'   888           d8'  `888b
-                    `YbodP'    o888o        o888o  o88888o
-
-
-                    The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2006 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
-
-
-
-WARNING - UNSTABLE BETA VERSION
-===============================
-
-The current stable release is 2.02, and the next stable release
-will be called version 3.00.
-
-
-MAJOR NEWS IN UPX 3
-===================
-
-The main news since UPX 2 are:
-
-  * new format: added support for linux elf/arm
-
-  * better compression using the LZMA algorithm (option '--lzma')
-

README.SRC

@@ -27,21 +27,6 @@ Foreword
   Markus & Laszlo
 
 
-Introduction
-------------
-
-  Welcome to the UPX source code release!
-
-  UPX is not a toy for kids. Apart from basic knowledge about executables
-  and data compression you will need to be firm in C++, assembler,
-  Perl and Makefiles. Probably some other things as well.
-
-  If you can't manage to compile it then the sources are
-  probably not for you. Don't email us for help.
-
-  The authors use Linux for development. You might want to as well.
-
-
 Short overview
 --------------
 
@@ -56,47 +41,33 @@ Short overview
      are #included by the individual executable format handlers.
 
 
-Prerequisites
--------------
-
-  - first of all you need to build the UCL compression library
-    http://www.oberhumer.com/opensource/ucl/
-
-
 Tools needed to build/modify the UPX sources
 --------------------------------------------
 
-  - A C++ compiler supporting inner classes, templates, exceptions
+  - A C++ compiler that supports C++ 14: clang, gcc or msvc
-    and RTTI.
 
-  - GNU make 3.80 or better (GNU make 3.81 recommened).
+  - GNU make
+
+  - CMake 3.13 or better; see https://cmake.org/
 
 
 To compile the packer sources
 -----------------------------
 
-  set the environment variable UPX_UCLDIR to point to your
+  - just run "make" in the top-level source directory
-  UCL installation, e.g.
-
-     set UPX_UCLDIR=c:\src\ucl-1.03                   (DOS / Windows)
-     export UPX_UCLDIR=$HOME/local/src/ucl-1.03       (Unix)
-
-  then type
-
-     make
 
 
 If you want to modify the stub sources you'll also need
 -------------------------------------------------------
 
-  - GNU make 3.81 or better
+  - Podman/Docker: see misc/rebuild-stubs-with-podman - this
-    http://savannah.gnu.org/projects/make/
+    is the preferred way of rebuilding the stubs
 
-  - Perl & Python
+  - otherwise you will need:
-
+    - a Linux host system with Perl, Python2 and some older compat-libs
-  - A number of cross-assemblers and cross-compilers - precompiled
+    - upx-stubtools - a number of cross-assemblers and cross-compilers.
-    binaries for i386-linux hosts are available from
+      Precompiled binaries for amd64-linux hosts are available from
-    http://sourceforge.net/project/showfiles.php?group_id=2331
+      https://github.com/upx/upx-stubtools/releases
 
 
 Misc. notes
@@ -112,9 +83,9 @@ Misc. notes
   - Use gcc extensions and other compiler specific stuff only through
     macros.
 
-***
 
 Some conventions:
+-----------------
 
   - follow our coding style
   - indent level = 4
@@ -123,17 +94,4 @@ Some conventions:
   - Use throwSomeException() functions instead of throw SomeException():
     this makes the code shorter if used often.
 
-***
+# vim:set ts=4 sw=4 et:
-
-Patches/Contributions
-
-  - Please send us bug fixes/contributions only using
-
-      diff -u oldfile newfile
-
-    or
-
-      diff -uNr olddirectory newdirectory
-
-
-# vi:ts=4:et

THANKS

@@ -8,8 +8,8 @@
 
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2006 Markus Oberhumer, Laszlo Molnar & John Reiser
+   Copyright (c) 1996-2022 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
+                           https://upx.github.io
 
 
 .___..        .
@@ -53,7 +53,8 @@ Ralph Roth <RalphRoth@gmx.net>
   for reporting several bugs
 Salvador Eduardo Tropea
   for beta testing
+Stefan Widmann
+  for the win32/pe TLS callback support
 The WINE project (http://www.winehq.com/)
   for lots of useful information found in their PE loader sources
 Natascha
-

TODO

@@ -1,120 +0,0 @@
-UPX TODO list. Last updated 2006-03-11.
-
-
-IMPORTANT PROBLEMS THAT SHOULD BE FIXED SOON:
-
-- [None]
-
-
-OTHER:
-
-- docs: convert docs from upx.pod to use AsciiDoc
-
-- check all <const_cast> to make sure they are not invalid
-
-- throwNotCompressible() is not a real error, so make the output nicer
-  (info: bla bla). Also ui.cpp (total_*).
-
-
------------------------------------------------------------------------
-
-
-IMPROVED COMPRESSION RATIO
-==========================
-
-- experiment with new filters
-
-- implement filters for dos/exe
-
-- filters: could we exploit a f->firstcall info field ?
-
-- for small programs (e.g. < 64k), try an additional algorithm
-  to see if it gives better compression
-
-
-ALL FORMATS
-===========
-
-- more thoroughly test the exe-header in canPack()
-  and throw exceptions when encountering bad values.
-
-- implement `--cpu=486' option to use bswap on the 32-bit formats
-    (if cpu >= 486)
-
-- consider removing "or ebp,-1" when not needed
-
-
-FORMAT DJGPP2/COFF
-==================
-
-- handle overlays
-
-- fix default file extension handling when the --coff option is set
-
-
-FORMAT DOS/EXE
-==============
-
-- implement filters
-
-- add a check so that we don't pack djgpp1 binaries
-
-
-FORMAT LINUX/386
-================
-
-- don't mmap() the temporary output file - this seems to improve
-    file io speed
-
-
-FORMAT TMT/ADAM
-===============
-
-- the decompressors are already aligned, no need for an
-    extra alignment
-
-
-FORMAT WATCOM/LE
-================
-
-- handle files without relocations
-
-- the decompressors are already aligned, no need for an
-    extra alignment
-
-- fix default file extension handling when the --le option is set
-
-- handle holes in the file
-
-- implement compressWithFilters()
-
-- add a call to verifyOverlappingDecompression()
-
-
-FORMAT WIN16/NE
-===============
-
-- implement readFileHeader() to correctly identify a win16/ne
-  executable, so that the call for contribution will get thrown
-
-
-FORMAT WIN32/PE
-===============
-
-- fix the section alignment with the Intel compiler
-
-- decrease runtime memory overhead
-
-3 - difficult) don't compress the BSS section and other holes.
-
-4 - medium - ml) fix when objectalign < 0x1000
-
-4 - easy - ml) put the original offset of moved resources somewhere into
-    the res.dir. (if it's safe to do)
-
-4 - ??? - ml) fix FIXMEs
-
-5 - medium - ml) try to put the preprocessed imports & relocs back to their
-    original section if possible. this could save some virtual memory
-    address space.
-

compile_flags.txt

@@ -0,0 +1,4 @@
+-Ivendor
+-fno-strict-aliasing
+-fno-strict-overflow
+-funsigned-char

doc/BUGS.txt

@@ -8,8 +8,8 @@
 
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2006 Markus Oberhumer, Laszlo Molnar & John Reiser
+   Copyright (c) 1996-2022 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
+                           https://upx.github.io
 
 
 Limitations and other things which are not (yet) supported:
@@ -28,7 +28,7 @@ dos/exe
 watcom/le
 ---------
  * 16-bit selector alias fixups
- * 16-bit offset relocation for objects larger than 4 kB
+ * 16-bit offset relocation for objects larger than 4 KiB
  * 16:16 fixups
 
 If you need any of the above (they're very rare), send us an URL of a
@@ -44,8 +44,7 @@ test file.
 
 win32/pe
 --------
- * writeable shared sections (`--force' *may* work)
+ * writable shared sections (`--force' *may* work)
  * certificates in the image
  * compressing files which contain a big BSS requires lots of memory
    during compression
-

doc/Makefile

@@ -1,5 +1,5 @@
 #
-# UPX doc Makefile - needs GNU make 3.80 or better
+# UPX doc Makefile - needs GNU make
 #
 
 MAKEFLAGS += -rR
@@ -12,20 +12,12 @@ empty :=
 space := $(empty) $(empty)
 tab   := $(empty)	$(empty)
 
-# update $PATH for our special stub build tools
-ifneq ($(wildcard $(HOME)/local/bin/bin-upx/.),)
-export PATH := $(HOME)/local/bin/bin-upx:$(PATH)
-endif
-ifneq ($(wildcard $(HOME)/bin/bin-upx/.),)
-export PATH := $(HOME)/bin/bin-upx:$(PATH)
-endif
-
 
 # /***********************************************************************
 # //
 # ************************************************************************/
 
-top_srcdir = ..
+top_srcdir ?= ..
 
 PACKAGE       = upx
 VERSION_DATE := $(shell sed -n 's/^.*UPX_VERSION_DATE_ISO .*"\(.*\)".*/\1/p' $(top_srcdir)/src/version.h)
@@ -34,8 +26,7 @@ VERSION      := $(shell sed -n 's/^.*UPX_VERSION_STRING .*"\(.*\)".*/\1/p' $(top
 RTRIM  := sed -e 's/[ $(tab)]*$$//'
 DETAB2 := sed -e 's/$(tab)/  /g'
 
-BUILT_SOURCES = upx.1 upx.doc upx.html upx.man upx.ps upx.tex
+BUILT_SOURCES = upx.1 upx-doc.html upx-doc.txt
-BUILT_SOURCES = upx.1 upx.doc upx.html
 
 
 ###
@@ -54,26 +45,32 @@ mostlyclean clean distclean maintainer-clean:
 ### rules
 ###
 
-.SUFFIXES: .1 .doc .html .man .pod .ps .tex
+.SUFFIXES: .1 .html .man .pod .ps .tex .txt
 
 %.1 : %.pod
 	pod2man --center=" " --release="$(PACKAGE) $(VERSION)" --date="$(VERSION_DATE)" $< | $(RTRIM) > $@
+	test -s $@
 
-%.doc : %.pod
+%-doc.html : %.pod
-	pod2text < $< | $(RTRIM) > $@
-
-%.html : %.pod
 	pod2html --noindex $< | $(RTRIM) | $(DETAB2) > $@
 	@rm -f pod2htm*
+	test -s $@
 
 %.man : %.1
 	nroff -man $< | $(RTRIM) > $@
+	test -s $@
 
 %.ps : %.1
 	groff -man $< | $(RTRIM) > $@
+	test -s $@
 
 %.tex : %.pod
 	pod2latex $<
+	test -s $@
+
+%-doc.txt : %.pod
+	pod2text < $< | $(RTRIM) > $@
+	test -s $@
 
 
 ###
@@ -81,4 +78,5 @@ mostlyclean clean distclean maintainer-clean:
 ###
 
 $(BUILT_SOURCES): $(top_srcdir)/src/version.h $(MAKEFILE_LIST)
+.DELETE_ON_ERROR: $(BUILT_SOURCES)
 

doc/elf-to-mem.txt

@@ -1,5 +1,5 @@
            Decompressing ELF Directly to Memory on Linux/x86
-        Copyright (C) 2000-2006 John F. Reiser  jreiser@BitWagon.com
+        Copyright (C) 2000-2022 John F. Reiser  jreiser@BitWagon.com
 
 References:
   <elf.h>   definitions for the ELF file format
@@ -46,8 +46,8 @@ may not be used to take the address of a function.
 
 The address  0x00400000 was chosen to be out of the way of the usual
 load address 0x08048000, and to minimize fragmentation in kernel
-page tables; one page of page tables covers 4MB. The address
+page tables; one page of page tables covers 4 MiB. The address
-0x00401000 was chosen as 1 page up from a 64KB boundary, to
+0x00401000 was chosen as 1 page up from a 64 KiB boundary, to
 make the startup code and its constants smaller.
 
 Decompression of the executable begins by decompressing the Elf32_Ehdr
@@ -57,23 +57,49 @@ Subroutine do_xmap() of src/stub/l_lx_elf.c performs the
 "virtual execve()" using the compressed data as source, and stores
 the decompressed bytes directly into the appropriate virtual addresses.
 
-Before transfering control to the PT_INTERP "program interpreter",
+Before transferring control to the PT_INTERP "program interpreter",
 minor tricks are required to setup the Elf32_auxv_t entries,
 clear the free portion of the stack (to compensate for ld-linux.so.2
 assuming that its automatic stack variables are initialized to zero),
 and remove (all but 4 bytes of) the decompression program (and
 compressed executable) from the address space.
 
-Because the UPX runtime stub removes all traces of the compressed file
+As of upx-3.05, by default on Linux, upon decompression then one page
-from the address space, then the Linux kernel erases the symlink
+of the compressed executable remains mapped into the address space
-/proc/self/exe.  Linux stores the pathname argument that was specified
+of the process.  If all of the pages of the compressed executable are
-to execve() immediately after the '\0' which terminates the character
+unmapped, then the Linux kernel erases the symlink /proc/self/exe,
-string of the last environment variable [as of execve()].  This is true
+and this can cause trouble for the runtime shared library loader
-for at least all Linux 2.6, 2.4, and 2.2 kernels.  The pathname is not
+expanding $ORIGIN in -rpath, or for application code that relies on
-"bound" to the file as strongly as /proc/self/exe (the file may be changed
+/proc/self/exe.  Use the compress-time command-line option
-without affecting the pathname), but the pathname does provide some
+--unmap-all-pages to achieve that effect at run time.  Upx-3.04
-information.  The pathname may be relative to the working directory,
+and previous versions did this by default with no option.  However,
-so look before any chdir().
+too much other software erroneously assumes that /proc/self/exe
+always exists.
+
+On arm*-linux-elf there is no good address at which to retain one
+page of the compressed executable.  Pages below the usual .p_vaddr
+0x8000 (32KiB) are rejected by the kernel.  Using a page above the
+original uncompressed brk(0) would require placing the entire initial
+compressed program above uncompressed brk(0), which would significantly
+increase the running brk(0); but too many programs break if brk(0)
+moves.  Thus on arm*-linux-elf the compressed executable begins
+with 0x8000==.p_vaddr, all pages mapped by execve() that are also
+occupied by decompressed bytes are removed before overwriting, and
+/proc/self/exe becomes a "(deleted)" symlink.  It might be possible
+to preserve /proc/self/exe if the original uncompressed executable
+were created with 0x9000==.p_vaddr (one page higher than the usual
+0x8000) so that the compressed page mapped at 0x8000 would linger.
+[This has not been tested.]
+
+Linux stores the pathname argument that was specified to execve()
+immediately after the '\0' which terminates the character string of the
+last environment variable [as of execve()].  This is true for at least
+all Linux 2.6, 2.4, and 2.2 kernels.  Linux kernel 2.6.29 and later
+records a pointer to that character string in Elf32_auxv[AT_EXECFN].
+The pathname is not "bound" to the file as strongly as /proc/self/exe
+(the file may be changed without affecting the pathname), but the
+pathname does provide some information.  The pathname may be relative
+to the working directory, so look before any chdir().
 
 The Elf formats for Linux add an environment variable named "   " [three
 spaces] which saves the results of readlink("/proc/self/exe",,) before

doc/filter.txt

@@ -108,14 +108,14 @@ then skip another one - the unfiltering process needs some information
 to be able to reverse the filtering.
 
 UPX uses the following idea, which works nicely. First we assume that
-the size of the area that should be filtered is less than 16MB. Then
+the size of the area that should be filtered is less than 16 MiB. Then
 UPX scans over this area and keeps a record of the bytes that are
 following the 0xE8 bytes. If we are lucky, there will be bytes that
 were not found following 0xE8. These bytes are our candidates to be
 used as markers.
 
 Do you still remember that we assumed that the size of scanned area is
-less than 16MB? Well, this means that when we process a real call, the
+less than 16 MiB? Well, this means that when we process a real call, the
 resulting offset will be less than 0x00FFFFFF too. So the MSB is always
 0x00. Which is a nice place to store our marker. Of course we should
 reverse the byte order in the resulting offset - so this marker will

doc/linker.txt

@@ -45,6 +45,6 @@ These symbols can be defined later in C++ using
 
         linker->defineSymbol("xx", yy)
 
-This functionality (we could say it's a simple linker) is achived by
+This functionality (we could say it's a simple linker) is achieved by
 compiling the assembly into an ELF object file which a little C++
 module (src/linker.cpp) can interpret and work with.

doc/selinux.txt

@@ -20,7 +20,7 @@ code 127, and a record will be added to the history file
 
 In "targeted enforcing" mode, SELinux pays close attention mostly to
 designated processes that run with elevated privileges: web server,
-print server, login server, etc.  Ordinary user excutables receive
+print server, login server, etc.  Ordinary user executables receive
 much less scrutiny.  However, one of the eventual goals of SELinux is to
 eradicate runtime generation of instructions because of the possibility
 for exploitation by malware (virus, trojan, key logger, privilege

doc/upx-doc.html

@@ -0,0 +1,809 @@
+<?xml version="1.0" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<title>upx - compress or expand executable files</title>
+<meta http-equiv="content-type" content="text/html; charset=utf-8" />
+<link rev="made" href="mailto:root@localhost" />
+</head>
+
+<body>
+
+
+
+<h1 id="NAME">NAME</h1>
+
+<p>upx - compress or expand executable files</p>
+
+<h1 id="SYNOPSIS">SYNOPSIS</h1>
+
+<p><b>upx</b> <span style="white-space: nowrap;">[ <i>command</i> ]</span> <span style="white-space: nowrap;">[ <i>options</i> ]</span> <i>filename</i>...</p>
+
+<h1 id="ABSTRACT">ABSTRACT</h1>
+
+<pre><code>                 The Ultimate Packer for eXecutables
+Copyright (c) 1996-2022 Markus Oberhumer, Laszlo Molnar &amp; John Reiser
+                        https://upx.github.io</code></pre>
+
+<p><b>UPX</b> is a portable, extendable, high-performance executable packer for several different executable formats. It achieves an excellent compression ratio and offers <i>*very*</i> fast decompression. Your executables suffer no memory overhead or other drawbacks for most of the formats supported, because of in-place decompression.</p>
+
+<h1 id="DISCLAIMER">DISCLAIMER</h1>
+
+<p><b>UPX</b> comes with ABSOLUTELY NO WARRANTY; for details see the file COPYING.</p>
+
+<p>Please report all problems or suggestions to the authors. Thanks.</p>
+
+<h1 id="SECURITY-CONTEXT">SECURITY CONTEXT</h1>
+
+<p>IMPORTANT NOTE: <b>UPX</b> inherits the security context of any files it handles.</p>
+
+<p>This means that packing, unpacking, or even testing or listing a file requires the same security considerations as actually executing the file.</p>
+
+<p>Use <b>UPX</b> on trusted files only!</p>
+
+<h1 id="DESCRIPTION">DESCRIPTION</h1>
+
+<p><b>UPX</b> is a versatile executable packer with the following features:</p>
+
+<pre><code>- secure: as UPX is documented Open Source since many years any relevant
+    Security/Antivirus software is able to peek inside UPX compressed
+    apps to verify them
+
+- excellent compression ratio: typically compresses better than Zip,
+    use UPX to decrease the size of your distribution !
+
+- very fast decompression: more than 500 MB/sec on any reasonably modern
+    machine
+
+- no memory overhead for your compressed executables for most of the
+    supported formats because of in-place decompression
+
+- safe: you can list, test and unpack your executables.
+    Also, a checksum of both the compressed and uncompressed file is
+    maintained internally.
+
+- universal: UPX can pack a number of executable formats, including
+    Windows programs and DLLs, macOS apps and Linux executables
+
+- portable: UPX is written in portable endian-neutral C++
+
+- extendable: because of the class layout it&#39;s very easy to support
+    new executable formats or add new compression algorithms
+
+- free: UPX is distributed with full source code under the GNU General
+    Public License v2+, with special exceptions granting the free usage
+    for commercial programs</code></pre>
+
+<p>You probably understand now why we call <b>UPX</b> the &quot;<i>ultimate</i>&quot; executable packer.</p>
+
+<h1 id="COMMANDS">COMMANDS</h1>
+
+<h2 id="Compress">Compress</h2>
+
+<p>This is the default operation, eg. <b>upx yourfile.exe</b> will compress the file specified on the command line.</p>
+
+<h2 id="Decompress">Decompress</h2>
+
+<p>All <b>UPX</b> supported file formats can be unpacked using the <b>-d</b> switch, eg. <b>upx -d yourfile.exe</b> will uncompress the file you&#39;ve just compressed.</p>
+
+<h2 id="Test">Test</h2>
+
+<p>The <b>-t</b> command tests the integrity of the compressed and uncompressed data, eg. <b>upx -t yourfile.exe</b> check whether your file can be safely decompressed. Note, that this command doesn&#39;t check the whole file, only the part that will be uncompressed during program execution. This means that you should not use this command instead of a virus checker.</p>
+
+<h2 id="List">List</h2>
+
+<p>The <b>-l</b> command prints out some information about the compressed files specified on the command line as parameters, eg <b>upx -l yourfile.exe</b> shows the compressed / uncompressed size and the compression ratio of <i>yourfile.exe</i>.</p>
+
+<h1 id="OPTIONS">OPTIONS</h1>
+
+<p><b>-q</b>: be quiet, suppress warnings</p>
+
+<p><b>-q -q</b> (or <b>-qq</b>): be very quiet, suppress errors</p>
+
+<p><b>-q -q -q</b> (or <b>-qqq</b>): produce no output at all</p>
+
+<p><b>--help</b>: prints the help</p>
+
+<p><b>--version</b>: print the version of <b>UPX</b></p>
+
+<p><b>--exact</b>: when compressing, require to be able to get a byte-identical file after decompression with option <b>-d</b>. [NOTE: this is work in progress and is not supported for all formats yet. If you do care, as a workaround you can compress and then decompress your program a first time - any further compress-decompress steps should then yield byte-identical results as compared to the first decompressed version.]</p>
+
+<p><b>-k</b>: keep backup files</p>
+
+<p><b>-o file</b>: write output to file</p>
+
+<p>[ ...more docs need to be written... - type `<b>upx --help</b>&#39; for now ]</p>
+
+<h1 id="COMPRESSION-LEVELS-TUNING">COMPRESSION LEVELS &amp; TUNING</h1>
+
+<p><b>UPX</b> offers ten different compression levels from <b>-1</b> to <b>-9</b>, and <b>--best</b>. The default compression level is <b>-8</b> for files smaller than 512 KiB, and <b>-7</b> otherwise.</p>
+
+<ul>
+
+<li><p>Compression levels 1, 2 and 3 are pretty fast.</p>
+
+</li>
+<li><p>Compression levels 4, 5 and 6 achieve a good time/ratio performance.</p>
+
+</li>
+<li><p>Compression levels 7, 8 and 9 favor compression ratio over speed.</p>
+
+</li>
+<li><p>Compression level <b>--best</b> may take a long time.</p>
+
+</li>
+</ul>
+
+<p>Note that compression level <b>--best</b> can be somewhat slow for large files, but you definitely should use it when releasing a final version of your program.</p>
+
+<p>Quick info for achieving the best compression ratio:</p>
+
+<ul>
+
+<li><p>Try <b>upx --brute --no-lzma myfile.exe</b> or even <b>upx --ultra-brute --no-lzma myfile.exe</b>.</p>
+
+</li>
+<li><p>The option <b>--lzma</b> enables LZMA compression, which compresses better but is *significantly slower* at decompression. You probably do not want to use it for large files.</p>
+
+<p>(Note that <b>--lzma</b> is automatically enabled by <b>--all-methods</b> and <b>--brute</b>, use <b>--no-lzma</b> to override.)</p>
+
+</li>
+<li><p>Try if <b>--overlay=strip</b> works.</p>
+
+</li>
+<li><p>For win32/pe programs there&#39;s <b>--strip-relocs=0</b>. See notes below.</p>
+
+</li>
+</ul>
+
+<h1 id="OVERLAY-HANDLING-OPTIONS">OVERLAY HANDLING OPTIONS</h1>
+
+<p>Info: An &quot;overlay&quot; means auxiliary data attached after the logical end of an executable, and it often contains application specific data (this is a common practice to avoid an extra data file, though it would be better to use resource sections).</p>
+
+<p><b>UPX</b> handles overlays like many other executable packers do: it simply copies the overlay after the compressed image. This works with some files, but doesn&#39;t work with others, depending on how an application actually accesses this overlayed data.</p>
+
+<pre><code>--overlay=copy    Copy any extra data attached to the file. [DEFAULT]
+
+--overlay=strip   Strip any overlay from the program instead of
+                  copying it. Be warned, this may make the compressed
+                  program crash or otherwise unusable.
+
+--overlay=skip    Refuse to compress any program which has an overlay.</code></pre>
+
+<h1 id="ENVIRONMENT-VARIABLE">ENVIRONMENT VARIABLE</h1>
+
+<p>The environment variable <b>UPX</b> can hold a set of default options for <b>UPX</b>. These options are interpreted first and can be overwritten by explicit command line parameters. For example:</p>
+
+<pre><code>for DOS/Windows:   set UPX=-9 --compress-icons#0
+for sh/ksh/zsh:    UPX=&quot;-9 --compress-icons=0&quot;; export UPX
+for csh/tcsh:      setenv UPX &quot;-9 --compress-icons=0&quot;</code></pre>
+
+<p>Under DOS/Windows you must use &#39;#&#39; instead of &#39;=&#39; when setting the environment variable because of a COMMAND.COM limitation.</p>
+
+<p>Not all of the options are valid in the environment variable - <b>UPX</b> will tell you.</p>
+
+<p>You can explicitly use the <b>--no-env</b> option to ignore the environment variable.</p>
+
+<h1 id="NOTES-FOR-THE-SUPPORTED-EXECUTABLE-FORMATS">NOTES FOR THE SUPPORTED EXECUTABLE FORMATS</h1>
+
+<h2 id="NOTES-FOR-ATARI-TOS">NOTES FOR ATARI/TOS</h2>
+
+<p>This is the executable format used by the Atari ST/TT, a Motorola 68000 based personal computer which was popular in the late &#39;80s. Support of this format is only because of nostalgic feelings of one of the authors and serves no practical purpose :-). See https://freemint.github.io for more info.</p>
+
+<p>Packed programs will be byte-identical to the original after uncompression. All debug information will be stripped, though.</p>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--all-methods       Compress the program several times, using all
+                    available compression methods. This may improve
+                    the compression ratio in some cases, but usually
+                    the default method gives the best results anyway.</code></pre>
+
+<h2 id="NOTES-FOR-BVMLINUZ-I386">NOTES FOR BVMLINUZ/I386</h2>
+
+<p>Same as vmlinuz/i386.</p>
+
+<h2 id="NOTES-FOR-DOS-COM">NOTES FOR DOS/COM</h2>
+
+<p>Obviously <b>UPX</b> won&#39;t work with executables that want to read data from themselves (like some commandline utilities that ship with Win95/98/ME).</p>
+
+<p>Compressed programs only work on a 286+.</p>
+
+<p>Packed programs will be byte-identical to the original after uncompression.</p>
+
+<p>Maximum uncompressed size: ~65100 bytes.</p>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--8086              Create an executable that works on any 8086 CPU.
+
+--all-methods       Compress the program several times, using all
+                    available compression methods. This may improve
+                    the compression ratio in some cases, but usually
+                    the default method gives the best results anyway.
+
+--all-filters       Compress the program several times, using all
+                    available preprocessing filters. This may improve
+                    the compression ratio in some cases, but usually
+                    the default filter gives the best results anyway.</code></pre>
+
+<h2 id="NOTES-FOR-DOS-EXE">NOTES FOR DOS/EXE</h2>
+
+<p>dos/exe stands for all &quot;normal&quot; 16-bit DOS executables.</p>
+
+<p>Obviously <b>UPX</b> won&#39;t work with executables that want to read data from themselves (like some command line utilities that ship with Win95/98/ME).</p>
+
+<p>Compressed programs only work on a 286+.</p>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--8086              Create an executable that works on any 8086 CPU.
+
+--no-reloc          Use no relocation records in the exe header.
+
+--all-methods       Compress the program several times, using all
+                    available compression methods. This may improve
+                    the compression ratio in some cases, but usually
+                    the default method gives the best results anyway.</code></pre>
+
+<h2 id="NOTES-FOR-DOS-SYS">NOTES FOR DOS/SYS</h2>
+
+<p>Compressed programs only work on a 286+.</p>
+
+<p>Packed programs will be byte-identical to the original after uncompression.</p>
+
+<p>Maximum uncompressed size: ~65350 bytes.</p>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--8086              Create an executable that works on any 8086 CPU.
+
+--all-methods       Compress the program several times, using all
+                    available compression methods. This may improve
+                    the compression ratio in some cases, but usually
+                    the default method gives the best results anyway.
+
+--all-filters       Compress the program several times, using all
+                    available preprocessing filters. This may improve
+                    the compression ratio in some cases, but usually
+                    the default filter gives the best results anyway.</code></pre>
+
+<h2 id="NOTES-FOR-DJGPP2-COFF">NOTES FOR DJGPP2/COFF</h2>
+
+<p>First of all, it is recommended to use <b>UPX</b> *instead* of <b>strip</b>. strip has the very bad habit of replacing your stub with its own (outdated) version. Additionally <b>UPX</b> corrects a bug/feature in strip v2.8.x: it will fix the 4 KiB alignment of the stub.</p>
+
+<p><b>UPX</b> includes the full functionality of stubify. This means it will automatically stubify your COFF files. Use the option <b>--coff</b> to disable this functionality (see below).</p>
+
+<p><b>UPX</b> automatically handles Allegro packfiles.</p>
+
+<p>The DLM format (a rather exotic shared library extension) is not supported.</p>
+
+<p>Packed programs will be byte-identical to the original after uncompression. All debug information and trailing garbage will be stripped, though.</p>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--coff              Produce COFF output instead of EXE. By default
+                    UPX keeps your current stub.
+
+--all-methods       Compress the program several times, using all
+                    available compression methods. This may improve
+                    the compression ratio in some cases, but usually
+                    the default method gives the best results anyway.
+
+--all-filters       Compress the program several times, using all
+                    available preprocessing filters. This may improve
+                    the compression ratio in some cases, but usually
+                    the default filter gives the best results anyway.</code></pre>
+
+<h2 id="NOTES-FOR-LINUX-general">NOTES FOR LINUX [general]</h2>
+
+<p>Introduction</p>
+
+<pre><code>Linux/386 support in UPX consists of 3 different executable formats,
+one optimized for ELF executables (&quot;linux/elf386&quot;), one optimized
+for shell scripts (&quot;linux/sh386&quot;), and one generic format
+(&quot;linux/386&quot;).
+
+We will start with a general discussion first, but please
+also read the relevant docs for each of the individual formats.
+
+Also, there is special support for bootable kernels - see the
+description of the vmlinuz/386 format.</code></pre>
+
+<p>General user&#39;s overview</p>
+
+<pre><code>Running a compressed executable program trades less space on a
+``permanent&#39;&#39; storage medium (such as a hard disk, floppy disk,
+CD-ROM, flash memory, EPROM, etc.) for more space in one or more
+``temporary&#39;&#39; storage media (such as RAM, swap space, /tmp, etc.).
+Running a compressed executable also requires some additional CPU
+cycles to generate the compressed executable in the first place,
+and to decompress it at each invocation.
+
+How much space is traded?  It depends on the executable, but many
+programs save 30% to 50% of permanent disk space.  How much CPU
+overhead is there?  Again, it depends on the executable, but
+decompression speed generally is at least many megabytes per second,
+and frequently is limited by the speed of the underlying disk
+or network I/O.
+
+Depending on the statistics of usage and access, and the relative
+speeds of CPU, RAM, swap space, /tmp, and file system storage, then
+invoking and running a compressed executable can be faster than
+directly running the corresponding uncompressed program.
+The operating system might perform fewer expensive I/O operations
+to invoke the compressed program.  Paging to or from swap space
+or /tmp might be faster than paging from the general file system.
+``Medium-sized&#39;&#39; programs which access about 1/3 to 1/2 of their
+stored program bytes can do particularly well with compression.
+Small programs tend not to benefit as much because the absolute
+savings is less.  Big programs tend not to benefit proportionally
+because each invocation may use only a small fraction of the program,
+yet UPX decompresses the entire program before invoking it.
+But in environments where disk or flash memory storage is limited,
+then compression may win anyway.
+
+Currently, executables compressed by UPX do not share RAM at runtime
+in the way that executables mapped from a file system do.  As a
+result, if the same program is run simultaneously by more than one
+process, then using the compressed version will require more RAM and/or
+swap space.  So, shell programs (bash, csh, etc.)  and ``make&#39;&#39;
+might not be good candidates for compression.
+
+UPX recognizes three executable formats for Linux: Linux/elf386,
+Linux/sh386, and Linux/386.  Linux/386 is the most generic format;
+it accommodates any file that can be executed.  At runtime, the UPX
+decompression stub re-creates in /tmp a copy of the original file,
+and then the copy is (re-)executed with the same arguments.
+ELF binary executables prefer the Linux/elf386 format by default,
+because UPX decompresses them directly into RAM, uses only one
+exec, does not use space in /tmp, and does not use /proc.
+Shell scripts where the underlying shell accepts a ``-c&#39;&#39; argument
+can use the Linux/sh386 format.  UPX decompresses the shell script
+into low memory, then maps the shell and passes the entire text of the
+script as an argument with a leading ``-c&#39;&#39;.</code></pre>
+
+<p>General benefits:</p>
+
+<pre><code>- UPX can compress all executables, be it AOUT, ELF, libc4, libc5,
+  libc6, Shell/Perl/Python/... scripts, standalone Java .class
+  binaries, or whatever...
+  All scripts and programs will work just as before.
+
+- Compressed programs are completely self-contained. No need for
+  any external program.
+
+- UPX keeps your original program untouched. This means that
+  after decompression you will have a byte-identical version,
+  and you can use UPX as a file compressor just like gzip.
+  [ Note that UPX maintains a checksum of the file internally,
+    so it is indeed a reliable alternative. ]
+
+- As the stub only uses syscalls and isn&#39;t linked against libc it
+  should run under any Linux configuration that can run ELF
+  binaries.
+
+- For the same reason compressed executables should run under
+  FreeBSD and other systems which can run Linux binaries.
+  [ Please send feedback on this topic ]</code></pre>
+
+<p>General drawbacks:</p>
+
+<pre><code>- It is not advisable to compress programs which usually have many
+  instances running (like `sh&#39; or `make&#39;) because the common segments of
+  compressed programs won&#39;t be shared any longer between different
+  processes.
+
+- `ldd&#39; and `size&#39; won&#39;t show anything useful because all they
+  see is the statically linked stub.  Since version 0.82 the section
+  headers are stripped from the UPX stub and `size&#39; doesn&#39;t even
+  recognize the file format.  The file patches/patch-elfcode.h has a
+  patch to fix this bug in `size&#39; and other programs which use GNU BFD.</code></pre>
+
+<p>General notes:</p>
+
+<pre><code>- As UPX leaves your original program untouched it is advantageous
+  to strip it before compression.
+
+- If you compress a script you will lose platform independence -
+  this could be a problem if you are using NFS mounted disks.
+
+- Compression of suid, guid and sticky-bit programs is rejected
+  because of possible security implications.
+
+- For the same reason there is no sense in making any compressed
+  program suid.
+
+- Obviously UPX won&#39;t work with executables that want to read data
+  from themselves. E.g., this might be a problem for Perl scripts
+  which access their __DATA__ lines.
+
+- In case of internal errors the stub will abort with exitcode 127.
+  Typical reasons for this to happen are that the program has somehow
+  been modified after compression.
+  Running `strace -o strace.log compressed_file&#39; will tell you more.</code></pre>
+
+<h2 id="NOTES-FOR-LINUX-ELF386">NOTES FOR LINUX/ELF386</h2>
+
+<p>Please read the general Linux description first.</p>
+
+<p>The linux/elf386 format decompresses directly into RAM, uses only one exec, does not use space in /tmp, and does not use /proc.</p>
+
+<p>Linux/elf386 is automatically selected for Linux ELF executables.</p>
+
+<p>Packed programs will be byte-identical to the original after uncompression.</p>
+
+<p>How it works:</p>
+
+<pre><code>For ELF executables, UPX decompresses directly to memory, simulating
+the mapping that the operating system kernel uses during exec(),
+including the PT_INTERP program interpreter (if any).
+The brk() is set by a special PT_LOAD segment in the compressed
+executable itself.  UPX then wipes the stack clean except for
+arguments, environment variables, and Elf_auxv entries (this is
+required by bugs in the startup code of /lib/ld-linux.so as of
+May 2000), and transfers control to the program interpreter or
+the e_entry address of the original executable.
+
+The UPX stub is about 1700 bytes long, partly written in assembler
+and only uses kernel syscalls. It is not linked against any libc.</code></pre>
+
+<p>Specific drawbacks:</p>
+
+<pre><code>- For linux/elf386 and linux/sh386 formats, you will be relying on
+  RAM and swap space to hold all of the decompressed program during
+  the lifetime of the process.  If you already use most of your swap
+  space, then you may run out.  A system that is &quot;out of memory&quot;
+  can become fragile.  Many programs do not react gracefully when
+  malloc() returns 0.  With newer Linux kernels, the kernel
+  may decide to kill some processes to regain memory, and you
+  may not like the kernel&#39;s choice of which to kill.  Running
+  /usr/bin/top is one way to check on the usage of swap space.</code></pre>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>(none)</code></pre>
+
+<h2 id="NOTES-FOR-LINUX-SH386">NOTES FOR LINUX/SH386</h2>
+
+<p>Please read the general Linux description first.</p>
+
+<p>Shell scripts where the underling shell accepts a ``-c&#39;&#39; argument can use the Linux/sh386 format. <b>UPX</b> decompresses the shell script into low memory, then maps the shell and passes the entire text of the script as an argument with a leading ``-c&#39;&#39;. It does not use space in /tmp, and does not use /proc.</p>
+
+<p>Linux/sh386 is automatically selected for shell scripts that use a known shell.</p>
+
+<p>Packed programs will be byte-identical to the original after uncompression.</p>
+
+<p>How it works:</p>
+
+<pre><code>For shell script executables (files beginning with &quot;#!/&quot; or &quot;#! /&quot;)
+where the shell is known to accept &quot;-c &lt;command&gt;&quot;, UPX decompresses
+the file into low memory, then maps the shell (and its PT_INTERP),
+and passes control to the shell with the entire decompressed file
+as the argument after &quot;-c&quot;.  Known shells are sh, ash, bash, bsh, csh,
+ksh, tcsh, pdksh.  Restriction: UPX cannot use this method
+for shell scripts which use the one optional string argument after
+the shell name in the script (example: &quot;#! /bin/sh option3\n&quot;.)
+
+The UPX stub is about 1700 bytes long, partly written in assembler
+and only uses kernel syscalls. It is not linked against any libc.</code></pre>
+
+<p>Specific drawbacks:</p>
+
+<pre><code>- For linux/elf386 and linux/sh386 formats, you will be relying on
+  RAM and swap space to hold all of the decompressed program during
+  the lifetime of the process.  If you already use most of your swap
+  space, then you may run out.  A system that is &quot;out of memory&quot;
+  can become fragile.  Many programs do not react gracefully when
+  malloc() returns 0.  With newer Linux kernels, the kernel
+  may decide to kill some processes to regain memory, and you
+  may not like the kernel&#39;s choice of which to kill.  Running
+  /usr/bin/top is one way to check on the usage of swap space.</code></pre>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>(none)</code></pre>
+
+<h2 id="NOTES-FOR-LINUX-386">NOTES FOR LINUX/386</h2>
+
+<p>Please read the general Linux description first.</p>
+
+<p>The generic linux/386 format decompresses to /tmp and needs /proc file system support. It starts the decompressed program via the execve() syscall.</p>
+
+<p>Linux/386 is only selected if the specialized linux/elf386 and linux/sh386 won&#39;t recognize a file.</p>
+
+<p>Packed programs will be byte-identical to the original after uncompression.</p>
+
+<p>How it works:</p>
+
+<pre><code>For files which are not ELF and not a script for a known &quot;-c&quot; shell,
+UPX uses kernel execve(), which first requires decompressing to a
+temporary file in the file system.  Interestingly -
+because of the good memory management of the Linux kernel - this
+often does not introduce a noticeable delay, and in fact there
+will be no disk access at all if you have enough free memory as
+the entire process takes places within the file system buffers.
+
+A compressed executable consists of the UPX stub and an overlay
+which contains the original program in a compressed form.
+
+The UPX stub is a statically linked ELF executable and does
+the following at program startup:
+
+  1) decompress the overlay to a temporary location in /tmp
+  2) open the temporary file for reading
+  3) try to delete the temporary file and start (execve)
+     the uncompressed program in /tmp using /proc/&lt;pid&gt;/fd/X as
+     attained by step 2)
+  4) if that fails, fork off a subprocess to clean up and
+     start the program in /tmp in the meantime
+
+The UPX stub is about 1700 bytes long, partly written in assembler
+and only uses kernel syscalls. It is not linked against any libc.</code></pre>
+
+<p>Specific drawbacks:</p>
+
+<pre><code>- You need additional free disk space for the uncompressed program
+  in your /tmp directory. This program is deleted immediately after
+  decompression, but you still need it for the full execution time
+  of the program.
+
+- You must have /proc file system support as the stub wants to open
+  /proc/&lt;pid&gt;/exe and needs /proc/&lt;pid&gt;/fd/X. This also means that you
+  cannot compress programs that are used during the boot sequence
+  before /proc is mounted.
+
+- Utilities like `top&#39; will display numerical values in the process
+  name field. This is because Linux computes the process name from
+  the first argument of the last execve syscall (which is typically
+  something like /proc/&lt;pid&gt;/fd/3).
+
+- Because of temporary decompression to disk the decompression speed
+  is not as fast as with the other executable formats. Still, I can see
+  no noticeable delay when starting programs like my ~3 MiB emacs (which
+  is less than 1 MiB when compressed :-).</code></pre>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--force-execve      Force the use of the generic linux/386 &quot;execve&quot;
+                    format, i.e. do not try the linux/elf386 and
+                    linux/sh386 formats.</code></pre>
+
+<h2 id="NOTES-FOR-PS1-EXE">NOTES FOR PS1/EXE</h2>
+
+<p>This is the executable format used by the Sony PlayStation (PSone), a MIPS R3000 based gaming console which is popular since the late &#39;90s. Support of this format is very similar to the Atari one, because of nostalgic feelings of one of the authors.</p>
+
+<p>Packed programs will be byte-identical to the original after uncompression, until further notice.</p>
+
+<p>Maximum uncompressed size: ~1.89 / ~7.60 MiB.</p>
+
+<p>Notes:</p>
+
+<pre><code>- UPX creates as default a suitable executable for CD-Mastering
+  and console transfer. For a CD-Master main executable you could also try
+  the special option &quot;--boot-only&quot; as described below.
+  It has been reported that upx packed executables are fully compatible with
+  the Sony PlayStation 2 (PS2, PStwo) and Sony PlayStation Portable (PSP) in
+  Sony PlayStation (PSone) emulation mode.
+
+- Normally the packed files use the same memory areas like the uncompressed
+  versions, so they will not override other memory areas while unpacking.
+  If this isn&#39;t possible UPX will abort showing a &#39;packed data overlap&#39;
+  error. With the &quot;--force&quot; option UPX will relocate the loading address
+  for the packed file, but this isn&#39;t a real problem if it is a single or
+  the main executable.</code></pre>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--all-methods       Compress the program several times, using all
+                    available compression methods. This may improve
+                    the compression ratio in some cases, but usually
+                    the default method gives the best results anyway.
+
+--8-bit             Uses 8 bit size compression [default: 32 bit]
+
+--8mib-ram          PSone has 8 MiB ram available [default: 2 MiB]
+
+--boot-only         This format is for main exes and CD-Mastering only !
+                    It may slightly improve the compression ratio,
+                    decompression routines are faster than default ones.
+                    But it cannot be used for console transfer !
+
+--no-align          This option disables CD mode 2 data sector format
+                    alignment. May slightly improves the compression ratio,
+                    but the compressed executable will not boot from a CD.
+                    Use it for console transfer only !</code></pre>
+
+<h2 id="NOTES-FOR-RTM32-PE-and-ARM-PE">NOTES FOR RTM32/PE and ARM/PE</h2>
+
+<p>Same as win32/pe.</p>
+
+<h2 id="NOTES-FOR-TMT-ADAM">NOTES FOR TMT/ADAM</h2>
+
+<p>This format is used by the TMT Pascal compiler - see http://www.tmt.com/ .</p>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--all-methods       Compress the program several times, using all
+                    available compression methods. This may improve
+                    the compression ratio in some cases, but usually
+                    the default method gives the best results anyway.
+
+--all-filters       Compress the program several times, using all
+                    available preprocessing filters. This may improve
+                    the compression ratio in some cases, but usually
+                    the default filter gives the best results anyway.</code></pre>
+
+<h2 id="NOTES-FOR-VMLINUZ-386">NOTES FOR VMLINUZ/386</h2>
+
+<p>The vmlinuz/386 and bvmlinuz/386 formats take a gzip-compressed bootable Linux kernel image (&quot;vmlinuz&quot;, &quot;zImage&quot;, &quot;bzImage&quot;), gzip-decompress it and re-compress it with the <b>UPX</b> compression method.</p>
+
+<p>vmlinuz/386 is completely unrelated to the other Linux executable formats, and it does not share any of their drawbacks.</p>
+
+<p>Notes:</p>
+
+<pre><code>- Be sure that &quot;vmlinuz/386&quot; or &quot;bvmlinuz/386&quot; is displayed
+during compression - otherwise a wrong executable format
+may have been used, and the kernel won&#39;t boot.</code></pre>
+
+<p>Benefits:</p>
+
+<pre><code>- Better compression (but note that the kernel was already compressed,
+so the improvement is not as large as with other formats).
+Still, the bytes saved may be essential for special needs like
+boot disks.
+
+   For example, this is what I get for my 2.2.16 kernel:
+      1589708  vmlinux
+       641073  bzImage        [original]
+       560755  bzImage.upx    [compressed by &quot;upx -9&quot;]
+
+- Much faster decompression at kernel boot time (but kernel
+  decompression speed is not really an issue these days).</code></pre>
+
+<p>Drawbacks:</p>
+
+<pre><code>(none)</code></pre>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--all-methods       Compress the program several times, using all
+                    available compression methods. This may improve
+                    the compression ratio in some cases, but usually
+                    the default method gives the best results anyway.
+
+--all-filters       Compress the program several times, using all
+                    available preprocessing filters. This may improve
+                    the compression ratio in some cases, but usually
+                    the default filter gives the best results anyway.</code></pre>
+
+<h2 id="NOTES-FOR-WATCOM-LE">NOTES FOR WATCOM/LE</h2>
+
+<p><b>UPX</b> has been successfully tested with the following extenders: DOS4G, DOS4GW, PMODE/W, DOS32a, CauseWay. The WDOS/X extender is partly supported (for details see the file bugs BUGS).</p>
+
+<p>DLLs and the LX format are not supported.</p>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--le                Produce an unbound LE output instead of
+                    keeping the current stub.</code></pre>
+
+<h2 id="NOTES-FOR-WIN32-PE">NOTES FOR WIN32/PE</h2>
+
+<p>The PE support in <b>UPX</b> is quite stable now, but probably there are still some incompatibilities with some files.</p>
+
+<p>Because of the way <b>UPX</b> (and other packers for this format) works, you can see increased memory usage of your compressed files because the whole program is loaded into memory at startup. If you start several instances of huge compressed programs you&#39;re wasting memory because the common segments of the program won&#39;t get shared across the instances. On the other hand if you&#39;re compressing only smaller programs, or running only one instance of larger programs, then this penalty is smaller, but it&#39;s still there.</p>
+
+<p>If you&#39;re running executables from network, then compressed programs will load faster, and require less bandwidth during execution.</p>
+
+<p>DLLs are supported. But UPX compressed DLLs can not share common data and code when they got used by multiple applications. So compressing msvcrt.dll is a waste of memory, but compressing the dll plugins of a particular application may be a better idea.</p>
+
+<p>Screensavers are supported, with the restriction that the filename must end with &quot;.scr&quot; (as screensavers are handled slightly different than normal exe files).</p>
+
+<p>UPX compressed PE files have some minor memory overhead (usually in the 10 - 30 KiB range) which can be seen by specifying the &quot;-i&quot; command line switch during compression.</p>
+
+<p>Extra options available for this executable format:</p>
+
+<pre><code>--compress-exports=0 Don&#39;t compress the export section.
+                     Use this if you plan to run the compressed
+                     program under Wine.
+--compress-exports=1 Compress the export section. [DEFAULT]
+                     Compression of the export section can improve the
+                     compression ratio quite a bit but may not work
+                     with all programs (like winword.exe).
+                     UPX never compresses the export section of a DLL
+                     regardless of this option.
+
+ --compress-icons=0  Don&#39;t compress any icons.
+ --compress-icons=1  Compress all but the first icon.
+ --compress-icons=2  Compress all icons which are not in the
+                     first icon directory. [DEFAULT]
+ --compress-icons=3  Compress all icons.
+
+ --compress-resources=0  Don&#39;t compress any resources at all.
+
+ --keep-resource=list Don&#39;t compress resources specified by the list.
+                     The members of the list are separated by commas.
+                     A list member has the following format: I&lt;type[/name]&gt;.
+                     I&lt;Type&gt; is the type of the resource. Standard types
+                     must be specified as decimal numbers, user types can be
+                     specified by decimal IDs or strings. I&lt;Name&gt; is the
+                     identifier of the resource. It can be a decimal number
+                     or a string. For example:
+
+                     --keep-resource=2/MYBITMAP,5,6/12345
+
+                     UPX won&#39;t compress the named bitmap resource &quot;MYBITMAP&quot;,
+                     it leaves every dialog (5) resource uncompressed, and
+                     it won&#39;t touch the string table resource with identifier
+                     12345.
+
+ --force             Force compression even when there is an
+                     unexpected value in a header field.
+                     Use with care.
+
+ --strip-relocs=0    Don&#39;t strip relocation records.
+ --strip-relocs=1    Strip relocation records. [DEFAULT]
+                     This option only works on executables with base
+                     address greater or equal to 0x400000. Usually the
+                     compressed files becomes smaller, but some files
+                     may become larger. Note that the resulting file will
+                     not work under Windows 3.x (Win32s).
+                     UPX never strips relocations from a DLL
+                     regardless of this option.
+
+ --all-methods       Compress the program several times, using all
+                     available compression methods. This may improve
+                     the compression ratio in some cases, but usually
+                     the default method gives the best results anyway.
+
+ --all-filters       Compress the program several times, using all
+                     available preprocessing filters. This may improve
+                     the compression ratio in some cases, but usually
+                     the default filter gives the best results anyway.</code></pre>
+
+<h1 id="DIAGNOSTICS">DIAGNOSTICS</h1>
+
+<p>Exit status is normally 0; if an error occurs, exit status is 1. If a warning occurs, exit status is 2.</p>
+
+<p><b>UPX</b>&#39;s diagnostics are intended to be self-explanatory.</p>
+
+<h1 id="BUGS">BUGS</h1>
+
+<p>Please report all bugs immediately to the authors.</p>
+
+<h1 id="AUTHORS">AUTHORS</h1>
+
+<pre><code>Markus F.X.J. Oberhumer &lt;markus@oberhumer.com&gt;
+http://www.oberhumer.com
+
+Laszlo Molnar &lt;ezerotven+github@gmail.com&gt;
+
+John F. Reiser &lt;jreiser@BitWagon.com&gt;
+
+Jens Medoch &lt;jssg@users.sourceforge.net&gt;</code></pre>
+
+<h1 id="COPYRIGHT">COPYRIGHT</h1>
+
+<p>Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer</p>
+
+<p>Copyright (C) 1996-2022 Laszlo Molnar</p>
+
+<p>Copyright (C) 2000-2022 John F. Reiser</p>
+
+<p>Copyright (C) 2002-2022 Jens Medoch</p>
+
+<p>This program may be used freely, and you are welcome to redistribute it under certain conditions.</p>
+
+<p>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.</p>
+
+<p><b>UPX</b> is distributed with full source code under the terms of the GNU General Public License v2+; either under the pure GPLv2+ (see the file COPYING), or (at your option) under the GPLv+2 with special exceptions and restrictions granting the free usage for commercial programs (see the file LICENSE).</p>
+
+<p>You should have received a copy of the UPX License Agreements along with this program; see the files COPYING and LICENSE. If not, visit the UPX home page.</p>
+
+
+</body>
+
+</html>
+
+

doc/upx-doc.txt

@@ -0,0 +1,845 @@
+NAME
+    upx - compress or expand executable files
+
+SYNOPSIS
+    upx [ *command* ] [ *options* ] *filename*...
+
+ABSTRACT
+                        The Ultimate Packer for eXecutables
+       Copyright (c) 1996-2022 Markus Oberhumer, Laszlo Molnar & John Reiser
+                               https://upx.github.io
+
+    UPX is a portable, extendable, high-performance executable packer for
+    several different executable formats. It achieves an excellent
+    compression ratio and offers **very** fast decompression. Your
+    executables suffer no memory overhead or other drawbacks for most of the
+    formats supported, because of in-place decompression.
+
+DISCLAIMER
+    UPX comes with ABSOLUTELY NO WARRANTY; for details see the file COPYING.
+
+    Please report all problems or suggestions to the authors. Thanks.
+
+SECURITY CONTEXT
+    IMPORTANT NOTE: UPX inherits the security context of any files it
+    handles.
+
+    This means that packing, unpacking, or even testing or listing a file
+    requires the same security considerations as actually executing the
+    file.
+
+    Use UPX on trusted files only!
+
+DESCRIPTION
+    UPX is a versatile executable packer with the following features:
+
+      - secure: as UPX is documented Open Source since many years any relevant
+          Security/Antivirus software is able to peek inside UPX compressed
+          apps to verify them
+
+      - excellent compression ratio: typically compresses better than Zip,
+          use UPX to decrease the size of your distribution !
+
+      - very fast decompression: more than 500 MB/sec on any reasonably modern
+          machine
+
+      - no memory overhead for your compressed executables for most of the
+          supported formats because of in-place decompression
+
+      - safe: you can list, test and unpack your executables.
+          Also, a checksum of both the compressed and uncompressed file is
+          maintained internally.
+
+      - universal: UPX can pack a number of executable formats, including
+          Windows programs and DLLs, macOS apps and Linux executables
+
+      - portable: UPX is written in portable endian-neutral C++
+
+      - extendable: because of the class layout it's very easy to support
+          new executable formats or add new compression algorithms
+
+      - free: UPX is distributed with full source code under the GNU General
+          Public License v2+, with special exceptions granting the free usage
+          for commercial programs
+
+    You probably understand now why we call UPX the "*ultimate*" executable
+    packer.
+
+COMMANDS
+  Compress
+    This is the default operation, eg. upx yourfile.exe will compress the
+    file specified on the command line.
+
+  Decompress
+    All UPX supported file formats can be unpacked using the -d switch, eg.
+    upx -d yourfile.exe will uncompress the file you've just compressed.
+
+  Test
+    The -t command tests the integrity of the compressed and uncompressed
+    data, eg. upx -t yourfile.exe check whether your file can be safely
+    decompressed. Note, that this command doesn't check the whole file, only
+    the part that will be uncompressed during program execution. This means
+    that you should not use this command instead of a virus checker.
+
+  List
+    The -l command prints out some information about the compressed files
+    specified on the command line as parameters, eg upx -l yourfile.exe
+    shows the compressed / uncompressed size and the compression ratio of
+    *yourfile.exe*.
+
+OPTIONS
+    -q: be quiet, suppress warnings
+
+    -q -q (or -qq): be very quiet, suppress errors
+
+    -q -q -q (or -qqq): produce no output at all
+
+    --help: prints the help
+
+    --version: print the version of UPX
+
+    --exact: when compressing, require to be able to get a byte-identical
+    file after decompression with option -d. [NOTE: this is work in progress
+    and is not supported for all formats yet. If you do care, as a
+    workaround you can compress and then decompress your program a first
+    time - any further compress-decompress steps should then yield
+    byte-identical results as compared to the first decompressed version.]
+
+    -k: keep backup files
+
+    -o file: write output to file
+
+    [ ...more docs need to be written... - type `upx --help' for now ]
+
+COMPRESSION LEVELS & TUNING
+    UPX offers ten different compression levels from -1 to -9, and --best.
+    The default compression level is -8 for files smaller than 512 KiB, and
+    -7 otherwise.
+
+    *   Compression levels 1, 2 and 3 are pretty fast.
+
+    *   Compression levels 4, 5 and 6 achieve a good time/ratio performance.
+
+    *   Compression levels 7, 8 and 9 favor compression ratio over speed.
+
+    *   Compression level --best may take a long time.
+
+    Note that compression level --best can be somewhat slow for large files,
+    but you definitely should use it when releasing a final version of your
+    program.
+
+    Quick info for achieving the best compression ratio:
+
+    *   Try upx --brute --no-lzma myfile.exe or even upx --ultra-brute
+        --no-lzma myfile.exe.
+
+    *   The option --lzma enables LZMA compression, which compresses better
+        but is *significantly slower* at decompression. You probably do not
+        want to use it for large files.
+
+        (Note that --lzma is automatically enabled by --all-methods and
+        --brute, use --no-lzma to override.)
+
+    *   Try if --overlay=strip works.
+
+    *   For win32/pe programs there's --strip-relocs=0. See notes below.
+
+OVERLAY HANDLING OPTIONS
+    Info: An "overlay" means auxiliary data attached after the logical end
+    of an executable, and it often contains application specific data (this
+    is a common practice to avoid an extra data file, though it would be
+    better to use resource sections).
+
+    UPX handles overlays like many other executable packers do: it simply
+    copies the overlay after the compressed image. This works with some
+    files, but doesn't work with others, depending on how an application
+    actually accesses this overlayed data.
+
+      --overlay=copy    Copy any extra data attached to the file. [DEFAULT]
+
+      --overlay=strip   Strip any overlay from the program instead of
+                        copying it. Be warned, this may make the compressed
+                        program crash or otherwise unusable.
+
+      --overlay=skip    Refuse to compress any program which has an overlay.
+
+ENVIRONMENT VARIABLE
+    The environment variable UPX can hold a set of default options for UPX.
+    These options are interpreted first and can be overwritten by explicit
+    command line parameters. For example:
+
+        for DOS/Windows:   set UPX=-9 --compress-icons#0
+        for sh/ksh/zsh:    UPX="-9 --compress-icons=0"; export UPX
+        for csh/tcsh:      setenv UPX "-9 --compress-icons=0"
+
+    Under DOS/Windows you must use '#' instead of '=' when setting the
+    environment variable because of a COMMAND.COM limitation.
+
+    Not all of the options are valid in the environment variable - UPX will
+    tell you.
+
+    You can explicitly use the --no-env option to ignore the environment
+    variable.
+
+NOTES FOR THE SUPPORTED EXECUTABLE FORMATS
+  NOTES FOR ATARI/TOS
+    This is the executable format used by the Atari ST/TT, a Motorola 68000
+    based personal computer which was popular in the late '80s. Support of
+    this format is only because of nostalgic feelings of one of the authors
+    and serves no practical purpose :-). See https://freemint.github.io for
+    more info.
+
+    Packed programs will be byte-identical to the original after
+    uncompression. All debug information will be stripped, though.
+
+    Extra options available for this executable format:
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+  NOTES FOR BVMLINUZ/I386
+    Same as vmlinuz/i386.
+
+  NOTES FOR DOS/COM
+    Obviously UPX won't work with executables that want to read data from
+    themselves (like some commandline utilities that ship with Win95/98/ME).
+
+    Compressed programs only work on a 286+.
+
+    Packed programs will be byte-identical to the original after
+    uncompression.
+
+    Maximum uncompressed size: ~65100 bytes.
+
+    Extra options available for this executable format:
+
+      --8086              Create an executable that works on any 8086 CPU.
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+      --all-filters       Compress the program several times, using all
+                          available preprocessing filters. This may improve
+                          the compression ratio in some cases, but usually
+                          the default filter gives the best results anyway.
+
+  NOTES FOR DOS/EXE
+    dos/exe stands for all "normal" 16-bit DOS executables.
+
+    Obviously UPX won't work with executables that want to read data from
+    themselves (like some command line utilities that ship with
+    Win95/98/ME).
+
+    Compressed programs only work on a 286+.
+
+    Extra options available for this executable format:
+
+      --8086              Create an executable that works on any 8086 CPU.
+
+      --no-reloc          Use no relocation records in the exe header.
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+  NOTES FOR DOS/SYS
+    Compressed programs only work on a 286+.
+
+    Packed programs will be byte-identical to the original after
+    uncompression.
+
+    Maximum uncompressed size: ~65350 bytes.
+
+    Extra options available for this executable format:
+
+      --8086              Create an executable that works on any 8086 CPU.
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+      --all-filters       Compress the program several times, using all
+                          available preprocessing filters. This may improve
+                          the compression ratio in some cases, but usually
+                          the default filter gives the best results anyway.
+
+  NOTES FOR DJGPP2/COFF
+    First of all, it is recommended to use UPX *instead* of strip. strip has
+    the very bad habit of replacing your stub with its own (outdated)
+    version. Additionally UPX corrects a bug/feature in strip v2.8.x: it
+    will fix the 4 KiB alignment of the stub.
+
+    UPX includes the full functionality of stubify. This means it will
+    automatically stubify your COFF files. Use the option --coff to disable
+    this functionality (see below).
+
+    UPX automatically handles Allegro packfiles.
+
+    The DLM format (a rather exotic shared library extension) is not
+    supported.
+
+    Packed programs will be byte-identical to the original after
+    uncompression. All debug information and trailing garbage will be
+    stripped, though.
+
+    Extra options available for this executable format:
+
+      --coff              Produce COFF output instead of EXE. By default
+                          UPX keeps your current stub.
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+      --all-filters       Compress the program several times, using all
+                          available preprocessing filters. This may improve
+                          the compression ratio in some cases, but usually
+                          the default filter gives the best results anyway.
+
+  NOTES FOR LINUX [general]
+    Introduction
+
+      Linux/386 support in UPX consists of 3 different executable formats,
+      one optimized for ELF executables ("linux/elf386"), one optimized
+      for shell scripts ("linux/sh386"), and one generic format
+      ("linux/386").
+
+      We will start with a general discussion first, but please
+      also read the relevant docs for each of the individual formats.
+
+      Also, there is special support for bootable kernels - see the
+      description of the vmlinuz/386 format.
+
+    General user's overview
+
+      Running a compressed executable program trades less space on a
+      ``permanent'' storage medium (such as a hard disk, floppy disk,
+      CD-ROM, flash memory, EPROM, etc.) for more space in one or more
+      ``temporary'' storage media (such as RAM, swap space, /tmp, etc.).
+      Running a compressed executable also requires some additional CPU
+      cycles to generate the compressed executable in the first place,
+      and to decompress it at each invocation.
+
+      How much space is traded?  It depends on the executable, but many
+      programs save 30% to 50% of permanent disk space.  How much CPU
+      overhead is there?  Again, it depends on the executable, but
+      decompression speed generally is at least many megabytes per second,
+      and frequently is limited by the speed of the underlying disk
+      or network I/O.
+
+      Depending on the statistics of usage and access, and the relative
+      speeds of CPU, RAM, swap space, /tmp, and file system storage, then
+      invoking and running a compressed executable can be faster than
+      directly running the corresponding uncompressed program.
+      The operating system might perform fewer expensive I/O operations
+      to invoke the compressed program.  Paging to or from swap space
+      or /tmp might be faster than paging from the general file system.
+      ``Medium-sized'' programs which access about 1/3 to 1/2 of their
+      stored program bytes can do particularly well with compression.
+      Small programs tend not to benefit as much because the absolute
+      savings is less.  Big programs tend not to benefit proportionally
+      because each invocation may use only a small fraction of the program,
+      yet UPX decompresses the entire program before invoking it.
+      But in environments where disk or flash memory storage is limited,
+      then compression may win anyway.
+
+      Currently, executables compressed by UPX do not share RAM at runtime
+      in the way that executables mapped from a file system do.  As a
+      result, if the same program is run simultaneously by more than one
+      process, then using the compressed version will require more RAM and/or
+      swap space.  So, shell programs (bash, csh, etc.)  and ``make''
+      might not be good candidates for compression.
+
+      UPX recognizes three executable formats for Linux: Linux/elf386,
+      Linux/sh386, and Linux/386.  Linux/386 is the most generic format;
+      it accommodates any file that can be executed.  At runtime, the UPX
+      decompression stub re-creates in /tmp a copy of the original file,
+      and then the copy is (re-)executed with the same arguments.
+      ELF binary executables prefer the Linux/elf386 format by default,
+      because UPX decompresses them directly into RAM, uses only one
+      exec, does not use space in /tmp, and does not use /proc.
+      Shell scripts where the underlying shell accepts a ``-c'' argument
+      can use the Linux/sh386 format.  UPX decompresses the shell script
+      into low memory, then maps the shell and passes the entire text of the
+      script as an argument with a leading ``-c''.
+
+    General benefits:
+
+      - UPX can compress all executables, be it AOUT, ELF, libc4, libc5,
+        libc6, Shell/Perl/Python/... scripts, standalone Java .class
+        binaries, or whatever...
+        All scripts and programs will work just as before.
+
+      - Compressed programs are completely self-contained. No need for
+        any external program.
+
+      - UPX keeps your original program untouched. This means that
+        after decompression you will have a byte-identical version,
+        and you can use UPX as a file compressor just like gzip.
+        [ Note that UPX maintains a checksum of the file internally,
+          so it is indeed a reliable alternative. ]
+
+      - As the stub only uses syscalls and isn't linked against libc it
+        should run under any Linux configuration that can run ELF
+        binaries.
+
+      - For the same reason compressed executables should run under
+        FreeBSD and other systems which can run Linux binaries.
+        [ Please send feedback on this topic ]
+
+    General drawbacks:
+
+      - It is not advisable to compress programs which usually have many
+        instances running (like `sh' or `make') because the common segments of
+        compressed programs won't be shared any longer between different
+        processes.
+
+      - `ldd' and `size' won't show anything useful because all they
+        see is the statically linked stub.  Since version 0.82 the section
+        headers are stripped from the UPX stub and `size' doesn't even
+        recognize the file format.  The file patches/patch-elfcode.h has a
+        patch to fix this bug in `size' and other programs which use GNU BFD.
+
+    General notes:
+
+      - As UPX leaves your original program untouched it is advantageous
+        to strip it before compression.
+
+      - If you compress a script you will lose platform independence -
+        this could be a problem if you are using NFS mounted disks.
+
+      - Compression of suid, guid and sticky-bit programs is rejected
+        because of possible security implications.
+
+      - For the same reason there is no sense in making any compressed
+        program suid.
+
+      - Obviously UPX won't work with executables that want to read data
+        from themselves. E.g., this might be a problem for Perl scripts
+        which access their __DATA__ lines.
+
+      - In case of internal errors the stub will abort with exitcode 127.
+        Typical reasons for this to happen are that the program has somehow
+        been modified after compression.
+        Running `strace -o strace.log compressed_file' will tell you more.
+
+  NOTES FOR LINUX/ELF386
+    Please read the general Linux description first.
+
+    The linux/elf386 format decompresses directly into RAM, uses only one
+    exec, does not use space in /tmp, and does not use /proc.
+
+    Linux/elf386 is automatically selected for Linux ELF executables.
+
+    Packed programs will be byte-identical to the original after
+    uncompression.
+
+    How it works:
+
+      For ELF executables, UPX decompresses directly to memory, simulating
+      the mapping that the operating system kernel uses during exec(),
+      including the PT_INTERP program interpreter (if any).
+      The brk() is set by a special PT_LOAD segment in the compressed
+      executable itself.  UPX then wipes the stack clean except for
+      arguments, environment variables, and Elf_auxv entries (this is
+      required by bugs in the startup code of /lib/ld-linux.so as of
+      May 2000), and transfers control to the program interpreter or
+      the e_entry address of the original executable.
+
+      The UPX stub is about 1700 bytes long, partly written in assembler
+      and only uses kernel syscalls. It is not linked against any libc.
+
+    Specific drawbacks:
+
+      - For linux/elf386 and linux/sh386 formats, you will be relying on
+        RAM and swap space to hold all of the decompressed program during
+        the lifetime of the process.  If you already use most of your swap
+        space, then you may run out.  A system that is "out of memory"
+        can become fragile.  Many programs do not react gracefully when
+        malloc() returns 0.  With newer Linux kernels, the kernel
+        may decide to kill some processes to regain memory, and you
+        may not like the kernel's choice of which to kill.  Running
+        /usr/bin/top is one way to check on the usage of swap space.
+
+    Extra options available for this executable format:
+
+      (none)
+
+  NOTES FOR LINUX/SH386
+    Please read the general Linux description first.
+
+    Shell scripts where the underling shell accepts a ``-c'' argument can
+    use the Linux/sh386 format. UPX decompresses the shell script into low
+    memory, then maps the shell and passes the entire text of the script as
+    an argument with a leading ``-c''. It does not use space in /tmp, and
+    does not use /proc.
+
+    Linux/sh386 is automatically selected for shell scripts that use a known
+    shell.
+
+    Packed programs will be byte-identical to the original after
+    uncompression.
+
+    How it works:
+
+      For shell script executables (files beginning with "#!/" or "#! /")
+      where the shell is known to accept "-c <command>", UPX decompresses
+      the file into low memory, then maps the shell (and its PT_INTERP),
+      and passes control to the shell with the entire decompressed file
+      as the argument after "-c".  Known shells are sh, ash, bash, bsh, csh,
+      ksh, tcsh, pdksh.  Restriction: UPX cannot use this method
+      for shell scripts which use the one optional string argument after
+      the shell name in the script (example: "#! /bin/sh option3\n".)
+
+      The UPX stub is about 1700 bytes long, partly written in assembler
+      and only uses kernel syscalls. It is not linked against any libc.
+
+    Specific drawbacks:
+
+      - For linux/elf386 and linux/sh386 formats, you will be relying on
+        RAM and swap space to hold all of the decompressed program during
+        the lifetime of the process.  If you already use most of your swap
+        space, then you may run out.  A system that is "out of memory"
+        can become fragile.  Many programs do not react gracefully when
+        malloc() returns 0.  With newer Linux kernels, the kernel
+        may decide to kill some processes to regain memory, and you
+        may not like the kernel's choice of which to kill.  Running
+        /usr/bin/top is one way to check on the usage of swap space.
+
+    Extra options available for this executable format:
+
+      (none)
+
+  NOTES FOR LINUX/386
+    Please read the general Linux description first.
+
+    The generic linux/386 format decompresses to /tmp and needs /proc file
+    system support. It starts the decompressed program via the execve()
+    syscall.
+
+    Linux/386 is only selected if the specialized linux/elf386 and
+    linux/sh386 won't recognize a file.
+
+    Packed programs will be byte-identical to the original after
+    uncompression.
+
+    How it works:
+
+      For files which are not ELF and not a script for a known "-c" shell,
+      UPX uses kernel execve(), which first requires decompressing to a
+      temporary file in the file system.  Interestingly -
+      because of the good memory management of the Linux kernel - this
+      often does not introduce a noticeable delay, and in fact there
+      will be no disk access at all if you have enough free memory as
+      the entire process takes places within the file system buffers.
+
+      A compressed executable consists of the UPX stub and an overlay
+      which contains the original program in a compressed form.
+
+      The UPX stub is a statically linked ELF executable and does
+      the following at program startup:
+
+        1) decompress the overlay to a temporary location in /tmp
+        2) open the temporary file for reading
+        3) try to delete the temporary file and start (execve)
+           the uncompressed program in /tmp using /proc/<pid>/fd/X as
+           attained by step 2)
+        4) if that fails, fork off a subprocess to clean up and
+           start the program in /tmp in the meantime
+
+      The UPX stub is about 1700 bytes long, partly written in assembler
+      and only uses kernel syscalls. It is not linked against any libc.
+
+    Specific drawbacks:
+
+      - You need additional free disk space for the uncompressed program
+        in your /tmp directory. This program is deleted immediately after
+        decompression, but you still need it for the full execution time
+        of the program.
+
+      - You must have /proc file system support as the stub wants to open
+        /proc/<pid>/exe and needs /proc/<pid>/fd/X. This also means that you
+        cannot compress programs that are used during the boot sequence
+        before /proc is mounted.
+
+      - Utilities like `top' will display numerical values in the process
+        name field. This is because Linux computes the process name from
+        the first argument of the last execve syscall (which is typically
+        something like /proc/<pid>/fd/3).
+
+      - Because of temporary decompression to disk the decompression speed
+        is not as fast as with the other executable formats. Still, I can see
+        no noticeable delay when starting programs like my ~3 MiB emacs (which
+        is less than 1 MiB when compressed :-).
+
+    Extra options available for this executable format:
+
+      --force-execve      Force the use of the generic linux/386 "execve"
+                          format, i.e. do not try the linux/elf386 and
+                          linux/sh386 formats.
+
+  NOTES FOR PS1/EXE
+    This is the executable format used by the Sony PlayStation (PSone), a
+    MIPS R3000 based gaming console which is popular since the late '90s.
+    Support of this format is very similar to the Atari one, because of
+    nostalgic feelings of one of the authors.
+
+    Packed programs will be byte-identical to the original after
+    uncompression, until further notice.
+
+    Maximum uncompressed size: ~1.89 / ~7.60 MiB.
+
+    Notes:
+
+      - UPX creates as default a suitable executable for CD-Mastering
+        and console transfer. For a CD-Master main executable you could also try
+        the special option "--boot-only" as described below.
+        It has been reported that upx packed executables are fully compatible with
+        the Sony PlayStation 2 (PS2, PStwo) and Sony PlayStation Portable (PSP) in
+        Sony PlayStation (PSone) emulation mode.
+
+      - Normally the packed files use the same memory areas like the uncompressed
+        versions, so they will not override other memory areas while unpacking.
+        If this isn't possible UPX will abort showing a 'packed data overlap'
+        error. With the "--force" option UPX will relocate the loading address
+        for the packed file, but this isn't a real problem if it is a single or
+        the main executable.
+
+    Extra options available for this executable format:
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+      --8-bit             Uses 8 bit size compression [default: 32 bit]
+
+      --8mib-ram          PSone has 8 MiB ram available [default: 2 MiB]
+
+      --boot-only         This format is for main exes and CD-Mastering only !
+                          It may slightly improve the compression ratio,
+                          decompression routines are faster than default ones.
+                          But it cannot be used for console transfer !
+
+      --no-align          This option disables CD mode 2 data sector format
+                          alignment. May slightly improves the compression ratio,
+                          but the compressed executable will not boot from a CD.
+                          Use it for console transfer only !
+
+  NOTES FOR RTM32/PE and ARM/PE
+    Same as win32/pe.
+
+  NOTES FOR TMT/ADAM
+    This format is used by the TMT Pascal compiler - see http://www.tmt.com/
+    .
+
+    Extra options available for this executable format:
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+      --all-filters       Compress the program several times, using all
+                          available preprocessing filters. This may improve
+                          the compression ratio in some cases, but usually
+                          the default filter gives the best results anyway.
+
+  NOTES FOR VMLINUZ/386
+    The vmlinuz/386 and bvmlinuz/386 formats take a gzip-compressed bootable
+    Linux kernel image ("vmlinuz", "zImage", "bzImage"), gzip-decompress it
+    and re-compress it with the UPX compression method.
+
+    vmlinuz/386 is completely unrelated to the other Linux executable
+    formats, and it does not share any of their drawbacks.
+
+    Notes:
+
+      - Be sure that "vmlinuz/386" or "bvmlinuz/386" is displayed
+      during compression - otherwise a wrong executable format
+      may have been used, and the kernel won't boot.
+
+    Benefits:
+
+      - Better compression (but note that the kernel was already compressed,
+      so the improvement is not as large as with other formats).
+      Still, the bytes saved may be essential for special needs like
+      boot disks.
+
+         For example, this is what I get for my 2.2.16 kernel:
+            1589708  vmlinux
+             641073  bzImage        [original]
+             560755  bzImage.upx    [compressed by "upx -9"]
+
+      - Much faster decompression at kernel boot time (but kernel
+        decompression speed is not really an issue these days).
+
+    Drawbacks:
+
+      (none)
+
+    Extra options available for this executable format:
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+      --all-filters       Compress the program several times, using all
+                          available preprocessing filters. This may improve
+                          the compression ratio in some cases, but usually
+                          the default filter gives the best results anyway.
+
+  NOTES FOR WATCOM/LE
+    UPX has been successfully tested with the following extenders: DOS4G,
+    DOS4GW, PMODE/W, DOS32a, CauseWay. The WDOS/X extender is partly
+    supported (for details see the file bugs BUGS).
+
+    DLLs and the LX format are not supported.
+
+    Extra options available for this executable format:
+
+      --le                Produce an unbound LE output instead of
+                          keeping the current stub.
+
+  NOTES FOR WIN32/PE
+    The PE support in UPX is quite stable now, but probably there are still
+    some incompatibilities with some files.
+
+    Because of the way UPX (and other packers for this format) works, you
+    can see increased memory usage of your compressed files because the
+    whole program is loaded into memory at startup. If you start several
+    instances of huge compressed programs you're wasting memory because the
+    common segments of the program won't get shared across the instances. On
+    the other hand if you're compressing only smaller programs, or running
+    only one instance of larger programs, then this penalty is smaller, but
+    it's still there.
+
+    If you're running executables from network, then compressed programs
+    will load faster, and require less bandwidth during execution.
+
+    DLLs are supported. But UPX compressed DLLs can not share common data
+    and code when they got used by multiple applications. So compressing
+    msvcrt.dll is a waste of memory, but compressing the dll plugins of a
+    particular application may be a better idea.
+
+    Screensavers are supported, with the restriction that the filename must
+    end with ".scr" (as screensavers are handled slightly different than
+    normal exe files).
+
+    UPX compressed PE files have some minor memory overhead (usually in the
+    10 - 30 KiB range) which can be seen by specifying the "-i" command line
+    switch during compression.
+
+    Extra options available for this executable format:
+
+     --compress-exports=0 Don't compress the export section.
+                          Use this if you plan to run the compressed
+                          program under Wine.
+     --compress-exports=1 Compress the export section. [DEFAULT]
+                          Compression of the export section can improve the
+                          compression ratio quite a bit but may not work
+                          with all programs (like winword.exe).
+                          UPX never compresses the export section of a DLL
+                          regardless of this option.
+
+      --compress-icons=0  Don't compress any icons.
+      --compress-icons=1  Compress all but the first icon.
+      --compress-icons=2  Compress all icons which are not in the
+                          first icon directory. [DEFAULT]
+      --compress-icons=3  Compress all icons.
+
+      --compress-resources=0  Don't compress any resources at all.
+
+      --keep-resource=list Don't compress resources specified by the list.
+                          The members of the list are separated by commas.
+                          A list member has the following format: I<type[/name]>.
+                          I<Type> is the type of the resource. Standard types
+                          must be specified as decimal numbers, user types can be
+                          specified by decimal IDs or strings. I<Name> is the
+                          identifier of the resource. It can be a decimal number
+                          or a string. For example:
+
+                          --keep-resource=2/MYBITMAP,5,6/12345
+
+                          UPX won't compress the named bitmap resource "MYBITMAP",
+                          it leaves every dialog (5) resource uncompressed, and
+                          it won't touch the string table resource with identifier
+                          12345.
+
+      --force             Force compression even when there is an
+                          unexpected value in a header field.
+                          Use with care.
+
+      --strip-relocs=0    Don't strip relocation records.
+      --strip-relocs=1    Strip relocation records. [DEFAULT]
+                          This option only works on executables with base
+                          address greater or equal to 0x400000. Usually the
+                          compressed files becomes smaller, but some files
+                          may become larger. Note that the resulting file will
+                          not work under Windows 3.x (Win32s).
+                          UPX never strips relocations from a DLL
+                          regardless of this option.
+
+      --all-methods       Compress the program several times, using all
+                          available compression methods. This may improve
+                          the compression ratio in some cases, but usually
+                          the default method gives the best results anyway.
+
+      --all-filters       Compress the program several times, using all
+                          available preprocessing filters. This may improve
+                          the compression ratio in some cases, but usually
+                          the default filter gives the best results anyway.
+
+DIAGNOSTICS
+    Exit status is normally 0; if an error occurs, exit status is 1. If a
+    warning occurs, exit status is 2.
+
+    UPX's diagnostics are intended to be self-explanatory.
+
+BUGS
+    Please report all bugs immediately to the authors.
+
+AUTHORS
+     Markus F.X.J. Oberhumer <markus@oberhumer.com>
+     http://www.oberhumer.com
+
+     Laszlo Molnar <ezerotven+github@gmail.com>
+
+     John F. Reiser <jreiser@BitWagon.com>
+
+     Jens Medoch <jssg@users.sourceforge.net>
+
+COPYRIGHT
+    Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
+
+    Copyright (C) 1996-2022 Laszlo Molnar
+
+    Copyright (C) 2000-2022 John F. Reiser
+
+    Copyright (C) 2002-2022 Jens Medoch
+
+    This program may be used freely, and you are welcome to redistribute it
+    under certain conditions.
+
+    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.
+
+    UPX is distributed with full source code under the terms of the GNU
+    General Public License v2+; either under the pure GPLv2+ (see the file
+    COPYING), or (at your option) under the GPLv+2 with special exceptions
+    and restrictions granting the free usage for commercial programs (see
+    the file LICENSE).
+
+    You should have received a copy of the UPX License Agreements along with
+    this program; see the files COPYING and LICENSE. If not, visit the UPX
+    home page.
+

doc/upx.pod

@@ -13,8 +13,8 @@ B<upx> S<[ I<command> ]> S<[ I<options> ]> I<filename>...
 =head1 ABSTRACT
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2006 Markus Oberhumer, Laszlo Molnar & John Reiser
+   Copyright (c) 1996-2022 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
+                           https://upx.github.io
 
 
 B<UPX> is a portable, extendable, high-performance executable packer for
@@ -23,74 +23,59 @@ ratio and offers I<*very*> fast decompression. Your executables suffer
 no memory overhead or other drawbacks for most of the formats supported,
 because of in-place decompression.
 
-While you may use B<UPX> freely for both non-commercial and commercial
-executables (for details see the file LICENSE), we would highly
-appreciate if you credit B<UPX> and ourselves in the documentation,
-possibly including a reference to the B<UPX> home page. Thanks.
-
-[ Using B<UPX> in non-OpenSource applications without proper credits
-is considered not politically correct ;-) ]
-
 
 
 =head1 DISCLAIMER
 
-B<UPX> comes with ABSOLUTELY NO WARRANTY; for details see the file LICENSE.
+B<UPX> comes with ABSOLUTELY NO WARRANTY; for details see the file COPYING.
-
-This is the first production quality release, and we plan that future 1.xx
-releases will be backward compatible with this version.
 
 Please report all problems or suggestions to the authors. Thanks.
 
 
 
+=head1 SECURITY CONTEXT
+
+IMPORTANT NOTE: B<UPX> inherits the security context of any files it handles.
+
+This means that packing, unpacking, or even testing or listing a file requires
+the same security considerations as actually executing the file.
+
+Use B<UPX> on trusted files only!
+
+
+
 =head1 DESCRIPTION
 
 B<UPX> is a versatile executable packer with the following features:
 
-  - excellent compression ratio: compresses better than zip/gzip,
+  - secure: as UPX is documented Open Source since many years any relevant
+      Security/Antivirus software is able to peek inside UPX compressed
+      apps to verify them
+
+  - excellent compression ratio: typically compresses better than Zip,
       use UPX to decrease the size of your distribution !
 
-  - very fast decompression: about 10 MB/sec on an ancient Pentium 133,
+  - very fast decompression: more than 500 MB/sec on any reasonably modern
-      about 200 MB/sec on an Athlon XP 2000+.
+      machine
 
   - no memory overhead for your compressed executables for most of the
-      supported formats
+      supported formats because of in-place decompression
 
-  - safe: you can list, test and unpack your executables
+  - safe: you can list, test and unpack your executables.
       Also, a checksum of both the compressed and uncompressed file is
       maintained internally.
 
-  - universal: UPX can pack a number of executable formats:
+  - universal: UPX can pack a number of executable formats, including
-      * atari/tos
+      Windows programs and DLLs, macOS apps and Linux executables
-      * bvmlinuz/386    [bootable Linux kernel]
-      * djgpp2/coff
-      * dos/com
-      * dos/exe
-      * dos/sys
-      * linux/386
-      * linux/elf386
-      * linux/sh386
-      * ps1/exe
-      * rtm32/pe
-      * tmt/adam
-      * vmlinuz/386     [bootable Linux kernel]
-      * vmlinux/386
-      * watcom/le (supporting DOS4G, PMODE/W, DOS32a and CauseWay)
-      * win32/pe (exe and dll)
-      * arm/pe (exe and dll)
-      * linux/elfamd64
-      * linux/elfppc32
-      * mach/elfppc32
 
   - portable: UPX is written in portable endian-neutral C++
 
   - extendable: because of the class layout it's very easy to support
       new executable formats or add new compression algorithms
 
-  - free: UPX can be distributed and used freely. And from version 0.99
+  - free: UPX is distributed with full source code under the GNU General
-      the full source code of UPX is released under the GNU General Public
+      Public License v2+, with special exceptions granting the free usage
-      License (GPL) !
+      for commercial programs
 
 You probably understand now why we call B<UPX> the "I<ultimate>"
 executable packer.
@@ -138,7 +123,18 @@ B<--help>: prints the help
 
 B<--version>: print the version of B<UPX>
 
-[ ...to be written... - type `B<upx --help>' for now ]
+B<--exact>: when compressing, require to be able to get a byte-identical file
+after decompression with option B<-d>. [NOTE: this is work in progress and is
+not supported for all formats yet. If you do care, as a workaround you can
+compress and then decompress your program a first time - any further
+compress-decompress steps should then yield byte-identical results
+as compared to the first decompressed version.]
+
+B<-k>: keep backup files
+
+B<-o file>: write output to file
+
+[ ...more docs need to be written... - type `B<upx --help>' for now ]
 
 
 
@@ -146,7 +142,7 @@ B<--version>: print the version of B<UPX>
 
 B<UPX> offers ten different compression levels from B<-1> to B<-9>,
 and B<--best>.  The default compression level is B<-8> for files
-smaller than 512 kB, and B<-7> otherwise.
+smaller than 512 KiB, and B<-7> otherwise.
 
 =over 4
 
@@ -172,38 +168,23 @@ Note that compression level B<--best> can be somewhat slow for large
 files, but you definitely should use it when releasing a final version
 of your program.
 
-Quick start for achieving the best compression ratio:
+Quick info for achieving the best compression ratio:
-
-=over 4
-
-Try B<upx --brute myfile.exe>.
-
-=back
-
-Details for achieving the best compression ratio:
 
 =over 4
 
 =item *
 
-Use the compression level B<--best>.
+Try B<upx --brute --no-lzma myfile.exe> or even
+B<upx --ultra-brute --no-lzma myfile.exe>.
 
 =item *
 
-Try one or both of the options B<--all-methods> and B<--all-filters>.
+The option B<--lzma> enables LZMA compression, which compresses better but
+is *significantly slower* at decompression. You probably do not want
+to use it for large files.
 
-=item *
+(Note that B<--lzma> is automatically enabled by B<--all-methods> and
-
+B<--brute>, use B<--no-lzma> to override.)
-Try the option B<--crp-ms=NUMBER>. This uses more memory during compression
-to achieve a (slightly) better compression ratio.
-
-NUMBER must be a decimal value from 10000 to 999999, inclusive.
-The default value is 10000 (ten thousand).
-
-=item *
-
-Info: the option B<--brute> is an abbrevation for the options
-B<S<--best> S<--all-methods> S<--all-filters> S<--crp-ms=999999>>.
 
 =item *
 
@@ -219,7 +200,7 @@ For win32/pe programs there's B<--strip-relocs=0>. See notes below.
 
 =head1 OVERLAY HANDLING OPTIONS
 
-Info: An "overlay" means auxillary data atached after the logical end of
+Info: An "overlay" means auxiliary data attached after the logical end of
 an executable, and it often contains application specific data
 (this is a common practice to avoid an extra data file, though
 it would be better to use resource sections).
@@ -239,7 +220,7 @@ actually accesses this overlayed data.
 
 
 
-=head1 ENVIRONMENT
+=head1 ENVIRONMENT VARIABLE
 
 The environment variable B<UPX> can hold a set of default
 options for B<UPX>. These options are interpreted first and
@@ -269,7 +250,7 @@ This is the executable format used by the Atari ST/TT, a Motorola 68000
 based personal computer which was popular in the late '80s. Support
 of this format is only because of nostalgic feelings of one of
 the authors and serves no practical purpose :-).
-See http://www.freemint.de for more info.
+See https://freemint.github.io for more info.
 
 Packed programs will be byte-identical to the original after uncompression.
 All debug information will be stripped, though.
@@ -367,7 +348,7 @@ Extra options available for this executable format:
 First of all, it is recommended to use B<UPX> *instead* of B<strip>. strip has
 the very bad habit of replacing your stub with its own (outdated) version.
 Additionally B<UPX> corrects a bug/feature in strip v2.8.x: it
-will fix the 4 KByte aligment of the stub.
+will fix the 4 KiB alignment of the stub.
 
 B<UPX> includes the full functionality of stubify. This means it will
 automatically stubify your COFF files. Use the option B<--coff> to
@@ -402,7 +383,7 @@ Extra options available for this executable format:
 Introduction
 
   Linux/386 support in UPX consists of 3 different executable formats,
-  one optimized for ELF excutables ("linux/elf386"), one optimized
+  one optimized for ELF executables ("linux/elf386"), one optimized
   for shell scripts ("linux/sh386"), and one generic format
   ("linux/386").
 
@@ -430,14 +411,14 @@ General user's overview
   or network I/O.
 
   Depending on the statistics of usage and access, and the relative
-  speeds of CPU, RAM, swap space, /tmp, and filesystem storage, then
+  speeds of CPU, RAM, swap space, /tmp, and file system storage, then
   invoking and running a compressed executable can be faster than
   directly running the corresponding uncompressed program.
-  The operating system might perfrom fewer expensive I/O operations
+  The operating system might perform fewer expensive I/O operations
   to invoke the compressed program.  Paging to or from swap space
-  or /tmp might be faster than paging from the general filesystem.
+  or /tmp might be faster than paging from the general file system.
   ``Medium-sized'' programs which access about 1/3 to 1/2 of their
-  stored program bytes can do particulary well with compression.
+  stored program bytes can do particularly well with compression.
   Small programs tend not to benefit as much because the absolute
   savings is less.  Big programs tend not to benefit proportionally
   because each invocation may use only a small fraction of the program,
@@ -446,7 +427,7 @@ General user's overview
   then compression may win anyway.
 
   Currently, executables compressed by UPX do not share RAM at runtime
-  in the way that executables mapped from a filesystem do.  As a
+  in the way that executables mapped from a file system do.  As a
   result, if the same program is run simultaneously by more than one
   process, then using the compressed version will require more RAM and/or
   swap space.  So, shell programs (bash, csh, etc.)  and ``make''
@@ -535,7 +516,7 @@ The linux/elf386 format decompresses directly into RAM,
 uses only one exec, does not use space in /tmp,
 and does not use /proc.
 
-Linux/elf386 is automatically selected for Linux ELF exectuables.
+Linux/elf386 is automatically selected for Linux ELF executables.
 
 Packed programs will be byte-identical to the original after uncompression.
 
@@ -624,7 +605,7 @@ Extra options available for this executable format:
 Please read the general Linux description first.
 
 The generic linux/386 format decompresses to /tmp and needs
-/proc filesystem support. It starts the decompressed program
+/proc file system support. It starts the decompressed program
 via the execve() syscall.
 
 Linux/386 is only selected if the specialized linux/elf386
@@ -636,11 +617,11 @@ How it works:
 
   For files which are not ELF and not a script for a known "-c" shell,
   UPX uses kernel execve(), which first requires decompressing to a
-  temporary file in the filesystem.  Interestingly -
+  temporary file in the file system.  Interestingly -
   because of the good memory management of the Linux kernel - this
-  often does not introduce a noticable delay, and in fact there
+  often does not introduce a noticeable delay, and in fact there
   will be no disk access at all if you have enough free memory as
-  the entire process takes places within the filesystem buffers.
+  the entire process takes places within the file system buffers.
 
   A compressed executable consists of the UPX stub and an overlay
   which contains the original program in a compressed form.
@@ -666,7 +647,7 @@ Specific drawbacks:
     decompression, but you still need it for the full execution time
     of the program.
 
-  - You must have /proc filesystem support as the stub wants to open
+  - You must have /proc file system support as the stub wants to open
     /proc/<pid>/exe and needs /proc/<pid>/fd/X. This also means that you
     cannot compress programs that are used during the boot sequence
     before /proc is mounted.
@@ -678,8 +659,8 @@ Specific drawbacks:
 
   - Because of temporary decompression to disk the decompression speed
     is not as fast as with the other executable formats. Still, I can see
-    no noticable delay when starting programs like my ~3 MB emacs (which
+    no noticeable delay when starting programs like my ~3 MiB emacs (which
-    is less than 1 MB when compressed :-).
+    is less than 1 MiB when compressed :-).
 
 Extra options available for this executable format:
 
@@ -692,20 +673,23 @@ Extra options available for this executable format:
 =head2 NOTES FOR PS1/EXE
 
 This is the executable format used by the Sony PlayStation (PSone),
-a Mips R3000 based gaming console which is popular since the late '90s.
+a MIPS R3000 based gaming console which is popular since the late '90s.
 Support of this format is very similar to the Atari one, because of
 nostalgic feelings of one of the authors.
 
 Packed programs will be byte-identical to the original after uncompression,
 until further notice.
 
-Maximum uncompressed size: ~1.89 / ~7.60 Mbytes.
+Maximum uncompressed size: ~1.89 / ~7.60 MiB.
 
 Notes:
 
   - UPX creates as default a suitable executable for CD-Mastering
     and console transfer. For a CD-Master main executable you could also try
-    the special option "--boot-only" as descriped below.
+    the special option "--boot-only" as described below.
+    It has been reported that upx packed executables are fully compatible with
+    the Sony PlayStation 2 (PS2, PStwo) and Sony PlayStation Portable (PSP) in
+    Sony PlayStation (PSone) emulation mode.
 
   - Normally the packed files use the same memory areas like the uncompressed
     versions, so they will not override other memory areas while unpacking.
@@ -723,7 +707,7 @@ Extra options available for this executable format:
 
   --8-bit             Uses 8 bit size compression [default: 32 bit]
 
-  --8mb-ram           PSone has 8 MB ram available [default: 2 MB]
+  --8mib-ram          PSone has 8 MiB ram available [default: 2 MiB]
 
   --boot-only         This format is for main exes and CD-Mastering only !
                       It may slightly improve the compression ratio,
@@ -781,7 +765,7 @@ Benefits:
   - Better compression (but note that the kernel was already compressed,
   so the improvement is not as large as with other formats).
   Still, the bytes saved may be essential for special needs like
-  bootdisks.
+  boot disks.
 
      For example, this is what I get for my 2.2.16 kernel:
         1589708  vmlinux
@@ -828,13 +812,13 @@ Extra options available for this executable format:
 =head2 NOTES FOR WIN32/PE
 
 The PE support in B<UPX> is quite stable now, but probably there are
-still some incompabilities with some files.
+still some incompatibilities with some files.
 
 Because of the way B<UPX> (and other packers for this format) works, you
 can see increased memory usage of your compressed files because the whole
 program is loaded into memory at startup.
 If you start several instances of huge compressed programs you're
-wasting memory because the common segements of the program won't
+wasting memory because the common segments of the program won't
 get shared across the instances.
 On the other hand if you're compressing only smaller programs, or
 running only one instance of larger programs, then this penalty is
@@ -852,8 +836,8 @@ Screensavers are supported, with the restriction that the filename
 must end with ".scr" (as screensavers are handled slightly different
 than normal exe files).
 
-UPX compressed PE files has some minor memory overhead (usually in the
+UPX compressed PE files have some minor memory overhead (usually in the
-10 - 30 kbytes range) which can be seen by specifying the "-i" command
+10 - 30 KiB range) which can be seen by specifying the "-i" command
 line switch during compression.
 
 Extra options available for this executable format:
@@ -872,6 +856,7 @@ Extra options available for this executable format:
   --compress-icons=1  Compress all but the first icon.
   --compress-icons=2  Compress all icons which are not in the
                       first icon directory. [DEFAULT]
+  --compress-icons=3  Compress all icons.
 
   --compress-resources=0  Don't compress any resources at all.
 
@@ -937,7 +922,7 @@ Please report all bugs immediately to the authors.
  Markus F.X.J. Oberhumer <markus@oberhumer.com>
  http://www.oberhumer.com
 
- Laszlo Molnar <ml1050@users.sourceforge.net>
+ Laszlo Molnar <ezerotven+github@gmail.com>
 
  John F. Reiser <jreiser@BitWagon.com>
 
@@ -947,22 +932,28 @@ Please report all bugs immediately to the authors.
 
 =head1 COPYRIGHT
 
-Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
 
-Copyright (C) 1996-2006 Laszlo Molnar
+Copyright (C) 1996-2022 Laszlo Molnar
 
-Copyright (C) 2000-2006 John F. Reiser
+Copyright (C) 2000-2022 John F. Reiser
 
-Copyright (C) 2002-2006 Jens Medoch
+Copyright (C) 2002-2022 Jens Medoch
 
 This program may be used freely, and you are welcome to
 redistribute it under certain conditions.
 
 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
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-B<UPX License Agreement> for more details.
 
-You should have received a copy of the UPX License Agreement along
+B<UPX> is distributed with full source code under the terms of the
-with this program; see the file LICENSE. If not, visit the UPX home page.
+GNU General Public License v2+;
+either under the pure GPLv2+ (see the file COPYING),
+or (at your option) under the GPLv+2 with special exceptions and
+restrictions granting the free usage for commercial
+programs (see the file LICENSE).
 
+You should have received a copy of the UPX License Agreements along
+with this program; see the files COPYING and LICENSE. If not,
+visit the UPX home page.

misc/rebuild-stubs-with-podman/10-create-image.sh

@@ -0,0 +1,14 @@
+#! /usr/bin/env bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+argv0=$0; argv0abs="$(readlink -fn "$argv0")"; argv0dir="$(dirname "$argv0abs")"
+
+# create the image from Dockerfile
+# using a rootless Podman container
+
+image=upx-stubtools-20210104-v5
+
+podman build -t "$image" -f "$argv0dir/Dockerfile" "$argv0dir"
+
+podman image list "$image"
+podman image tree "$image"

misc/rebuild-stubs-with-podman/20-image-run-shell.sh

@@ -0,0 +1,46 @@
+#! /usr/bin/env bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+argv0=$0; argv0abs="$(readlink -fn "$argv0")"; argv0dir="$(dirname "$argv0abs")"
+
+# run an interactive shell in the image
+# using a rootless Podman container
+
+image=upx-stubtools-20210104-v5
+
+flags=( -ti --read-only --rm )
+flags+=( --cap-drop=all )           # drop all capabilities
+flags+=( --network=none )           # no network needed
+flags+=( -e TERM="$TERM" )          # pass $TERM
+if [[ 1 == 1 ]]; then
+    # run as user upx 2000:2000
+    flags+=( --user 2000 )
+    # map container user 0 to subuid-user 1, and map container user 2000 to current host user
+    flags+=( --uidmap=0:1:1 --uidmap=2000:0:1 )
+    # map container group 0 to subgid-group 1, and map container group 2000 to current host group
+    flags+=( --gidmap=0:1:1 --gidmap=2000:0:1 )
+    # NOTE: we mount the upx top-level directory read-write under /home/upx/src/upx
+    # INFO: SELinux users *may* have to add ":z" to the volume mount flags; check the docs!
+    flags+=( -v "${argv0dir}/../..:/home/upx/src/upx" )
+    flags+=( -w /home/upx/src/upx ) # working directory
+else
+    # run as user root 0:0
+    # ONLY FOR DEBUGGING THE IMAGE
+    # map container user/group 0 to current host user/group
+    flags+=( --user 0 )
+fi
+
+podman run "${flags[@]}" "$image" bash -l
+
+# now we can rebuild the UPX stubs:
+#   cd /home/upx/src/upx/src/stub
+#   # make sure that git is clean:
+#   git status .
+#   # remove stub files and make sure that they got deleted:
+#   make maintainer-clean
+#   git status .
+#   # rebuild
+#   make all
+#   # make sure that the stub files did rebuild correctly:
+#   git status .
+#   git diff .

misc/rebuild-stubs-with-podman/Dockerfile

@@ -0,0 +1,66 @@
+FROM docker.io/library/ubuntu:22.04
+ARG DEBIAN_FRONTEND=noninteractive
+ENV LANG=C.UTF-8
+
+# install system packages
+RUN dpkg --add-architecture i386 \
+    && apt-get update && apt-get upgrade -y \
+    && apt-get install -y --no-install-recommends \
+        aria2 ca-certificates git less libmpc3 libncurses5 make \
+        ncurses-term perl-base python2-minimal wget xz-utils \
+        libc6:i386 zlib1g:i386 \
+        # the following packages are not required for rebuilding the stubs,
+        # but they do make the image more convenient and also allow building
+        # the full UPX binary inside the container via CMake:
+        bzip2 cmake elfutils file g++ libzstd-dev lzop ninja-build patch \
+        patchelf pax-utils rsync unzip vim zip zlib1g-dev zsh zstd \
+    && true
+
+# manually install compat libs from Ubuntu 16.04
+RUN cd /root \
+    && aria2c --checksum=sha-256=2605f43f8047fc972855bb909f1dd7af761bbfd35ae559ad689b0d55a4236d69 \
+              'http://mirror.enzu.com/ubuntu/pool/main/g/gmp/libgmp10_6.1.0+dfsg-2_amd64.deb' \
+    && aria2c --checksum=sha-256=3973a97387bbe0e8a775995c22861d8478edee2a594e8117970f635de25b2c8a \
+              'http://mirror.enzu.com/ubuntu/pool/main/m/mpfr4/libmpfr4_3.1.4-1_amd64.deb' \
+    && mkdir packages \
+    && for f in ./*.deb; do dpkg -x $f ./packages; done \
+    && mv -v -n ./packages/usr/lib/x86_64-linux-gnu/lib* /usr/lib/x86_64-linux-gnu/ \
+    && rm -rf ./*.deb ./packages \
+    && ldconfig \
+    && true
+
+# install upx-stubtools into /usr/local/bin/bin-upx-20210104
+RUN cd /root \
+    && aria2c --checksum=sha-256=abcd8337cc656fe68d7bbb2ffe0f1e5ddce618688aa0e18c1ebcc40072843884 \
+              'https://github.com/upx/upx-stubtools/releases/download/v20210104/bin-upx-20210104.tar.xz' \
+    && cd /usr/local/bin \
+    && tar -xoaf /root/bin-upx-20210104.tar.xz \
+    && rm /root/bin-upx-20210104.tar.xz \
+    && true
+
+# install previous UPX versions into /usr/local/bin
+RUN cd /root \
+    && wget -q https://github.com/upx/upx/releases/download/v3.91/upx-3.91-amd64_linux.tar.bz2 \
+    && wget -q https://github.com/upx/upx/releases/download/v3.92/upx-3.92-amd64_linux.tar.xz \
+    && wget -q https://github.com/upx/upx/releases/download/v3.93/upx-3.93-amd64_linux.tar.xz \
+    && wget -q https://github.com/upx/upx/releases/download/v3.94/upx-3.94-amd64_linux.tar.xz \
+    && wget -q https://github.com/upx/upx/releases/download/v3.95/upx-3.95-amd64_linux.tar.xz \
+    && wget -q https://github.com/upx/upx/releases/download/v3.96/upx-3.96-amd64_linux.tar.xz \
+    && for f in ./upx-*.tar.*; do tar -xoaf $f; done \
+    && rm ./upx-*.tar.* \
+    && d=upx-3.91-amd64_linux; ./$d/upx -d $d/upx -o /usr/local/bin/upx-3.91 \
+    && d=upx-3.92-amd64_linux; ./$d/upx -d $d/upx -o /usr/local/bin/upx-3.92 \
+    && d=upx-3.93-amd64_linux; ./$d/upx -d $d/upx -o /usr/local/bin/upx-3.93 \
+    && d=upx-3.94-amd64_linux; ./$d/upx -d $d/upx -o /usr/local/bin/upx-3.94 \
+    && d=upx-3.95-amd64_linux; ./$d/upx -d $d/upx -o /usr/local/bin/upx-3.95 \
+    && d=upx-3.96-amd64_linux; ./$d/upx -d $d/upx -o /usr/local/bin/upx-3.96 \
+    && rm -rf ./upx-*linux \
+    && true
+
+# create default user upx 2000:2000
+RUN useradd upx -U --uid 2000 --shell /bin/bash -m \
+    && mkdir -p /home/upx/.local/bin /home/upx/src/upx \
+    && ln -s /usr/local/bin/bin-upx-20210104 /home/upx/.local/bin/bin-upx \
+    && chown -R upx:upx /home/upx \
+    && true
+USER upx

misc/scripts/check_whitespace.sh

@@ -0,0 +1,39 @@
+#! /usr/bin/env bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+[[ -z $1 ]] || cd "$1" || exit 1
+
+find . \
+    -type d -name '.git' -prune -o \
+    -type d -name '.hg' -prune -o \
+    -type d -name 'build*' -prune -o \
+    -type d -name 'tmp*' -prune -o \
+    -type d -name 'vendor' -prune -o \
+    -type f -iname '*.bat' -prune -o \
+    -type f -iname '*.exe' -prune -o \
+    -type f -iname '*.o' -prune -o \
+    -type f -iname '*.obj' -prune -o \
+    -type f -iname '*.out' -prune -o \
+    -type f -iname '*.pdf' -prune -o \
+    -type f -iname '*.swp' -prune -o \
+    -type f -print0 | \
+LC_ALL=C sort -z | xargs -0r perl -n -e '
+    #print("$ARGV\n");
+    if (m,[\x00\x01\x02\x7f\xfe\xff],) { print "ERROR: binary file detected $ARGV: $_"; exit(1); }
+    if (m,[\r\x1a],) { print "ERROR: DOS EOL detected $ARGV: $_"; exit(1); }
+    if (m,([ \t]+)$,) {
+        # allow exactly two trailing spaces for GitHub flavoured Markdown in .md files
+        if ($1 ne "  " || $ARGV !~ m,\.md$,) {
+            print "ERROR: trailing whitespace detected $ARGV: $_"; exit(1);
+        }
+    }
+    if (m,\t,) {
+       if ($ARGV =~ m,(^|/)(gnu|m)?make(file|vars),i) { }
+       elsif ($ARGV =~ m,/tmp/.*\.(disasm|dump)$,) { }
+       elsif ($ARGV =~ m,/src/stub/src/arch/.*/lzma\w+\.S$,) { }
+       else { print "ERROR: hard TAB detected $ARGV: $_"; exit(1); }
+    }
+' || exit 1

misc/scripts/check_whitespace_git.sh

@@ -0,0 +1,33 @@
+#! /usr/bin/env bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+[[ -z $1 ]] || cd "$1" || exit 1
+[[ -d .git ]] || exit 1
+
+git ls-files --full-name -z | perl -0 -n -e '
+    s,^,./,;
+    if (m,^\./src/lzma-sdk(\0|$),) { }
+    elsif (m,^\./vendor/,) { }
+    elsif (m,\.bat(\0|$),) { }
+    elsif (m,\.exe(\0|$),) { }
+    else { print; }
+' | LC_ALL=C sort -z | xargs -0r perl -n -e '
+    #print("$ARGV\n");
+    if (m,[\x00\x01\x02\x7f\xfe\xff],) { print "ERROR: binary file detected $ARGV: $_"; exit(1); }
+    if (m,[\r\x1a],) { print "ERROR: DOS EOL detected $ARGV: $_"; exit(1); }
+    if (m,([ \t]+)$,) {
+        # allow exactly two trailing spaces for GitHub flavoured Markdown in .md files
+        if ($1 ne "  " || $ARGV !~ m,\.md$,) {
+            print "ERROR: trailing whitespace detected $ARGV: $_"; exit(1);
+        }
+    }
+    if (m,\t,) {
+       if ($ARGV =~ m,(^|/)(gnu|m)?make(file|vars),i) { }
+       elsif ($ARGV =~ m,/tmp/.*\.(disasm|dump)$,) { }
+       elsif ($ARGV =~ m,/src/stub/src/arch/.*/lzma\w+\.S$,) { }
+       else { print "ERROR: hard TAB detected $ARGV: $_"; exit(1); }
+    }
+' || exit 1

misc/scripts/upx-clang-format

@@ -0,0 +1,32 @@
+#! /usr/bin/env bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+
+# "Gofmt's style is nobody's favourite, but gofmt is everybody's favourite." --Rob Pike
+
+# NOTE: we are using clang-format-10.0.1 from upx-stubtools
+# see https://github.com/upx/upx-stubtools/releases
+
+# NOTE: we use .clang-format config from upx.git/.clang-format
+
+if [[ ! -f $UPX_CLANG_FORMAT ]]; then
+UPX_CLANG_FORMAT="$HOME/local/bin/bin-upx/clang-format-10.0.1"
+fi
+if [[ ! -f $UPX_CLANG_FORMAT ]]; then
+UPX_CLANG_FORMAT="$HOME/.local/bin/bin-upx/clang-format-10.0.1"
+fi
+if [[ ! -f $UPX_CLANG_FORMAT ]]; then
+UPX_CLANG_FORMAT="$HOME/bin/bin-upx/clang-format-10.0.1"
+fi
+if [[ ! -f $UPX_CLANG_FORMAT ]]; then
+    echo "ERROR: $0: cannot find clang-format-10.0.1"
+    echo "ERROR: $0: please visit https://github.com/upx/upx-stubtools"
+    exit 1
+fi
+
+# limit memory usage to 1 GiB (in case of clang-format problems with invalid files)
+ulimit -v 1048576 || true
+
+#echo $UPX_CLANG_FORMAT
+exec "$UPX_CLANG_FORMAT" -style=file "$@"
+exit 1

src/Makefile

@@ -1,104 +1,103 @@
 #
-# UPX Makefile - needs GNU make 3.80 or better
+# UPX Makefile - needs GNU make
 #
 
-MAKEFLAGS += -rR
+# IMPORTANT NOTE: this Makefile is deprecated - please
+#   directly use the CMake build instead!
+
+MAKEFLAGS += -r
 .SUFFIXES:
 export SHELL = /bin/sh
-override e = $($1) $(EXTRA_$1) $(upx_$1) $($(basename $(notdir $@)).$1)
 
-srcdir ?= $(dir $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
+ifndef srcdir
-ifneq ($(srcdir),./)
+  srcdir := $(dir $(lastword $(MAKEFILE_LIST)))
-srcdir := $(shell echo '$(srcdir)' | sed 's,/*$$,,')
+  srcdir := $(shell echo '$(srcdir)' | sed 's,/*$$,,' || echo 'ERROR')
-##$(info Info: using VPATH . $(srcdir))
+endif
-VPATH := . $(srcdir)
+ifndef top_srcdir
+  top_srcdir := $(srcdir)/..
 endif
 
-ifeq ($(CXX),)
+#
-CXX = g++
+# redirect to top-level CMake build
-endif
+#
-ifeq ($(firstword $(CXX)),g++)
-USE_GNUC ?= 1
-endif
-ifeq ($(USE_GNUC),1)
-CXXFLAGS += -MMD
-ifeq ($(DEBUG),1)
-CXXFLAGS += -O0 -g
-else
-CXXFLAGS += -O2
-endif
-CXXFLAGS += -Wall -W -Wcast-align -Wcast-qual -Wpointer-arith -Wwrite-strings -Werror
-##CXXFLAGS += -Wshadow
-endif
-CPPFLAGS += $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
-CXXLD ?= $(CXX)
 
-exeext ?= .out
+default: debug
-libext ?= .a
+all: debug release
-objext ?= .o
+debug: $(top_srcdir)/build/debug/upx
+release: $(top_srcdir)/build/release/upx
 
-upx_SOURCES := $(wildcard $(srcdir)/*.cpp)
+$(top_srcdir)/build/debug/upx:
-upx_OBJECTS := $(notdir $(upx_SOURCES:.cpp=$(objext)))
+	$(MAKE) -C $(top_srcdir) build/debug
+$(top_srcdir)/build/release/upx:
+	$(MAKE) -C $(top_srcdir) build/release
 
-# we need UCL and zlib - you can set envvar UPX_UCLDIR
+.PHONY: default all debug release
-ifneq ($(wildcard $(UPX_UCLDIR)/include/ucl/ucl.h),)
+.PHONY: $(top_srcdir)/build/debug/upx
-INCLUDES += -I$(UPX_UCLDIR)/include
+.PHONY: $(top_srcdir)/build/release/upx
-LIBS += $(addprefix -L,$(dir $(wildcard $(UPX_UCLDIR)/libucl$(libext) $(UPX_UCLDIR)/src/.libs/libucl$(libext))))
-endif
-LIBS += -lucl -lz
-# you should set envvar UPX_LZMADIR to point to your unpacked lzma443.tar.bz2
-ifneq ($(wildcard $(UPX_LZMADIR)/C/7zip/.),)
-DEFS += -DWITH_LZMA
-INCLUDES += -I$(UPX_LZMADIR)
-endif
-# you should set envvar UPX_LUADIR to point to your unpacked lua-5.1.1.tar.gz
-# [disabled for now]
-ifneq ($(wildcard $(UPX_LUADIR)/src/lua.h),)
-##DEFS += -DWITH_LUA
-##upx_SOURCES_LUA := $(wildcard $(UPX_LUADIR)/src/*.c)
-##upx_SOURCES_LUA := $(filter-out %lua.c, $(upx_SOURCES_LUA))
-##upx_SOURCES_LUA := $(filter-out %luac.c, $(upx_SOURCES_LUA))
-##upx_OBJECTS_LUA := $(notdir $(upx_SOURCES_LUA:.c=$(objext)))
-##upx_OBJECTS_LUA := $(addprefix lua_,$(upx_OBJECTS_LUA))
-##upx_OBJECTS     += $(upx_OBJECTS_LUA)
-else
-##$(error please set UPX_LUADIR)
-endif
 
+#
+# "make run-testsuite"
+#
 
-all: upx$(exeext)
+# search for the UPX testsuite -- git clone https://github.com/upx/upx-testsuite.git
-
+# you also can override upx_testsuite_SRCDIR
-upx$(exeext): $(upx_OBJECTS) $(upx_DEPENDENCIES)
+ifndef upx_testsuite_SRCDIR
-	$($(notdir $@).PRE_LINK_STEP)
+# search standard locations below $(top_srcdir)
-	$(strip $(CXXLD) $(call e,CPPFLAGS) $(call e,CXXFLAGS) $(call e,LDFLAGS) -o $@ $(upx_OBJECTS) $(call e,LDADD) $(call e,LIBS))
+ifneq ($(wildcard $(top_srcdir)/../upx--upx-testsuite.git/files/packed/.),)
-	$($(notdir $@).POST_LINK_STEP)
+upx_testsuite_SRCDIR := $(top_srcdir)/../upx--upx-testsuite.git
-
+else ifneq ($(wildcard $(top_srcdir)/../upx-testsuite.git/files/packed/.),)
-%.o : %.cpp
+upx_testsuite_SRCDIR := $(top_srcdir)/../upx-testsuite.git
-	$(strip $(CXX) $(call e,CPPFLAGS) $(call e,CXXFLAGS) -o $@ -c $<)
+else ifneq ($(wildcard $(top_srcdir)/../upx-testsuite/files/packed/.),)
-
+upx_testsuite_SRCDIR := $(top_srcdir)/../upx-testsuite
-
-ifeq ($(USE_GNUC),1)
-##compress_lzma$(objext) : CXXFLAGS += -O3 -fomit-frame-pointer
-compress_lzma$(objext) : CXXFLAGS += -Wno-cast-qual
-compress_lzma$(objext) : CXXFLAGS += -Wno-non-virtual-dtor
-compress_lzma$(objext) : CXXFLAGS += -Wno-shadow
-compress_lzma$(objext) : CXXFLAGS += -Wno-unused
-##compress_lzma$(objext) : CXXFLAGS += -Wno-error
-endif
-
-ifneq ($(strip $(upx_OBJECTS_LUA)),)
-$(upx_OBJECTS_LUA) : lua_%.o : $(UPX_LUADIR)/src/%.c
-	$(strip $(CXX) $(call e,CPPFLAGS) $(call e,CXXFLAGS) -o $@ -c $<)
-ifeq ($(USE_GNUC),1)
-$(upx_OBJECTS_LUA)     : CXXFLAGS += -Wno-cast-align
-$(upx_OBJECTS_LUA)     : CXXFLAGS += -Wno-cast-qual
-$(upx_OBJECTS_LUA)     : CXXFLAGS += -Wno-error
 endif
 endif
 
+# run the UPX testsuite
+# The expected (old) checksums are in $(top_srcdir)/.github/travis_testsuite_1-expected_sha256sums.sh
+# The   actual (new) checksums are in tmp-testsuite/testsuite_1/.sha256sums.recreate
+ifneq ($(wildcard $(upx_testsuite_SRCDIR)/files/packed/.),)
+ifneq ($(wildcard $(top_srcdir)/.github/travis_testsuite_1.sh),)
+run-testsuite: export upx_exe                := $(top_srcdir)/build/release/upx
+run-testsuite: export upx_testsuite_SRCDIR   := $(upx_testsuite_SRCDIR)
+run-testsuite: export upx_testsuite_BUILDDIR := ./tmp-testsuite
+run-testsuite: $(top_srcdir)/build/release/upx
+	time -p bash $(top_srcdir)/.github/travis_testsuite_1.sh
+.PHONY: run-testsuite
+endif
+endif
 
-mostlyclean clean distclean maintainer-clean:
+#
-	rm -f *.d *.map *.o *.obj *.res upx.exe upx.out upx.ttp upx$(exeext)
+# "make clang-format"
+#
 
--include *.d
+# automatically format some C++ source code files
-.PHONY: all mostlyclean clean distclean maintainer-clean
+ifeq ($(shell uname),Linux)
+CLANG_FORMAT_FILES += bele.h bele_policy.h
+CLANG_FORMAT_FILES += except.cpp except.h
+CLANG_FORMAT_FILES += file.cpp file.h
+CLANG_FORMAT_FILES += linker.cpp linker.h packhead.cpp packmast.cpp packmast.h
+CLANG_FORMAT_FILES += main.cpp options.cpp options.h packer.cpp packer.h
+CLANG_FORMAT_FILES += p_tos.cpp p_tos.h
+CLANG_FORMAT_FILES += s_djgpp2.cpp s_object.cpp s_vcsa.cpp s_win32.cpp screen.h
+CLANG_FORMAT_FILES += ui.cpp ui.h work.cpp
+CLANG_FORMAT_FILES += $(wildcard util/[a-ln-z]*.[ch]* util/mem*.[ch]*)
+clang-format:
+	$(top_srcdir)/misc/scripts/upx-clang-format -i $(addprefix $(top_srcdir)/src/,$(sort $(CLANG_FORMAT_FILES)))
+.PHONY: clang-format
+endif
+
+#
+# "make check-whitespace"
+#
+
+CHECK_WHITESPACE =
+ifeq ($(shell uname),Linux)
+CHECK_WHITESPACE = $(top_srcdir)/misc/scripts/check_whitespace.sh $(top_srcdir)
+ifneq ($(wildcard $(top_srcdir)/.git/.),)
+CHECK_WHITESPACE = $(top_srcdir)/misc/scripts/check_whitespace_git.sh $(top_srcdir)
+endif
+check-whitespace : ; $(CHECK_WHITESPACE)
+endif
+.PHONY: check-whitespace
+
+# vim:set ts=8 sw=8 noet:

src/bele_policy.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,37 +22,34 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
-
+#ifndef UPX_BELE_H__
-#ifndef __UPX_BELE_H
+#error "this is an internal include file"
-#  error "this is an internal include file"
 #endif
 
-
 /*************************************************************************
 //
 **************************************************************************/
 
 #if defined(BELE_CTP)
-   // CTP - Compile-Time Polymorphism (templates)
+// CTP - Compile-Time Polymorphism (templates)
-#  define V     static inline
+#define V static inline
-#  define S     static int __acc_cdecl_qsort
+#define S static int __acc_cdecl_qsort
-#  define C
+#define C /*empty*/
 #elif defined(BELE_RTP)
-   // RTP - Run-Time Polymorphism (virtual functions)
+// RTP - Run-Time Polymorphism (virtual functions)
-#  define V     virtual
+#define V virtual
-#  define S     virtual int
+#define S virtual int
-#  define C     const
+#define C const
 #else
-#  error
+#error
 #endif
 
-
 #if defined(BELE_RTP)
-struct AbstractPolicy
+struct AbstractPolicy {
-{
+    inline AbstractPolicy() {}
     virtual inline ~AbstractPolicy() {}
     V bool isBE() C = 0;
     V bool isLE() C = 0;
@@ -60,17 +57,17 @@ struct AbstractPolicy
     V unsigned get16(const void *p) C = 0;
     V unsigned get24(const void *p) C = 0;
     V unsigned get32(const void *p) C = 0;
-    V acc_uint64l_t get64(const void *p) C = 0;
+    V upx_uint64_t get64(const void *p) C = 0;
 
     V void set16(void *p, unsigned v) C = 0;
     V void set24(void *p, unsigned v) C = 0;
     V void set32(void *p, unsigned v) C = 0;
-    V void set64(void *p, acc_uint64l_t v) C = 0;
+    V void set64(void *p, upx_uint64_t v) C = 0;
 
-    V unsigned get16_signed(const void *p) C = 0;
+    V int get16_signed(const void *p) C = 0;
-    V unsigned get24_signed(const void *p) C = 0;
+    V int get24_signed(const void *p) C = 0;
-    V unsigned get32_signed(const void *p) C = 0;
+    V int get32_signed(const void *p) C = 0;
-    V acc_uint64l_t get64_signed(const void *p) C = 0;
+    V upx_int64_t get64_signed(const void *p) C = 0;
 
     S u16_compare(const void *a, const void *b) C = 0;
     S u24_compare(const void *a, const void *b) C = 0;
@@ -81,177 +78,162 @@ struct AbstractPolicy
     S u24_compare_signed(const void *a, const void *b) C = 0;
     S u32_compare_signed(const void *a, const void *b) C = 0;
     S u64_compare_signed(const void *a, const void *b) C = 0;
+
+private:
+    // disable copy, assignment and move assignment
+    AbstractPolicy(const AbstractPolicy &) = delete;
+    AbstractPolicy &operator=(const AbstractPolicy &) = delete;
+    AbstractPolicy &operator=(AbstractPolicy &&) = delete;
+    // disable dynamic allocation
+    ACC_CXX_DISABLE_NEW_DELETE
 };
 #endif
 
+#if defined(BELE_RTP)
+#undef C
+#define C const override
+#endif
 
 struct BEPolicy
 #if defined(BELE_RTP)
-    : public AbstractPolicy
+    final : public AbstractPolicy
 #endif
 {
+    inline BEPolicy() {}
 #if defined(BELE_CTP)
     typedef N_BELE_RTP::BEPolicy RTP_Policy;
-    enum { isBE = 1, isLE = 0 };
 #elif defined(BELE_RTP)
     typedef N_BELE_CTP::BEPolicy CTP_Policy;
-    V bool isBE() C { return CTP_Policy::isBE; }
-    V bool isLE() C { return CTP_Policy::isLE; }
 #endif
+    V bool isBE() C { return true; }
+    V bool isLE() C { return false; }
 
     typedef BE16 U16;
     typedef BE32 U32;
     typedef BE64 U64;
 
-    V unsigned get16(const void *p) C
+    V unsigned get16(const void *p) C { return get_be16(p); }
-        { return get_be16(p); }
+    V unsigned get24(const void *p) C { return get_be24(p); }
-    V unsigned get24(const void *p) C
+    V unsigned get32(const void *p) C { return get_be32(p); }
-        { return get_be24(p); }
+    V upx_uint64_t get64(const void *p) C { return get_be64(p); }
-    V unsigned get32(const void *p) C
-        { return get_be32(p); }
-    V acc_uint64l_t get64(const void *p) C
-        { return get_be64(p); }
 
-    V void set16(void *p, unsigned v) C
+    V void set16(void *p, unsigned v) C { set_be16(p, v); }
-        { set_be16(p, v); }
+    V void set24(void *p, unsigned v) C { set_be24(p, v); }
-    V void set24(void *p, unsigned v) C
+    V void set32(void *p, unsigned v) C { set_be32(p, v); }
-        { set_be24(p, v); }
+    V void set64(void *p, upx_uint64_t v) C { set_be64(p, v); }
-    V void set32(void *p, unsigned v) C
-        { set_be32(p, v); }
-    V void set64(void *p, acc_uint64l_t v) C
-        { set_be64(p, v); }
 
-    V unsigned get16_signed(const void *p) C
+    V int get16_signed(const void *p) C { return get_be16_signed(p); }
-        { return get_be16_signed(p); }
+    V int get24_signed(const void *p) C { return get_be24_signed(p); }
-    V unsigned get24_signed(const void *p) C
+    V int get32_signed(const void *p) C { return get_be32_signed(p); }
-        { return get_be24_signed(p); }
+    V upx_int64_t get64_signed(const void *p) C { return get_be64_signed(p); }
-    V unsigned get32_signed(const void *p) C
-        { return get_be32_signed(p); }
-    V acc_uint64l_t get64_signed(const void *p) C
-        { return get_be64_signed(p); }
 
-    S u16_compare(const void *a, const void *b) C
+    S u16_compare(const void *a, const void *b) C { return be16_compare(a, b); }
-        { return be16_compare(a, b); }
+    S u24_compare(const void *a, const void *b) C { return be24_compare(a, b); }
-    S u24_compare(const void *a, const void *b) C
+    S u32_compare(const void *a, const void *b) C { return be32_compare(a, b); }
-        { return be24_compare(a, b); }
+    S u64_compare(const void *a, const void *b) C { return be64_compare(a, b); }
-    S u32_compare(const void *a, const void *b) C
-        { return be32_compare(a, b); }
-    S u64_compare(const void *a, const void *b) C
-        { return be64_compare(a, b); }
 
-    S u16_compare_signed(const void *a, const void *b) C
+    S u16_compare_signed(const void *a, const void *b) C { return be16_compare_signed(a, b); }
-        { return be16_compare_signed(a, b); }
+    S u24_compare_signed(const void *a, const void *b) C { return be24_compare_signed(a, b); }
-    S u24_compare_signed(const void *a, const void *b) C
+    S u32_compare_signed(const void *a, const void *b) C { return be32_compare_signed(a, b); }
-        { return be24_compare_signed(a, b); }
+    S u64_compare_signed(const void *a, const void *b) C { return be64_compare_signed(a, b); }
-    S u32_compare_signed(const void *a, const void *b) C
-        { return be32_compare_signed(a, b); }
-    S u64_compare_signed(const void *a, const void *b) C
-        { return be64_compare_signed(a, b); }
 
     static void compileTimeAssertions() {
         COMPILE_TIME_ASSERT(sizeof(U16) == 2)
         COMPILE_TIME_ASSERT(sizeof(U32) == 4)
         COMPILE_TIME_ASSERT(sizeof(U64) == 8)
-        COMPILE_TIME_ASSERT_ALIGNOF(U16, char)
+        COMPILE_TIME_ASSERT_ALIGNED1(U16)
-        COMPILE_TIME_ASSERT_ALIGNOF(U32, char)
+        COMPILE_TIME_ASSERT_ALIGNED1(U32)
-        COMPILE_TIME_ASSERT_ALIGNOF(U64, char)
+        COMPILE_TIME_ASSERT_ALIGNED1(U64)
     }
-};
 
+private:
+    // disable copy, assignment and move assignment
+    BEPolicy(const BEPolicy &) = delete;
+    BEPolicy &operator=(const BEPolicy &) = delete;
+    BEPolicy &operator=(BEPolicy &&) = delete;
+    // disable dynamic allocation
+    ACC_CXX_DISABLE_NEW_DELETE
+};
 
 struct LEPolicy
 #if defined(BELE_RTP)
-    : public AbstractPolicy
+    final : public AbstractPolicy
 #endif
 {
+    inline LEPolicy() {}
 #if defined(BELE_CTP)
     typedef N_BELE_RTP::LEPolicy RTP_Policy;
-    enum { isBE = 0, isLE = 1 };
 #elif defined(BELE_RTP)
     typedef N_BELE_CTP::LEPolicy CTP_Policy;
-    V bool isBE() C { return CTP_Policy::isBE; }
-    V bool isLE() C { return CTP_Policy::isLE; }
 #endif
+    V bool isBE() C { return false; }
+    V bool isLE() C { return true; }
 
     typedef LE16 U16;
     typedef LE32 U32;
     typedef LE64 U64;
 
-    V unsigned get16(const void *p) C
+    V unsigned get16(const void *p) C { return get_le16(p); }
-        { return get_le16(p); }
+    V unsigned get24(const void *p) C { return get_le24(p); }
-    V unsigned get24(const void *p) C
+    V unsigned get32(const void *p) C { return get_le32(p); }
-        { return get_le24(p); }
+    V upx_uint64_t get64(const void *p) C { return get_le64(p); }
-    V unsigned get32(const void *p) C
-        { return get_le32(p); }
-    V acc_uint64l_t get64(const void *p) C
-        { return get_le64(p); }
 
-    V void set16(void *p, unsigned v) C
+    V void set16(void *p, unsigned v) C { set_le16(p, v); }
-        { set_le16(p, v); }
+    V void set24(void *p, unsigned v) C { set_le24(p, v); }
-    V void set24(void *p, unsigned v) C
+    V void set32(void *p, unsigned v) C { set_le32(p, v); }
-        { set_le24(p, v); }
+    V void set64(void *p, upx_uint64_t v) C { set_le64(p, v); }
-    V void set32(void *p, unsigned v) C
-        { set_le32(p, v); }
-    V void set64(void *p, acc_uint64l_t v) C
-        { set_le64(p, v); }
 
-    V unsigned get16_signed(const void *p) C
+    V int get16_signed(const void *p) C { return get_le16_signed(p); }
-        { return get_le16_signed(p); }
+    V int get24_signed(const void *p) C { return get_le24_signed(p); }
-    V unsigned get24_signed(const void *p) C
+    V int get32_signed(const void *p) C { return get_le32_signed(p); }
-        { return get_le24_signed(p); }
+    V upx_int64_t get64_signed(const void *p) C { return get_le64_signed(p); }
-    V unsigned get32_signed(const void *p) C
-        { return get_le32_signed(p); }
-    V acc_uint64l_t get64_signed(const void *p) C
-        { return get_le64_signed(p); }
 
-    S u16_compare(const void *a, const void *b) C
+    S u16_compare(const void *a, const void *b) C { return le16_compare(a, b); }
-        { return le16_compare(a, b); }
+    S u24_compare(const void *a, const void *b) C { return le24_compare(a, b); }
-    S u24_compare(const void *a, const void *b) C
+    S u32_compare(const void *a, const void *b) C { return le32_compare(a, b); }
-        { return le24_compare(a, b); }
+    S u64_compare(const void *a, const void *b) C { return le64_compare(a, b); }
-    S u32_compare(const void *a, const void *b) C
-        { return le32_compare(a, b); }
-    S u64_compare(const void *a, const void *b) C
-        { return le64_compare(a, b); }
 
-    S u16_compare_signed(const void *a, const void *b) C
+    S u16_compare_signed(const void *a, const void *b) C { return le16_compare_signed(a, b); }
-        { return le16_compare_signed(a, b); }
+    S u24_compare_signed(const void *a, const void *b) C { return le24_compare_signed(a, b); }
-    S u24_compare_signed(const void *a, const void *b) C
+    S u32_compare_signed(const void *a, const void *b) C { return le32_compare_signed(a, b); }
-        { return le24_compare_signed(a, b); }
+    S u64_compare_signed(const void *a, const void *b) C { return le64_compare_signed(a, b); }
-    S u32_compare_signed(const void *a, const void *b) C
-        { return le32_compare_signed(a, b); }
-    S u64_compare_signed(const void *a, const void *b) C
-        { return le64_compare_signed(a, b); }
 
     static void compileTimeAssertions() {
         COMPILE_TIME_ASSERT(sizeof(U16) == 2)
         COMPILE_TIME_ASSERT(sizeof(U32) == 4)
         COMPILE_TIME_ASSERT(sizeof(U64) == 8)
-        COMPILE_TIME_ASSERT_ALIGNOF(U16, char)
+        COMPILE_TIME_ASSERT_ALIGNED1(U16)
-        COMPILE_TIME_ASSERT_ALIGNOF(U32, char)
+        COMPILE_TIME_ASSERT_ALIGNED1(U32)
-        COMPILE_TIME_ASSERT_ALIGNOF(U64, char)
+        COMPILE_TIME_ASSERT_ALIGNED1(U64)
     }
+
+private:
+    // disable copy, assignment and move assignment
+    LEPolicy(const LEPolicy &) = delete;
+    LEPolicy &operator=(const LEPolicy &) = delete;
+    LEPolicy &operator=(LEPolicy &&) = delete;
+    // disable dynamic allocation
+    ACC_CXX_DISABLE_NEW_DELETE
 };
 
-
+// native policy (aka host policy)
 #if (ACC_ABI_BIG_ENDIAN)
 typedef BEPolicy HostPolicy;
 #elif (ACC_ABI_LITTLE_ENDIAN)
 typedef LEPolicy HostPolicy;
 #else
-#  error "ACC_ABI_ENDIAN"
+#error "ACC_ABI_ENDIAN"
 #endif
 
-
 #if 0 /* UNUSED */
-struct HostAlignedPolicy
+struct HostAlignedPolicy {
-{
 #if defined(BELE_CTP)
     enum { isBE = HostPolicy::isBE, isLE = HostPolicy::isLE };
 #endif
 
-    typedef acc_uint16e_t U16;
+    typedef upx_uint16_t U16;
-    typedef acc_uint32e_t U32;
+    typedef upx_uint32_t U32;
-    typedef acc_uint64l_t U64;
+    typedef upx_uint64_t U64;
 
     static void compileTimeAssertions() {
         COMPILE_TIME_ASSERT(sizeof(U16) == 2)
@@ -261,13 +243,8 @@ struct HostAlignedPolicy
 };
 #endif
 
-
 #undef V
 #undef S
 #undef C
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/bptr.h

@@ -1,115 +0,0 @@
-/* bptr.h --
-
-   This file is part of the UPX executable compressor.
-
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 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
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
- */
-
-
-#ifndef __UPX_BPTR_H
-#define __UPX_BPTR_H
-
-
-/*************************************************************************
-// BoundedPtr
-**************************************************************************/
-
-template <class T>
-class BoundedPtr
-{
-//    typedef BoundedPtr<T> Self;
-public:
-    typedef T* StoredType;
-    typedef T* PointerType;
-    typedef T& ReferenceType;
-
-    ~BoundedPtr() { }
-
-    explicit BoundedPtr(void* base, unsigned size, T* ptr=0)
-        : ptr_(ptr), base_(base), size_(size) { check(); }
-    BoundedPtr& operator= (const BoundedPtr& other) {
-        assert(base_ == other.base_); assert(size_ == other.size_);
-        ptr_ = other.ptr_; check(); return *this;
-    }
-    BoundedPtr& operator= (T* other) {
-        ptr_ = other; check(); return *this;
-    }
-
-    operator T* () { check(); return ptr_; }
-    operator const T* () const { check(); return ptr_; }
-
-    BoundedPtr& operator += (size_t n) {
-        checkStrict(); ptr_ += n; checkStrict(); return *this;
-    }
-    BoundedPtr& operator -= (size_t n) {
-        checkStrict(); ptr_ -= n; checkStrict(); return *this;
-    }
-    BoundedPtr& operator ++ (void) {
-        checkStrict(); ptr_ += 1; checkStrict(); return *this;
-    }
-//    T* operator ++ (int) {
-//        T* p = ptr_; checkStrict(); ptr_ += 1; checkStrict(); return p;
-//    }
-//    BoundedPtr& operator -- (void) {
-//        checkStrict(); ptr_ -= 1; checkStrict(); return *this;
-//    }
-
-
-private:
-    void checkNULL() const {
-        if (!ptr_)
-            throwCantUnpack("unexpected NULL pointer; take care!");
-    }
-    void checkRange(size_t extra=0) const {
-        size_t off = (const char *) ptr_ - (const char *) base_;
-        if (off > size_ || off + extra > size_)
-            throwCantUnpack("pointer out of range; take care!");
-    }
-    void checkStrict(size_t extra=0) const {
-        checkNULL();
-        checkRange(extra);
-    }
-    void check(size_t extra=0) const {
-        if (ptr_) checkRange(extra);
-    }
-
-    T* ptr_;
-    void* base_;
-    size_t size_;
-
-    // disable copy
-    BoundedPtr(const BoundedPtr&); // {}
-//    BoundedPtr& operator= (const BoundedPtr&); // { return *this; }
-
-    // disable dynamic allocation
-    DISABLE_NEW_DELETE
-};
-
-
-#endif /* already included */
-
-
-/*
-vi:ts=4:et
-*/
-

src/c_file.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,13 +22,13 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 
-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)
 
 /*************************************************************************
 //
@@ -89,8 +89,4 @@ console_t console_file =
 
 #endif /* USE_CONSOLE */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/c_init.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,15 +22,15 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 
-FILE *con_term = NULL;
+FILE *con_term = nullptr;
 
-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)
 
 /*************************************************************************
 //
@@ -60,7 +60,7 @@ static void try_init(console_t *c, FILE *f)
     {
         con_mode = k;
         con = c;
-        con->init = 0;
+        con->init = nullptr;
         if (!con->set_fg)
             con->set_fg = console_none.set_fg;
         if (!con->print0)
@@ -84,14 +84,14 @@ static int do_init(FILE *f)
     if (!acc_isatty(STDIN_FILENO) || !acc_isatty(STDOUT_FILENO) || !acc_isatty(STDERR_FILENO))
         return con_mode;
 
-#if defined(USE_ANSI)
+#if (USE_ANSI)
     try_init(&console_ansi_mono,f);
     try_init(&console_ansi_color,f);
 #endif
-#if defined(USE_SCREEN)
+#if (USE_SCREEN)
     try_init(&console_screen,f);
 #endif
-#if defined(USE_AALIB)
+#if (USE_AALIB)
     try_init(&console_aalib,f);
 #endif
 
@@ -137,18 +137,18 @@ console_t console_init =
 {
     init,
     set_fg,
-    0,
+    nullptr,
     intro
 };
 
 
-void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...)
+void con_fprintf(FILE *f, const char *format, ...)
 {
     va_list args;
     char buf[80*25];
 
     va_start(args, format);
-    upx_vsnprintf(buf, sizeof(buf), format,args);
+    upx_safe_vsnprintf(buf, sizeof(buf), format,args);
     va_end(args);
 
     if (con == me)
@@ -159,8 +159,4 @@ void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...)
 
 #endif /* USE_CONSOLE */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/c_none.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,13 +22,13 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 
-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)
 
 /*************************************************************************
 //
@@ -75,8 +75,4 @@ console_t console_none =
 
 #endif /* USE_CONSOLE */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/c_screen.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,13 +22,13 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 
-#if defined(USE_SCREEN)
+#if (USE_SCREEN)
 
 #include "screen.h"
 
@@ -72,11 +72,11 @@ static int do_init(screen_t *s, int fd)
 static screen_t *do_construct(screen_t *s, int fd)
 {
     if (!s)
-        return NULL;
+        return nullptr;
     if (do_init(s,fd) != 0)
     {
         s->destroy(s);
-        return NULL;
+        return nullptr;
     }
     return s;
 }
@@ -86,7 +86,7 @@ static screen_t *do_construct(screen_t *s, int fd)
 //
 **************************************************************************/
 
-static screen_t *screen = NULL;
+static screen_t *screen = nullptr;
 
 static void __acc_cdecl_atexit do_destroy(void)
 {
@@ -95,7 +95,7 @@ static void __acc_cdecl_atexit do_destroy(void)
         if (screen->atExit)
             screen->atExit();
         screen->destroy(screen);
-        screen = NULL;
+        screen = nullptr;
     }
 }
 
@@ -113,7 +113,7 @@ static int init(FILE *f, int o, int now)
     int n;
 
     UNUSED(now);
-    assert(screen == NULL);
+    assert(screen == nullptr);
 
     if (o == CON_SCREEN)
         n = CON_SCREEN;
@@ -126,19 +126,19 @@ static int init(FILE *f, int o, int now)
     else
         return CON_INIT;
 
-#if defined(__DJGPP__)
+#if (ACC_OS_DOS32) && defined(__DJGPP__)
     if (!screen)
         screen = do_construct(screen_djgpp2_construct(),fd);
 #endif
-#if defined(USE_SCREEN_WIN32)
+#if (USE_SCREEN_WIN32)
     if (!screen)
         screen = do_construct(screen_win32_construct(),fd);
 #endif
-#if defined(USE_SCREEN_VCSA)
+#if (USE_SCREEN_VCSA)
     if (!screen)
         screen = do_construct(screen_vcsa_construct(),fd);
 #endif
-#if defined(USE_SCREEN_CURSES)
+#if (USE_SCREEN_CURSES)
     if (!screen && o == CON_SCREEN)
         screen = do_construct(screen_curses_construct(),fd);
 #endif
@@ -298,7 +298,7 @@ static void print0(FILE *f, const char *ss)
 static bool intro(FILE *f)
 {
     UNUSED(f);
-#if defined(USE_FRAMES)
+#if (USE_FRAMES)
     if (screen->intro)
         return screen->intro(screen,screen_show_frames);
 #endif
@@ -317,8 +317,4 @@ console_t console_screen =
 
 #endif /* USE_SCREEN */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/compress.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,14 +22,13 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 #include "compress.h"
-#include "mem.h"
+#include "util/membuffer.h"
-#include <zlib.h>
 
 
 /*************************************************************************
@@ -40,13 +39,11 @@ unsigned upx_adler32(const void *buf, unsigned len, unsigned adler)
 {
     if (len == 0)
         return adler;
-    assert(buf != NULL);
+    assert(buf != nullptr);
-#if 0
+#if 1
-    return adler32(adler, (const Bytef *) buf, len); // zlib
+    return upx_ucl_adler32(buf, len, adler);
-#elif defined(WITH_UCL)
-    return ucl_adler32(adler, (const ucl_bytep) buf, len);
 #else
-#  error
+    return upx_zlib_adler32(buf, len, adler);
 #endif
 }
 
@@ -56,13 +53,11 @@ unsigned upx_crc32(const void *buf, unsigned len, unsigned crc)
 {
     if (len == 0)
         return crc;
-    assert(buf != NULL);
+    assert(buf != nullptr);
-#if 0
+#if 1
-    return crc32(crc, (const Bytef *) buf, len); // zlib
+    return upx_ucl_crc32(buf, len, crc);
-#elif defined(WITH_UCL)
-    return ucl_crc32(crc, (const ucl_bytep) buf, len);
 #else
-#  error
+    return upx_zlib_crc32(buf, len, crc);
 #endif
 }
 #endif /* UNUSED */
@@ -72,7 +67,7 @@ unsigned upx_crc32(const void *buf, unsigned len, unsigned crc)
 //
 **************************************************************************/
 
-int upx_compress           ( const upx_bytep src, unsigned  src_len,
+int upx_compress( const upx_bytep src, unsigned  src_len,
                         upx_bytep dst, unsigned* dst_len,
                         upx_callback_p cb,
                         int method, int level,
@@ -106,19 +101,19 @@ int upx_compress           ( const upx_bytep src, unsigned  src_len,
     cresult->c_len = 0;
 #endif
 
-    if (method < 0) {
+    if __acc_cte(0) {
     }
-#if defined(WITH_LZMA)
+#if (WITH_LZMA)
     else if (M_IS_LZMA(method))
         r = upx_lzma_compress(src, src_len, dst, dst_len,
                               cb, method, level, cconf, cresult);
 #endif
-#if defined(WITH_NRV)
+#if (WITH_NRV)
-    else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
+    else if ((M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method)) && !opt->prefer_ucl)
         r = upx_nrv_compress(src, src_len, dst, dst_len,
                              cb, method, level, cconf, cresult);
 #endif
-#if defined(WITH_UCL)
+#if (WITH_UCL)
     else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
         r = upx_ucl_compress(src, src_len, dst, dst_len,
                              cb, method, level, cconf, cresult);
@@ -139,7 +134,7 @@ int upx_compress           ( const upx_bytep src, unsigned  src_len,
 //
 **************************************************************************/
 
-int upx_decompress         ( const upx_bytep src, unsigned  src_len,
+int upx_decompress(const upx_bytep src, unsigned  src_len,
                          upx_bytep dst, unsigned* dst_len,
                          int method,
                    const upx_compress_result_t *cresult )
@@ -150,21 +145,25 @@ int upx_decompress         ( const upx_bytep src, unsigned  src_len,
     assert(src_len < *dst_len); // must be compressed
 
     if (cresult && cresult->method == 0)
-        cresult = NULL;
+        cresult = nullptr;
 
-    if (method < 0) {
+    if __acc_cte(0) {
     }
-#if defined(WITH_LZMA)
+#if (WITH_LZMA)
     else if (M_IS_LZMA(method))
         r = upx_lzma_decompress(src, src_len, dst, dst_len, method, cresult);
 #endif
-#if defined(WITH_NRV)
+#if (WITH_NRV)
-    else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
+    else if ((M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method)) && !opt->prefer_ucl)
         r = upx_nrv_decompress(src, src_len, dst, dst_len, method, cresult);
 #endif
-#if defined(WITH_UCL)
+#if (WITH_UCL)
     else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
         r = upx_ucl_decompress(src, src_len, dst, dst_len, method, cresult);
+#endif
+#if (WITH_ZLIB)
+    else if (M_IS_DEFLATE(method))
+        r = upx_zlib_decompress(src, src_len, dst, dst_len, method, cresult);
 #endif
     else {
         throwInternalError("unknown decompression method");
@@ -178,34 +177,36 @@ int upx_decompress         ( const upx_bytep src, unsigned  src_len,
 //
 **************************************************************************/
 
-int upx_test_overlap       ( const upx_bytep buf, unsigned src_off,
+int upx_test_overlap( const upx_bytep buf,
-                                   unsigned  src_len, unsigned* dst_len,
+                      const upx_bytep tbuf,
+                            unsigned  src_off, unsigned src_len,
+                            unsigned* dst_len,
                             int method,
                       const upx_compress_result_t *cresult )
 {
     int r = UPX_E_ERROR;
 
     if (cresult && cresult->method == 0)
-        cresult = NULL;
+        cresult = nullptr;
 
     assert(*dst_len > 0);
     assert(src_len < *dst_len); // must be compressed
     unsigned overlap_overhead = src_off + src_len - *dst_len;
     assert((int)overlap_overhead > 0);
 
-    if (method < 0) {
+    if __acc_cte(0) {
     }
-#if defined(WITH_LZMA)
+#if (WITH_LZMA)
     else if (M_IS_LZMA(method))
-        r = upx_lzma_test_overlap(buf, src_off, src_len, dst_len, method, cresult);
+        r = upx_lzma_test_overlap(buf, tbuf, src_off, src_len, dst_len, method, cresult);
 #endif
-#if defined(WITH_NRV)
+#if (WITH_NRV)
-    else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
+    else if ((M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method)) && !opt->prefer_ucl)
-        r = upx_nrv_test_overlap(buf, src_off, src_len, dst_len, method, cresult);
+        r = upx_nrv_test_overlap(buf, tbuf, src_off, src_len, dst_len, method, cresult);
 #endif
-#if defined(WITH_UCL)
+#if (WITH_UCL)
     else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
-        r = upx_ucl_test_overlap(buf, src_off, src_len, dst_len, method, cresult);
+        r = upx_ucl_test_overlap(buf, tbuf, src_off, src_len, dst_len, method, cresult);
 #endif
     else {
         throwInternalError("unknown decompression method");
@@ -214,8 +215,4 @@ int upx_test_overlap       ( const upx_bytep buf, unsigned src_off,
     return r;
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/compress.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,19 +22,21 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_COMPRESS_H
-#define __UPX_COMPRESS_H
+#define __UPX_COMPRESS_H 1
 
 
 /*************************************************************************
 //
 **************************************************************************/
 
-#if defined(WITH_LZMA)
+#if (WITH_LZMA)
+int upx_lzma_init(void);
+const char *upx_lzma_version_string(void);
 int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    upx_callback_p cb,
@@ -45,14 +47,18 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult );
-int upx_lzma_test_overlap  ( const upx_bytep buf, unsigned src_off,
+int upx_lzma_test_overlap  ( const upx_bytep buf,
-                                   unsigned  src_len, unsigned* dst_len,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult );
 #endif
 
 
-#if defined(WITH_NRV)
+#if (WITH_NRV)
+int upx_nrv_init(void);
+const char *upx_nrv_version_string(void);
 int upx_nrv_compress       ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    upx_callback_p cb,
@@ -63,14 +69,18 @@ int upx_nrv_decompress     ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult );
-int upx_nrv_test_overlap   ( const upx_bytep buf, unsigned src_off,
+int upx_nrv_test_overlap   ( const upx_bytep buf,
-                                   unsigned  src_len, unsigned* dst_len,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult );
 #endif
 
 
-#if defined(WITH_UCL)
+#if (WITH_UCL)
+int upx_ucl_init(void);
+const char *upx_ucl_version_string(void);
 int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    upx_callback_p cb,
@@ -81,17 +91,41 @@ int upx_ucl_decompress     ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult );
-int upx_ucl_test_overlap   ( const upx_bytep buf, unsigned src_off,
+int upx_ucl_test_overlap   ( const upx_bytep buf,
-                                   unsigned  src_len, unsigned* dst_len,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult );
+unsigned upx_ucl_adler32(const void *buf, unsigned len, unsigned adler);
+unsigned upx_ucl_crc32  (const void *buf, unsigned len, unsigned crc);
+#endif
+
+
+#if (WITH_ZLIB)
+int upx_zlib_init(void);
+const char *upx_zlib_version_string(void);
+int upx_zlib_compress      ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   upx_callback_p cb,
+                                   int method, int level,
+                             const upx_compress_config_t *cconf,
+                                   upx_compress_result_t *cresult );
+int upx_zlib_decompress    ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult );
+int upx_zlib_test_overlap  ( const upx_bytep buf,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult );
+unsigned upx_zlib_adler32(const void *buf, unsigned len, unsigned adler);
+unsigned upx_zlib_crc32  (const void *buf, unsigned len, unsigned crc);
 #endif
 
 
 #endif /* already included */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/compress_lzma.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,16 +22,43 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 #include "compress.h"
-#if !defined(WITH_LZMA)
+#include "util/membuffer.h"
-extern int compress_lzma_dummy;
+
-int compress_lzma_dummy = 0;
+#if (ACC_CC_CLANG)
-#else
+#  pragma clang diagnostic ignored "-Wshadow"
+#endif
+#if (ACC_CC_GNUC >= 0x040200)
+#  pragma GCC diagnostic ignored "-Wshadow"
+#endif
+#if (ACC_CC_MSC)
+#  pragma warning(disable: 4456)    // -Wno-shadow
+#endif
+#if (ACC_CC_MSC && (_MSC_VER < 1900))
+#  pragma warning(disable: 4127)    // warning C4127: conditional expression is constant
+#endif
+#if (ACC_CC_INTELC_GNUC)
+#  pragma warning(error: 424)       // #424: extra ";" ignored
+#endif
+
+
+void lzma_compress_config_t::reset()
+{
+    pos_bits.reset();
+    lit_pos_bits.reset();
+    lit_context_bits.reset();
+    dict_size.reset();
+    fast_mode = 2;
+    num_fast_bytes.reset();
+    match_finder_cycles = 0;
+
+    max_num_probs = 0;
+}
 
 
 // INFO: the LZMA SDK is covered by a permissive license which allows
@@ -72,145 +99,52 @@ int compress_lzma_dummy = 0;
 
 
 /*************************************************************************
-// cruft because of pseudo-COM layer
+// compress defaults
 **************************************************************************/
 
-#undef USE_LZMA_PROPERTIES
+static int prepare(lzma_compress_result_t *res,
-
+                   unsigned src_len, int method, int level,
-#undef MSDOS
+                   const lzma_compress_config_t *lcconf)
-#undef OS2
-#undef _WIN32
-#undef _WIN32_WCE
-#undef COMPRESS_MF_MT
-#undef _NO_EXCEPTIONS
-#include "C/Common/MyInitGuid.h"
-//#include "C/7zip/Compress/LZMA/LZMADecoder.h"
-#include "C/7zip/Compress/LZMA/LZMAEncoder.h"
-
-namespace MyLzma {
-
-struct InStreamRam: public ISequentialInStream, public CMyUnknownImp
 {
-    MY_UNKNOWN_IMP
-    const Byte *Data; size_t Size; size_t Pos;
-    void Init(const Byte *data, size_t size) {
-        Data = data; Size = size; Pos = 0;
-    }
-    STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP InStreamRam::Read(void *data, UInt32 size, UInt32 *processedSize)
-{
-    UInt32 remain = Size - Pos;
-    if (size > remain) size = remain;
-    memmove(data, Data + Pos, size);
-    Pos += size;
-    if (processedSize != NULL) *processedSize = size;
-    return S_OK;
-}
-
-struct OutStreamRam : public ISequentialOutStream, public CMyUnknownImp
-{
-    MY_UNKNOWN_IMP
-    Byte *Data; size_t Size; size_t Pos; bool Overflow;
-    void Init(Byte *data, size_t size) {
-        Data = data; Size = size; Pos = 0; Overflow = false;
-    }
-    HRESULT WriteByte(Byte b) {
-        if (Pos >= Size) { Overflow = true; return E_FAIL; }
-        Data[Pos++] = b;
-        return S_OK;
-    }
-    STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize);
-};
-
-STDMETHODIMP OutStreamRam::Write(const void *data, UInt32 size, UInt32 *processedSize)
-{
-    UInt32 i;
-    for (i = 0; i < size && Pos < Size; i++)
-        Data[Pos++] = ((const Byte *)data)[i];
-    if (processedSize != NULL) *processedSize = i;
-    if (i != size) { Overflow = true; return E_FAIL; }
-    return S_OK;
-}
-
-struct ProgressInfo : public ICompressProgressInfo, public CMyUnknownImp
-{
-    MY_UNKNOWN_IMP
-    STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
-    upx_callback_p cb;
-};
-
-STDMETHODIMP ProgressInfo::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
-{
-    if (cb && cb->nprogress)
-        cb->nprogress(cb, (unsigned) *inSize, (unsigned) *outSize);
-    return S_OK;
-}
-
-} // namespace
-
-
-int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
-                                   upx_bytep dst, unsigned* dst_len,
-                                   upx_callback_p cb,
-                                   int method, int level,
-                             const upx_compress_config_t *cconf_parm,
-                                   upx_compress_result_t *cresult )
-{
-    assert(method == M_LZMA);
-    assert(level > 0); assert(cresult != NULL);
-
-    int r = UPX_E_ERROR;
-    HRESULT rh;
-    lzma_compress_result_t *res = &cresult->result_lzma;
-
-    MyLzma::InStreamRam is; is.AddRef();
-    MyLzma::OutStreamRam os; os.AddRef();
-    is.Init(src, src_len);
-    os.Init(dst, *dst_len);
-
-    MyLzma::ProgressInfo progress; progress.AddRef();
-    progress.cb = cb;
-
-    NCompress::NLZMA::CEncoder enc;
-    const PROPID propIDs[7] = {
-        NCoderPropID::kPosStateBits,        // 0  pb  _posStateBits(2)
-        NCoderPropID::kLitPosBits,          // 1  lp  _numLiteralPosStateBits(0)
-        NCoderPropID::kLitContextBits,      // 2  lc  _numLiteralContextBits(3)
-        NCoderPropID::kDictionarySize,      // 3
-        NCoderPropID::kAlgorithm,           // 4      _fastmode
-        NCoderPropID::kNumFastBytes,        // 5
-        NCoderPropID::kMatchFinderCycles    // 6
-    };
-    PROPVARIANT pr[7];
-    pr[0].vt = pr[1].vt = pr[2].vt = pr[3].vt = VT_UI4;
-    pr[4].vt = pr[5].vt = pr[6].vt = VT_UI4;
-
     // setup defaults
-    pr[0].uintVal = 2;              // 0..4
+    res->pos_bits            = 2;                   // 0 .. 4
-    pr[1].uintVal = 0;              // 0..4
+    res->lit_pos_bits        = 0;                   // 0 .. 4
-    pr[2].uintVal = 3;              // 0..8
+    res->lit_context_bits    = 3;                   // 0 .. 8
-    pr[3].uintVal = 1024 * 1024;
+    res->dict_size           = 4 * 1024 * 1024;     // 1 .. 2**30
-    pr[4].uintVal = 2;
+    res->fast_mode           = 2;
-    pr[5].uintVal = 64;             // 5..
+    res->num_fast_bytes      = 64;                  // 5 .. 273
-    pr[6].uintVal = 0;
+    res->match_finder_cycles = 0;
+    // UPX overrides
+    res->pos_bits            = lzma_compress_config_t::pos_bits_t::default_value;
+    res->lit_pos_bits        = lzma_compress_config_t::lit_pos_bits_t::default_value;
+    res->lit_context_bits    = lzma_compress_config_t::lit_context_bits_t::default_value;
+    res->dict_size           = lzma_compress_config_t::dict_size_t::default_value;
+    res->num_fast_bytes      = lzma_compress_config_t::num_fast_bytes_t::default_value;
+    // method overrides
+    if (method >= 0x100) {
+        res->pos_bits         = (method >> 16) & 15;
+        res->lit_pos_bits     = (method >> 12) & 15;
+        res->lit_context_bits = (method >>  8) & 15;
+    }
 #if 0
     // DEBUG - set sizes so that we use a maxmimum amount of stack.
     //  These settings cause res->num_probs == 3147574, i.e. we will
-    //  need about 6 MB of stack during runtime decompression.
+    //  need about 6 MiB of stack during runtime decompression.
-    pr[1].uintVal = 4;
+    res->lit_pos_bits     = 4;
-    pr[2].uintVal = 8;
+    res->lit_context_bits = 8;
 #endif
 
-    // FIXME: tune these settings according to level
+    // TODO: tune these settings according to level
     switch (level)
     {
     case 1:
-        pr[3].uintVal = 256 * 1024;
+        res->dict_size      = 256 * 1024;
-        pr[4].uintVal = 0;
+        res->fast_mode      = 0;
+        res->num_fast_bytes = 8;
         break;
     case 2:
+        res->dict_size      = 256 * 1024;
+        res->fast_mode      = 0;
         break;
     case 3:
         break;
@@ -225,117 +159,261 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
     case 8:
         break;
     case 9:
-        pr[3].uintVal = 8 * 1024 * 1024;
+        res->dict_size      = 8 * 1024 * 1024;
         break;
     case 10:
-        pr[3].uintVal = src_len;
+        res->dict_size      = src_len;
         break;
     default:
         goto error;
     }
 
+    // cconf overrides
+    if (lcconf)
+    {
+        oassign(res->pos_bits, lcconf->pos_bits);
+        oassign(res->lit_pos_bits, lcconf->lit_pos_bits);
+        oassign(res->lit_context_bits, lcconf->lit_context_bits);
+        oassign(res->dict_size, lcconf->dict_size);
+        oassign(res->num_fast_bytes, lcconf->num_fast_bytes);
+    }
+
     // limit dictionary size
-    if (pr[3].uintVal > src_len)
+    if (res->dict_size > src_len)
-        pr[3].uintVal = src_len;
+        res->dict_size = src_len;
 
     // limit num_probs
-    if (cconf_parm && cconf_parm->conf_lzma.max_num_probs)
+    if (lcconf && lcconf->max_num_probs)
     {
         for (;;)
         {
-            unsigned n = 1846 + (768 << (pr[2].uintVal + pr[1].uintVal));
+            unsigned n = 1846 + (768u << (res->lit_context_bits + res->lit_pos_bits));
-            if (n <= cconf_parm->conf_lzma.max_num_probs)
+            if (n <= lcconf->max_num_probs)
                 break;
-            if (pr[1].uintVal > pr[2].uintVal)
+            if (res->lit_pos_bits > res->lit_context_bits)
             {
-                if (pr[1].uintVal == 0)
+                if (res->lit_pos_bits == 0)
                     goto error;
-                pr[1].uintVal -= 1;
+                res->lit_pos_bits -= 1;
             }
             else
             {
-                if (pr[2].uintVal == 0)
+                if (res->lit_context_bits == 0)
                     goto error;
-                pr[2].uintVal -= 1;
+                res->lit_context_bits -= 1;
             }
         }
     }
 
-    res->pos_bits = pr[0].uintVal;
+    lzma_compress_config_t::pos_bits_t::assertValue(res->pos_bits);
-    res->lit_pos_bits = pr[1].uintVal;
+    lzma_compress_config_t::lit_pos_bits_t::assertValue(res->lit_pos_bits);
-    res->lit_context_bits = pr[2].uintVal;
+    lzma_compress_config_t::lit_context_bits_t::assertValue(res->lit_context_bits);
-    res->dict_size = pr[3].uintVal;
+    lzma_compress_config_t::dict_size_t::assertValue(res->dict_size);
-    //res->num_probs = LzmaGetNumProbs(&s.Properties));
+    lzma_compress_config_t::num_fast_bytes_t::assertValue(res->num_fast_bytes);
-    //res->num_probs = (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
+
-    res->num_probs = 1846 + (768 << (res->lit_context_bits + res->lit_pos_bits));
+    res->num_probs = 1846 + (768u << (res->lit_context_bits + res->lit_pos_bits));
+    //printf("\nlzma_compress config: %u %u %u %u %u\n", res->pos_bits, res->lit_pos_bits, res->lit_context_bits, res->dict_size, res->num_probs);
+    return 0;
+
+error:
+    return -1;
+}
+
+
+/*************************************************************************
+// compress - cruft because of pseudo-COM layer
+**************************************************************************/
+
+#undef MSDOS
+#undef OS2
+#undef _WIN32
+#undef _WIN32_WCE
+#undef COMPRESS_MF_MT
+#undef _NO_EXCEPTIONS
+#undef NULL
+#define NULL nullptr
+#include <lzma-sdk/C/Common/MyInitGuid.h>
+//#include <lzma-sdk/C/7zip/Compress/LZMA/LZMADecoder.h>
+#include <lzma-sdk/C/7zip/Compress/LZMA/LZMAEncoder.h>
+
+namespace MyLzma {
+
+struct InStream: public ISequentialInStream, public CMyUnknownImp
+{
+    virtual ~InStream() { }
+    MY_UNKNOWN_IMP
+    const Byte *b_buf; size_t b_size; size_t b_pos;
+    void Init(const Byte *data, size_t size) {
+        b_buf = data; b_size = size; b_pos = 0;
+    }
+    STDMETHOD(Read)(void *data, UInt32 size, UInt32 *processedSize) override;
+};
+
+STDMETHODIMP InStream::Read(void *data, UInt32 size, UInt32 *processedSize)
+{
+    size_t remain = b_size - b_pos;
+    if (size > remain) size = (UInt32) remain;
+    memmove(data, b_buf + b_pos, size);
+    b_pos += size;
+    if (processedSize != nullptr) *processedSize = size;
+    return S_OK;
+}
+
+struct OutStream : public ISequentialOutStream, public CMyUnknownImp
+{
+    virtual ~OutStream() { }
+    MY_UNKNOWN_IMP
+    Byte *b_buf; size_t b_size; size_t b_pos; bool overflow;
+    void Init(Byte *data, size_t size) {
+        b_buf = data; b_size = size; b_pos = 0; overflow = false;
+    }
+    HRESULT WriteByte(Byte c) {
+        if (b_pos >= b_size) { overflow = true; return E_FAIL; }
+        b_buf[b_pos++] = c;
+        return S_OK;
+    }
+    STDMETHOD(Write)(const void *data, UInt32 size, UInt32 *processedSize) override;
+};
+
+STDMETHODIMP OutStream::Write(const void *data, UInt32 size, UInt32 *processedSize)
+{
+    size_t remain = b_size - b_pos;
+    if (size > remain) size = (UInt32) remain, overflow = true;
+    memmove(b_buf + b_pos, data, size);
+    b_pos += size;
+    if (processedSize != nullptr) *processedSize = size;
+    return overflow ? E_FAIL : S_OK;
+}
+
+struct ProgressInfo : public ICompressProgressInfo, public CMyUnknownImp
+{
+    virtual ~ProgressInfo() { }
+    MY_UNKNOWN_IMP
+    STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize) override;
+    upx_callback_p cb;
+};
+
+STDMETHODIMP ProgressInfo::SetRatioInfo(const UInt64 *inSize, const UInt64 *outSize)
+{
+    if (cb && cb->nprogress)
+        cb->nprogress(cb, (unsigned) *inSize, (unsigned) *outSize);
+    return S_OK;
+}
+
+} // namespace
+
+#include <lzma-sdk/C/Common/Alloc.cpp>
+#include <lzma-sdk/C/Common/CRC.cpp>
+//#include <lzma-sdk/C/7zip/Common/InBuffer.cpp>
+#include <lzma-sdk/C/7zip/Common/OutBuffer.cpp>
+#include <lzma-sdk/C/7zip/Common/StreamUtils.cpp>
+#include <lzma-sdk/C/7zip/Compress/LZ/LZInWindow.cpp>
+//#include <lzma-sdk/C/7zip/Compress/LZ/LZOutWindow.cpp>
+//#include <lzma-sdk/C/7zip/Compress/LZMA/LZMADecoder.cpp>
+#include <lzma-sdk/C/7zip/Compress/LZMA/LZMAEncoder.cpp>
+#include <lzma-sdk/C/7zip/Compress/RangeCoder/RangeCoderBit.cpp>
+#undef RC_NORMALIZE
+
+
+int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   upx_callback_p cb,
+                                   int method, int level,
+                             const upx_compress_config_t *cconf_parm,
+                                   upx_compress_result_t *cresult )
+{
+    assert(M_IS_LZMA(method));
+    assert(level > 0); assert(cresult != nullptr);
+
+    int r = UPX_E_ERROR;
+    HRESULT rh;
+    const lzma_compress_config_t *lcconf = cconf_parm ? &cconf_parm->conf_lzma : nullptr;
+    lzma_compress_result_t *res = &cresult->result_lzma;
+
+    MyLzma::InStream is; is.AddRef();
+    MyLzma::OutStream os; os.AddRef();
+    is.Init(src, src_len);
+    os.Init(dst, *dst_len);
+
+    MyLzma::ProgressInfo progress; progress.AddRef();
+    progress.cb = cb;
+
+    NCompress::NLZMA::CEncoder enc;
+    const PROPID propIDs[8] = {
+        NCoderPropID::kPosStateBits,        // 0  pb    _posStateBits(2)
+        NCoderPropID::kLitPosBits,          // 1  lp    _numLiteralPosStateBits(0)
+        NCoderPropID::kLitContextBits,      // 2  lc    _numLiteralContextBits(3)
+        NCoderPropID::kDictionarySize,      // 3  ds
+        NCoderPropID::kAlgorithm,           // 4  fm    _fastmode
+        NCoderPropID::kNumFastBytes,        // 5  fb
+        NCoderPropID::kMatchFinderCycles,   // 6  mfc   _matchFinderCycles, _cutValue
+        NCoderPropID::kMatchFinder          // 7  mf
+    };
+    PROPVARIANT pr[8];
+    const unsigned nprops = 8;
+    static const wchar_t matchfinder[] = L"BT4";
+    assert(NCompress::NLZMA::FindMatchFinder(matchfinder) >= 0);
+    pr[7].vt = VT_BSTR; pr[7].bstrVal = ACC_PCAST(BSTR, ACC_UNCONST_CAST(wchar_t *, matchfinder));
+    pr[0].vt = pr[1].vt = pr[2].vt = pr[3].vt = VT_UI4;
+    pr[4].vt = pr[5].vt = pr[6].vt = VT_UI4;
+    if (prepare(res, src_len, method, level, lcconf) != 0)
+        goto error;
+    pr[0].uintVal = res->pos_bits;
+    pr[1].uintVal = res->lit_pos_bits;
+    pr[2].uintVal = res->lit_context_bits;
+    pr[3].uintVal = res->dict_size;
+    pr[4].uintVal = res->fast_mode;
+    pr[5].uintVal = res->num_fast_bytes;
+    pr[6].uintVal = res->match_finder_cycles;
 
-#ifndef _NO_EXCEPTIONS
     try {
-#else
-#  error
-#endif
 
-    if (enc.SetCoderProperties(propIDs, pr, 7) != S_OK)
+    if (enc.SetCoderProperties(propIDs, pr, nprops) != S_OK)
         goto error;
     if (enc.WriteCoderProperties(&os) != S_OK)
         goto error;
-    if (os.Overflow) {
+    if (os.overflow) {
         //r = UPX_E_OUTPUT_OVERRUN;
         r = UPX_E_NOT_COMPRESSIBLE;
         goto error;
     }
-    assert(os.Pos == 5);
+    assert(os.b_pos == 5);
-#if defined(USE_LZMA_PROPERTIES)
+    os.b_pos = 0;
-    os.Pos = 1;
-#else
-    os.Pos = 0;
     // extra stuff in first byte: 5 high bits convenience for stub decompressor
     unsigned t = res->lit_context_bits + res->lit_pos_bits;
-    os.WriteByte((t << 3) | res->pos_bits);
+    os.WriteByte(Byte((t << 3) | res->pos_bits));
-    os.WriteByte((res->lit_pos_bits << 4) | (res->lit_context_bits));
+    os.WriteByte(Byte((res->lit_pos_bits << 4) | (res->lit_context_bits)));
-#endif
 
-    rh = enc.Code(&is, &os, NULL, NULL, &progress);
+    rh = enc.Code(&is, &os, nullptr, nullptr, &progress);
 
-#ifndef _NO_EXCEPTIONS
+    } catch (...) {
-    } catch(...) { return UPX_E_OUT_OF_MEMORY; }
+        rh = E_OUTOFMEMORY;
-#endif
+    }
 
-    assert(is.Pos <=  src_len);
+    assert(is.b_pos <=  src_len);
-    assert(os.Pos <= *dst_len);
+    assert(os.b_pos <= *dst_len);
     if (rh == E_OUTOFMEMORY)
         r = UPX_E_OUT_OF_MEMORY;
-    else if (os.Overflow)
+    else if (os.overflow)
     {
-        assert(os.Pos == *dst_len);
+        assert(os.b_pos == *dst_len);
         //r = UPX_E_OUTPUT_OVERRUN;
         r = UPX_E_NOT_COMPRESSIBLE;
     }
     else if (rh == S_OK)
     {
-        assert(is.Pos == src_len);
+        assert(is.b_pos == src_len);
         r = UPX_E_OK;
     }
 
 error:
-    *dst_len = os.Pos;
+    *dst_len = (unsigned) os.b_pos;
+    //printf("\nlzma_compress: %d: %u %u %u %u %u, %u - > %u\n", r, res->pos_bits, res->lit_pos_bits, res->lit_context_bits, res->dict_size, res->num_probs, src_len, *dst_len);
+    //printf("%u %u %u\n", is.__m_RefCount, os.__m_RefCount, progress.__m_RefCount);
     return r;
 }
 
 
-#include "C/Common/Alloc.cpp"
-#include "C/Common/CRC.cpp"
-//#include "C/7zip/Common/InBuffer.cpp"
-#include "C/7zip/Common/OutBuffer.cpp"
-#include "C/7zip/Common/StreamUtils.cpp"
-#include "C/7zip/Compress/LZ/LZInWindow.cpp"
-//#include "C/7zip/Compress/LZ/LZOutWindow.cpp"
-//#include "C/7zip/Compress/LZMA/LZMADecoder.cpp"
-#include "C/7zip/Compress/LZMA/LZMAEncoder.cpp"
-#include "C/7zip/Compress/RangeCoder/RangeCoderBit.cpp"
-#undef RC_NORMALIZE
-
-
 /*************************************************************************
 // decompress
 **************************************************************************/
@@ -344,15 +422,15 @@ error:
 #undef _LZMA_OUT_READ
 #undef _LZMA_PROB32
 #undef _LZMA_LOC_OPT
-#include "C/7zip/Compress/LZMA_C/LzmaDecode.h"
+#include <lzma-sdk/C/7zip/Compress/LZMA_C/LzmaDecode.h>
-#include "C/7zip/Compress/LZMA_C/LzmaDecode.c"
+#include <lzma-sdk/C/7zip/Compress/LZMA_C/LzmaDecode.c>
 
 int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult )
 {
-    assert(method == M_LZMA);
+    assert(M_IS_LZMA(method));
     // see res->num_probs above
     COMPILE_TIME_ASSERT(sizeof(CProb) == 2)
     COMPILE_TIME_ASSERT(LZMA_BASE_SIZE == 1846)
@@ -363,14 +441,6 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
     int r = UPX_E_ERROR;
     int rh;
 
-#if defined(USE_LZMA_PROPERTIES)
-    if (src_len < 2)
-        goto error;
-    rh = LzmaDecodeProperties(&s.Properties, src, src_len);
-    if (rh != 0)
-        goto error;
-    src += 1; src_len -= 1;
-#else
     if (src_len < 3)
         goto error;
     s.Properties.pb = src[0] & 7;
@@ -382,7 +452,6 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
     // extra
     if ((src[0] >> 3) != s.Properties.lc + s.Properties.lp) goto error;
     src += 2; src_len -= 2;
-#endif
 
     if (cresult)
     {
@@ -391,6 +460,9 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
         assert(cresult->result_lzma.lit_pos_bits == (unsigned) s.Properties.lp);
         assert(cresult->result_lzma.lit_context_bits == (unsigned) s.Properties.lc);
         assert(cresult->result_lzma.num_probs == (unsigned) LzmaGetNumProbs(&s.Properties));
+        const lzma_compress_result_t *res = &cresult->result_lzma;
+        UNUSED(res);
+        //printf("\nlzma_decompress config: %u %u %u %u %u\n", res->pos_bits, res->lit_pos_bits, res->lit_context_bits, res->dict_size, res->num_probs);
     }
     s.Probs = (CProb *) malloc(sizeof(CProb) * LzmaGetNumProbs(&s.Properties));
     if (!s.Probs)
@@ -411,40 +483,58 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
 error:
     *dst_len = dst_out;
     free(s.Probs);
-
-    UNUSED(cresult);
     return r;
 }
 
 
 /*************************************************************************
-// test_overlap
+// test_overlap - see <ucl/ucl.h> for semantics
 **************************************************************************/
 
-int upx_lzma_test_overlap  ( const upx_bytep buf, unsigned src_off,
+int upx_lzma_test_overlap  ( const upx_bytep buf,
-                                   unsigned  src_len, unsigned* dst_len,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult )
 {
-    assert(method == M_LZMA);
+    assert(M_IS_LZMA(method));
 
-    // FIXME - implement this
+    MemBuffer b(src_off + src_len);
-    // Note that Packer::verifyOverlappingDecompression() will
+    memcpy(b + src_off, buf + src_off, src_len);
-    // verify the final result in any case.
+    unsigned saved_dst_len = *dst_len;
-    UNUSED(buf);
+    int r = upx_lzma_decompress(b + src_off, src_len, b, dst_len, method, cresult);
-
+    if (r != UPX_E_OK)
-    unsigned overlap_overhead = src_off + src_len - *dst_len;
+        return r;
-    //printf("upx_lzma_test_overlap: %d\n", overlap_overhead);
+    if (*dst_len != saved_dst_len)
-    if ((int)overlap_overhead >= 256)
-        return UPX_E_OK;
-
-    UNUSED(cresult);
         return UPX_E_ERROR;
+    // NOTE: there is a very tiny possibility that decompression has
+    //   succeeded but the data is not restored correctly because of
+    //   in-place buffer overlapping, so we use an extra memcmp().
+    if (tbuf != nullptr && memcmp(tbuf, b, *dst_len) != 0)
+        return UPX_E_ERROR;
+    return UPX_E_OK;
 }
 
 
-#endif /* WITH_LZMA */
+/*************************************************************************
-/*
+// misc
-vi:ts=4:et:nowrap
+**************************************************************************/
-*/
 
+int upx_lzma_init(void)
+{
+    return 0;
+}
+
+const char *upx_lzma_version_string(void)
+{
+#if (WITH_LZMA == 0x443)
+    return "4.43";
+#else
+#   error "unknown WITH_LZMA version"
+    return nullptr;
+#endif
+}
+
+
+/* vim:set ts=4 sw=4 et: */

src/compress_ucl.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,40 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 #include "compress.h"
-#if !defined(WITH_UCL)
-extern int compress_ucl_dummy;
-int compress_ucl_dummy = 0;
-#else
-
-#if 1 && !defined(UCL_USE_ASM) && (ACC_ARCH_I386)
-#  if (ACC_CC_GNUC || ACC_CC_INTELC || ACC_CC_MSC || ACC_CC_WATCOMC)
-#    define UCL_USE_ASM
-#  endif
-#endif
-#if defined(UCL_NO_ASM)
-#  undef UCL_USE_ASM
-#endif
-#if defined(ACC_CFG_NO_UNALIGNED)
-#  undef UCL_USE_ASM
-#endif
-#if 1 && defined(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
 
 
 /*************************************************************************
@@ -84,13 +56,14 @@ static int convert_errno_from_ucl(int r)
 }
 
 
-static void wrap_nprogress_ucl(ucl_uint a, ucl_uint b, int state, ucl_voidp user)
+extern "C" {
+static void __UCL_CDECL wrap_nprogress_ucl(ucl_uint a, ucl_uint b, int state, ucl_voidp user)
 {
     if (state != -1 && state != 3) return;
     upx_callback_p cb = (upx_callback_p) user;
     if (cb && cb->nprogress)
         cb->nprogress(cb, a, b);
-}
+}}
 
 
 /*************************************************************************
@@ -105,20 +78,21 @@ int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
                                    upx_compress_result_t *cresult )
 {
     int r;
-    assert(level > 0); assert(cresult != NULL);
+    assert(level > 0); assert(cresult != nullptr);
+
+    COMPILE_TIME_ASSERT(sizeof(ucl_compress_config_t) == sizeof(REAL_ucl_compress_config_t))
 
     ucl_progress_callback_t cb;
-    cb.callback = 0;
+    cb.callback = nullptr;
-    cb.user = NULL;
+    cb.user = nullptr;
     if (cb_parm && cb_parm->nprogress) {
         cb.callback = wrap_nprogress_ucl;
         cb.user = cb_parm;
     }
 
-    ucl_compress_config_t cconf;
+    ucl_compress_config_t cconf; cconf.reset();
-    memset(&cconf, 0xff, sizeof(cconf));
     if (cconf_parm)
-        cconf = cconf_parm->conf_ucl; // struct copy
+        memcpy(&cconf, &cconf_parm->conf_ucl, sizeof(cconf)); // cconf = cconf_parm->conf_ucl; // struct copy
 
     ucl_uint *res = cresult->result_ucl.result;
     // assume no info available - fill in worst case results
@@ -134,7 +108,7 @@ int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
     // prepare bit-buffer settings
     cconf.bb_endian = 0;
     cconf.bb_size = 0;
-    if (method >= M_NRV2B_LE32 && method <= M_CL1B_LE16)
+    if (method >= M_NRV2B_LE32 && method <= M_NRV2E_LE16)
     {
         static const unsigned char sizes[3] = {32, 8, 16};
         cconf.bb_size = sizes[(method - M_NRV2B_LE32) % 3];
@@ -164,6 +138,10 @@ int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
         return UPX_E_ERROR;
     }
 
+    // make sure first_offset_found is set
+    if (res[6] == 0)
+        res[6] = 1;
+
     return convert_errno_from_ucl(r);
 }
 
@@ -182,31 +160,31 @@ int upx_ucl_decompress     ( const upx_bytep src, unsigned  src_len,
     switch (method)
     {
     case M_NRV2B_8:
-        r = ucl_nrv2b_decompress_safe_8(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2b_decompress_safe_8(src,src_len,dst,dst_len,nullptr);
         break;
     case M_NRV2B_LE16:
-        r = ucl_nrv2b_decompress_safe_le16(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2b_decompress_safe_le16(src,src_len,dst,dst_len,nullptr);
         break;
     case M_NRV2B_LE32:
-        r = ucl_nrv2b_decompress_safe_le32(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2b_decompress_safe_le32(src,src_len,dst,dst_len,nullptr);
         break;
     case M_NRV2D_8:
-        r = ucl_nrv2d_decompress_safe_8(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2d_decompress_safe_8(src,src_len,dst,dst_len,nullptr);
         break;
     case M_NRV2D_LE16:
-        r = ucl_nrv2d_decompress_safe_le16(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2d_decompress_safe_le16(src,src_len,dst,dst_len,nullptr);
         break;
     case M_NRV2D_LE32:
-        r = ucl_nrv2d_decompress_safe_le32(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2d_decompress_safe_le32(src,src_len,dst,dst_len,nullptr);
         break;
     case M_NRV2E_8:
-        r = ucl_nrv2e_decompress_safe_8(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2e_decompress_safe_8(src,src_len,dst,dst_len,nullptr);
         break;
     case M_NRV2E_LE16:
-        r = ucl_nrv2e_decompress_safe_le16(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2e_decompress_safe_le16(src,src_len,dst,dst_len,nullptr);
         break;
     case M_NRV2E_LE32:
-        r = ucl_nrv2e_decompress_safe_le32(src,src_len,dst,dst_len,NULL);
+        r = ucl_nrv2e_decompress_safe_le32(src,src_len,dst,dst_len,nullptr);
         break;
     default:
         throwInternalError("unknown decompression method");
@@ -222,41 +200,44 @@ int upx_ucl_decompress     ( const upx_bytep src, unsigned  src_len,
 //
 **************************************************************************/
 
-int upx_ucl_test_overlap   ( const upx_bytep buf, unsigned src_off,
+int upx_ucl_test_overlap   ( const upx_bytep buf,
-                                   unsigned  src_len, unsigned* dst_len,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
                                    int method,
                              const upx_compress_result_t *cresult )
 {
     int r;
+    UNUSED(tbuf); // not needed for UCL
 
     switch (method)
     {
     case M_NRV2B_8:
-        r = ucl_nrv2b_test_overlap_8(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2b_test_overlap_8(buf,src_off,src_len,dst_len,nullptr);
         break;
     case M_NRV2B_LE16:
-        r = ucl_nrv2b_test_overlap_le16(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2b_test_overlap_le16(buf,src_off,src_len,dst_len,nullptr);
         break;
     case M_NRV2B_LE32:
-        r = ucl_nrv2b_test_overlap_le32(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2b_test_overlap_le32(buf,src_off,src_len,dst_len,nullptr);
         break;
     case M_NRV2D_8:
-        r = ucl_nrv2d_test_overlap_8(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2d_test_overlap_8(buf,src_off,src_len,dst_len,nullptr);
         break;
     case M_NRV2D_LE16:
-        r = ucl_nrv2d_test_overlap_le16(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2d_test_overlap_le16(buf,src_off,src_len,dst_len,nullptr);
         break;
     case M_NRV2D_LE32:
-        r = ucl_nrv2d_test_overlap_le32(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2d_test_overlap_le32(buf,src_off,src_len,dst_len,nullptr);
         break;
     case M_NRV2E_8:
-        r = ucl_nrv2e_test_overlap_8(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2e_test_overlap_8(buf,src_off,src_len,dst_len,nullptr);
         break;
     case M_NRV2E_LE16:
-        r = ucl_nrv2e_test_overlap_le16(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2e_test_overlap_le16(buf,src_off,src_len,dst_len,nullptr);
         break;
     case M_NRV2E_LE32:
-        r = ucl_nrv2e_test_overlap_le32(buf,src_off,src_len,dst_len,NULL);
+        r = ucl_nrv2e_test_overlap_le32(buf,src_off,src_len,dst_len,nullptr);
         break;
     default:
         throwInternalError("unknown decompression method");
@@ -268,8 +249,92 @@ int upx_ucl_test_overlap   ( const upx_bytep buf, unsigned src_off,
 }
 
 
-#endif /* WITH_UCL */
+/*************************************************************************
-/*
+// misc
-vi:ts=4:et:nowrap
+**************************************************************************/
-*/
 
+extern "C" {
+static ucl_voidp __UCL_CDECL my_malloc(ucl_uint n) { return calloc(1, n); }
+static void __UCL_CDECL my_free(ucl_voidp p) { free(p); }
+}
+
+int upx_ucl_init(void)
+{
+    if (ucl_init() != UCL_E_OK)
+        return -1;
+    if (UCL_VERSION != ucl_version() || strcmp(UCL_VERSION_STRING, ucl_version_string()) != 0)
+        return -2;
+    ucl_set_malloc_hooks(my_malloc, my_free);
+    return 0;
+}
+
+const char *upx_ucl_version_string(void)
+{
+    return ucl_version_string();
+}
+
+unsigned upx_ucl_adler32(const void *buf, unsigned len, unsigned adler)
+{
+    return ucl_adler32(adler, (const ucl_bytep) buf, len);
+}
+
+#if 0 /* UNUSED */
+unsigned upx_ucl_crc32(const void *buf, unsigned len, unsigned crc)
+{
+    return ucl_crc32(crc, (const ucl_bytep) buf, len);
+}
+#endif
+
+/*************************************************************************
+// Debug checks
+**************************************************************************/
+
+#if DEBUG && 1
+
+#include "util/membuffer.h"
+
+static bool check_ucl(const int method, const unsigned expected_c_len) {
+    const unsigned u_len = 16384;
+    const unsigned c_extra = 4096;
+    MemBuffer u_buf, c_buf, d_buf;
+    unsigned c_len, d_len;
+    upx_compress_result_t cresult;
+    int r;
+    const int level = 3; // don't waste time
+
+    u_buf.alloc(u_len);
+    memset(u_buf, 0, u_len);
+    c_buf.allocForCompression(u_len, c_extra);
+    d_buf.allocForUncompression(u_len);
+
+    c_len = c_buf.getSize() - c_extra;
+    r = upx_ucl_compress(u_buf, u_len, c_buf + c_extra, &c_len, nullptr, method, level, NULL_cconf, &cresult);
+    if (r != 0 || c_len != expected_c_len) return false;
+
+    d_len = d_buf.getSize();
+    r = upx_ucl_decompress(c_buf + c_extra, c_len, d_buf, &d_len, method, nullptr);
+    if (r != 0 || d_len != u_len) return false;
+    if (memcmp(u_buf, d_buf, u_len) != 0) return false;
+
+    // TODO: rewrite Packer::findOverlapOverhead() so that we can test it here
+    //unsigned x_len = d_len;
+    //r = upx_ucl_test_overlap(c_buf, u_buf, c_extra, c_len, &x_len, method, nullptr);
+    return true;
+}
+
+TEST_CASE("compress_ucl") {
+    CHECK(check_ucl(M_NRV2B_8, 34));
+    CHECK(check_ucl(M_NRV2B_LE16, 34));
+    CHECK(check_ucl(M_NRV2B_LE32, 34));
+    CHECK(check_ucl(M_NRV2D_8, 32));
+    CHECK(check_ucl(M_NRV2D_LE16, 32));
+    CHECK(check_ucl(M_NRV2D_LE32, 34));
+    CHECK(check_ucl(M_NRV2E_8, 32));
+    CHECK(check_ucl(M_NRV2E_LE16, 32));
+    CHECK(check_ucl(M_NRV2E_LE32, 34));
+}
+
+#endif // DEBUG
+
+
+/* vim:set ts=4 sw=4 et: */

src/compress_zlib.cpp

@@ -0,0 +1,291 @@
+/* compress_zlib.cpp --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 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 "compress.h"
+#include "util/membuffer.h"
+#include <zlib/zlib.h>
+#include <zlib/deflate.h>
+
+
+void zlib_compress_config_t::reset()
+{
+    mem_clear(this, sizeof(*this));
+
+    mem_level.reset();
+    window_bits.reset();
+    strategy.reset();
+}
+
+
+static int convert_errno_from_zlib(int zr)
+{
+    switch (zr)
+    {
+    case Z_OK:                  return UPX_E_OK;
+    case Z_DATA_ERROR:          return UPX_E_ERROR;
+    case Z_NEED_DICT:           return UPX_E_ERROR;
+    }
+    return UPX_E_ERROR;
+}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+int upx_zlib_compress      ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   upx_callback_p cb_parm,
+                                   int method, int level,
+                             const upx_compress_config_t *cconf_parm,
+                                   upx_compress_result_t *cresult )
+{
+    assert(method == M_DEFLATE);
+    assert(level > 0); assert(cresult != nullptr);
+    UNUSED(cb_parm);
+    int r = UPX_E_ERROR;
+    int zr;
+    const zlib_compress_config_t *lcconf = cconf_parm ? &cconf_parm->conf_zlib : nullptr;
+    zlib_compress_result_t *res = &cresult->result_zlib;
+
+    if (level == 10)
+        level = 9;
+
+    zlib_compress_config_t::mem_level_t mem_level;
+    zlib_compress_config_t::window_bits_t window_bits;
+    zlib_compress_config_t::strategy_t strategy;
+    // cconf overrides
+    if (lcconf)
+    {
+        oassign(mem_level, lcconf->mem_level);
+        oassign(window_bits, lcconf->window_bits);
+        oassign(strategy, lcconf->strategy);
+    }
+
+    res->dummy = 0;
+
+    z_stream s;
+    s.zalloc = (alloc_func) nullptr;
+    s.zfree = (free_func) nullptr;
+    s.next_in = ACC_UNCONST_CAST(upx_bytep, src);
+    s.avail_in = src_len;
+    s.next_out = dst;
+    s.avail_out = *dst_len;
+    s.total_in = s.total_out = 0;
+
+    zr = (int)deflateInit2(&s, level, Z_DEFLATED, 0 - (int)window_bits,
+                      mem_level, strategy);
+    if (zr != Z_OK)
+        goto error;
+    assert(s.state->level == level);
+    zr = deflate(&s, Z_FINISH);
+    if (zr != Z_STREAM_END)
+        goto error;
+    zr = deflateEnd(&s);
+    if (zr != Z_OK)
+        goto error;
+    r = UPX_E_OK;
+    goto done;
+error:
+    (void) deflateEnd(&s);
+    r = convert_errno_from_zlib(zr);
+    if (r == UPX_E_OK)
+        r = UPX_E_ERROR;
+done:
+    if (r == UPX_E_OK)
+    {
+        if (s.avail_in != 0 || s.total_in != src_len)
+            r = UPX_E_ERROR;
+    }
+    assert(s.total_in  <=  src_len);
+    assert(s.total_out <= *dst_len);
+    *dst_len = s.total_out;
+    return r;
+}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+int upx_zlib_decompress    ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult )
+{
+    assert(method == M_DEFLATE);
+    UNUSED(method);
+    UNUSED(cresult);
+    int r = UPX_E_ERROR;
+    int zr;
+
+    z_stream s;
+    s.zalloc = (alloc_func) nullptr;
+    s.zfree = (free_func) nullptr;
+    s.next_in = ACC_UNCONST_CAST(upx_bytep, src);
+    s.avail_in = src_len;
+    s.next_out = dst;
+    s.avail_out = *dst_len;
+    s.total_in = s.total_out = 0;
+
+    zr = inflateInit2(&s, -15);
+    if (zr != Z_OK)
+        goto error;
+    zr = inflate(&s, Z_FINISH);
+    if (zr != Z_STREAM_END)
+        goto error;
+    zr = inflateEnd(&s);
+    if (zr != Z_OK)
+        goto error;
+    r = UPX_E_OK;
+    goto done;
+error:
+    (void) inflateEnd(&s);
+    r = convert_errno_from_zlib(zr);
+    if (r == UPX_E_OK)
+        r = UPX_E_ERROR;
+done:
+    if (r == UPX_E_OK)
+    {
+        if (s.avail_in != 0 || s.total_in != src_len)
+            r = UPX_E_INPUT_NOT_CONSUMED;
+    }
+    assert(s.total_in  <=  src_len);
+    assert(s.total_out <= *dst_len);
+    *dst_len = s.total_out;
+    return r;
+}
+
+
+/*************************************************************************
+// test_overlap - see <ucl/ucl.h> for semantics
+**************************************************************************/
+
+int upx_zlib_test_overlap  ( const upx_bytep buf,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult )
+{
+    assert(method == M_DEFLATE);
+
+    MemBuffer b(src_off + src_len);
+    memcpy(b + src_off, buf + src_off, src_len);
+    unsigned saved_dst_len = *dst_len;
+    int r = upx_zlib_decompress(b + src_off, src_len, b, dst_len, method, cresult);
+    if (r != UPX_E_OK)
+        return r;
+    if (*dst_len != saved_dst_len)
+        return UPX_E_ERROR;
+    // NOTE: there is a very tiny possibility that decompression has
+    //   succeeded but the data is not restored correctly because of
+    //   in-place buffer overlapping, so we use an extra memcmp().
+    if (tbuf != nullptr && memcmp(tbuf, b, *dst_len) != 0)
+        return UPX_E_ERROR;
+    return UPX_E_OK;
+}
+
+
+/*************************************************************************
+// misc
+**************************************************************************/
+
+int upx_zlib_init(void)
+{
+    if (strcmp(ZLIB_VERSION, zlibVersion()) != 0)
+        return -2;
+    return 0;
+}
+
+const char *upx_zlib_version_string(void)
+{
+    return zlibVersion();
+}
+
+#if 0 /* UNUSED */
+unsigned upx_zlib_adler32(const void *buf, unsigned len, unsigned adler)
+{
+    return adler32(adler, (const Bytef *) buf, len);
+}
+#endif
+
+#if 0 /* UNUSED */
+unsigned upx_zlib_crc32(const void *buf, unsigned len, unsigned crc)
+{
+    return crc32(crc, (const Bytef *) buf, len);
+}
+#endif
+
+/*************************************************************************
+// Debug checks
+**************************************************************************/
+
+#if DEBUG && 1
+
+#include "util/membuffer.h"
+
+static bool check_zlib(const int method, const int level, const unsigned expected_c_len) {
+    const unsigned u_len = 16384;
+    const unsigned c_extra = 4096;
+    MemBuffer u_buf, c_buf, d_buf;
+    unsigned c_len, d_len;
+    upx_compress_result_t cresult;
+    int r;
+
+    u_buf.alloc(u_len);
+    memset(u_buf, 0, u_len);
+    c_buf.allocForCompression(u_len, c_extra);
+    d_buf.allocForUncompression(u_len);
+
+    c_len = c_buf.getSize() - c_extra;
+    r = upx_zlib_compress(u_buf, u_len, c_buf + c_extra, &c_len, nullptr, method, level, NULL_cconf, &cresult);
+    if (r != 0 || c_len != expected_c_len) return false;
+
+    d_len = d_buf.getSize();
+    r = upx_zlib_decompress(c_buf + c_extra, c_len, d_buf, &d_len, method, nullptr);
+    if (r != 0 || d_len != u_len) return false;
+    if (memcmp(u_buf, d_buf, u_len) != 0) return false;
+
+    // TODO: rewrite Packer::findOverlapOverhead() so that we can test it here
+    //unsigned x_len = d_len;
+    //r = upx_zlib_test_overlap(c_buf, u_buf, c_extra, c_len, &x_len, method, nullptr);
+    return true;
+}
+
+TEST_CASE("compress_zlib") {
+    CHECK(check_zlib(M_DEFLATE, 1, 89));
+    CHECK(check_zlib(M_DEFLATE, 3, 89));
+    CHECK(check_zlib(M_DEFLATE, 5, 33));
+}
+
+#endif // DEBUG
+
+
+/* vim:set ts=4 sw=4 et: */

src/console.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -39,41 +39,41 @@
 #undef USE_SCREEN_WIN32
 #undef USE_FRAMES
 
-#if defined(WITH_GUI) && !defined(NO_CONSOLE)
+#if 1 && (WITH_GUI) && !defined(NO_CONSOLE)
-#  define NO_CONSOLE
+#  define NO_CONSOLE 1
 #endif
 
 #if 1 && defined(__linux__)
-#  define USE_SCREEN
+#  define USE_SCREEN 1
-#  define USE_SCREEN_VCSA
+#  define USE_SCREEN_VCSA 1
-#  if !defined(HAVE_LINUX_KD_H)
+#  if !(HAVE_LINUX_KD_H)
 #    undef USE_SCREEN
 #    undef USE_SCREEN_VCSA
 #  endif
-#  if !defined(HAVE_LINUX_KDEV_T_H) || !defined(HAVE_LINUX_MAJOR_H)
+#  if !(HAVE_LINUX_KDEV_T_H) || !(HAVE_LINUX_MAJOR_H)
 #    undef USE_SCREEN
 #    undef USE_SCREEN_VCSA
 #  endif
 #endif
 
-#if 1 && defined(__DJGPP__)
+#if 1 && (ACC_OS_DOS32) && defined(__DJGPP__)
-#  define USE_SCREEN
+#  define USE_SCREEN 1
 #elif 1 && (ACC_OS_CYGWIN || ACC_OS_WIN32 || ACC_OS_WIN64)
-#  define USE_SCREEN
+#  define USE_SCREEN 1
-#  define USE_SCREEN_WIN32
+#  define USE_SCREEN_WIN32 1
 #elif 1 && (ACC_OS_EMX && defined(__RSXNT__))
-#  define USE_SCREEN
+#  define USE_SCREEN 1
-#  define USE_SCREEN_WIN32
+#  define USE_SCREEN_WIN32 1
 #endif
 
 
-#if 0 || defined(NO_ANSI)
+#if 0 || (NO_ANSI)
 #  undef USE_ANSI
 #endif
-#if 0 || defined(NO_SCREEN)
+#if 0 || (NO_SCREEN)
 #  undef USE_SCREEN
 #endif
-#if 0 || defined(NO_FRAMES) || !defined(USE_SCREEN)
+#if 0 || (NO_FRAMES) || !(USE_SCREEN)
 #  undef USE_FRAMES
 #endif
 #if 1
@@ -81,11 +81,11 @@
 #endif
 
 
-#if 0 || defined(USE_ANSI) || defined(USE_SCREEN)
+#if 0 || (USE_ANSI) || (USE_SCREEN)
-#  define USE_CONSOLE
+#  define USE_CONSOLE 1
 #endif
 
-#if 0 || defined(NO_CONSOLE) || !defined(USE_CONSOLE)
+#if 0 || (NO_CONSOLE) || !(USE_CONSOLE)
 #  undef USE_CONSOLE
 #  undef USE_ANSI
 #  undef USE_SCREEN
@@ -110,7 +110,7 @@ enum {
 };
 
 
-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)
 
 typedef struct
 {
@@ -122,12 +122,7 @@ typedef struct
 console_t;
 
 
-#if defined(__GNUC__)
+void con_fprintf(FILE *f, const char *format, ...) attribute_format(2, 3);
-void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...)
-        __attribute__((__format__(printf,2,3)));
-#else
-void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...);
-#endif
 
 
 #define FG_BLACK     0x00
@@ -165,7 +160,7 @@ void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...);
 
 extern FILE *con_term;
 
-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)
 
 extern int con_mode;
 extern console_t *con;
@@ -187,8 +182,4 @@ extern console_t console_screen;
 
 #endif /* USE_CONSOLE */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/except.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,60 +22,55 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
-
 #include "conf.h"
 
-
 /*************************************************************************
 //
 **************************************************************************/
 
-long Throwable::counter = 0;
+unsigned long Throwable::counter = 0;
 
-Throwable::Throwable(const char *m, int e, bool w) NOTHROW
+Throwable::Throwable(const char *m, int e, bool w) noexcept : super(),
-    : super(), msg(NULL), err(e), is_warning(w)
+                                                              msg(nullptr),
-{
+                                                              err(e),
+                                                              is_warning(w) {
     if (m)
         msg = strdup(m);
 #if 0
-    fprintf(stderr, "construct exception: %s %ld\n", msg, counter);
+    fprintf(stderr, "construct exception: %s %lu\n", msg, counter);
     counter++;
 #endif
 }
 
-
+Throwable::Throwable(const Throwable &other) noexcept : super(other),
-Throwable::Throwable(const Throwable &other) NOTHROW
+                                                        msg(nullptr),
-    : super(other), msg(NULL), err(other.err), is_warning(other.is_warning)
+                                                        err(other.err),
-{
+                                                        is_warning(other.is_warning) {
     if (other.msg)
         msg = strdup(other.msg);
 #if 0
-    fprintf(stderr, "copy exception: %s %ld\n", msg, counter);
+    fprintf(stderr, "copy exception: %s %lu\n", msg, counter);
     counter++;
 #endif
 }
 
-
+Throwable::~Throwable() noexcept {
-Throwable::~Throwable() NOTHROW
-{
 #if 0
     counter--;
-    fprintf(stderr, "destruct exception: %s %ld\n", msg, counter);
+    fprintf(stderr, "destruct exception: %s %lu\n", msg, counter);
 #endif
     if (msg)
         free(msg);
 }
 
-
 /*************************************************************************
 // compression
 **************************************************************************/
 
-void throwCantPack(const char *msg)
+void throwCantPack(const char *msg) {
-{
     // UGLY, but makes things easier
     if (opt->cmd == CMD_COMPRESS)
         throw CantPackException(msg);
@@ -85,101 +80,73 @@ void throwCantPack(const char *msg)
         throw CantUnpackException(msg);
 }
 
-void throwFilterException()
+void throwCantPackExact() { throwCantPack("option '--exact' does not work with this file"); }
-{
-    throwCantPack("filter problem");
-}
 
-void throwUnknownExecutableFormat(const char *msg, bool warn)
+void throwFilterException() { throwCantPack("filter problem"); }
-{
+
+void throwUnknownExecutableFormat(const char *msg, bool warn) {
     throw UnknownExecutableFormatException(msg, warn);
 }
 
-void throwNotCompressible(const char *msg)
+void throwNotCompressible(const char *msg) { throw NotCompressibleException(msg); }
-{
-    throw NotCompressibleException(msg);
-}
 
-void throwAlreadyPacked(const char *msg)
+void throwAlreadyPacked(const char *msg) { throw AlreadyPackedException(msg); }
-{
-    throw AlreadyPackedException(msg);
-}
 
-void throwAlreadyPackedByUPX(const char *msg)
+void throwAlreadyPackedByUPX(const char *msg) {
-{
+    if (msg == nullptr)
-    if (msg == NULL)
         msg = "already packed by UPX";
     throwAlreadyPacked(msg);
 }
 
-
 /*************************************************************************
 // decompression
 **************************************************************************/
 
-void throwCantUnpack(const char *msg)
+void throwCantUnpack(const char *msg) {
-{
     // UGLY, but makes things easier
     throwCantPack(msg);
 }
 
-void throwNotPacked(const char *msg)
+void throwNotPacked(const char *msg) {
-{
+    if (msg == nullptr)
-    if (msg == NULL)
         msg = "not packed by UPX";
     throw NotPackedException(msg);
 }
 
-void throwChecksumError()
+void throwChecksumError() { throw Exception("checksum error"); }
-{
-    throw Exception("checksum error");
-}
-
-void throwCompressedDataViolation()
-{
-    throw Exception("compressed data violation");
-}
 
+void throwCompressedDataViolation() { throw Exception("compressed data violation"); }
 
 /*************************************************************************
 // other
 **************************************************************************/
 
-void throwInternalError(const char *msg)
+void throwInternalError(const char *msg) { throw InternalError(msg); }
-{
+
-    throw InternalError(msg);
+void throwBadLoader() { throwInternalError("bad loader"); }
+
+void throwOutOfMemoryException(const char *msg) {
+    if (msg == nullptr)
+        msg = "out of memory";
+    throw OutOfMemoryException(msg);
 }
 
-void throwBadLoader()
+void throwIOException(const char *msg, int e) { throw IOException(msg, e); }
-{
-    throwInternalError("bad loader");
-}
 
-
+void throwEOFException(const char *msg, int e) {
-void throwIOException(const char *msg, int e)
+    if (msg == nullptr && e == 0)
-{
-    throw IOException(msg, e);
-}
-
-
-void throwEOFException(const char *msg, int e)
-{
-    if (msg == NULL && e == 0)
         msg = "premature end of file";
     throw EOFException(msg, e);
 }
 
-
 /*************************************************************************
 //
 **************************************************************************/
 
-const char *prettyName(const char *n) NOTHROW
+const char *prettyName(const char *n) noexcept {
-{
+    if (n == nullptr)
-    if (n == NULL)
         return "(null)";
-    while (*n)
+    while (*n) {
-    {
         if (*n >= '0' && *n <= '9') // Linux ABI
             n++;
         else if (*n == ' ')
@@ -192,8 +159,4 @@ const char *prettyName(const char *n) NOTHROW
     return n;
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/except.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,215 +22,203 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
-
+#pragma once
-#ifndef __UPX_EXCEPT_H
+#ifndef UPX_EXCEPT_H__
-#define __UPX_EXCEPT_H
+#define UPX_EXCEPT_H__ 1
 
 #ifdef __cplusplus
 
-const char *prettyName(const char *n) NOTHROW;
+const char *prettyName(const char *n) noexcept;
-
 
 /*************************************************************************
 // exceptions
 **************************************************************************/
 
-class Throwable : public std::exception
+class Throwable : public std::exception {
-{
     typedef std::exception super;
+
 protected:
-    Throwable(const char *m = 0, int e = 0, bool w = false) NOTHROW;
+    Throwable(const char *m = nullptr, int e = 0, bool w = false) noexcept;
+
 public:
-    Throwable(const Throwable &) NOTHROW;
+    Throwable(const Throwable &) noexcept;
-    virtual ~Throwable() NOTHROW;
+    virtual ~Throwable() noexcept;
-    const char *getMsg() const NOTHROW { return msg; }
+    const char *getMsg() const noexcept { return msg; }
-    int getErrno() const NOTHROW { return err; }
+    int getErrno() const noexcept { return err; }
-    bool isWarning() const NOTHROW { return is_warning; }
+    bool isWarning() const noexcept { return is_warning; }
+
 private:
-    char *msg;
+    char *msg = nullptr;
-    int err;
+    int err = 0;
+
 protected:
-    bool is_warning;                    // can be set by subclasses
+    bool is_warning = false; // can be set by subclasses
 
 private:
     // disable assignment
-    Throwable& operator= (const Throwable &);
+    Throwable &operator=(const Throwable &) = delete;
-    // disable dynamic allocation
+    // disable dynamic allocation => force throwing by value
-    DISABLE_NEW_DELETE
+    ACC_CXX_DISABLE_NEW_DELETE
 
 private:
-    static long counter;                // for debugging
+    static unsigned long counter; // for debugging
 };
 
-
 // Exceptions can/should be caught
-class Exception : public Throwable
+class Exception : public Throwable {
-{
     typedef Throwable super;
-public:
-    Exception(const char *m = 0, int e = 0, bool w = false) NOTHROW : super(m,e,w) { }
-};
 
+public:
+    Exception(const char *m = nullptr, int e = 0, bool w = false) noexcept : super(m, e, w) {}
+};
 
 // Errors should not be caught (or re-thrown)
-class Error : public Throwable
+class Error : public Throwable {
-{
     typedef Throwable super;
-public:
-    Error(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
-};
 
+public:
+    Error(const char *m = nullptr, int e = 0) noexcept : super(m, e) {}
+};
 
 /*************************************************************************
 // system exception
 **************************************************************************/
 
-class OutOfMemoryException : public Exception
+class OutOfMemoryException : public Exception {
-{
     typedef Exception super;
+
 public:
-    OutOfMemoryException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
+    OutOfMemoryException(const char *m = nullptr, int e = 0) noexcept : super(m, e) {}
 };
 
-
+class IOException : public Exception {
-class IOException : public Exception
-{
     typedef Exception super;
+
 public:
-    IOException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
+    IOException(const char *m = nullptr, int e = 0) noexcept : super(m, e) {}
 };
 
-
+class EOFException : public IOException {
-class EOFException : public IOException
-{
     typedef IOException super;
+
 public:
-    EOFException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
+    EOFException(const char *m = nullptr, int e = 0) noexcept : super(m, e) {}
 };
 
-
+class FileNotFoundException : public IOException {
-class FileNotFoundException : public IOException
-{
     typedef IOException super;
+
 public:
-    FileNotFoundException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
+    FileNotFoundException(const char *m = nullptr, int e = 0) noexcept : super(m, e) {}
 };
 
-
+class FileAlreadyExistsException : public IOException {
-class FileAlreadyExistsException : public IOException
-{
     typedef IOException super;
-public:
-    FileAlreadyExistsException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
-};
 
+public:
+    FileAlreadyExistsException(const char *m = nullptr, int e = 0) noexcept : super(m, e) {}
+};
 
 /*************************************************************************
-// application execptions
+// application exceptions
 **************************************************************************/
 
-class OverlayException : public Exception
+class OverlayException : public Exception {
-{
     typedef Exception super;
+
 public:
-    OverlayException(const char *m = 0, bool w = false) NOTHROW : super(m,0,w) { }
+    OverlayException(const char *m = nullptr, bool w = false) noexcept : super(m, 0, w) {}
 };
 
-class CantPackException : public Exception
+class CantPackException : public Exception {
-{
     typedef Exception super;
+
 public:
-    CantPackException(const char *m = 0, bool w = false) NOTHROW : super(m,0,w) { }
+    CantPackException(const char *m = nullptr, bool w = false) noexcept : super(m, 0, w) {}
 };
 
-class UnknownExecutableFormatException : public CantPackException
+class UnknownExecutableFormatException : public CantPackException {
-{
     typedef CantPackException super;
+
 public:
-    UnknownExecutableFormatException(const char *m = 0, bool w = false) NOTHROW : super(m,w) { }
+    UnknownExecutableFormatException(const char *m = nullptr, bool w = false) noexcept
+        : super(m, w) {}
 };
 
-class AlreadyPackedException : public CantPackException
+class AlreadyPackedException : public CantPackException {
-{
     typedef CantPackException super;
+
 public:
-    AlreadyPackedException(const char *m = 0) NOTHROW : super(m) { is_warning = true; }
+    AlreadyPackedException(const char *m = nullptr) noexcept : super(m) { is_warning = true; }
 };
 
-class NotCompressibleException : public CantPackException
+class NotCompressibleException : public CantPackException {
-{
     typedef CantPackException super;
+
 public:
-    NotCompressibleException(const char *m = 0) NOTHROW : super(m) { }
+    NotCompressibleException(const char *m = nullptr) noexcept : super(m) {}
 };
 
-
+class CantUnpackException : public Exception {
-class CantUnpackException : public Exception
-{
     typedef Exception super;
+
 public:
-    CantUnpackException(const char *m = 0, bool w = false) NOTHROW : super(m,0,w) { }
+    CantUnpackException(const char *m = nullptr, bool w = false) noexcept : super(m, 0, w) {}
 };
 
-class NotPackedException : public CantUnpackException
+class NotPackedException : public CantUnpackException {
-{
     typedef CantUnpackException super;
-public:
-    NotPackedException(const char *m = 0) NOTHROW : super(m,true) { }
-};
 
+public:
+    NotPackedException(const char *m = nullptr) noexcept : super(m, true) {}
+};
 
 /*************************************************************************
 // errors
 **************************************************************************/
 
-class InternalError : public Error
+class InternalError : public Error {
-{
     typedef Error super;
-public:
-    InternalError(const char *m = 0) NOTHROW : super(m,0) { }
-};
 
+public:
+    InternalError(const char *m = nullptr) noexcept : super(m, 0) {}
+};
 
 /*************************************************************************
 // util
 **************************************************************************/
 
 #undef NORET
-#if 0 && defined(__GNUC__)
+#if 1 && defined(__GNUC__)
-// (noreturn) is probably not the correct semantics for throwing exceptions
+#define NORET __acc_noinline __attribute__((__noreturn__))
-#define NORET __attribute__((__noreturn__))
 #else
-#define NORET
+#define NORET __acc_noinline
 #endif
 
-void throwCantPack(const char *msg) NORET;
+NORET void throwCantPack(const char *msg);
-void throwUnknownExecutableFormat(const char *msg = NULL, bool warn = false) NORET;
+NORET void throwCantPackExact();
-void throwNotCompressible(const char *msg = NULL) NORET;
+NORET void throwUnknownExecutableFormat(const char *msg = nullptr, bool warn = false);
-void throwAlreadyPacked(const char *msg = NULL) NORET;
+NORET void throwNotCompressible(const char *msg = nullptr);
-void throwAlreadyPackedByUPX(const char *msg = NULL) NORET;
+NORET void throwAlreadyPacked(const char *msg = nullptr);
-void throwCantUnpack(const char *msg) NORET;
+NORET void throwAlreadyPackedByUPX(const char *msg = nullptr);
-void throwNotPacked(const char *msg = NULL) NORET;
+NORET void throwCantUnpack(const char *msg);
-void throwFilterException() NORET;
+NORET void throwNotPacked(const char *msg = nullptr);
-void throwBadLoader() NORET;
+NORET void throwFilterException();
-void throwChecksumError() NORET;
+NORET void throwBadLoader();
-void throwCompressedDataViolation() NORET;
+NORET void throwChecksumError();
-void throwInternalError(const char *msg) NORET;
+NORET void throwCompressedDataViolation();
-void throwIOException(const char *msg = NULL, int e = 0) NORET;
+NORET void throwInternalError(const char *msg);
-void throwEOFException(const char *msg = NULL, int e = 0) NORET;
+NORET void throwOutOfMemoryException(const char *msg = nullptr);
+NORET void throwIOException(const char *msg = nullptr, int e = 0);
+NORET void throwEOFException(const char *msg = nullptr, int e = 0);
 
 #undef NORET
 
-
 #endif /* __cplusplus */
 
 #endif /* already included */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/file.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,61 +22,50 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
-
 #include "conf.h"
 #include "file.h"
-#include "mem.h"
-
 
 /*************************************************************************
-//
+// static functions
 **************************************************************************/
 
-void File::chmod(const char *name, int mode)
+void FileBase::chmod(const char *name, int mode) {
-{
+#if (HAVE_CHMOD)
-#if defined(HAVE_CHMOD)
+    if (::chmod(name, mode) != 0)
-    if (::chmod(name,mode) != 0)
+        throwIOException(name, errno);
-        throwIOException(name,errno);
 #else
-    UNUSED(name); UNUSED(mode);
+    UNUSED(name);
+    UNUSED(mode);
 #endif
 }
 
-
+void FileBase::rename(const char *old_, const char *new_) {
-void File::rename(const char *old_, const char *new_)
+#if (ACC_OS_DOS32) && defined(__DJGPP__)
-{
+    if (::_rename(old_, new_) != 0)
-#if defined(__DJGPP__)
-    if (::_rename(old_,new_) != 0)
 #else
-    if (::rename(old_,new_) != 0)
+    if (::rename(old_, new_) != 0)
 #endif
-        throwIOException("rename error",errno);
+        throwIOException("rename error", errno);
 }
 
-
+void FileBase::unlink(const char *name) {
-void File::unlink(const char *name)
-{
     if (::unlink(name) != 0)
-        throwIOException(name,errno);
+        throwIOException(name, errno);
 }
 
-
 /*************************************************************************
 //
 **************************************************************************/
 
-FileBase::FileBase() :
+FileBase::FileBase()
-    _fd(-1), _flags(0), _shflags(0), _mode(0), _name(NULL)
+    : _fd(-1), _flags(0), _shflags(0), _mode(0), _name(nullptr), _offset(0), _length(0) {
-{
+    memset(&st, 0, sizeof(st));
-    memset(&st,0,sizeof(st));
 }
 
-
+FileBase::~FileBase() {
-FileBase::~FileBase()
-{
 #if 0 && defined(__GNUC__) // debug
     if (isOpen())
         fprintf(stderr,"%s: %s\n", _name, __PRETTY_FUNCTION__);
@@ -87,28 +76,29 @@ FileBase::~FileBase()
     closex();
 }
 
-
+bool FileBase::do_sopen() {
-void FileBase::sopen()
-{
     if (_shflags < 0)
         _fd = ::open(_name, _flags, _mode);
-    else
+    else {
-    {
+#if (ACC_OS_DOS32) && defined(__DJGPP__)
-#if defined(__DJGPP__)
+        _fd = ::open(_name, _flags | _shflags, _mode);
-        _fd = ::open(_name,_flags | _shflags, _mode);
 #elif defined(__MINT__)
-        _fd = ::open(_name,_flags | (_shflags & O_SHMODE), _mode);
+        _fd = ::open(_name, _flags | (_shflags & O_SHMODE), _mode);
 #elif defined(SH_DENYRW)
         _fd = ::sopen(_name, _flags, _shflags, _mode);
 #else
-        assert(0);
+        throwInternalError("bad usage of do_sopen()");
 #endif
     }
+    if (_fd < 0)
+        return false;
+    if (::fstat(_fd, &st) != 0)
+        throwIOException(_name, errno);
+    _length = st.st_size;
+    return true;
 }
 
-
+bool FileBase::close() {
-bool FileBase::close()
-{
     bool ok = true;
     if (isOpen() && _fd != STDIN_FILENO && _fd != STDOUT_FILENO && _fd != STDERR_FILENO)
         if (::close(_fd) == -1)
@@ -116,98 +106,68 @@ bool FileBase::close()
     _fd = -1;
     _flags = 0;
     _mode = 0;
-    _name = NULL;
+    _name = nullptr;
+    _offset = 0;
+    _length = 0;
     return ok;
 }
 
-
+void FileBase::closex() {
-void FileBase::closex()
-{
     if (!close())
-        throwIOException("close failed",errno);
+        throwIOException("close failed", errno);
 }
 
-
+upx_off_t FileBase::seek(upx_off_t off, int whence) {
-int FileBase::read(void *buf, int len)
-{
-    if (!isOpen() || len < 0)
-        throwIOException("bad read");
-    errno = 0;
-    long l = acc_safe_hread(_fd, buf, len);
-    if (errno)
-        throwIOException("read error",errno);
-    return (int) l;
-}
-
-
-int FileBase::readx(void *buf, int len)
-{
-    int l = this->read(buf, len);
-    if (l != len)
-        throwEOFException();
-    return l;
-}
-
-
-void FileBase::write(const void *buf, int len)
-{
-    if (!isOpen() || len < 0)
-        throwIOException("bad write");
-    errno = 0;
-    long l = acc_safe_hwrite(_fd, buf, len);
-    if (l != len)
-        throwIOException("write error",errno);
-}
-
-
-void FileBase::seek(off_t off, int whence)
-{
     if (!isOpen())
         throwIOException("bad seek 1");
-    if (whence == SEEK_SET && off < 0)
+    mem_size_assert(1, off >= 0 ? off : -off); // sanity check
+    if (whence == SEEK_SET) {
+        if (off < 0)
             throwIOException("bad seek 2");
-    if (whence == SEEK_END && off > 0)
+        off += _offset;
+    }
+    if (whence == SEEK_END) {
+        if (off > 0)
             throwIOException("bad seek 3");
-    if (::lseek(_fd,off,whence) < 0)
+        off += _offset + _length;
-        throwIOException("seek error",errno);
+        whence = SEEK_SET;
+    }
+    if (::lseek(_fd, off, whence) < 0)
+        throwIOException("seek error", errno);
+    return off - _offset;
 }
 
-
+upx_off_t FileBase::tell() const {
-off_t FileBase::tell() const
-{
     if (!isOpen())
         throwIOException("bad tell");
-    off_t l = ::lseek(_fd, 0, SEEK_CUR);
+    upx_off_t l = ::lseek(_fd, 0, SEEK_CUR);
     if (l < 0)
-        throwIOException("tell error",errno);
+        throwIOException("tell error", errno);
-    return l;
+    return l - _offset;
 }
 
+void FileBase::set_extent(upx_off_t offset, upx_off_t length) {
+    _offset = offset;
+    _length = length;
+}
+
+upx_off_t FileBase::st_size() const { return _length; }
 
 /*************************************************************************
 //
 **************************************************************************/
 
-InputFile::InputFile()
+InputFile::InputFile() {}
-{
-}
 
-
+void InputFile::sopen(const char *name, int flags, int shflags) {
-InputFile::~InputFile()
-{
-}
-
-
-void InputFile::sopen(const char *name, int flags, int shflags)
-{
     close();
     _name = name;
     _flags = flags;
     _shflags = shflags;
     _mode = 0;
-    FileBase::sopen();
+    _offset = 0;
-    if (!isOpen())
+    _length = 0;
-    {
+    if (!super::do_sopen()) {
         if (errno == ENOENT)
             throw FileNotFoundException(_name, errno);
         else if (errno == EEXIST)
@@ -215,83 +175,51 @@ void InputFile::sopen(const char *name, int flags, int shflags)
         else
             throwIOException(_name, errno);
     }
+    _length_orig = _length;
 }
 
-
+int InputFile::read(SPAN_P(void) buf, int len) {
-int InputFile::read(void *buf, int len)
+    if (!isOpen() || len < 0)
-{
+        throwIOException("bad read");
-    return super::read(buf, len);
+    mem_size_assert(1, len); // sanity check
+    errno = 0;
+    long l = acc_safe_hread(_fd, raw_bytes(buf, len), len);
+    if (errno)
+        throwIOException("read error", errno);
+    return (int) l;
 }
 
-int InputFile::readx(void *buf, int len)
+int InputFile::readx(SPAN_P(void) buf, int len) {
-{
+    int l = this->read(buf, len);
-    return super::readx(buf, len);
+    if (l != len)
+        throwEOFException();
+    return l;
 }
 
-
+upx_off_t InputFile::seek(upx_off_t off, int whence) {
-int InputFile::read(MemBuffer *buf, int len)
+    upx_off_t pos = super::seek(off, whence);
-{
+    if (_length < pos)
-    buf->checkState();
+        throwIOException("bad seek 4");
-    assert((unsigned)len <= buf->getSize());
+    return pos;
-    return read(buf->getVoidPtr(), len);
-}
-
-int InputFile::readx(MemBuffer *buf, int len)
-{
-    buf->checkState();
-    assert((unsigned)len <= buf->getSize());
-    return read(buf->getVoidPtr(), len);
-}
-
-
-int InputFile::read(MemBuffer &buf, int len)
-{
-    return read(&buf, len);
-}
-
-int InputFile::readx(MemBuffer &buf, int len)
-{
-    return readx(&buf, len);
-}
-
-
-void InputFile::seek(off_t off, int whence)
-{
-    super::seek(off,whence);
-}
-
-
-off_t InputFile::tell() const
-{
-    return super::tell();
 }
 
+upx_off_t InputFile::st_size_orig() const { return _length_orig; }
 
 /*************************************************************************
 //
 **************************************************************************/
 
-OutputFile::OutputFile() :
+OutputFile::OutputFile() : bytes_written(0) {}
-    bytes_written(0)
-{
-}
 
-
+void OutputFile::sopen(const char *name, int flags, int shflags, int mode) {
-OutputFile::~OutputFile()
-{
-}
-
-
-void OutputFile::sopen(const char *name, int flags, int shflags, int mode)
-{
     close();
     _name = name;
     _flags = flags;
     _shflags = shflags;
     _mode = mode;
-    FileBase::sopen();
+    _offset = 0;
-    if (!isOpen())
+    _length = 0;
-    {
+    if (!super::do_sopen()) {
 #if 0
         // don't throw FileNotFound here -- this is confusing
         if (errno == ENOENT)
@@ -299,15 +227,13 @@ void OutputFile::sopen(const char *name, int flags, int shflags, int mode)
         else
 #endif
         if (errno == EEXIST)
-            throw FileAlreadyExistsException(_name,errno);
+            throw FileAlreadyExistsException(_name, errno);
         else
-            throwIOException(_name,errno);
+            throwIOException(_name, errno);
     }
 }
 
-
+bool OutputFile::openStdout(int flags, bool force) {
-bool OutputFile::openStdout(int flags, bool force)
-{
     close();
     int fd = STDOUT_FILENO;
     if (!force && acc_isatty(fd))
@@ -316,76 +242,105 @@ bool OutputFile::openStdout(int flags, bool force)
     _flags = flags;
     _shflags = -1;
     _mode = 0;
+    _offset = 0;
+    _length = 0;
     if (flags && acc_set_binmode(fd, 1) == -1)
         throwIOException(_name, errno);
     _fd = fd;
     return true;
 }
 
-
+void OutputFile::write(SPAN_0(const void) buf, int len) {
-void OutputFile::write(const void *buf, int len)
+    if (!isOpen() || len < 0)
-{
+        throwIOException("bad write");
-    super::write(buf, len);
+    // allow nullptr if len == 0
+    if (len == 0)
+        return;
+    mem_size_assert(1, len); // sanity check
+    errno = 0;
+#if 0
+    fprintf(stderr, "write %p %zd (%p) %d\n", buf.raw_ptr(), buf.raw_size_in_bytes(),
+            buf.raw_base(), len);
+#endif
+    long l = acc_safe_hwrite(_fd, raw_bytes(buf, len), len);
+    if (l != len)
+        throwIOException("write error", errno);
     bytes_written += len;
 }
 
-
+upx_off_t OutputFile::st_size() const {
-void OutputFile::write(const MemBuffer *buf, int len)
+    if (opt->to_stdout) {     // might be a pipe ==> .st_size is invalid
-{
+        return bytes_written; // too big if seek()+write() instead of rewrite()
-    buf->checkState();
+    }
-    assert((unsigned)len <= buf->getSize());
+    struct stat my_st;
-    write(buf->getVoidPtr(), len);
+    my_st.st_size = 0;
+    if (::fstat(_fd, &my_st) != 0)
+        throwIOException(_name, errno);
+    return my_st.st_size;
 }
 
-
+void OutputFile::rewrite(SPAN_P(const void) buf, int len) {
-void OutputFile::write(const MemBuffer &buf, int len)
+    assert(!opt->to_stdout);
-{
+    write(buf, len);
-    write(&buf, len);
+    bytes_written -= len; // restore
 }
 
+upx_off_t OutputFile::seek(upx_off_t off, int whence) {
+    mem_size_assert(1, off >= 0 ? off : -off); // sanity check
+    assert(!opt->to_stdout);
+    switch (whence) {
+    case SEEK_SET: {
+        if (bytes_written < off) {
+            bytes_written = off;
+        }
+        _length = bytes_written; // cheap, lazy update; needed?
+    } break;
+    case SEEK_END: {
+        _length = bytes_written; // necessary
+    } break;
+    }
+    return super::seek(off, whence);
+}
 
-void OutputFile::dump(const char *name, const void *buf, int len, int flags)
+// WARNING: fsync() does not exist in some Windows environments.
-{
+// This trick works only on UNIX-like systems.
+// int OutputFile::read(void *buf, int len)
+//{
+//    fsync(_fd);
+//    InputFile infile;
+//    infile.open(this->getName(), O_RDONLY | O_BINARY);
+//    infile.seek(this->tell(), SEEK_SET);
+//    return infile.read(buf, len);
+//}
+
+void OutputFile::set_extent(upx_off_t offset, upx_off_t length) {
+    super::set_extent(offset, length);
+    bytes_written = 0;
+    if (0 == offset && (upx_off_t) ~0u == length) {
+        if (::fstat(_fd, &st) != 0)
+            throwIOException(_name, errno);
+        _length = st.st_size - offset;
+    }
+}
+
+upx_off_t OutputFile::unset_extent() {
+    upx_off_t l = ::lseek(_fd, 0, SEEK_END);
+    if (l < 0)
+        throwIOException("lseek error", errno);
+    _offset = 0;
+    _length = l;
+    bytes_written = _length;
+    return _length;
+}
+
+void OutputFile::dump(const char *name, SPAN_P(const void) buf, int len, int flags) {
     if (flags < 0)
-         flags = O_CREAT | O_BINARY | O_TRUNC;
+        flags = O_CREAT | O_TRUNC;
-    flags |= O_WRONLY;
+    flags |= O_WRONLY | O_BINARY;
     OutputFile f;
     f.open(name, flags, 0600);
-    f.write(buf, len);
+    f.write(raw_bytes(buf, len), len);
     f.closex();
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-/*************************************************************************
-//
-**************************************************************************/
-
-#if 0
-
-MemoryOutputFile::MemoryOutputFile() :
-    b(NULL), b_size(0), b_pos(0), bytes_written(0)
-{
-}
-
-
-void MemoryOutputFile::write(const void *buf, int len)
-{
-    if (!isOpen() || len < 0)
-        throwIOException("bad write");
-    if (len == 0)
-        return;
-    if (b_pos + len > b_size)
-        throwIOException("write error",ENOSPC);
-    memcpy(b + b_pos, buf, len);
-    b_pos += len;
-    bytes_written += len;
-}
-
-
-#endif /* if 0 */
-
-
-/*
-vi:ts=4:et
-*/
-

src/file.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,170 +22,113 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
-
+#pragma once
-#ifndef __UPX_FILE_H
+#ifndef UPX_FILE_H__
-#define __UPX_FILE_H
+#define UPX_FILE_H__ 1
-
-class MemBuffer;
-
 
 /*************************************************************************
 //
 **************************************************************************/
 
-class File
+class FileBase {
-{
-protected:
-    File() { }
-    virtual ~File() { }
-public:
-    static void chmod(const char *name, int mode);
-    static void rename(const char *old_, const char *new_);
-    static void unlink(const char *name);
-};
-
-
-class FileBase : public File
-{
 protected:
     FileBase();
     virtual ~FileBase();
+
 public:
-    virtual bool close();
+    bool close();
-    virtual void closex();
+    void closex();
-    virtual bool isOpen() const { return _fd >= 0; }
+    bool isOpen() const { return _fd >= 0; }
     int getFd() const { return _fd; }
     const char *getName() const { return _name; }
 
-protected:
+    virtual upx_off_t seek(upx_off_t off, int whence);
-    void sopen();
+    upx_off_t tell() const;
-    virtual int read(void *buf, int len);
+    virtual upx_off_t st_size() const; // { return _length; }
-    virtual int readx(void *buf, int len);
+    virtual void set_extent(upx_off_t offset, upx_off_t length);
-    virtual void write(const void *buf, int len);
-    virtual void seek(off_t off, int whence);
-    virtual off_t tell() const;
 
-    int _fd;
-    int _flags;
-    int _shflags;
-    int _mode;
-    const char *_name;
 public:
-    struct stat st;
+    // static file-related util functions
-};
+    static void chmod(const char *name, int mode);
+    static void rename(const char *old_, const char *new_);
+    static void unlink(const char *name);
 
+protected:
+    bool do_sopen();
+    int _fd = -1;
+    int _flags = 0;
+    int _shflags = 0;
+    int _mode = 0;
+    const char *_name = nullptr;
+    upx_off_t _offset = 0;
+    upx_off_t _length = 0;
+
+public:
+    struct stat st = {};
+};
 
 /*************************************************************************
 //
 **************************************************************************/
 
-class InputFile : public FileBase
+class InputFile final : public FileBase {
-{
     typedef FileBase super;
+
 public:
     InputFile();
-    virtual ~InputFile();
+    virtual ~InputFile() {}
 
-    virtual void sopen(const char *name, int flags, int shflags);
+    void sopen(const char *name, int flags, int shflags);
-    virtual void open(const char *name, int flags)
+    void open(const char *name, int flags) { sopen(name, flags, -1); }
-    {
-        sopen(name, flags, -1);
-    }
 
-    virtual int read(void *buf, int len);
+    int read(SPAN_P(void) buf, int len);
-    virtual int readx(void *buf, int len);
+    int readx(SPAN_P(void) buf, int len);
-    virtual int read(MemBuffer *buf, int len);
-    virtual int readx(MemBuffer *buf, int len);
-    virtual int read(MemBuffer &buf, int len);
-    virtual int readx(MemBuffer &buf, int len);
 
-    virtual void seek(off_t off, int whence);
+    virtual upx_off_t seek(upx_off_t off, int whence) override;
-    virtual off_t tell() const;
+    upx_off_t st_size_orig() const;
+
+protected:
+    upx_off_t _length_orig = 0;
 };
 
-
 /*************************************************************************
 //
 **************************************************************************/
 
-class OutputFile : public FileBase
+class OutputFile final : public FileBase {
-{
     typedef FileBase super;
+
 public:
     OutputFile();
-    virtual ~OutputFile();
+    virtual ~OutputFile() {}
 
-    virtual void sopen(const char *name, int flags, int shflags, int mode);
+    void sopen(const char *name, int flags, int shflags, int mode);
-    virtual void open(const char *name, int flags, int mode)
+    void open(const char *name, int flags, int mode) { sopen(name, flags, -1, mode); }
-    {
+    bool openStdout(int flags = 0, bool force = false);
-        sopen(name, flags, -1, mode);
-    }
-    virtual bool openStdout(int flags=0, bool force=false);
 
-    virtual void write(const void *buf, int len);
+    // info: allow nullptr if len == 0
-    virtual void write(const MemBuffer *buf, int len);
+    void write(SPAN_0(const void) buf, int len);
-    virtual void write(const MemBuffer &buf, int len);
 
-    off_t getBytesWritten() const { return bytes_written; }
+    virtual upx_off_t seek(upx_off_t off, int whence) override;
+    virtual upx_off_t st_size() const override; // { return _length; }
+    virtual void set_extent(upx_off_t offset, upx_off_t length) override;
+    upx_off_t unset_extent(); // returns actual length
 
-    // FIXME - these won't work when using the `--stdout' option
+    upx_off_t getBytesWritten() const { return bytes_written; }
-    virtual void seek(off_t off, int whence)
+
-    {
+    // FIXME - these won't work when using the '--stdout' option
-        assert(!opt->to_stdout);
+    void rewrite(SPAN_P(const void) buf, int len);
-        super::seek(off,whence);
-    }
-    virtual void rewrite(const void *buf, int len)
-    {
-        assert(!opt->to_stdout);
-        write(buf, len);
-        bytes_written -= len;       // restore
-    }
 
     // util
-    static void dump(const char *name, const void *buf, int len, int flags=-1);
+    static void dump(const char *name, SPAN_P(const void) buf, int len, int flags = -1);
 
 protected:
-    off_t bytes_written;
+    upx_off_t bytes_written = 0;
 };
 
+#endif
 
-/*************************************************************************
+/* vim:set ts=4 sw=4 et: */
-//
-**************************************************************************/
-
-#if 0 /* NOT USED */
-class MemoryOutputFile : public FileBase
-{
-    typedef FileBase super;
-public:
-    MemoryOutputFile();
-    virtual ~MemoryOutputFile() { b = NULL; }
-
-    virtual bool close() { b = NULL; return true; }
-    virtual bool isOpen() const { return b != NULL; }
-    virtual void open(void *buf, unsigned size)
-        { b = (upx_bytep) buf; b_size = size; }
-
-    virtual void write(const void *buf, int len);
-
-    off_t getBytesWritten() const { return bytes_written; }
-
-protected:
-    upx_bytep b;
-    unsigned b_size;
-    unsigned b_pos;
-    off_t bytes_written;
-};
-#endif /* if 0 */
-
-
-#endif /* already included */
-
-
-/*
-vi:ts=4:et
-*/
-

src/filter.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -61,19 +61,19 @@ const FilterImp::FilterEntry *FilterImp::getFilter(int id)
         memset(filter_map, 0xff, sizeof(filter_map));
         for (int i = 0; i < n_filters; i++)
         {
-            int fid = filters[i].id;
+            int filter_id = filters[i].id;
-            assert(fid >= 0 && fid <= 255);
+            assert(filter_id >= 0 && filter_id <= 255);
-            assert(filter_map[fid] == 0xff);
+            assert(filter_map[filter_id] == 0xff);
-            filter_map[fid] = (unsigned char) i;
+            filter_map[filter_id] = (unsigned char) i;
         }
         done = true;
     }
 
     if (id < 0 || id > 255)
-        return NULL;
+        return nullptr;
     unsigned index = filter_map[id];
     if (index == 0xff)                  // empty slot
-        return NULL;
+        return nullptr;
     assert(filters[index].id == id);
     return &filters[index];
 }
@@ -82,7 +82,21 @@ const FilterImp::FilterEntry *FilterImp::getFilter(int id)
 bool Filter::isValidFilter(int filter_id)
 {
     const FilterImp::FilterEntry * const fe = FilterImp::getFilter(filter_id);
-    return fe != NULL;
+    return fe != nullptr;
+}
+
+bool Filter::isValidFilter(int filter_id, const int *allowed_filters)
+{
+    if (!isValidFilter(filter_id))
+        return false;
+    if (filter_id == 0)
+        return true;
+    if (allowed_filters == nullptr)
+        return false;
+    while (*allowed_filters != FT_END)
+        if (*allowed_filters++ == filter_id)
+            return true;
+    return false;
 }
 
 
@@ -93,10 +107,10 @@ bool Filter::isValidFilter(int filter_id)
 void Filter::init(int id_, unsigned addvalue_)
 {
     this->id = id_;
-    initFilter(this, NULL, 0);
+    initFilter(this, nullptr, 0);
     // clear input parameters
     this->addvalue = addvalue_;
-    this->preferred_ctos = NULL;
+    this->preferred_ctos = nullptr;
     // clear input/output parameters
     this->cto = 0;
     this->n_mru = 0;
@@ -108,7 +122,7 @@ bool Filter::filter(upx_byte *buf_, unsigned buf_len_)
     initFilter(this, buf_, buf_len_);
 
     const FilterImp::FilterEntry * const fe = FilterImp::getFilter(id);
-    if (fe == NULL)
+    if (fe == nullptr)
         throwInternalError("filter-1");
     if (fe->id == 0)
         return true;
@@ -141,7 +155,7 @@ void Filter::unfilter(upx_byte *buf_, unsigned buf_len_, bool verify_checksum)
     initFilter(this, buf_, buf_len_);
 
     const FilterImp::FilterEntry * const fe = FilterImp::getFilter(id);
-    if (fe == NULL)
+    if (fe == nullptr)
         throwInternalError("unfilter-1");
     if (fe->id == 0)
         return;
@@ -193,7 +207,7 @@ bool Filter::scan(const upx_byte *buf_, unsigned buf_len_)
     initFilter(this, b, buf_len_);
 
     const FilterImp::FilterEntry * const fe = FilterImp::getFilter(id);
-    if (fe == NULL)
+    if (fe == nullptr)
         throwInternalError("scan-1");
     if (fe->id == 0)
         return true;
@@ -214,8 +228,4 @@ bool Filter::scan(const upx_byte *buf_, unsigned buf_len_)
     return false;
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/filter.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   markus@oberhumer.com      ml1050@users.sourceforge.net
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_FILTER_H
-#define __UPX_FILTER_H
+#define __UPX_FILTER_H 1
 
 class Filter;
 class FilterImp;
@@ -62,12 +62,13 @@ public:
     bool scan(const upx_byte *buf, unsigned buf_len);
 
     static bool isValidFilter(int filter_id);
+    static bool isValidFilter(int filter_id, const int *allowed_filters);
 
 public:
     // Will be set by each call to filter()/unfilter().
     // Read-only afterwards.
-    upx_byte *buf;
+    upx_byte *buf = nullptr;
-    unsigned buf_len;
+    unsigned buf_len = 0;
 
     // Checksum of the buffer before applying the filter
     // or after un-applying the filter.
@@ -75,7 +76,7 @@ public:
 
     // Input parameters used by various filters.
     unsigned addvalue;
-    const int *preferred_ctos;
+    const int *preferred_ctos = nullptr;
 
     // Input/output parameters used by various filters
     unsigned char cto;              // call trick offset
@@ -130,8 +131,4 @@ private:
 
 #endif /* already included */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/filter/ct.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -459,7 +459,45 @@ static int s_ct24arm_be(Filter *f)
 #undef CT24ARM_BE
 #undef ARMCT_COND
 
-/*
+/*************************************************************************
-vi:ts=4:et:nowrap
+// 26-bit ARM calltrick ("naive")
-*/
+**************************************************************************/
 
+#define CT26ARM_LE(f, cond, addvalue, get, set) \
+    upx_byte *b = f->buf; \
+    upx_byte *b_end = b + f->buf_len - 4; \
+    do { \
+        if (cond) \
+        { \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b) + (addvalue)); \
+            f->calls++; \
+        } \
+        b += 4; \
+    } while (b < b_end); \
+    if (f->lastcall) f->lastcall += 4; \
+    return 0;
+
+
+#define ARMCT_COND (((b[3] & 0x7C) == 0x14))
+
+static int f_ct26arm_le(Filter *f)
+{
+    CT26ARM_LE(f, ARMCT_COND, a / 4 + f->addvalue, get_le26, set_le26)
+}
+
+static int u_ct26arm_le(Filter *f)
+{
+    CT26ARM_LE(f, ARMCT_COND, 0 - a / 4 - f->addvalue, get_le26, set_le26)
+}
+
+static int s_ct26arm_le(Filter *f)
+{
+    CT26ARM_LE(f, ARMCT_COND, a + f->addvalue, get_le26, set_dummy)
+}
+
+#undef CT26ARM_LE
+#undef ARMCT_COND
+
+/* vim:set ts=4 sw=4 et: */

src/filter/cto.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -47,7 +47,7 @@ static int F(Filter *f)
     unsigned calls = 0, noncalls = 0, noncalls2 = 0;
     unsigned lastnoncall = size, lastcall = 0;
 
-    // find a 16MB large empty address space
+    // find a 16 MiB large empty address space
     {
         unsigned char buf[256];
         memset(buf,0,256);
@@ -58,8 +58,16 @@ static int F(Filter *f)
         // must not conflict with the mark.
         // Note that unsigned comparison checks both edges of buffer.
         for (ic = 0; ic < size - 5; ic++)
-            if (COND(b,ic) && get_le32(b+ic+1)+ic+1 >= size)
         {
+            if (!COND(b,ic))
+                continue;
+            jc = get_le32(b+ic+1)+ic+1;
+            if (jc < size)
+            {
+                if (jc + addvalue >= (1u << 24)) // hi 8 bits won't be cto8
+                    return -1;
+            }
+            else
                 buf[b[ic+1]] |= 1;
         }
 
@@ -79,8 +87,7 @@ static int F(Filter *f)
         // try to detect 'real' calls only
         if (jc < size)
         {
-            if ((1u<<24)<=(jc+addvalue))  // hi 8 bits won't be cto8
+            assert(jc + addvalue < (1u << 24)); // hi 8 bits won't be cto8
-                return 1;  // fail - buffer not restored
 #ifdef U
             set_be32(b+ic+1,jc+addvalue+cto);
 #endif
@@ -119,9 +126,10 @@ static int F(Filter *f)
     f->noncalls = noncalls;
     f->lastcall = lastcall;
 
-#ifdef TESTING
+#if 0 || defined(TESTING)
     printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",calls,noncalls,noncalls2,size,cto);
 #endif
+    UNUSED(noncalls2);
     return 0;
 }
 
@@ -162,8 +170,4 @@ static int U(Filter *f)
 #undef F
 #undef U
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/ctoj.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
-   Copyright (C) 2000-2006 John F. Reiser
+   Copyright (C) 2000-2022 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -51,14 +51,22 @@ static int F(Filter *f)
     unsigned calls = 0, noncalls = 0, noncalls2 = 0;
     unsigned lastnoncall = size, lastcall = 0;
 
-    // find a 16MB large empty address space
+    // find a 16 MiB large empty address space
     {
         unsigned char buf[256];
         memset(buf,0,256);
 
         for (ic = 0; ic < size - 5; ic++)
-            if (COND(b,ic,lastcall) && get_le32(b+ic+1)+ic+1 >= size)
         {
+            if (!COND(b,ic,lastcall))
+                continue;
+            jc = get_le32(b+ic+1)+ic+1;
+            if (jc < size)
+            {
+                if (jc + addvalue >= (1u << 24)) // hi 8 bits won't be cto8
+                    return -1;
+            }
+            else
                 buf[b[ic+1]] |= 1;
         }
 
@@ -78,8 +86,7 @@ static int F(Filter *f)
         // try to detect 'real' calls only
         if (jc < size)
         {
-            if ((1u<<24)<=(jc+addvalue))  // hi 8 bits won't be cto8
+            assert(jc + addvalue < (1u << 24)); // hi 8 bits won't be cto8
-                return 1;  // fail - buffer not restored
 #ifdef U
             set_be32(b+ic+1,jc+addvalue+cto);
 #endif
@@ -118,9 +125,10 @@ static int F(Filter *f)
     f->noncalls = noncalls;
     f->lastcall = lastcall;
 
-#ifdef TESTING
+#if 0 || defined(TESTING)
     printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",calls,noncalls,noncalls2,size,cto);
 #endif
+    UNUSED(noncalls2);
     return 0;
 }
 
@@ -161,8 +169,4 @@ static int U(Filter *f)
 #undef F
 #undef U
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/ctojr.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
-   Copyright (C) 2000-2006 John F. Reiser
+   Copyright (C) 2000-2022 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -62,7 +62,7 @@ f80_jcc2(Filter const *f)
     return f80_jmp1(f);
 }
 
-static int const N_MRU = 32;  // does not have to be a power of 2
+#define N_MRU 32    // does not have to be a power of 2
 
 // Adaptively remember recent destinations.
 static void
@@ -123,8 +123,8 @@ static int F(Filter *f)
         N_MRU : 0;
 #endif  //}
 
-    // FIXME: We must fit into 8MB because we steal one bit.
+    // FIXME: We must fit into 8 MiB because we steal one bit.
-    // find a 16MB large empty address space
+    // find a 16 MiB large empty address space
     {
         int which;
         unsigned char buf[256];
@@ -249,11 +249,12 @@ static int F(Filter *f)
     f->noncalls = noncalls;
     f->lastcall = lastcall;
 
-/*#ifdef TESTING*/
+#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*/
+#endif
+    UNUSED(noncalls2);
     return 0;
 }
 
@@ -300,6 +301,9 @@ static int U(Filter *f)
                         }
                         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;
@@ -337,12 +341,8 @@ static int U(Filter *f)
 }
 #endif
 
-
+#undef N_MRU
 #undef F
 #undef U
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/ctok.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
-   Copyright (C) 2000-2006 John F. Reiser
+   Copyright (C) 2000-2022 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -52,14 +52,22 @@ static int F(Filter *f)
     unsigned calls = 0, noncalls = 0, noncalls2 = 0;
     unsigned lastnoncall = size, lastcall = 0;
 
-    // find a 16MB large empty address space
+    // find a 16 MiB large empty address space
     {
         unsigned char buf[256];
         memset(buf,0,256);
 
         for (ic = 0; ic < size - 5; ic++)
-            if (COND(b,ic,lastcall,id) && get_le32(b+ic+1)+ic+1 >= size)
         {
+            if (!COND(b,ic,lastcall,id))
+                continue;
+            jc = get_le32(b+ic+1)+ic+1;
+            if (jc < size)
+            {
+                if (jc + addvalue >= (1u << 24)) // hi 8 bits won't be cto8
+                    return -1;
+            }
+            else
                 buf[b[ic+1]] |= 1;
         }
 
@@ -79,8 +87,7 @@ static int F(Filter *f)
         // try to detect 'real' calls only
         if (jc < size)
         {
-            if ((1u<<24)<=(jc+addvalue))  // hi 8 bits won't be cto8
+            assert(jc + addvalue < (1u << 24)); // hi 8 bits won't be cto8
-                return 1;  // fail - buffer not restored
 #ifdef U
             set_be32(b+ic+1,jc+addvalue+cto);
 #endif
@@ -119,9 +126,10 @@ static int F(Filter *f)
     f->noncalls = noncalls;
     f->lastcall = lastcall;
 
-#ifdef TESTING
+#if 0 || defined(TESTING)
     printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",calls,noncalls,noncalls2,size,cto);
 #endif
+    UNUSED(noncalls2);
     return 0;
 }
 
@@ -164,8 +172,4 @@ static int U(Filter *f)
 #undef F
 #undef U
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/ctsw.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -166,8 +166,4 @@ static int s_ctsw32_e9_e8(Filter *f)
 
 #undef CTSW32
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/getcto.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -67,9 +67,4 @@ static int getcto(Filter *f, const unsigned char *buf, const int n=256)
     return ic;
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/ppcbxx.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
-   Copyright (C) 2004-2006 John F. Reiser
+   Copyright (C) 2004-2022 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -47,7 +47,7 @@ static int F(Filter *f)
     // scan
     const upx_byte *b = f->buf;
 #endif
-    const unsigned size  = umin(f->buf_len, -(~0u<<(32 - (6+ W_CTO))));
+    const unsigned size  = umin(f->buf_len, 0u - (~0u<<(32 - (6+ W_CTO))));
     const unsigned size4 = size -4;
 
     unsigned ic;
@@ -58,7 +58,7 @@ static int F(Filter *f)
     {
         unsigned char buf[256];
         unsigned short wbuf[256];
-        const size_t WW = (size_t)0 - (~(size_t)0) << W_CTO; // ???
+        const size_t WW = (size_t)0 - ((~(size_t)0) << W_CTO); // ???
         memset(wbuf, 0, sizeof(wbuf));
         memset(buf     , 0,       WW);
         memset(buf + WW, 1, 256 - WW);
@@ -72,9 +72,11 @@ static int F(Filter *f)
         }
 
         if (getcto(f, buf) < 0) {
-            if (0!=W_CTO)  // FIXME: what is this ???
+#if (W_CTO != 0)
             return -1;
+#else
             f->cto = 0;
+#endif
         }
     }
     const unsigned char cto8 = f->cto;
@@ -95,8 +97,9 @@ static int F(Filter *f)
             lastcall = ic;
         }
         else {
-            assert(0==W_CTO  // FIXME: what is this ???
+#if (W_CTO != 0)
-            || (~(~0u<<W_CTO) & (word>>(24+2 - W_CTO))) != cto8);  // this should not happen
+            assert((~(~0u<<W_CTO) & (word>>(24+2 - W_CTO))) != (unsigned) cto8);  // this should not happen
+#endif
             lastnoncall = ic;
             noncalls++;
         }
@@ -105,8 +108,9 @@ static int F(Filter *f)
     f->calls = calls;
     f->noncalls = noncalls;
     f->lastcall = lastcall;
+    ACC_UNUSED(lastnoncall);
 
-#if 0
+#if 0 || defined(TESTING)
     printf("\ncalls=%d noncalls=%d text_size=%x calltrickoffset=%x\n",
         calls,noncalls,size,cto8);
 #endif
@@ -122,14 +126,14 @@ static int F(Filter *f)
 static int U(Filter *f)
 {
     upx_byte *b = f->buf;
-    const unsigned size4 = umin(f->buf_len - 4, -(~0u<<(32 - (6+ W_CTO))));
+    const unsigned size4 = umin(f->buf_len - 4, 0u - (~0u<<(32 - (6+ W_CTO))));
     const unsigned addvalue = f->addvalue;
 
     unsigned ic;
 
    for (ic = 0; ic<=size4; ic+=4) if (COND(b,ic)) {
         unsigned const word = get_be32(b+ic);
-        if ((~(~0u<<W_CTO) & (word>>(24+2 - W_CTO))) == f->cto) {
+        if ((~(~0u<<W_CTO) & (word>>(24+2 - W_CTO))) == (unsigned) f->cto) {
             unsigned const jc = word & (~(~0u<<(26 - W_CTO)) & (~0u<<2));
             set_be32(b+ic, (0xfc000003&word)|(0x03fffffc&(jc-ic-addvalue)));
             f->calls++;
@@ -149,7 +153,4 @@ static int U(Filter *f)
 
 #undef W_CTO
 
-/*
+/* vim:set ts=4 sw=4 et: */
-vi:ts=4:et:nowrap
-*/
-

src/filter/sub.hh

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -79,9 +79,4 @@
     assert((int)f->calls > 0); \
     return 0;
 
-
+/* vim:set ts=4 sw=4 et: */
-
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/sub16.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -115,8 +115,4 @@ static int s_sub16_4(Filter *f)
 #undef ADD16
 #undef SCAN16
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/sub32.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -115,8 +115,4 @@ static int s_sub32_4(Filter *f)
 #undef ADD32
 #undef SCAN32
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/sub8.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -115,8 +115,4 @@ static int s_sub8_4(Filter *f)
 #undef ADD8
 #undef SCAN8
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filter/sw.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -180,9 +180,4 @@ static int s_sw32_e8e9(Filter *f)
 
 #undef SW32
 
-
+/* vim:set ts=4 sw=4 et: */
-
-/*
-vi:ts=4:et:nowrap
-*/
-

src/filteri.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   markus@oberhumer.com      ml1050@users.sourceforge.net
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -170,7 +170,7 @@ umin(unsigned const a, unsigned const b)
 
 const FilterImp::FilterEntry FilterImp::filters[] = {
     // no filter
-    { 0x00, 0,          0, NULL, NULL, NULL },
+    { 0x00, 0,          0, nullptr, nullptr, nullptr },
 
     // 16-bit calltrick
     { 0x01, 4,          0, f_ct16_e8, u_ct16_e8, s_ct16_e8 },
@@ -228,6 +228,9 @@ const FilterImp::FilterEntry FilterImp::filters[] = {
     { 0x50, 8, 0x01ffffff, f_ct24arm_le, u_ct24arm_le, s_ct24arm_le },
     { 0x51, 8, 0x01ffffff, f_ct24arm_be, u_ct24arm_be, s_ct24arm_be },
 
+    // 26-bit calltrick for arm64
+    { 0x52, 8, 0x03ffffff, f_ct26arm_le, u_ct26arm_le, s_ct26arm_le },
+
     // 32-bit cto calltrick with jmp and jcc(swap 0x0f/0x8Y) and relative renumbering
     { 0x80, 8, 0x00ffffff, f_ctojr32_e8e9_bswap_le, u_ctojr32_e8e9_bswap_le, s_ctojr32_e8e9_bswap_le },
     { 0x81, 8, 0x00ffffff, f_ctojr32_e8e9_bswap_le, u_ctojr32_e8e9_bswap_le, s_ctojr32_e8e9_bswap_le },
@@ -260,8 +263,4 @@ const FilterImp::FilterEntry FilterImp::filters[] = {
 
 const int FilterImp::n_filters = TABLESIZE(filters);
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/help.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,11 +22,14 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
+#include "compress.h"
+#include "packmast.h"
+#include "packer.h"
 
 
 /*************************************************************************
@@ -35,6 +38,12 @@
 
 static bool head_done = 0;
 
+#if defined(UPX_VERSION_GITREV)
+const char gitrev[] = UPX_VERSION_GITREV;
+#else
+const char gitrev[1] = { 0 };
+#endif
+
 void show_head(void)
 {
     FILE *f = con_term;
@@ -44,18 +53,19 @@ void show_head(void)
         return;
     head_done = 1;
 
-#define V(x)    (strcmp(UPX_VERSION_STRING, UPX_VERSION_STRING4) ? UPX_VERSION_STRING : UPX_VERSION_STRING x)
     fg = con_fg(f,FG_GREEN);
     con_fprintf(f,
                 "                       Ultimate Packer for eXecutables\n"
-                "    Copyright (C) 1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006\n"
+                "                          Copyright (C) 1996 - " UPX_VERSION_YEAR "\n"
-                "UPX %-10s  Markus Oberhumer, Laszlo Molnar & John Reiser  %14s\n\n",
+#if defined(UPX_VERSION_GITREV)
-#if (ACC_OS_DOS16 || ACC_OS_DOS32)
+                "UPX git-%6.6s%c"
-                V("d"),
+#else
-#elif (ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
+                "UPX %-11s"
-                V("w"),
+#endif
-#elif 0 && defined(__linux__)
+                " Markus Oberhumer, Laszlo Molnar & John Reiser  %14s\n\n",
-                V("l"),
+#if defined(UPX_VERSION_GITREV)
+                gitrev,
+                (sizeof(gitrev)-1 > 6 && gitrev[sizeof(gitrev)-2] == '+') ? '+' : ' ',
 #else
                 UPX_VERSION_STRING,
 #endif
@@ -76,7 +86,7 @@ void show_usage(void)
     FILE *f = con_term;
 
     con_fprintf(f,"Usage: %s [-123456789dlthVL] [-qvfk] [-o file] %sfile..\n", progname,
-#if defined(__DJGPP__) || defined(__EMX__)
+#if (ACC_OS_DOS32) && defined(__DJGPP__)
                 "[@]");
 #else
                 "");
@@ -88,7 +98,79 @@ void show_usage(void)
 //
 **************************************************************************/
 
-void show_help(int x)
+struct PackerNames
+{
+    struct Entry {
+        const char* fname;
+        const char* sname;
+    };
+    Entry names[64];
+    size_t names_count;
+    const options_t *o;
+    PackerNames() : names_count(0), o(nullptr) { }
+    void add(const Packer *p)
+    {
+        p->assertPacker();
+        assert(names_count < 64);
+        names[names_count].fname = p->getFullName(o);
+        names[names_count].sname = p->getName();
+        names_count++;
+    }
+    static Packer* visit(Packer *p, void *user)
+    {
+        PackerNames *self = (PackerNames *) user;
+        self->add(p);
+        delete p; p = nullptr;
+        return nullptr;
+    }
+    static int __acc_cdecl_qsort cmp_fname(const void *a, const void *b) {
+        return strcmp(((const Entry *) a)->fname, ((const Entry *) b)->fname);
+    }
+    static int __acc_cdecl_qsort cmp_sname(const void *a, const void *b) {
+        return strcmp(((const Entry *) a)->sname, ((const Entry *) b)->sname);
+    }
+};
+
+static void show_all_packers(FILE *f, int verbose)
+{
+    options_t o; o.reset();
+    PackerNames pn; pn.o = &o;
+    PackMaster::visitAllPackers(PackerNames::visit, nullptr, &o, &pn);
+    qsort(pn.names, pn.names_count, sizeof(PackerNames::Entry), PackerNames::cmp_fname);
+    size_t pos = 0;
+    for (size_t i = 0; i < pn.names_count; ++i)
+    {
+        const char *fn = pn.names[i].fname;
+        const char *sn = pn.names[i].sname;
+        if (verbose > 0)
+        {
+            con_fprintf(f, "    %-36s %s\n", fn, sn);
+        }
+        else
+        {
+            size_t fl = strlen(fn);
+            if (pos == 0) {
+                con_fprintf(f, "  %s", fn);
+                pos = 2 + fl;
+            } else if (pos + 1 + fl > 80) {
+                con_fprintf(f, "\n  %s", fn);
+                pos = 2 + fl;
+            } else {
+                con_fprintf(f, " %s", fn);
+                pos += 1 + fl;
+            }
+        }
+    }
+    if (verbose <= 0 && pn.names_count)
+        con_fprintf(f, "\n");
+}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+void show_help(int verbose)
 {
     FILE *f = con_term;
     int fg;
@@ -105,8 +187,8 @@ void show_help(int x)
                 "  -d     decompress                        -l    list compressed file\n"
                 "  -t     test compressed file              -V    display version number\n"
                 "  -h     give %s help                    -L    display software license\n%s",
-                x == 0 ? "" : "  --best compress best (can be slow for big files)\n",
+                verbose == 0 ? "" : "  --best compress best (can be slow for big files)\n",
-                x == 0 ? "more" : "this", x == 0 ? "" : "\n");
+                verbose == 0 ? "more" : "this", verbose == 0 ? "" : "\n");
 
     fg = con_fg(f,FG_YELLOW);
     con_fprintf(f,"Options:\n");
@@ -114,22 +196,30 @@ void show_help(int x)
 
     con_fprintf(f,
                 "  -q     be quiet                          -v    be verbose\n"
-                "  -oFILE write output to `FILE'\n"
+                "  -oFILE write output to 'FILE'\n"
                 //"  -f     force overwrite of output files and compression of suspicious files\n"
                 "  -f     force compression of suspicious files\n"
                 "%s%s"
-                , (x == 0) ? "  -k     keep backup files\n" : ""
+                , (verbose == 0) ? "  -k     keep backup files\n" : ""
 #if 1
-                , (x > 0) ? "  --no-color, --mono, --color, --no-progress   change look\n" : ""
+                , (verbose > 0) ? "  --no-color, --mono, --color, --no-progress   change look\n" : ""
 #else
                 , ""
 #endif
                 );
 
-    if (x > 0)
+    if (verbose > 0)
     {
         fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"\nBackup options:\n");
+        con_fprintf(f,"\nCompression tuning options:\n");
+        fg = con_fg(f,fg);
+        con_fprintf(f,
+                    "  --lzma              try LZMA [slower but tighter than NRV]\n"
+                    "  --brute             try all available compression methods & filters [slow]\n"
+                    "  --ultra-brute       try even more compression variants [very slow]\n"
+                    "\n");
+        fg = con_fg(f,FG_YELLOW);
+        con_fprintf(f,"Backup options:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  -k, --backup        keep backup files\n"
@@ -144,26 +234,16 @@ void show_help(int x)
                     "  --overlay=skip      don't compress a file with an overlay\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"Options for atari/tos:\n");
-        fg = con_fg(f,fg);
-        con_fprintf(f,
-                    "  --all-methods       try all available compression methods\n"
-                    "\n");
-        fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for djgpp2/coff:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  --coff              produce COFF output [default: EXE]\n"
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for dos/com:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  --8086              make compressed com work on any 8086\n"
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for dos/exe:\n");
@@ -171,57 +251,30 @@ void show_help(int x)
         con_fprintf(f,
                     "  --8086              make compressed exe work on any 8086\n"
                     "  --no-reloc          put no relocations in to the exe header\n"
-                    "  --all-methods       try all available compression methods\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for dos/sys:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  --8086              make compressed sys work on any 8086\n"
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
                     "\n");
-#if 0
-        fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"Options for linux/386\n");
-        fg = con_fg(f,fg);
-        con_fprintf(f,
-                    "  --script             use /usr/local/lib/upx/upx[bd] as decompressor\n"
-                    "  --script=/path/upxX  use path/upxX as decompressor\n"
-                    "\n");
-#endif
         fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for ps1/exe:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
-                    "  --all-methods       try all available compression methods\n"
                     "  --8-bit             uses 8 bit size compression [default: 32 bit]\n"
-                    "  --8mb-ram           8 megabyte memory limit [default: 2 mb]\n"
+                    "  --8mib-ram          8 megabyte memory limit [default: 2 MiB]\n"
                     "  --boot-only         disables client/host transfer compatibility\n"
                     "  --no-align          don't align to 2048 bytes [enables: --console-run]\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"Options for tmt/adam:\n");
-        fg = con_fg(f,fg);
-        con_fprintf(f,
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
-                    "\n");
-        fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"Options for vmlinuz/386\n");
-        fg = con_fg(f,fg);
-        con_fprintf(f,
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
-                    "\n");
-        fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for watcom/le:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  --le                produce LE output [default: EXE]\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"Options for win32/pe & rtm32/pe:\n");
+        con_fprintf(f,"Options for win32/pe, win64/pe, rtm32/pe & arm/pe:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  --compress-exports=0    do not compress the export section\n"
@@ -229,60 +282,45 @@ void show_help(int x)
                     "  --compress-icons=0      do not compress any icons\n"
                     "  --compress-icons=1      compress all but the first icon\n"
                     "  --compress-icons=2      compress all but the first icon directory [default]\n"
+                    "  --compress-icons=3      compress all icons\n"
                     "  --compress-resources=0  do not compress any resources at all\n"
                     "  --keep-resource=list    do not compress resources specified by list\n"
                     "  --strip-relocs=0        do not strip relocations\n"
                     "  --strip-relocs=1        strip relocations [default]\n"
-                    "  --all-methods           try all available compression methods\n"
+                    "\n");
-                    "  --all-filters           try all available preprocessing filters\n"
+        fg = con_fg(f,FG_YELLOW);
+        con_fprintf(f,"Options for linux/elf:\n");
+        fg = con_fg(f,fg);
+        con_fprintf(f,
+                    "  --preserve-build-id     copy .gnu.note.build-id to compressed output\n"
                     "\n");
     }
 
-    con_fprintf(f,
+    con_fprintf(f, "file..   executables to (de)compress\n");
-                "file..   executables to (de)compress\n"
+
-                "\n");
+    if (verbose > 0)
+    {
         fg = con_fg(f,FG_YELLOW);
-    con_fprintf(f,"This version supports:\n");
+        con_fprintf(f,"\nThis version supports:\n");
         fg = con_fg(f,fg);
-    con_fprintf(f,"   "
+        show_all_packers(f, verbose);
-// TODO:
+    }
-// support for mach/ppc32
+    else
-// support for linux elf/ppc32
+    {
-// support for linux elf/amd64
+        con_fprintf(f,"\nType '%s --help' for more detailed help.\n", progname);
-                " arm/pe,"
+    }
-                " atari/tos,"
+
-                " bvmlinuz/386,"
+    con_fprintf(f,"\nUPX comes with ABSOLUTELY NO WARRANTY; for details visit https://upx.github.io\n"
-                " djgpp2/coff,"
+//                "\nUPX comes with ABSOLUTELY NO WARRANTY; for details type 'upx -L'.\n"
-                " dos/com,"
-                " dos/exe,"
-                " dos/sys,"
-                "\n   "
-                //" elks/8086,"
-                " linux/amd64,"
-                " linux/i386,"
-                " linux/ppc32,"
-                " mach/ppc32,"
-                " ps1/exe,"
-                " rtm32/pe,"
-                "\n   "
-                " tmt/adam,"
-                " vmlinux/386,"
-                " vmlinuz/386,"
-                " watcom/le,"
-                //" win16/ne,"
-                " win32/pe"
-                "\n\nUPX comes with ABSOLUTELY NO WARRANTY; for details visit http://upx.sf.net\n"
-//                "\n\nUPX comes with ABSOLUTELY NO WARRANTY; for details type `upx -L'.\n"
                 "");
 
-
+#if DEBUG || TESTING
-#if defined(DEBUG) || defined(TESTING)
     fg = con_fg(f,FG_RED);
     con_fprintf(f,"\nWARNING: this version is compiled with"
-#if defined(DEBUG)
+#if DEBUG
                 " -DDEBUG"
 #endif
-#if defined(TESTING)
+#if TESTING
                 " -DTESTING"
 #endif
                 "\n");
@@ -310,23 +348,23 @@ void show_license(void)
         "   This program is distributed in the hope that it will be useful,\n"
         "   but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
         "   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n"
-        "   UPX License Agreement for more details.\n"
+        "   UPX License Agreements for more details.\n"
         "\n"
-        "   You should have received a copy of the UPX License Agreement\n"
+        "   You should have received a copy of the UPX License Agreements\n"
-        "   along with this program; see the file LICENSE.\n"
+        "   along with this program; see the files COPYING and LICENSE.\n"
         "   If not, visit one of the following pages:\n"
         "\n"
     );
     int fg = con_fg(f,FG_CYAN);
     con_fprintf(f,
-        "        http://upx.sourceforge.net\n"
+        "        https://upx.github.io\n"
-        "        http://www.oberhumer.com/opensource/upx/\n"
+        "        https://www.oberhumer.com/opensource/upx/\n"
     );
     (void)con_fg(f,FG_ORANGE);
     con_fprintf(f,
         "\n"
         "   Markus F.X.J. Oberhumer              Laszlo Molnar\n"
-        "   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>\n"
+        "   <markus@oberhumer.com>               <ezerotven+github@gmail.com>\n"
     );
     fg = con_fg(f,fg);
 
@@ -338,33 +376,55 @@ void show_license(void)
 //
 **************************************************************************/
 
-void show_version(int x)
+void show_version(bool one_line)
 {
-    FILE *f = stdout;
+    FILE *fp = stdout;
-    UNUSED(x);
+    const char *v;
 
-    fprintf(f,"upx %s\n", UPX_VERSION_STRING);
+    fprintf(fp, "upx %s\n", UPX_VERSION_STRING
-#if defined(WITH_NRV)
+#if defined(UPX_VERSION_GITREV)
-    fprintf(f,"NRV data compression library %s\n", nrv_version_string());
+            "-git-" UPX_VERSION_GITREV
 #endif
-#if defined(WITH_UCL)
+           );
-    fprintf(f,"UCL data compression library %s\n", ucl_version_string());
+    if (one_line)
+        return;
+#if (WITH_NRV)
+    v = upx_nrv_version_string();
+    if (v != nullptr && v[0])
+        fprintf(fp, "NRV data compression library %s\n", v);
 #endif
-#if 0 && defined(WITH_LZMA)
+#if (WITH_UCL)
-    fprintf(f,"LZMA SDK version ???\n");
+    v = upx_ucl_version_string();
+    if (v != nullptr && v[0])
+        fprintf(fp, "UCL data compression library %s\n", v);
 #endif
-    fprintf(f,"Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer\n");
+#if (WITH_ZLIB)
-    fprintf(f,"Copyright (C) 1996-2006 Laszlo Molnar\n");
+    v = upx_zlib_version_string();
-    fprintf(f,"Copyright (C) 2000-2006 John F. Reiser\n");
+    if (v != nullptr && v[0])
-    fprintf(f,"Copyright (C) 2002-2006 Jens Medoch\n");
+        fprintf(fp, "zlib data compression library %s\n", v);
-#if defined(WITH_LZMA)
-    fprintf(f,"Copyright (C) 1999-2006 Igor Pavlov\n");
 #endif
-    fprintf(f,"UPX comes with ABSOLUTELY NO WARRANTY; for details type `%s -L'.\n", progname);
+#if (WITH_LZMA)
+    v = upx_lzma_version_string();
+    if (v != nullptr && v[0])
+        fprintf(fp, "LZMA SDK version %s\n", v);
+#endif
+#if !defined(DOCTEST_CONFIG_DISABLE)
+    fprintf(fp, "doctest C++ testing framework version %s\n", DOCTEST_VERSION_STR);
+#endif
+    fprintf(fp, "Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer\n");
+    fprintf(fp, "Copyright (C) 1996-2022 Laszlo Molnar\n");
+    fprintf(fp, "Copyright (C) 2000-2022 John F. Reiser\n");
+    fprintf(fp, "Copyright (C) 2002-2022 Jens Medoch\n");
+#if (WITH_ZLIB)
+    fprintf(fp, "Copyright (C) 1995" "-2022 Jean-loup Gailly and Mark Adler\n");
+#endif
+#if (WITH_LZMA)
+    fprintf(fp, "Copyright (C) 1999" "-2006 Igor Pavlov\n");
+#endif
+#if !defined(DOCTEST_CONFIG_DISABLE)
+    fprintf(fp, "Copyright (C) 2016" "-2021 Viktor Kirilov\n");
+#endif
+    fprintf(fp, "UPX comes with ABSOLUTELY NO WARRANTY; for details type '%s -L'.\n", progname);
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/lefile.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,18 +22,18 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 #include "file.h"
-#include "mem.h"
+#include "util/membuffer.h"
 #include "lefile.h"
 
 
 LeFile::LeFile(InputFile *f) :
-    fif(f), fof(NULL),
+    fif(f), fof(nullptr),
     le_offset(0), exe_offset(0)
 {
     COMPILE_TIME_ASSERT(sizeof(le_header_t) == 196);
@@ -41,13 +41,13 @@ LeFile::LeFile(InputFile *f) :
     COMPILE_TIME_ASSERT(sizeof(le_pagemap_entry_t) == 4);
     memset(&ih,0,sizeof ih);
     memset(&oh,0,sizeof oh);
-    iobject_table = oobject_table = NULL;
+    iobject_table = oobject_table = nullptr;
-    ifpage_table = ofpage_table = NULL;
+    ifpage_table = ofpage_table = nullptr;
-    ipm_entries = opm_entries = NULL;
+    ipm_entries = opm_entries = nullptr;
-    ires_names = ores_names = NULL;
+    ires_names = ores_names = nullptr;
-    ifixups = ofixups = NULL;
+    ifixups = ofixups = nullptr;
-    inonres_names = ononres_names = NULL;
+    inonres_names = ononres_names = nullptr;
-    ientries = oentries = NULL;
+    ientries = oentries = nullptr;
 }
 
 
@@ -77,7 +77,8 @@ LeFile::~LeFile()
 
 void LeFile::readObjectTable()
 {
-    iobject_table = new le_object_table_entry_t[soobject_table = objects];
+    soobject_table = objects;
+    iobject_table = New(le_object_table_entry_t, soobject_table);
     fif->seek(le_offset + ih.object_table_offset,SEEK_SET);
     fif->readx(iobject_table,sizeof(*iobject_table)*objects);
 }
@@ -92,7 +93,8 @@ void LeFile::writeObjectTable()
 
 void LeFile::readPageMap()
 {
-    ipm_entries = new le_pagemap_entry_t[sopm_entries = pages];
+    sopm_entries = pages;
+    ipm_entries = New(le_pagemap_entry_t, sopm_entries);
     fif->seek(le_offset + ih.object_pagemap_offset,SEEK_SET);
     fif->readx(ipm_entries,sizeof(*ipm_entries)*pages);
 
@@ -112,7 +114,7 @@ void LeFile::writePageMap()
 void LeFile::readResidentNames()
 {
     sores_names = ih.entry_table_offset - ih.resident_names_offset;
-    ires_names = new upx_byte[sores_names];
+    ires_names = New(upx_byte, sores_names);
     fif->seek(le_offset+ih.resident_names_offset,SEEK_SET);
     fif->readx(ires_names,sores_names);
 }
@@ -129,7 +131,7 @@ void LeFile::readEntryTable()
 {
     soentries = ih.fixup_page_table_offset - ih.entry_table_offset;
     fif->seek(le_offset + ih.entry_table_offset,SEEK_SET);
-    ientries = new upx_byte[soentries];
+    ientries = New(upx_byte, soentries);
     fif->readx(ientries,soentries);
 }
 
@@ -143,7 +145,8 @@ void LeFile::writeEntryTable()
 
 void LeFile::readFixupPageTable()
 {
-    ifpage_table = new unsigned[sofpage_table = 1+pages];
+    sofpage_table = 1+pages;
+    ifpage_table = New(unsigned, sofpage_table);
     fif->seek(le_offset + ih.fixup_page_table_offset,SEEK_SET);
     fif->readx(ifpage_table,4*sofpage_table);
 }
@@ -159,7 +162,7 @@ void LeFile::writeFixupPageTable()
 void LeFile::readFixups()
 {
     sofixups = get_le32(ifpage_table+pages)-get_le32(ifpage_table);
-    ifixups = new upx_byte[sofixups];
+    ifixups = New(upx_byte, sofixups);
     fif->seek(le_offset + ih.fixup_record_table_offset,SEEK_SET);
     fif->readx(ifixups,sofixups);
 }
@@ -187,8 +190,9 @@ unsigned LeFile::getImageSize() const
 void LeFile::readImage()
 {
     soimage = pages*mps;
-    iimage.alloc(soimage);
+    mb_iimage.alloc(soimage);
-    memset(iimage,0,soimage);
+    mb_iimage.clear();
+    iimage = mb_iimage;
 
     unsigned ic,jc;
     for (ic = jc = 0; ic < pages; ic++)
@@ -197,7 +201,8 @@ void LeFile::readImage()
         {
             fif->seek(ih.data_pages_offset + exe_offset +
                 (ipm_entries[ic].m*0x100 + ipm_entries[ic].l-1) * mps,SEEK_SET);
-            fif->readx(iimage+jc,ic != pages-1 ? mps : ih.bytes_on_last_page);
+            auto bytes = ic != pages-1 ? mps : ih.bytes_on_last_page;
+            fif->readx(raw_bytes(iimage+jc, bytes), bytes);
         }
         jc += mps;
     }
@@ -206,8 +211,8 @@ void LeFile::readImage()
 
 void LeFile::writeImage()
 {
-    if (fof && oimage != NULL)
+    if (fof && oimage != nullptr)
-        fof->write(oimage, soimage);
+        fof->write(raw_bytes(oimage, soimage), soimage);
 }
 
 
@@ -215,7 +220,8 @@ void LeFile::readNonResidentNames()
 {
     if (ih.non_resident_name_table_length)
     {
-        inonres_names = new upx_byte[sononres_names = ih.non_resident_name_table_length];
+        sononres_names = ih.non_resident_name_table_length;
+        inonres_names = New(upx_byte, sononres_names);
         fif->seek(exe_offset+ih.non_resident_name_table_offset,SEEK_SET);
         fif->readx(inonres_names,sononres_names);
     }
@@ -338,6 +344,7 @@ void LeFile::countFixups(unsigned *counts) const
                 break;
             case 6:       // 16:32 pointer
                 counts[o] += 9;
+                // fall through
             case 7:       // 32-bit offset
                 counts[fix[4]-1] += 4;
                 fix += (fix[1] & 0x10) ? 9 : 7;
@@ -360,8 +367,4 @@ void LeFile::countFixups(unsigned *counts) const
     counts[o+1] += 4; // extra space for 0xFFFFFFFF
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/lefile.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_LEFILE_H
-#define __UPX_LEFILE_H
+#define __UPX_LEFILE_H 1
 
 class InputFile;
 class OutputFile;
@@ -39,7 +39,7 @@ class OutputFile;
 
 class LeFile
 {
-public:
+protected:
     LeFile(InputFile *);
     virtual ~LeFile();
 
@@ -49,8 +49,8 @@ public:
 protected:
     enum { FIXUP_EXTRA = 3 };
 
-    struct le_header_t
+    __packed_struct(le_header_t)
-    {   // 0x00
+        // 0x00
         char  _[2];             // signature: 'LE' || 'LX'
         char  byte_order;       // 0 little endian
         char  word_order;       // 0 little endian
@@ -112,72 +112,67 @@ protected:
         LE32  extra_heap_alloc;
         char  reserved[12];
         LE32  versioninfo;
-        LE32  unkown;
+        LE32  unknown;
         // 0xC0
         LE16  device_id;
         LE16  ddk_version;
 #endif
-    }
+    __packed_struct_end()
-    __attribute_packed;
 
-    struct le_object_table_entry_t
+    __packed_struct(le_object_table_entry_t)
-    {
         LE32  virtual_size;
         LE32  base_address;
         LE32  flags;
         LE32  pagemap_index;
         LE32  npages;
         LE32  reserved;
-    }
+    __packed_struct_end()
-    __attribute_packed;
 
-    struct le_pagemap_entry_t
+    __packed_struct(le_pagemap_entry_t)
-    {
         unsigned char h;
         unsigned char m;
         unsigned char l;
         unsigned char type;  // 0x00-legal;0x40-iterated;0x80-invalid;0xC0-zeroed
-    }
+    __packed_struct_end()
-    __attribute_packed;
 
     virtual void readObjectTable();
     virtual void writeObjectTable();
-    //virtual void encodeObjectTable(){oobject_table = iobject_table; iobject_table = NULL;}
+    //virtual void encodeObjectTable(){oobject_table = iobject_table; iobject_table = nullptr;}
     //virtual void decodeObjectTable(){encodeObjectTable();}
 
     virtual void readFixupPageTable();
     virtual void writeFixupPageTable();
-    //virtual void encodeFixupPageTable(){ofpage_table = ifpage_table; ifpage_table = NULL;}
+    //virtual void encodeFixupPageTable(){ofpage_table = ifpage_table; ifpage_table = nullptr;}
     //virtual void decodeFixupPageTable(){encodeFixupPageTable();}
 
     virtual void readPageMap();
     virtual void writePageMap();
-    virtual void encodePageMap(){opm_entries = ipm_entries; ipm_entries = NULL;}
+    virtual void encodePageMap(){opm_entries = ipm_entries; ipm_entries = nullptr;}
     virtual void decodePageMap(){encodePageMap();}
 
     virtual void readResidentNames();
     virtual void writeResidentNames();
-    virtual void encodeResidentNames(){ores_names = ires_names; ires_names = NULL;}
+    virtual void encodeResidentNames(){ores_names = ires_names; ires_names = nullptr;}
     virtual void decodeResidentNames(){encodeResidentNames();}
 
     virtual void readNonResidentNames();
     virtual void writeNonResidentNames();
-    virtual void encodeNonResidentNames(){ononres_names = inonres_names; inonres_names = NULL;}
+    virtual void encodeNonResidentNames(){ononres_names = inonres_names; inonres_names = nullptr;}
     virtual void decodeNonResidentNames(){encodeNonResidentNames();}
 
     virtual void readEntryTable();
     virtual void writeEntryTable();
-    //virtual void encodeEntryTable(){oentries = ientries; ientries = NULL;}
+    //virtual void encodeEntryTable(){oentries = ientries; ientries = nullptr;}
     //virtual void decodeEntryTable(){encodeEntryTable();}
 
     virtual void readFixups();
     virtual void writeFixups();
-    //virtual void encodeFixups(){ofixups = ifixups; ifixups = NULL;}
+    //virtual void encodeFixups(){ofixups = ifixups; ifixups = nullptr;}
     //virtual void decodeFixups(){encodeFixups();}
 
     virtual void readImage();
     virtual void writeImage();
-    //virtual void encodeImage(){oimage = iimage; iimage = NULL;}
+    //virtual void encodeImage(){oimage = iimage; iimage = nullptr;}
     //virtual void decodeImage(){encodeImage();}
 
     void countFixups(unsigned *) const;
@@ -185,8 +180,8 @@ protected:
 
     InputFile *fif;
     OutputFile *fof;
-    long le_offset;
+    unsigned le_offset;
-    long exe_offset;
+    unsigned exe_offset;
 
     le_header_t ih;
     le_header_t oh;
@@ -203,8 +198,10 @@ protected:
     upx_byte *ofixups;
     upx_byte *inonres_names;
     upx_byte *ononres_names;
-    MemBuffer iimage;
+    MemBuffer mb_iimage;
-    MemBuffer oimage;
+    SPAN_0(upx_byte) iimage = nullptr;
+    MemBuffer mb_oimage;
+    SPAN_0(upx_byte) oimage = nullptr;
     upx_byte *ientries;
     upx_byte *oentries;
 
@@ -219,15 +216,11 @@ protected:
 
 private:
     // disable copy and assignment
-    LeFile(const LeFile &); // {}
+    LeFile(const LeFile &) = delete;
-    LeFile& operator= (const LeFile &); // { return *this; }
+    LeFile& operator= (const LeFile &) = delete;
 };
 
 
 #endif /* already included */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/linker.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,186 +22,257 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   markus@oberhumer.com      ml1050@users.sourceforge.net
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
-
 #ifndef __UPX_LINKER_H
-#define __UPX_LINKER_H
+#define __UPX_LINKER_H 1
-
 
 /*************************************************************************
 // ElfLinker
 **************************************************************************/
 
-class ElfLinker : private nocopy
+class ElfLinker : private noncopyable {
-{
+    friend class Packer;
+
+public:
+    const N_BELE_RTP::AbstractPolicy *bele = nullptr; // target endianness
 protected:
     struct Section;
     struct Symbol;
     struct Relocation;
 
-    bool        frozen;         // FIXME: can we remove this ?
+    upx_byte *input = nullptr;
+    int inputlen = 0;
+    upx_byte *output = nullptr;
+    int outputlen = 0;
 
-    upx_byte    *input;
+    Section *head = nullptr;
-    int         inputlen;
+    Section *tail = nullptr;
-    upx_byte    *output;
-    int         outputlen;
 
-    Section     *head;
+    Section **sections = nullptr;
-    Section     *tail;
+    Symbol **symbols = nullptr;
+    Relocation **relocations = nullptr;
 
-    Section     **sections;
+    unsigned nsections = 0;
-    Symbol      **symbols;
+    unsigned nsections_capacity = 0;
-    Relocation  **relocations;
+    unsigned nsymbols = 0;
+    unsigned nsymbols_capacity = 0;
+    unsigned nrelocations = 0;
+    unsigned nrelocations_capacity = 0;
 
-    unsigned    nsections;
+    bool reloc_done = false;
-    unsigned    nsections_capacity;
-    unsigned    nsymbols;
-    unsigned    nsymbols_capacity;
-    unsigned    nrelocations;
-    unsigned    nrelocations_capacity;
 
-    void preprocessSections(char *start, const char *end);
+protected:
-    void preprocessSymbols(char *start, const char *end);
+    void preprocessSections(char *start, char const *end);
-    void preprocessRelocations(char *start, const char *end);
+    void preprocessSymbols(char *start, char const *end);
-    Section *findSection(const char *name) const;
+    void preprocessRelocations(char *start, char const *end);
-    Symbol *findSymbol(const char *name) /*const*/;
+    Section *findSection(const char *name, bool fatal = true) const;
+    Symbol *findSymbol(const char *name, bool fatal = true) const;
 
-    Symbol *addSymbol(const char *name, const char *section, unsigned offset);
+    Symbol *addSymbol(const char *name, const char *section, upx_uint64_t offset);
     Relocation *addRelocation(const char *section, unsigned off, const char *type,
-                              const char *symbol, unsigned add);
+                              const char *symbol, upx_uint64_t add);
 
 public:
     ElfLinker();
     virtual ~ElfLinker();
 
-    virtual void init(const void *pdata, int plen);
+    void init(const void *pdata, int plen, unsigned pxtra = 0);
-    virtual void setLoaderAlignOffset(int phase);
+    // virtual void setLoaderAlignOffset(int phase);
-    virtual int addLoader(const char *sname);
+    int addLoader(const char *sname);
-    virtual void addSection(const char *sname, const void *sdata, int slen, int align);
+    void addLoader(const char *s, va_list ap);
-    virtual void freeze();
+#if (ACC_CC_CLANG || ACC_CC_GNUC)
-    virtual int getSection(const char *sname, int *slen=NULL);
+    void addLoaderVA(const char *s, ...) __attribute__((__sentinel__));
-    virtual upx_byte *getLoader(int *llen=NULL);
+#else
-    virtual void relocate();
+    void addLoaderVA(const char *s, ...);
-    virtual void defineSymbol(const char *name, unsigned value);
+#endif
-    virtual unsigned getSymbolOffset(const char *) const;
+    Section *addSection(const char *sname, const void *sdata, int slen, unsigned p2align);
-    virtual void dumpSymbols(FILE *fp=NULL) const;
+    int getSection(const char *sname, int *slen = nullptr) const;
+    int getSectionSize(const char *sname) const;
+    upx_byte *getLoader(int *llen = nullptr) const;
+    void defineSymbol(const char *name, upx_uint64_t value);
+    upx_uint64_t getSymbolOffset(const char *) const;
 
-    void alignWithByte(unsigned len, upx_byte b);
+    void dumpSymbol(const Symbol *, unsigned flags, FILE *fp) const;
+    void dumpSymbols(unsigned flags = 0, FILE *fp = nullptr) const;
+
+    void alignWithByte(unsigned len, unsigned char b);
     virtual void alignCode(unsigned len) { alignWithByte(len, 0); }
     virtual void alignData(unsigned len) { alignWithByte(len, 0); }
 
-    virtual void relocate1(const Relocation *, upx_byte *location,
+    // provide overloads to pacify GitHub CodeQL
-                           unsigned value, const char *type);
+    void defineSymbol(const char *name, int value) { defineSymbol(name, upx_uint64_t(value)); }
+    void defineSymbol(const char *name, unsigned value) { defineSymbol(name, upx_uint64_t(value)); }
+    void defineSymbol(const char *name, unsigned long value) {
+        defineSymbol(name, upx_uint64_t(value));
+    }
+
+protected:
+    void relocate();
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+
+    // target endianness abstraction
+    unsigned get_te16(const void *p) const { return bele->get16(p); }
+    unsigned get_te32(const void *p) const { return bele->get32(p); }
+    upx_uint64_t get_te64(const void *p) const { return bele->get64(p); }
+    void set_te16(void *p, unsigned v) const { bele->set16(p, v); }
+    void set_te32(void *p, unsigned v) const { bele->set32(p, v); }
+    void set_te64(void *p, upx_uint64_t v) const { bele->set64(p, v); }
 };
 
+struct ElfLinker::Section : private noncopyable {
+    char *name = nullptr;
+    void *input = nullptr;
+    upx_byte *output = nullptr;
+    unsigned size = 0;
+    upx_uint64_t offset = 0;
+    unsigned p2align = 0; // log2
+    Section *next = nullptr;
 
-struct ElfLinker::Section : private nocopy
+    Section(const char *n, const void *i, unsigned s, unsigned a = 0);
-{
-    char *name;
-    void *input;
-    upx_byte *output;
-    unsigned size;
-    unsigned offset;
-    unsigned char align;  // log2
-    Section *next;
-
-    Section(const char *n, const void *i, unsigned s, unsigned a=0);
     ~Section();
 };
 
+struct ElfLinker::Symbol : private noncopyable {
+    char *name = nullptr;
+    Section *section = nullptr;
+    upx_uint64_t offset = 0;
 
-struct ElfLinker::Symbol : private nocopy
+    Symbol(const char *n, Section *s, upx_uint64_t o);
-{
-    char *name;
-    Section *section;
-    unsigned offset;
-
-    Symbol(const char *n, Section *s, unsigned o);
     ~Symbol();
 };
 
+struct ElfLinker::Relocation : private noncopyable {
+    const Section *section = nullptr;
+    unsigned offset = 0;
+    const char *type = nullptr;
+    const Symbol *value = nullptr;
+    upx_uint64_t add; // used in .rela relocations
 
-struct ElfLinker::Relocation : private nocopy
+    Relocation(const Section *s, unsigned o, const char *t, const Symbol *v, upx_uint64_t a);
-{
-    const Section *section;
-    unsigned offset;
-    const char *type;
-    const Symbol *value;
-    unsigned add;           // used in .rela relocations
-
-    Relocation(const Section *s, unsigned o, const char *t,
-               const Symbol *v, unsigned a);
 };
 
-
 /*************************************************************************
 // ElfLinker arch subclasses
 **************************************************************************/
 
-class ElfLinkerAMD64 : public ElfLinker
+class ElfLinkerAMD64 : public ElfLinker {
-{
     typedef ElfLinker super;
+
 protected:
-    virtual void alignCode(unsigned len) { alignWithByte(len, 0x90); }
+    virtual void alignCode(unsigned len) override { alignWithByte(len, 0x90); }
-    virtual void relocate1(const Relocation *, upx_byte *location,
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
-                           unsigned value, const char *type);
+                           const char *type) override;
 };
 
-
+class ElfLinkerARM64 final : public ElfLinker {
-class ElfLinkerArmBE : public ElfLinker
-{
     typedef ElfLinker super;
+
 protected:
-    virtual void relocate1(const Relocation *, upx_byte *location,
+    virtual void alignCode(unsigned len) override { alignWithByte(len, 0x90); }
-                           unsigned value, const char *type);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type) override;
 };
 
-
+class ElfLinkerArmBE final : public ElfLinker {
-class ElfLinkerArmLE : public ElfLinker
-{
     typedef ElfLinker super;
+
+public:
+    ElfLinkerArmBE() { bele = &N_BELE_RTP::be_policy; }
+
 protected:
-    virtual void relocate1(const Relocation *, upx_byte *location,
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
-                           unsigned value, const char *type);
+                           const char *type) override;
 };
 
-
+class ElfLinkerArmLE final : public ElfLinker {
-class ElfLinkerM68k : public ElfLinker
-{
     typedef ElfLinker super;
+
 protected:
-    virtual void alignCode(unsigned len);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
-    virtual void relocate1(const Relocation *, upx_byte *location,
+                           const char *type) override;
-                           unsigned value, const char *type);
 };
 
-
+class ElfLinkerArm64LE final : public ElfLinker {
-class ElfLinkerPpc32 : public ElfLinker
-{
     typedef ElfLinker super;
+
 protected:
-    virtual void relocate1(const Relocation *, upx_byte *location,
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
-                           unsigned value, const char *type);
+                           const char *type) override;
 };
 
-
+class ElfLinkerM68k final : public ElfLinker {
-class ElfLinkerX86 : public ElfLinker
-{
     typedef ElfLinker super;
+
+public:
+    ElfLinkerM68k() { bele = &N_BELE_RTP::be_policy; }
+
 protected:
-    virtual void alignCode(unsigned len) { alignWithByte(len, 0x90); }
+    virtual void alignCode(unsigned len) override;
-    virtual void relocate1(const Relocation *, upx_byte *location,
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
-                           unsigned value, const char *type);
+                           const char *type) override;
 };
 
+class ElfLinkerMipsBE final : public ElfLinker {
+    typedef ElfLinker super;
 
+public:
+    ElfLinkerMipsBE() { bele = &N_BELE_RTP::be_policy; }
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type) override;
+};
+
+class ElfLinkerMipsLE final : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type) override;
+};
+
+class ElfLinkerPpc32 final : public ElfLinker {
+    typedef ElfLinker super;
+
+public:
+    ElfLinkerPpc32() { bele = &N_BELE_RTP::be_policy; }
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type) override;
+};
+
+class ElfLinkerPpc64le final : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type) override;
+};
+
+class ElfLinkerPpc64 final : public ElfLinker {
+    typedef ElfLinker super;
+
+public:
+    ElfLinkerPpc64() { bele = &N_BELE_RTP::be_policy; }
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type) override;
+};
+
+class ElfLinkerX86 final : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void alignCode(unsigned len) override { alignWithByte(len, 0x90); }
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type) override;
+};
 
 #endif /* already included */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/mem.cpp

@@ -1,218 +0,0 @@
-/* mem.cpp --
-
-   This file is part of the UPX executable compressor.
-
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 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
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
- */
-
-
-#include "conf.h"
-#include "mem.h"
-
-
-/*************************************************************************
-//
-**************************************************************************/
-
-static int use_mcheck = -1;
-
-static int mcheck_init()
-{
-    if (use_mcheck < 0)
-    {
-        use_mcheck = 1;
-#if defined(WITH_VALGRIND) && defined(RUNNING_ON_VALGRIND)
-        if (RUNNING_ON_VALGRIND)
-        {
-            //fprintf(stderr, "upx: detected RUNNING_ON_VALGRIND\n");
-            use_mcheck = 0;
-        }
-#endif
-    }
-    return use_mcheck;
-}
-
-
-/*************************************************************************
-//
-**************************************************************************/
-
-MemBuffer::MemBuffer() :
-    b(NULL), b_size(0)
-{
-    if (use_mcheck < 0)
-        mcheck_init();
-}
-
-MemBuffer::MemBuffer(unsigned size) :
-    b(NULL), b_size(0)
-{
-    alloc(size);
-}
-
-
-MemBuffer::~MemBuffer()
-{
-    this->dealloc();
-}
-
-void MemBuffer::dealloc()
-{
-    if (b)
-    {
-        checkState();
-        if (use_mcheck)
-        {
-            // remove magic constants
-            set_be32(b - 8, 0);
-            set_be32(b - 4, 0);
-            set_be32(b + b_size, 0);
-            set_be32(b + b_size + 4, 0);
-            //
-            ::free(b - 16);
-        }
-        else
-            ::free(b);
-        b = NULL;
-        b_size = 0;
-    }
-    else
-        assert(b_size == 0);
-}
-
-
-unsigned MemBuffer::getSizeForCompression(unsigned uncompressed_size, unsigned extra)
-{
-    assert((int)uncompressed_size > 0);
-    assert((int)extra >= 0);
-    unsigned size = uncompressed_size + uncompressed_size/8 + 256 + extra;
-    return size;
-}
-
-unsigned MemBuffer::getSizeForUncompression(unsigned uncompressed_size, unsigned extra)
-{
-    assert((int)uncompressed_size > 0);
-    assert((int)extra >= 0);
-    unsigned size = uncompressed_size + extra;
-//    size += 512;   // 512 safety bytes
-    // INFO: 3 bytes are the allowed overrun for the i386 asm_fast decompressors
-#if (ACC_ARCH_I386)
-    size += 3;
-#endif
-    return size;
-}
-
-
-void MemBuffer::allocForCompression(unsigned uncompressed_size, unsigned extra)
-{
-    unsigned size = getSizeForCompression(uncompressed_size, extra);
-    alloc(size);
-}
-
-
-void MemBuffer::allocForUncompression(unsigned uncompressed_size, unsigned extra)
-{
-    unsigned size = getSizeForUncompression(uncompressed_size, extra);
-    alloc(size);
-}
-
-
-void MemBuffer::fill(unsigned off, unsigned len, int value)
-{
-    checkState();
-    assert((int)off >= 0);
-    assert((int)len >= 0);
-    assert(off <= b_size);
-    assert(len <= b_size);
-    assert(off + len <= b_size);
-    if (len > 0)
-        memset(b + off, value, len);
-}
-
-
-/*************************************************************************
-//
-**************************************************************************/
-
-#define PTR(p)      ((unsigned) ((acc_uintptr_t)(p) & 0xffffffff))
-#define MAGIC1(p)   (PTR(p) ^ 0xfefdbeeb)
-#define MAGIC2(p)   (PTR(p) ^ 0xfefdbeeb ^ 0x80024001)
-
-unsigned MemBuffer::global_alloc_counter = 0;
-
-
-void MemBuffer::checkState() const
-{
-    if (!b)
-        throwInternalError("block not allocated");
-    if (use_mcheck)
-    {
-        if (get_be32(b - 4) != MAGIC1(b))
-            throwInternalError("memory clobbered before allocated block 1");
-        if (get_be32(b - 8) != b_size)
-            throwInternalError("memory clobbered before allocated block 2");
-        if (get_be32(b + b_size) != MAGIC2(b))
-            throwInternalError("memory clobbered past end of allocated block");
-    }
-    assert((int)b_size > 0);
-}
-
-
-void MemBuffer::alloc(unsigned size)
-{
-    if (use_mcheck < 0)
-        mcheck_init();
-
-    // NOTE: we don't automatically free a used buffer
-    assert(b == NULL);
-    assert(b_size == 0);
-    //
-    assert((int)size > 0);
-    unsigned total = use_mcheck ? size + 32 : size;
-    assert((int)total > 0);
-    unsigned char *p = (unsigned char *) malloc(total);
-    if (!p)
-    {
-        //throw bad_alloc();
-        throw OutOfMemoryException("out of memory");
-        //exit(1);
-    }
-    b_size = size;
-    if (use_mcheck)
-    {
-        b = p + 16;
-        // store magic constants to detect buffer overruns
-        set_be32(b - 8, b_size);
-        set_be32(b - 4, MAGIC1(b));
-        set_be32(b + b_size, MAGIC2(b));
-        set_be32(b + b_size + 4, global_alloc_counter++);
-    }
-    else
-        b = p ;
-}
-
-
-/*
-vi:ts=4:et
-*/
-

src/mem.h

@@ -1,86 +0,0 @@
-/* mem.h --
-
-   This file is part of the UPX executable compressor.
-
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 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
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
- */
-
-
-#ifndef __UPX_MEM_H
-#define __UPX_MEM_H
-
-
-/*************************************************************************
-//
-**************************************************************************/
-
-class MemBuffer
-{
-public:
-    MemBuffer();
-    MemBuffer(unsigned size);
-    ~MemBuffer();
-
-    static unsigned getSizeForCompression(unsigned uncompressed_size, unsigned extra=0);
-    static unsigned getSizeForUncompression(unsigned uncompressed_size, unsigned extra=0);
-
-    void alloc(unsigned size);
-    void allocForCompression(unsigned uncompressed_size, unsigned extra=0);
-    void allocForUncompression(unsigned uncompressed_size, unsigned extra=0);
-
-    void dealloc();
-
-    void checkState() const;
-
-    unsigned getSize() const { return b_size; }
-
-    operator       unsigned char * ()       { return b; }
-    //operator const unsigned char * () const { return b; }
-          void *getVoidPtr()                { return (void *) b; }
-    const void *getVoidPtr() const          { return (const void *) b; }
-
-    void fill(unsigned off, unsigned len, int value);
-    void clear(unsigned off, unsigned len)  { fill(off, len, 0); }
-    void clear()                            { fill(0, b_size, 0); }
-
-private:
-    unsigned char *b;
-    unsigned b_size;
-
-    static unsigned global_alloc_counter;
-
-    // disable copy and assignment
-    MemBuffer(const MemBuffer &); // {}
-    MemBuffer& operator= (const MemBuffer &); // { return *this; }
-
-    // disable dynamic allocation
-    DISABLE_NEW_DELETE
-};
-
-#endif /* already included */
-
-
-/*
-vi:ts=4:et
-*/
-

src/msg.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -55,9 +55,9 @@ void printClearLine(FILE *f)
     }
 
     fflush(stdout); fflush(stderr);
-    if (f == NULL)
+    if (f == nullptr)
         f = stdout;
-    con_fprintf(f,clear_line_msg);
+    con_fprintf(f, "%s", clear_line_msg);
     fflush(f);
     printSetNl(0);
 }
@@ -91,10 +91,10 @@ static void pr_error(const char *iname, const char *msg, bool is_warning)
     bool c = acc_isatty(STDERR_FILENO) ? 1 : 0;
 
     int fg = con_fg(stderr,FG_BRTRED);
-    upx_snprintf(buf+strlen(buf),sizeof(buf)-strlen(buf),"%s: ", progname);
+    snprintf(buf+strlen(buf),sizeof(buf)-strlen(buf),"%s: ", progname);
     pr_print(c,buf);
     //(void)con_fg(stderr,FG_RED);
-    upx_snprintf(buf,sizeof(buf),"%s: ", iname);
+    snprintf(buf,sizeof(buf),"%s: ", iname);
     pr_print(c,buf);
     //(void)con_fg(stderr,FG_BRTRED);
     pr_print(c,msg);
@@ -112,13 +112,13 @@ void printErr(const char *iname, const Throwable *e)
     char buf[1024];
     size_t l;
 
-    upx_snprintf(buf, sizeof(buf), "%s", prettyName(typeid(*e).name()));
+    snprintf(buf, sizeof(buf), "%s", prettyName(typeid(*e).name()));
     l = strlen(buf);
     if (l < sizeof(buf) && e->getMsg())
-        upx_snprintf(buf+l, sizeof(buf)-l, ": %s", e->getMsg());
+        snprintf(buf+l, sizeof(buf)-l, ": %s", e->getMsg());
     l = strlen(buf);
     if (l < sizeof(buf) && e->getErrno()) {
-        upx_snprintf(buf+l, sizeof(buf)-l, ": %s", strerror(e->getErrno()));
+        snprintf(buf+l, sizeof(buf)-l, ": %s", strerror(e->getErrno()));
 #if 1
         // some compilers (e.g. Borland C++) put a trailing '\n'
         // into strerror() result
@@ -131,26 +131,26 @@ void printErr(const char *iname, const Throwable *e)
 }
 
 
-void __acc_cdecl_va printErr(const char *iname, const char *format, ...)
+void printErr(const char *iname, const char *format, ...)
 {
     va_list args;
     char buf[1024];
 
     va_start(args,format);
-    upx_vsnprintf(buf,sizeof(buf),format,args);
+    upx_safe_vsnprintf(buf,sizeof(buf),format,args);
     va_end(args);
 
     pr_error(iname,buf,false);
 }
 
 
-void __acc_cdecl_va printWarn(const char *iname, const char *format, ...)
+void printWarn(const char *iname, const char *format, ...)
 {
     va_list args;
     char buf[1024];
 
     va_start(args,format);
-    upx_vsnprintf(buf,sizeof(buf),format,args);
+    upx_safe_vsnprintf(buf,sizeof(buf),format,args);
     va_end(args);
 
     pr_error(iname,buf,true);
@@ -201,21 +201,21 @@ void infoHeader()
     info_header = 0;
 }
 
-void __acc_cdecl_va infoHeader(const char *format, ...)
+void infoHeader(const char *format, ...)
 {
     if (opt->info_mode <= 0)
         return;
     va_list args;
     char buf[1024];
     va_start(args,format);
-    upx_vsnprintf(buf,sizeof(buf),format,args);
+    upx_safe_vsnprintf(buf,sizeof(buf),format,args);
     va_end(args);
     info_print(buf);
     info_header = 1;
 }
 
 
-void __acc_cdecl_va info(const char *format, ...)
+void info(const char *format, ...)
 {
     if (opt->info_mode <= 0)
         return;
@@ -224,13 +224,13 @@ void __acc_cdecl_va info(const char *format, ...)
     const int n = 4 * info_header;
     memset(buf, ' ', n);
     va_start(args,format);
-    upx_vsnprintf(buf+n,sizeof(buf)-n,format,args);
+    upx_safe_vsnprintf(buf+n,sizeof(buf)-n,format,args);
     va_end(args);
     info_print(buf);
 }
 
 
-void __acc_cdecl_va infoWarning(const char *format, ...)
+void infoWarning(const char *format, ...)
 {
     if (opt->info_mode <= 0)
     {
@@ -240,7 +240,7 @@ void __acc_cdecl_va infoWarning(const char *format, ...)
     va_list args;
     char buf[1024];
     va_start(args,format);
-    upx_vsnprintf(buf,sizeof(buf),format,args);
+    upx_safe_vsnprintf(buf,sizeof(buf),format,args);
     va_end(args);
     info("[WARNING] %s\n", buf);
 }
@@ -253,8 +253,4 @@ void infoWriting(const char *what, long size)
     info("Writing %s: %ld bytes", what, size);
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et:nowrap
-*/
-

src/mygetopt.cpp

@@ -1,706 +0,0 @@
-/* Getopt for GNU.
-   NOTE: getopt is now part of the C library, so if you don't know what
-   "Keep this file name-space clean" means, talk to roland@gnu.ai.mit.edu
-   before changing it!
-
-   Copyright (C) 1987, 88, 89, 90, 91, 92, 1993
-        Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify it
-   under the terms of the GNU General Public License as published by the
-   Free Software Foundation; either version 2, 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; if not, write to the Free Software
-   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-
-
-#undef PROGNAME
-#if 0
-#ifndef EOF
-#include <stdio.h>
-#include <string.h>
-#endif
-#define PROGNAME(x)     (x)
-#else
-#include "conf.h"
-static const char *my_progname(const char *argv0)
-{
-    return progname ? progname : argv0;
-}
-#define PROGNAME(x)     my_progname(x)
-#endif
-
-
-/* If GETOPT_COMPAT is defined, `+' as well as `--' can introduce a
-   long-named option.  Because this is not POSIX.2 compliant, it is
-   being phased out.  */
-/* #define GETOPT_COMPAT */
-#undef GETOPT_COMPAT
-
-/* This version of `getopt' appears to the caller like standard Unix `getopt'
-   but it behaves differently for the user, since it allows the user
-   to intersperse the options with the other arguments.
-
-   As `getopt' works, it permutes the elements of ARGV so that,
-   when it is done, all the options precede everything else.  Thus
-   all application programs are extended to handle flexible argument order.
-
-   Setting the environment variable POSIXLY_CORRECT disables permutation.
-   Then the behavior is completely standard.
-
-   GNU application programs can use a third alternative mode in which
-   they can distinguish the relative order of options and other arguments.  */
-
-#include "mygetopt.h"
-#define option                  mfx_option
-#define optarg                  mfx_optarg
-#define optind                  mfx_optind
-#define opterr                  mfx_opterr
-#define optopt                  mfx_optopt
-#undef BAD_OPTION
-
-/* For communication from `getopt' to the caller.
-   When `getopt' finds an option that takes an argument,
-   the argument value is returned here.
-   Also, when `ordering' is RETURN_IN_ORDER,
-   each non-option ARGV-element is returned here.  */
-
-char *optarg = NULL;
-
-/* Index in ARGV of the next element to be scanned.
-   This is used for communication to and from the caller
-   and for communication between successive calls to `getopt'.
-
-   On entry to `getopt', zero means this is the first call; initialize.
-
-   When `getopt' returns EOF, this is the index of the first of the
-   non-option elements that the caller should itself scan.
-
-   Otherwise, `optind' communicates from one call to the next
-   how much of ARGV has been scanned so far.  */
-
-/* XXX 1003.2 says this must be 1 before any call.  */
-int optind = 0;
-
-/* The next char to be scanned in the option-element
-   in which the last option character we returned was found.
-   This allows us to pick up the scan where we left off.
-
-   If this is zero, or a null string, it means resume the scan
-   by advancing to the next ARGV-element.  */
-
-static char *nextchar;
-
-/* Callers store zero here to inhibit the error message
-   for unrecognized options.  */
-
-int opterr = 1;
-
-/* Set to an option character which was unrecognized.
-   This must be initialized on some systems to avoid linking in the
-   system's own getopt implementation.  */
-
-#define BAD_OPTION '\0'
-int optopt = BAD_OPTION;
-
-/* Describe how to deal with options that follow non-option ARGV-elements.
-
-   If the caller did not specify anything,
-   the default is REQUIRE_ORDER if the environment variable
-   POSIXLY_CORRECT is defined, PERMUTE otherwise.
-
-   REQUIRE_ORDER means don't recognize them as options;
-   stop option processing when the first non-option is seen.
-   This is what Unix does.
-   This mode of operation is selected by either setting the environment
-   variable POSIXLY_CORRECT, or using `+' as the first character
-   of the list of option characters.
-
-   PERMUTE is the default.  We permute the contents of ARGV as we scan,
-   so that eventually all the non-options are at the end.  This allows options
-   to be given in any order, even with programs that were not written to
-   expect this.
-
-   RETURN_IN_ORDER is an option available to programs that were written
-   to expect options and other ARGV-elements in any order and that care about
-   the ordering of the two.  We describe each non-option ARGV-element
-   as if it were the argument of an option with character code 1.
-   Using `-' as the first character of the list of option characters
-   selects this mode of operation.
-
-   The special argument `--' forces an end of option-scanning regardless
-   of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
-   `--' can cause `getopt' to return EOF with `optind' != ARGC.  */
-
-static enum
-{
-  REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
-} ordering;
-
-/* Handle permutation of arguments.  */
-
-/* Describe the part of ARGV that contains non-options that have
-   been skipped.  `first_nonopt' is the index in ARGV of the first of them;
-   `last_nonopt' is the index after the last of them.  */
-
-static int first_nonopt;
-static int last_nonopt;
-
-/* Exchange two adjacent subsequences of ARGV.
-   One subsequence is elements [first_nonopt,last_nonopt)
-   which contains all the non-options that have been skipped so far.
-   The other is elements [last_nonopt,optind), which contains all
-   the options processed since those non-options were skipped.
-
-   `first_nonopt' and `last_nonopt' are relocated so that they describe
-   the new indices of the non-options in ARGV after they are moved.
-
-   To perform the swap, we first reverse the order of all elements. So
-   all options now come before all non options, but they are in the
-   wrong order. So we put back the options and non options in original
-   order by reversing them again. For example:
-       original input:      a b c -x -y
-       reverse all:         -y -x c b a
-       reverse options:     -x -y c b a
-       reverse non options: -x -y a b c
-*/
-
-
-static void exchange (char **argv)
-{
-  char *temp; char **first, **last;
-
-  /* Reverse all the elements [first_nonopt, optind) */
-  first = &argv[first_nonopt];
-  last  = &argv[optind-1];
-  while (first < last) {
-    temp = *first; *first = *last; *last = temp; first++; last--;
-  }
-  /* Put back the options in order */
-  first = &argv[first_nonopt];
-  first_nonopt += (optind - last_nonopt);
-  last  = &argv[first_nonopt - 1];
-  while (first < last) {
-    temp = *first; *first = *last; *last = temp; first++; last--;
-  }
-
-  /* Put back the non options in order */
-  first = &argv[first_nonopt];
-  last_nonopt = optind;
-  last  = &argv[last_nonopt-1];
-  while (first < last) {
-    temp = *first; *first = *last; *last = temp; first++; last--;
-  }
-}
-
-/* Scan elements of ARGV (whose length is ARGC) for option characters
-   given in OPTSTRING.
-
-   If an element of ARGV starts with '-', and is not exactly "-" or "--",
-   then it is an option element.  The characters of this element
-   (aside from the initial '-') are option characters.  If `getopt'
-   is called repeatedly, it returns successively each of the option characters
-   from each of the option elements.
-
-   If `getopt' finds another option character, it returns that character,
-   updating `optind' and `nextchar' so that the next call to `getopt' can
-   resume the scan with the following option character or ARGV-element.
-
-   If there are no more option characters, `getopt' returns `EOF'.
-   Then `optind' is the index in ARGV of the first ARGV-element
-   that is not an option.  (The ARGV-elements have been permuted
-   so that those that are not options now come last.)
-
-   OPTSTRING is a string containing the legitimate option characters.
-   If an option character is seen that is not listed in OPTSTRING,
-   return BAD_OPTION after printing an error message.  If you set `opterr' to
-   zero, the error message is suppressed but we still return BAD_OPTION.
-
-   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
-   so the following text in the same ARGV-element, or the text of the following
-   ARGV-element, is returned in `optarg'.  Two colons mean an option that
-   wants an optional arg; if there is text in the current ARGV-element,
-   it is returned in `optarg', otherwise `optarg' is set to zero.
-
-   If OPTSTRING starts with `-' or `+', it requests different methods of
-   handling the non-option ARGV-elements.
-   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
-
-   Long-named options begin with `--' instead of `-'.
-   Their names may be abbreviated as long as the abbreviation is unique
-   or is an exact match for some defined option.  If they have an
-   argument, it follows the option name in the same ARGV-element, separated
-   from the option name by a `=', or else the in next ARGV-element.
-   When `getopt' finds a long-named option, it returns 0 if that option's
-   `flag' field is nonzero, the value of the option's `val' field
-   if the `flag' field is zero.
-
-   LONGOPTS is a vector of `struct option' terminated by an
-   element containing a name which is zero.
-
-   LONGIND returns the index in LONGOPT of the long-named option found.
-   It is only valid when a long-named option has been found by the most
-   recent call.
-
-   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
-   long-named options.  */
-
-static int _getopt_internal (int argc, char **argv, const char *optstring,
-                 const struct option *longopts, int *longind,
-                 int long_only)
-{
-  static char empty_string[1];
-  int option_index;
-
-  if (longind != NULL)
-    *longind = -1;
-
-  optarg = 0;
-
-  /* Initialize the internal data when the first call is made.
-     Start processing options with ARGV-element 1 (since ARGV-element 0
-     is the program name); the sequence of previously skipped
-     non-option ARGV-elements is empty.  */
-
-  if (optind == 0)
-    {
-      first_nonopt = last_nonopt = optind = 1;
-
-      nextchar = NULL;
-
-      /* Determine how to handle the ordering of options and nonoptions.  */
-
-      if (optstring[0] == '-')
-        {
-          ordering = RETURN_IN_ORDER;
-          ++optstring;
-        }
-      else if (optstring[0] == '+')
-        {
-          ordering = REQUIRE_ORDER;
-          ++optstring;
-        }
-#if 0
-      else if (getenv ("POSIXLY_CORRECT") != NULL)
-        ordering = REQUIRE_ORDER;
-#endif
-      else
-        ordering = PERMUTE;
-    }
-
-  if (nextchar == NULL || *nextchar == '\0')
-    {
-      if (ordering == PERMUTE)
-        {
-          /* If we have just processed some options following some non-options,
-             exchange them so that the options come first.  */
-
-          if (first_nonopt != last_nonopt && last_nonopt != optind)
-            exchange (argv);
-          else if (last_nonopt != optind)
-            first_nonopt = optind;
-
-          /* Now skip any additional non-options
-             and extend the range of non-options previously skipped.  */
-
-          while (optind < argc
-                 && (argv[optind][0] != '-' || argv[optind][1] == '\0')
-#ifdef GETOPT_COMPAT
-                 && (longopts == NULL
-                     || argv[optind][0] != '+' || argv[optind][1] == '\0')
-#endif                          /* GETOPT_COMPAT */
-                 )
-            optind++;
-          last_nonopt = optind;
-        }
-
-      /* Special ARGV-element `--' means premature end of options.
-         Skip it like a null option,
-         then exchange with previous non-options as if it were an option,
-         then skip everything else like a non-option.  */
-
-      if (optind != argc && !strcmp (argv[optind], "--"))
-        {
-          optind++;
-
-          if (first_nonopt != last_nonopt && last_nonopt != optind)
-            exchange (argv);
-          else if (first_nonopt == last_nonopt)
-            first_nonopt = optind;
-          last_nonopt = argc;
-
-          optind = argc;
-        }
-
-      /* If we have done all the ARGV-elements, stop the scan
-         and back over any non-options that we skipped and permuted.  */
-
-      if (optind == argc)
-        {
-          /* Set the next-arg-index to point at the non-options
-             that we previously skipped, so the caller will digest them.  */
-          if (first_nonopt != last_nonopt)
-            optind = first_nonopt;
-          return EOF;
-        }
-
-      /* If we have come to a non-option and did not permute it,
-         either stop the scan or describe it to the caller and pass it by.  */
-
-      if ((argv[optind][0] != '-' || argv[optind][1] == '\0')
-#ifdef GETOPT_COMPAT
-          && (longopts == NULL
-              || argv[optind][0] != '+' || argv[optind][1] == '\0')
-#endif                          /* GETOPT_COMPAT */
-          )
-        {
-          if (ordering == REQUIRE_ORDER)
-            return EOF;
-          optarg = argv[optind++];
-          return 1;
-        }
-
-      /* We have found another option-ARGV-element.
-         Start decoding its characters.  */
-
-      nextchar = (argv[optind] + 1
-                  + (longopts != NULL && argv[optind][1] == '-'));
-    }
-
-  if (longopts != NULL
-      && ((argv[optind][0] == '-'
-           && (argv[optind][1] == '-' || long_only))
-#ifdef GETOPT_COMPAT
-          || argv[optind][0] == '+'
-#endif                          /* GETOPT_COMPAT */
-          ))
-    {
-      const struct option *p;
-      char *s = nextchar;
-      int exact = 0;
-      int ambig = 0;
-      const struct option *pfound = NULL;
-      int indfound = 0;
-      int needexact = 0;
-
-      /* allow `--option#value' because you cannout assign a '='
-         to an environment variable under DOS command.com */
-      while (*s && *s != '=' && * s != '#')
-        s++;
-
-      /* Test all options for either exact match or abbreviated matches.  */
-      for (p = longopts, option_index = 0; p->name;
-           p++, option_index++)
-        if (!strncmp (p->name, nextchar, (unsigned) (s - nextchar)))
-          {
-            if (p->has_arg & 0x10)
-              needexact = 1;
-            if ((unsigned) (s - nextchar) == strlen (p->name))
-              {
-                /* Exact match found.  */
-                pfound = p;
-                indfound = option_index;
-                exact = 1;
-                break;
-              }
-            else if (pfound == NULL)
-              {
-                /* First nonexact match found.  */
-                pfound = p;
-                indfound = option_index;
-              }
-            else
-              /* Second nonexact match found.  */
-              ambig = 1;
-          }
-
-      /* don't allow nonexact longoptions */
-      if (needexact && !exact)
-        {
-          if (opterr)
-            fprintf (stderr, "%s: unrecognized option `%s'\n",
-                     PROGNAME(argv[0]), argv[optind]);
-          nextchar += strlen (nextchar);
-          optind++;
-          return BAD_OPTION;
-        }
-      if (ambig && !exact)
-        {
-          if (opterr)
-            fprintf (stderr, "%s: option `%s' is ambiguous\n",
-                     PROGNAME(argv[0]), argv[optind]);
-          nextchar += strlen (nextchar);
-          optind++;
-          return BAD_OPTION;
-        }
-
-      if (pfound != NULL)
-        {
-          int have_arg = (s[0] != '\0');
-          if (have_arg && (pfound->has_arg & 0xf))
-            have_arg = (s[1] != '\0');
-          option_index = indfound;
-          optind++;
-          if (have_arg)
-            {
-              /* Don't test has_arg with >, because some C compilers don't
-                 allow it to be used on enums.  */
-              if (pfound->has_arg & 0xf)
-                optarg = s + 1;
-              else
-                {
-                  if (opterr)
-                    {
-                      if (argv[optind - 1][1] == '-')
-                        /* --option */
-                        fprintf (stderr,
-                                 "%s: option `--%s' doesn't allow an argument\n",
-                                 PROGNAME(argv[0]), pfound->name);
-                      else
-                        /* +option or -option */
-                        fprintf (stderr,
-                             "%s: option `%c%s' doesn't allow an argument\n",
-                             PROGNAME(argv[0]), argv[optind - 1][0], pfound->name);
-                    }
-                  nextchar += strlen (nextchar);
-                  return BAD_OPTION;
-                }
-            }
-          else if ((pfound->has_arg & 0xf) == 1)
-            {
-#if 0
-              if (optind < argc)
-#else
-              if (optind < argc && (pfound->has_arg & 0x20) == 0)
-#endif
-                optarg = argv[optind++];
-              else
-                {
-                  if (opterr)
-                    fprintf (stderr, "%s: option `--%s%s' requires an argument\n",
-                             PROGNAME(argv[0]), pfound->name,
-                             (pfound->has_arg & 0x20) ? "=" : "");
-                  nextchar += strlen (nextchar);
-                  return optstring[0] == ':' ? ':' : BAD_OPTION;
-                }
-            }
-          nextchar += strlen (nextchar);
-          if (longind != NULL)
-            *longind = option_index;
-          if (pfound->flag)
-            {
-              *(pfound->flag) = pfound->val;
-              return 0;
-            }
-          return pfound->val;
-        }
-      /* Can't find it as a long option.  If this is not getopt_long_only,
-         or the option starts with '--' or is not a valid short
-         option, then it's an error.
-         Otherwise interpret it as a short option.  */
-      if (!long_only || argv[optind][1] == '-'
-#ifdef GETOPT_COMPAT
-          || argv[optind][0] == '+'
-#endif                          /* GETOPT_COMPAT */
-          || strchr (optstring, *nextchar) == NULL)
-        {
-          if (opterr)
-            {
-              if (argv[optind][1] == '-')
-                /* --option */
-                fprintf (stderr, "%s: unrecognized option `--%s'\n",
-                         PROGNAME(argv[0]), nextchar);
-              else
-                /* +option or -option */
-                fprintf (stderr, "%s: unrecognized option `%c%s'\n",
-                         PROGNAME(argv[0]), argv[optind][0], nextchar);
-            }
-          nextchar = empty_string;
-          optind++;
-          return BAD_OPTION;
-        }
-        (void) &ambig;  /* UNUSED */
-    }
-
-  /* Look at and handle the next option-character.  */
-
-  {
-    char c = *nextchar++;
-    const char *temp = strchr (optstring, c);
-
-    /* Increment `optind' when we start to process its last character.  */
-    if (*nextchar == '\0')
-      ++optind;
-
-    if (temp == NULL || c == ':')
-      {
-        if (opterr)
-          {
-#if 0
-            if (c < 040 || c >= 0177)
-              fprintf (stderr, "%s: unrecognized option, character code 0%o\n",
-                       PROGNAME(argv[0]), c);
-            else
-              fprintf (stderr, "%s: unrecognized option `-%c'\n", PROGNAME(argv[0]), c);
-#else
-            /* 1003.2 specifies the format of this message.  */
-            fprintf (stderr, "%s: illegal option -- %c\n", PROGNAME(argv[0]), c);
-#endif
-          }
-        optopt = c;
-        return BAD_OPTION;
-      }
-    if (temp[1] == ':')
-      {
-        if (temp[2] == ':')
-          {
-            /* This is an option that accepts an argument optionally.  */
-            if (*nextchar != '\0')
-              {
-                optarg = nextchar;
-                optind++;
-              }
-            else
-              optarg = 0;
-            nextchar = NULL;
-          }
-        else
-          {
-            /* This is an option that requires an argument.  */
-            if (*nextchar != '\0')
-              {
-                optarg = nextchar;
-                /* If we end this ARGV-element by taking the rest as an arg,
-                   we must advance to the next element now.  */
-                optind++;
-              }
-            else if (optind == argc)
-              {
-                if (opterr)
-                  {
-#if 0
-                    fprintf (stderr, "%s: option `-%c' requires an argument\n",
-                             PROGNAME(argv[0]), c);
-#else
-                    /* 1003.2 specifies the format of this message.  */
-                    fprintf (stderr, "%s: option requires an argument -- %c\n",
-                             PROGNAME(argv[0]), c);
-#endif
-                  }
-                optopt = c;
-                if (optstring[0] == ':')
-                  c = ':';
-                else
-                  c = BAD_OPTION;
-              }
-            else
-              /* We already incremented `optind' once;
-                 increment it again when taking next ARGV-elt as argument.  */
-              optarg = argv[optind++];
-            nextchar = NULL;
-          }
-      }
-    return c;
-  }
-}
-
-int mfx_getopt(int argc, char **argv, const char *optstring)
-{
-  return _getopt_internal (argc, argv, optstring,
-                           (const struct option *) 0,
-                           (int *) 0,
-                           0);
-}
-
-int mfx_getopt_long(int argc, char **argv, const char *options,
-                    const struct option *long_options, int *opt_index)
-{
-  return _getopt_internal (argc, argv, options, long_options, opt_index, 0);
-}
-
-
-#ifdef TEST
-
-/* Compile with -DTEST to make an executable for use in testing
-   the above definition of `getopt'.  */
-
-int
-main (argc, argv)
-     int argc;
-     char **argv;
-{
-  int c;
-  int digit_optind = 0;
-
-  while (1)
-    {
-      int this_option_optind = optind ? optind : 1;
-
-      c = getopt (argc, argv, "abc:d:0123456789");
-      if (c == EOF)
-        break;
-
-      switch (c)
-        {
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9':
-          if (digit_optind != 0 && digit_optind != this_option_optind)
-            printf ("digits occur in two different argv-elements.\n");
-          digit_optind = this_option_optind;
-          printf ("option %c\n", c);
-          break;
-
-        case 'a':
-          printf ("option a\n");
-          break;
-
-        case 'b':
-          printf ("option b\n");
-          break;
-
-        case 'c':
-          printf ("option c with value `%s'\n", optarg);
-          break;
-
-        case BAD_OPTION:
-          break;
-
-        default:
-          printf ("?? getopt returned character code 0%o ??\n", c);
-        }
-    }
-
-  if (optind < argc)
-    {
-      printf ("non-option ARGV-elements: ");
-      while (optind < argc)
-        printf ("%s ", argv[optind++]);
-      printf ("\n");
-    }
-
-  exit (0);
-}
-
-#endif /* TEST */
-
-
-/*
-vi:ts=4:et:nowrap
-*/
-

src/mygetopt.h

@@ -1,102 +0,0 @@
-/* Declarations for getopt.
-   Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
-
-   This program is free software; you can redistribute it and/or modify it
-   under the terms of the GNU General Public License as published by the
-   Free Software Foundation; either version 2, 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; if not, write to the Free Software
-   Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
-
-#ifndef __MFX_GETOPT_H
-#define __MFX_GETOPT_H 1
-
-#ifdef __cplusplus
-/* extern "C" { */
-#endif
-
-/* For communication from `getopt' to the caller.
-   When `getopt' finds an option that takes an argument,
-   the argument value is returned here.
-   Also, when `ordering' is RETURN_IN_ORDER,
-   each non-option ARGV-element is returned here.  */
-
-extern char *mfx_optarg;
-
-/* Index in ARGV of the next element to be scanned.
-   This is used for communication to and from the caller
-   and for communication between successive calls to `getopt'.
-
-   On entry to `getopt', zero means this is the first call; initialize.
-
-   When `getopt' returns EOF, this is the index of the first of the
-   non-option elements that the caller should itself scan.
-
-   Otherwise, `optind' communicates from one call to the next
-   how much of ARGV has been scanned so far.  */
-
-extern int mfx_optind;
-
-/* Callers store zero here to inhibit the error message `getopt' prints
-   for unrecognized options.  */
-
-extern int mfx_opterr;
-
-/* Set to an option character which was unrecognized.  */
-
-extern int mfx_optopt;
-
-/* Describe the long-named options requested by the application.
-   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
-   of `struct option' terminated by an element containing a name which is
-   zero.
-
-   The field `has_arg' is:
-   no_argument          (or 0) if the option does not take an argument,
-   required_argument    (or 1) if the option requires an argument,
-   optional_argument    (or 2) if the option takes an optional argument.
-
-   If the field `flag' is not NULL, it points to a variable that is set
-   to the value given in the field `val' when the option is found, but
-   left unchanged if the option is not found.
-
-   To have a long-named option do something other than set an `int' to
-   a compiled-in constant, such as set a value from `optarg', set the
-   option's `flag' field to zero and its `val' field to a nonzero
-   value (the equivalent single-letter option character, if there is
-   one).  For long options that have a zero `flag' field, `getopt'
-   returns the contents of the `val' field.  */
-
-struct mfx_option
-{
-  const char *name;
-  /* has_arg can't be an enum because some compilers complain about
-     type mismatches in all the code that assumes it is an int.  */
-  int has_arg;
-  int *flag;
-  int val;
-};
-
-/* Names for the values of the `has_arg' field of `struct option'.  */
-
-#define mfx_no_argument         0
-#define mfx_required_argument   1
-#define mfx_optional_argument   2
-#define mfx_exact_argument      0x10            /* no abbrev. */
-
-int mfx_getopt(int argc, char **argv, const char *shortopts);
-int mfx_getopt_long(int argc, char **argv, const char *shortopts,
-                    const struct mfx_option *longopts, int *longind);
-
-#ifdef __cplusplus
-/* } */
-#endif
-
-#endif /* __MFX_GETOPT_H */

src/options.cpp

@@ -0,0 +1,148 @@
+/* options.cpp --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 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"
+
+/*************************************************************************
+// options
+**************************************************************************/
+
+void options_t::reset() {
+    options_t *o = this;
+    mem_clear(o, sizeof(*o));
+    o->crp.reset();
+
+    o->cmd = CMD_NONE;
+    o->method = M_NONE;
+    o->level = -1;
+    o->filter = FT_NONE;
+
+    o->backup = -1;
+    o->overlay = -1;
+    o->preserve_mode = true;
+    o->preserve_ownership = true;
+    o->preserve_timestamp = true;
+
+    o->console = CON_FILE;
+#if (ACC_OS_DOS32) && defined(__DJGPP__)
+    o->console = CON_INIT;
+#elif (USE_SCREEN_WIN32)
+    o->console = CON_INIT;
+#elif 1 && defined(__linux__)
+    o->console = CON_INIT;
+#endif
+    o->verbose = 2;
+
+    opt->o_unix.osabi0 = 3; // 3 == ELFOSABI_LINUX
+
+    o->win32_pe.compress_exports = 1;
+    o->win32_pe.compress_icons = 2;
+    o->win32_pe.compress_resources = -1;
+    for (unsigned i = 0; i < TABLESIZE(o->win32_pe.compress_rt); i++)
+        o->win32_pe.compress_rt[i] = -1;
+    o->win32_pe.compress_rt[24] = false; // 24 == RT_MANIFEST
+    o->win32_pe.strip_relocs = -1;
+    o->win32_pe.keep_resource = "";
+}
+
+static options_t global_options;
+options_t *opt = &global_options;
+
+/*************************************************************************
+//
+**************************************************************************/
+
+template <size_t N>
+static inline void test_options(const char *(&a)[N]) {
+    (void) main_get_options((int) (N - 1), ACC_UNCONST_CAST(char **, a));
+}
+
+TEST_CASE("getopt") {
+    options_t *saved_opt = opt;
+    options_t local_options;
+    opt = &local_options;
+    opt->reset();
+    opt->debug.getopt_throw_instead_of_exit = true;
+    static const char a0[] = "<argv0>";
+
+    SUBCASE("issue 587") {
+        const char *a[] = {a0, "--brute", "--lzma", nullptr};
+        test_options(a);
+        CHECK(opt->all_methods);
+        CHECK(opt->all_methods_use_lzma == 1);
+    }
+    SUBCASE("issue 587") {
+        const char *a[] = {a0, "--lzma", "--brute", nullptr};
+        test_options(a);
+        CHECK(opt->all_methods);
+        CHECK(opt->all_methods_use_lzma == 1);
+    }
+    SUBCASE("issue 587") {
+        const char *a[] = {a0, "--brute", "--no-lzma", nullptr};
+        test_options(a);
+        CHECK(opt->all_methods);
+        CHECK(opt->all_methods_use_lzma == -1);
+    }
+    SUBCASE("issue 587") {
+        const char *a[] = {a0, "--no-lzma", "--brute", nullptr};
+        test_options(a);
+        CHECK(opt->all_methods);
+        CHECK(opt->all_methods_use_lzma == -1);
+    }
+    SUBCASE("issue 587") {
+        const char *a[] = {a0, "--no-lzma", "--lzma", nullptr};
+        test_options(a);
+        CHECK(!opt->all_methods);
+        CHECK(opt->all_methods_use_lzma == 1);
+        CHECK(opt->method == M_LZMA);
+    }
+    SUBCASE("issue 587") {
+        const char *a[] = {a0, "--no-lzma", "--lzma", "--brute", nullptr};
+        test_options(a);
+        CHECK(opt->all_methods);
+        CHECK(opt->all_methods_use_lzma == 1);
+        CHECK(opt->method == -1);
+    }
+    SUBCASE("issue 587") {
+        const char *a[] = {a0, "--lzma", "--no-lzma", nullptr};
+        test_options(a);
+        CHECK(!opt->all_methods);
+        CHECK(opt->all_methods_use_lzma == -1);
+        CHECK(opt->method == -1);
+    }
+    SUBCASE("issue 587") {
+        const char *a[] = {a0, "--lzma", "--no-lzma", "--brute", nullptr};
+        test_options(a);
+        CHECK(opt->all_methods);
+        CHECK(opt->all_methods_use_lzma == -1);
+        CHECK(opt->method == -1);
+    }
+
+    opt = saved_opt;
+}
+
+/* vim:set ts=4 sw=4 et: */

src/options.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,13 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
-
+#pragma once
-#ifndef __UPX_OPTIONS_H
+#ifndef UPX_OPTIONS_H__
-#define __UPX_OPTIONS_H
+#define UPX_OPTIONS_H__ 1
-
 
 /*************************************************************************
 // globals
@@ -37,22 +36,34 @@
 // options - command
 enum {
     CMD_NONE,
-    CMD_COMPRESS, CMD_DECOMPRESS, CMD_TEST, CMD_LIST, CMD_FILEINFO,
+    CMD_COMPRESS,
-    CMD_HELP, CMD_LICENSE, CMD_VERSION
+    CMD_DECOMPRESS,
+    CMD_TEST,
+    CMD_LIST,
+    CMD_FILEINFO,
+    CMD_HELP,
+    CMD_LICENSE,
+    CMD_VERSION
 };
 
-
 struct options_t {
     int cmd;
 
     // compression options
     int method;
+    bool method_lzma_seen;
+    bool method_nrv2b_seen;
+    bool method_nrv2d_seen;
+    bool method_nrv2e_seen;
     int level;  // compression level 1..10
     int filter; // preferred filter from Packer::getFilters()
+    bool ultra_brute;
     bool all_methods; // try all available compression methods ?
-    bool all_methods_use_lzma;
+    int all_methods_use_lzma;
     bool all_filters; // try all available filters ?
     bool no_filter;   // force no filter
+    bool prefer_ucl;  // prefer UCL
+    bool exact;       // user requires byte-identical decompression
 
     // other options
     int backup;
@@ -63,6 +74,9 @@ struct options_t {
     bool no_env;
     bool no_progress;
     const char *output_name;
+    bool preserve_mode;
+    bool preserve_ownership;
+    bool preserve_timestamp;
     int small;
     int verbose;
     bool to_stdout;
@@ -70,45 +84,27 @@ struct options_t {
     // debug options
     struct {
         int debug_level;
+        bool disable_random_id; // for Packer::getRandomId()
         const char *dump_stub_loader;
-        char fake_stub_version[4+1];    // for internal debugging
+        char fake_stub_version[4 + 1];     // for internal debugging
-        char fake_stub_year[4+1];       // for internal debugging
+        char fake_stub_year[4 + 1];        // for internal debugging
+        bool getopt_throw_instead_of_exit; // for doctest
     } debug;
 
     // overlay handling
-    enum {
+    enum { SKIP_OVERLAY = 0, COPY_OVERLAY = 1, STRIP_OVERLAY = 2 };
-        SKIP_OVERLAY      = 0,
-        COPY_OVERLAY      = 1,
-        STRIP_OVERLAY     = 2
-    };
     int overlay;
 
-    // compression runtime parameters - see struct ucl_compress_config_t
+    // compression runtime parameters - see struct XXX_compress_config_t
-    struct crp_lzma_t {
-        int dummy;
-#if 0
-        unsigned pos_bits;              // pb
-        unsigned lit_pos_bits;          // lp
-        unsigned lit_context_bits;      // lc
-        unsigned dict_size;
-        unsigned mf_passes;
-#endif
-        void reset() { memset(this, 0, sizeof(*this)); }
-    };
-    struct crp_ucl_t {
-        unsigned max_offset;
-        unsigned max_match;
-        int s_level;
-        int h_level;
-        int p_level;
-        int c_flags;
-        unsigned m_size;
-        void reset() { memset(this, 0xff, sizeof(*this)); }
-    };
     struct crp_t {
-        crp_lzma_t  crp_lzma;
+        lzma_compress_config_t crp_lzma;
-        crp_ucl_t   crp_ucl;
+        ucl_compress_config_t crp_ucl;
-        void reset() { crp_lzma.reset(); crp_ucl.reset(); }
+        zlib_compress_config_t crp_zlib;
+        void reset() {
+            crp_lzma.reset();
+            crp_ucl.reset();
+            crp_zlib.reset();
+        }
     };
     crp_t crp;
 
@@ -139,7 +135,7 @@ struct options_t {
         bool boot_only;
         bool no_align;
         bool do_8bit;
-        bool do_8mb;
+        bool do_8mib;
     } ps1_exe;
     struct {
         unsigned blocksize;
@@ -147,9 +143,11 @@ struct options_t {
         bool is_ptinterp;       // is PT_INTERP, so don't adjust auxv_t
         bool use_ptinterp;      // use PT_INTERP /opt/upx/run
         bool make_ptinterp;     // make PT_INTERP [ignore current file!]
+        bool unmap_all_pages;   // thus /proc/self/exe vanishes
         unsigned char osabi0;   // replacement if 0==.e_ident[EI_OSABI]
-        enum { SCRIPT_MAX = 32 };
+        bool preserve_build_id; // copy the build-id to the compressed binary
-        const char *script_name;
+        bool android_shlib;     // keep some ElfXX_Shdr for dlopen()
+        bool force_pie;         // choose DF_1_PIE instead of is_shlib
     } o_unix;
     struct {
         bool le;
@@ -162,15 +160,12 @@ struct options_t {
         int strip_relocs;
         const char *keep_resource;
     } win32_pe;
+
+    void reset();
 };
 
 extern struct options_t *opt;
 
-
 #endif /* already included */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-

src/p_armpe.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,43 +22,55 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   markus@oberhumer.com      ml1050@users.sourceforge.net
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_P_ARMPE_H
-#define __UPX_P_ARMPE_H
+#define __UPX_P_ARMPE_H 1
+
 
 /*************************************************************************
 // arm/pe
 **************************************************************************/
 
-class PackArmPe : public PeFile
+class PackArmPe : public PeFile32
 {
-    typedef PeFile super;
+    typedef PeFile32 super;
 
 public:
     PackArmPe(InputFile *f);
-    ~PackArmPe();
+    virtual ~PackArmPe();
-    virtual int getFormat() const { return UPX_F_WINCE_ARM_PE; }
+    virtual int getFormat() const override { return UPX_F_WINCE_ARM_PE; }
-    virtual const char *getName() const { return "arm/pe"; }
+    virtual const char *getName() const override { return "arm/pe"; }
-    virtual const int *getCompressionMethods(int method, int level) const;
+    virtual const char *getFullName(const options_t *) const override { return "arm-wince.pe"; }
-    virtual const int *getFilters() const;
+    virtual const int *getCompressionMethods(int method, int level) const override;
+    virtual const int *getFilters() const override;
+    virtual void defineFilterSymbols(const Filter *) override {}
 
-    virtual void pack(OutputFile *fo);
+    virtual bool handleForceOption() override;
+    virtual void callCompressWithFilters(Filter &, int filter_strategy,
+                                         unsigned ih_codebase) override;
+    virtual void defineSymbols(unsigned ncsection, unsigned upxsection,
+                               unsigned sizeof_oh, unsigned isize_isplit,
+                               unsigned s1addr) override;
+    virtual void addNewRelocations(Reloc &, unsigned upxsection) override;
+    virtual unsigned getProcessImportParam(unsigned upxsection) override;
+    virtual void setOhDataBase(const pe_section_t *osection) override;
+    virtual void setOhHeaderSize(const pe_section_t *osection) override;
+    virtual void pack(OutputFile *fo) override;
 
-    virtual bool canPack();
+    virtual bool canPack() override;
-    virtual int canUnpack();
 
 protected:
-    virtual int buildLoader(const Filter *ft);
+    virtual void buildLoader(const Filter *ft) override;
-    virtual Linker* newLinker() const;
+    virtual Linker* newLinker() const override;
 
-    virtual unsigned processImports();
+    virtual const char *kernelDll() const override { return "COREDLL.dll"; }
-    virtual void processImports(unsigned, unsigned);
+    virtual void processImports2(unsigned, unsigned) override;
-    virtual void rebuildImports(upx_byte *&);
+    virtual void addStubImports() override;
 
-    virtual void processTls(Interval *);
+    virtual void processTls(Interval *) override;
 
     bool use_thumb_stub;
 };
@@ -66,7 +78,4 @@ protected:
 
 #endif /* already included */
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/

src/p_com.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2006 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2022 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2006 Laszlo Molnar
+   Copyright (C) 1996-2022 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   markus@oberhumer.com      ml1050@users.sourceforge.net
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -36,7 +36,7 @@
 static const
 #include "stub/i086-dos16.com.h"
 
-//#define TESTING
+//#define TESTING 1
 
 
 /*************************************************************************
@@ -45,16 +45,11 @@ static const
 
 const int *PackCom::getCompressionMethods(int method, int level) const
 {
-    static const int m_nrv2b[] = { M_NRV2B_LE16, -1 };
+    static const int m_nrv2b[] = { M_NRV2B_LE16, M_END };
-    if (M_IS_NRV2B(method))
-        return m_nrv2b;
 #if 0
-    // NOT IMPLEMENTED
+    static const int m_nrv2d[] = { M_NRV2D_LE16, M_END };
-    static const int m_nrv2d[] = { M_NRV2D_LE16, -1 };
-    if (M_IS_NRV2D(method))
-        return m_nrv2d;
 #endif
-    UNUSED(level);
+    UNUSED(method); UNUSED(level);
     return m_nrv2b;
 }
 
@@ -63,7 +58,7 @@ const int *PackCom::getFilters() const
 {
     static const int filters[] = {
         0x06, 0x03, 0x04, 0x01, 0x05, 0x02,
-    -1 };
+    FT_END };
     return filters;
 }
 
@@ -101,7 +96,7 @@ void PackCom::patchLoader(OutputFile *fo,
 {
     const int e_len = getLoaderSectionStart("COMCUTPO");
     const int d_len = lsize - e_len;
-    assert(e_len > 0 && e_len < 256);
+    assert(e_len > 0 && e_len < 128);
     assert(d_len > 0 && d_len < 256);
 
     const unsigned upper_end = ph.u_len + ph.overlap_overhead + d_len + 0x100;
@@ -116,9 +111,10 @@ void PackCom::patchLoader(OutputFile *fo,
     linker->defineSymbol("bytes_to_copy", ph.c_len + lsize);
     linker->defineSymbol("copy_source", ph.c_len + lsize + 0x100);
     linker->defineSymbol("copy_destination", upper_end);
-    linker->defineSymbol("COMCUTPO", ph.u_len + ph.overlap_overhead);
+    linker->defineSymbol("neg_e_len", 0 - e_len);
+    linker->defineSymbol("NRV2B160", ph.u_len + ph.overlap_overhead);
 
-    linker->relocate();
+    relocateLoader();
     loader = getLoader();
 
     // some day we could use the relocation stuff for patchPackHeader too
@@ -135,9 +131,9 @@ void PackCom::patchLoader(OutputFile *fo,
 }
 
 
-int PackCom::buildLoader(const Filter *ft)
+void PackCom::buildLoader(const Filter *ft)
 {
-    initLoader(nrv2b_loader,sizeof(nrv2b_loader));
+    initLoader(stub_i086_dos16_com, sizeof(stub_i086_dos16_com));
     addLoader("COMMAIN1",
               ph.first_offset_found == 1 ? "COMSBBBP" : "",
               "COMPSHDI",
@@ -147,15 +143,13 @@ int PackCom::buildLoader(const Filter *ft)
               "NRVDECO1",
               ph.max_offset_found <= 0xd00 ? "NRVLED00" : "NRVGTD00",
               "NRVDECO2",
-              NULL
+              nullptr
              );
     if (ft->id)
     {
         assert(ft->calls > 0);
         addFilter16(ft->id);
     }
-    freezeLoader();
-    return getLoaderSize();
 }
 
 
@@ -170,7 +164,7 @@ void PackCom::addFilter16(int filter_id)
                   filter_id < 4 ? "" : (opt->cpu == opt->CPU_8086 ? "CT16I086" : "CT16I286,CT16SUB0"),
                   "CALLTRI2",
                   getFormat() == UPX_F_DOS_COM ? "CORETURN" : "",
-                  NULL
+                  nullptr
                  );
     else
         addLoader(filter_id%3 == 1 ? "CT16E800" : "CT16E900",
@@ -179,7 +173,7 @@ void PackCom::addFilter16(int filter_id)
                   filter_id < 4 ? "CT16SUB1" : "",
                   filter_id < 4 ? "" : (opt->cpu == opt->CPU_8086 ? "CT16I087" : "CT16I287,CT16SUB1"),
                   "CALLTRI6",
-                  NULL
+                  nullptr
                  );
 }
 
@@ -203,7 +197,7 @@ void PackCom::pack(OutputFile *fo)
     ft.addvalue = getCallTrickOffset();
     // compress
     const unsigned overlap_range = ph.u_len < 0xFE00 - ft.addvalue ? 32 : 0;
-    compressWithFilters(&ft, overlap_range);
+    compressWithFilters(&ft, overlap_range, NULL_cconf);
 
     const int lsize = getLoaderSize();
     MemBuffer loader(lsize);
@@ -229,7 +223,7 @@ int PackCom::canUnpack()
 {
     if (!readPackHeader(128))
         return false;
-    if (file_size <= (off_t) ph.c_len)
+    if (file_size_u <= ph.c_len)
         return false;
     return true;
 }
@@ -249,8 +243,8 @@ void PackCom::unpack(OutputFile *fo)
     fi->readx(ibuf,file_size);
 
     // get compressed data offset
-    int e_len = ph.buf_offset + ph.getPackHeaderSize();
+    unsigned e_len = ph.buf_offset + ph.getPackHeaderSize();
-    if (file_size <= e_len + (off_t)ph.c_len)
+    if (file_size_u <= e_len + ph.c_len)
         throwCantUnpack("file damaged");
 
     // decompress
@@ -272,8 +266,4 @@ Linker* PackCom::newLinker() const
     return new ElfLinkerX86();
 }
 
-
+/* vim:set ts=4 sw=4 et: */
-/*
-vi:ts=4:et
-*/
-