Update NEWS.

Bump release date.
Update Travis.
2017-05-12 13:01:20 +02:00 · 2017-05-12 12:47:14 +02:00 · 2017-05-12 12:45:43 +02:00 · 2017-05-09 22:50:18 +02:00 · 2017-05-05 18:36:44 -07:00 · 2017-05-04 08:28:03 -07:00
621 changed files with 186272 additions and 20211 deletions
@@ -0,0 +1,109 @@
+# Support for AppVeyor CI -- https://www.appveyor.com/
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+os: Visual Studio 2015
+
+environment:
+  global: { TRAVIS_OS_NAME: windows, CROSS: "", C: "", B: release, T: "", X: "" }
+  matrix:
+    - { C: msvc-10.0-x86, CL_VERSION: 16.00, VS_VERSION: 2010 }
+### - { C: msvc-10.0-x64, CL_VERSION: 16.00, VS_VERSION: 2010 } # AppVeyor: x64 compiler is not installed
+    - { C: msvc-11.0-x86, CL_VERSION: 17.00, VS_VERSION: 2012 }
+### - { C: msvc-11.0-x64, CL_VERSION: 17.00, VS_VERSION: 2012 } # AppVeyor: x64 compiler is not installed
+    - { C: msvc-12.0-x86, CL_VERSION: 18.00, VS_VERSION: 2013 }
+    - { C: msvc-12.0-x64, CL_VERSION: 18.00, VS_VERSION: 2013 }
+    - { C: msvc-14.0-x86, CL_VERSION: 19.00, VS_VERSION: 2015 }
+    - { C: msvc-14.0-x64, CL_VERSION: 19.00, VS_VERSION: 2015 }
+    - { C: msvc-15.0-x86, CL_VERSION: 19.10, VS_VERSION: 2017, APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 }
+    - { C: msvc-15.0-x64, CL_VERSION: 19.10, VS_VERSION: 2017, APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017 }
+#   - { C: gcc-4.9-m32, T: SKIP }
+#   - { C: gcc-4.9-m64, T: SKIP }
+  UPX_AUTOMATIC_BUILDS_SSL_KEY:
+    secure: PZMpVeqnEYe39kK+Zu2/fnmZ6/HG6Lvls0hh9GMVU9vCWsr8xaU7kIbHBS01puUkb4bEWPILKYvSEDuhOhguDjd/P4QdXWipvV/F2GaVax0=
+  UPX_AUTOMATIC_BUILDS_SSL_IV:
+    secure: ZshjJ/78dbY60mVJjZJv9Si7rHY9VQb1tfQvFd4lqvY=
+
+init:
+  - git config --global core.autocrlf input
+  - 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
+# - bash --version & git --version & sed --version & tar --version
+  - git --version & bash --version
+# - dir "c:\Program Files\Git\usr\bin"
+# - dir "c:\cygwin\bin"
+# - dir "c:\mingw\bin"
+# - dir "c:\mingw-w64\i686-5.3.0-posix-dwarf-rt_v4-rev0\mingw32\bin"
+
+install:
+  - cd c:\projects
+  - md build build\%C% deps
+  - cd c:\projects\upx
+  - git submodule update --init --recursive
+  - cd c:\projects\deps
+  - curl -q -L --retry 5 -o ucl-1.03.tar.gz   "https://github.com/upx/upx/releases/download/v3.00/ucl-1.03.tar.gz"
+  - curl -q -L --retry 5 -o zlib-1.2.8.tar.gz "https://github.com/upx/upx/releases/download/v3.00/zlib-1.2.8.tar.gz"
+  - git clone https://github.com/upx/upx-testsuite
+  - tar -xzf ucl-1.03.tar.gz
+  - tar -xzf zlib-1.2.8.tar.gz
+  # patch UCL for msvc-14.0 (vsnprintf issue)
+  - sed -i '/# *define.*snprintf  *_v*snprintf$/d' ucl-1.03/acc/acc_auto.h
+##- curl -q -L --retry 5 -o config.guess "http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD"
+##- curl -q -L --retry 5 -o config.sub   "http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD"
+##- cp config.guess config.sub ucl-1.03/acconfig/
+  # setup compiler
+  - if "%C%"=="msvc-10.0-x86" ( call "c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" x86 )
+  - if "%C%"=="msvc-10.0-x64" ( call "c:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat" amd64 )
+  - if "%C%"=="msvc-11.0-x86" ( call "c:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\vcvarsall.bat" x86 )
+  - if "%C%"=="msvc-11.0-x64" ( call "c:\Program Files (x86)\Microsoft Visual Studio 11.0\VC\vcvarsall.bat" amd64 )
+  - if "%C%"=="msvc-12.0-x86" ( call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat" x86 )
+  - if "%C%"=="msvc-12.0-x64" ( call "c:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\vcvarsall.bat" amd64 )
+  - if "%C%"=="msvc-14.0-x86" ( call "c:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" x86 )
+  - if "%C%"=="msvc-14.0-x64" ( call "c:\Program Files (x86)\Microsoft Visual Studio 14.0\VC\vcvarsall.bat" amd64 )
+  - if "%C%"=="msvc-15.0-x86" ( call "c:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" x86 )
+  - if "%C%"=="msvc-15.0-x64" ( call "c:\Program Files (x86)\Microsoft Visual Studio\2017\Community\VC\Auxiliary\Build\vcvarsall.bat" amd64 )
+
+build_script:
+  - cd c:\projects\upx
+  - if "%C%"=="gcc-4.9-m32" set PATH=c:\cygwin\bin;%PATH%
+  - if "%C%"=="gcc-4.9-m32" bash -x ./.github/travis_build.sh
+  - if "%C%"=="gcc-4.9-m32" exit
+  - if "%C%"=="gcc-4.9-m64" set PATH=c:\cygwin\bin;%PATH%
+  - if "%C%"=="gcc-4.9-m64" bash -x ./.github/travis_build.sh
+  - if "%C%"=="gcc-4.9-m64" exit
+  # setup directories following the VPATH build in travis_build.sh
+  - where cl & where link
+  - set BDIR=c:\projects\build\%C%\%B%
+  - md %BDIR% %BDIR%\ucl-1.03 %BDIR%\upx %BDIR%\upx-testsuite %BDIR%\zlib-1.2.8
+  - set DEFS=-D_CRT_SECURE_NO_WARNINGS
+  - git rev-parse --short=12 HEAD > %BDIR%\upx\.GITREV.txt
+  # build UCL
+  - cd %BDIR%\ucl-1.03
+  - set s=c:\projects\deps\ucl-1.03
+  - cl -MT -O2 -W4 %DEFS% -I%s%\include -I%s% -c %s%\src\*.c
+  - link -lib -out:ucl.lib *.obj
+  # build zlib
+  - cd %BDIR%\zlib-1.2.8
+  - cl -MT -O2 -W2 %DEFS% -c c:\projects\deps\zlib-1.2.8\*.c
+  - link -lib -out:zlib.lib *.obj
+  # build UPX
+  - cd %BDIR%\upx
+  - set s=c:\projects\upx\src
+  - cat .GITREV.txt
+  - set /p GITREV=<.GITREV.txt
+  - cl -MT -EHsc -J -O2 -W4 -WX -DUPX_VERSION_GITREV="""%GITREV%""" %DEFS% -DWITH_LZMA=0x443 -DUCL_NO_ASM -I%s%\lzma-sdk -Ic:\projects\deps\ucl-1.03\include -Ic:\projects\deps\zlib-1.2.8 -Feupx.exe %s%\*.cpp %BDIR%\ucl-1.03\ucl.lib %BDIR%\zlib-1.2.8\zlib.lib
+
+test_script:
+  - set UPX=--no-color --no-progress
+  - cd %BDIR%\upx
+  # basic tests
+  - .\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
+  # now run the UPX testsuite using bash
+  - cd c:\projects\upx
+  - bash ./.github/travis_testsuite_1.sh
+  - bash ./.github/travis_deploy.sh
+
+# vim:set ts=2 sw=2 et:
@@ -1,5 +0,0 @@
-.cvsignore
-.mfxcvsup
-ChangeLog.cvs*
-build
-maint
@@ -0,0 +1,21 @@
+#
+# see http://editorconfig.org/
+#
+
+[*]
+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
@@ -0,0 +1,33 @@
+<!---
+
+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:
@@ -0,0 +1,169 @@
+#! /bin/bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+
+# Support for Travis CI -- https://travis-ci.org/upx/upx/builds
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+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 ./src/stub/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-20160918")
+    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/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
+
+#
+# build UCL
+#
+
+cd / && cd $ucl_BUILDDIR || exit 1
+# patch UCL
+sed 's/^#elif (ACC_ARCH_AMD64 || ACC_ARCH_IA64)$/& \&\& !defined(__ILP32__)/' $ucl_SRCDIR/acc/acc_chk.ch > a.tmp
+if cmp -s a.tmp $ucl_SRCDIR/acc/acc_chk.ch; then rm a.tmp; else mv a.tmp $ucl_SRCDIR/acc/acc_chk.ch; fi
+if [[ $BUILD_LOCAL_UCL == 1 ]]; then
+    # ucl-1.03/configure is too old - build manually
+    rm -f ./*.o libucl.a
+    $CC -O2 -I$ucl_SRCDIR/include -I$ucl_SRCDIR -c $ucl_SRCDIR/src/*.c
+    $AR rcs libucl.a *.o
+    mkdir -p src/.libs
+    cp libucl.a src/.libs
+else
+    if [[ ! -f config.status ]]; then
+        $ucl_SRCDIR/configure --enable-static --disable-shared --disable-asm
+    fi
+    make
+fi
+
+#
+# build zlib
+#
+
+if [[ $BUILD_LOCAL_ZLIB == 1 ]]; then
+    cd / && cd $zlib_BUILDDIR || exit 1
+    # build manually
+    rm -f ./*.o libz.a
+    $CC -O2 -c $zlib_SRCDIR/*.c
+    $AR rcs libz.a *.o
+fi
+
+#
+# build UPX
+#
+
+export UPX_UCLDIR="$ucl_SRCDIR"
+cd / && cd $upx_BUILDDIR || exit 1
+make="make -f $upx_SRCDIR/src/Makefile"
+EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS -DUCL_NO_ASM"
+EXTRA_LDFLAGS="$EXTRA_LDFLAGS -L$ucl_BUILDDIR/src/.libs"
+if [[ $BUILD_LOCAL_ZLIB == 1 ]]; then
+    EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS -I$zlib_SRCDIR"
+    EXTRA_LDFLAGS="$EXTRA_LDFLAGS -L$zlib_BUILDDIR"
+fi
+if [[ $BM_B =~ (^|\+)coverage($|\+) ]]; then
+    EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS -fprofile-arcs -ftest-coverage"
+    EXTRA_LDFLAGS="$EXTRA_LDFLAGS -fprofile-arcs -ftest-coverage"
+fi
+if [[ $BM_B =~ (^|\+)debug($|\+) ]]; then
+    make="$make BUILD_TYPE_DEBUG=1"
+fi
+if [[ $BM_B =~ (^|\+)sanitize($|\+) ]]; then
+    case $TRAVIS_OS_NAME-$CC in linux-gcc*) EXTRA_LDFLAGS="$EXTRA_LDFLAGS -fuse-ld=gold" ;; esac
+    make="$make BUILD_TYPE_SANITIZE=1"
+fi
+if [[ $BM_B =~ (^|\+)scan-build($|\+) ]]; then
+    make="$SCAN_BUILD $make"
+fi
+if [[ $BM_B =~ (^|\+)valgrind($|\+) ]]; then
+    EXTRA_CPPFLAGS="$EXTRA_CPPFLAGS -DWITH_VALGRIND"
+fi
+if [[ $BM_B =~ (^|\+)ALLOW_FAIL($|\+) ]]; then
+    echo "ALLOW_FAIL"
+    set +e
+fi
+export EXTRA_CPPFLAGS EXTRA_CXXFLAGS EXTRA_LDFLAGS
+
+[[ -z $upx_exeext ]] && upx_exeext=.out
+$make exeext=$upx_exeext
+
+pwd
+ls -l upx${upx_exeext}
+$SIZE upx${upx_exeext} || true
+file upx${upx_exeext}
+
+exit 0
@@ -0,0 +1,194 @@
+#! /bin/bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+
+# Support for Travis CI -- https://travis-ci.org/upx/upx/builds
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+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
+
+set -x # debug
+
+if [[ $BM_X == rebuild-stubs ]]; then exit 0; fi
+# save space
+if [[ $BM_B =~ (^|\+)coverage($|\+) ]]; then exit 0; fi
+if [[ $BM_B =~ (^|\+)debug($|\+) ]]; then exit 0; fi
+if [[ $BM_B =~ (^|\+)sanitize($|\+) ]]; then exit 0; fi
+if [[ $BM_B =~ (^|\+)scan-build($|\+) ]]; then exit 0; fi
+if [[ $BM_B =~ (^|\+)valgrind($|\+) ]]; then exit 0; fi
+
+# prepare $subdir and $branch
+subdir=
+branch=
+if [[ -n $APPVEYOR_JOB_ID ]]; then
+    branch=$APPVEYOR_REPO_BRANCH
+    if [[ -n $APPVEYOR_PULL_REQUEST_NUMBER ]]; then exit 0; fi
+elif [[ -n $GITLAB_CI ]]; then
+    subdir=$CI_BUILD_NAME
+    branch=$CI_BUILD_REF_NAME
+else
+    branch=$TRAVIS_BRANCH
+    if [[ "$TRAVIS_PULL_REQUEST" != "false" ]]; then exit 0; fi
+fi
+subdir=${subdir%%:*}; subdir=${subdir%%/*}; subdir=${subdir%%--*}
+case $branch in
+    devel*) ;;
+    gitlab*) ;;
+    master*) ;;
+    travis*) ;;
+    *) exit 0;;
+esac
+
+# get $rev, $branch and $git_user
+cd / && cd $upx_SRCDIR || exit 1
+rev=$(git rev-parse --verify HEAD)
+if [[ "$branch" == gitlab* ]]; then
+    if git fetch -v origin devel; then
+        git branch -a -v
+        rev=$(git merge-base origin/devel $rev || echo $rev)
+    fi
+fi
+timestamp=$(git log -n1 --format='%at' $rev)
+date=$(TZ=UTC0 date -d "@$timestamp" '+%Y%m%d-%H%M%S')
+#branch="$branch-$date-${rev:0:6}"
+# make the branch name a little bit shorter so that it looks nice on GitHub
+branch="$branch-${date:0:8}-${rev:0:7}"
+if [[ -n $APPVEYOR_JOB_ID ]]; then
+    branch="$branch-appveyor"
+    git_user="AppVeyor CI"
+elif [[ -n $GITLAB_CI ]]; then
+    branch="$branch-gitlab"
+    git_user="GitLab CI"
+else
+    branch="$branch-travis"
+    git_user="Travis CI"
+fi
+unset timestamp date
+
+# /***********************************************************************
+# // prepare directory $d
+# ************************************************************************/
+
+cd / && cd $upx_BUILDDIR || exit 1
+
+mkdir deploy || exit 1
+chmod 700 deploy
+cd deploy || exit 1
+
+if [[ -n $BM_CROSS ]]; then
+    d=$BM_CROSS
+else
+    cpu=unknown
+    case $BM_C in
+        clang*-m32  | gcc*-m32)  cpu=i386;;
+        clang*-m64  | gcc*-m64)  cpu=amd64;;
+        clang*-mx32 | gcc*-mx32) cpu=amd64;;
+        msvc*-x86) cpu=i386;;
+        msvc*-x64) cpu=amd64;;
+    esac
+    os=$TRAVIS_OS_NAME
+    if [[ $os == osx ]]; then
+        os=darwin
+    elif [[ $os == windows ]]; then
+        [[ $cpu == i386 ]] && os=win32
+        [[ $cpu == amd64 ]] && os=win64
+    fi
+    d=$cpu-$os
+fi
+d=$d-$BM_C-$BM_B
+
+if [[ -n $subdir ]]; then
+    print_header "DEPLOY $subdir/$d"
+else
+    print_header "DEPLOY $d"
+fi
+
+mkdir $d || exit 1
+for exeext in .exe .out; do
+    f=$upx_BUILDDIR/upx$exeext
+    if [[ -f $f ]]; then
+        cp -p -i $f  $d/upx-git-${rev:0:12}$exeext
+        sha256sum -b $d/upx-git-${rev:0:12}$exeext
+    fi
+done
+
+# /***********************************************************************
+# // clone, add files & push
+# ************************************************************************/
+
+new_branch=0
+if ! git clone -b "$branch" --single-branch https://github.com/upx/upx-automatic-builds.git; then
+    git  clone -b master    --single-branch https://github.com/upx/upx-automatic-builds.git
+    new_branch=1
+fi
+cd upx-automatic-builds || exit 1
+chmod 700 .git
+git config user.name "$git_user"
+git config user.email "none@none"
+if [[ $new_branch == 1 ]]; then
+    git checkout --orphan "$branch"
+    git reset --hard || true
+fi
+git ls-files -v
+
+if [[ -n $subdir ]]; then
+    [[ -d $subdir ]] || mkdir $subdir
+    mv ../$d $subdir/
+    git add $subdir/$d
+else
+    mv ../$d .
+    git add $d
+fi
+
+if git diff --cached --exit-code --quiet >/dev/null; then
+    # nothing to do ???
+    exit 0
+fi
+
+now=$(date '+%s')
+##date=$(TZ=UTC0 date -d "@$now" '+%Y-%m-%d %H:%M:%S')
+git commit --date="$now" -m "Automatic build $d"
+git ls-files -v
+#git log --pretty=fuller
+
+umask 077
+[[ -d ~/.ssh ]] || mkdir ~/.ssh
+fix_home_ssh_perms
+repo=$(git config remote.origin.url)
+ssh_repo=${repo/https:\/\/github.com\//git@github.com:}
+eval $(ssh-agent -s)
+set +x # IMPORTANT
+openssl aes-256-cbc -d -a -K "$UPX_AUTOMATIC_BUILDS_SSL_KEY" -iv "$UPX_AUTOMATIC_BUILDS_SSL_IV" -in "$upx_SRCDIR/.github/upx-automatic-builds@github.com.enc" -out .git/deploy.key
+set -x
+chmod 600 .git/deploy.key
+ssh-add .git/deploy.key
+fix_home_ssh_perms
+ssh-keyscan -H github.com >> ~/.ssh/known_hosts
+fix_home_ssh_perms
+
+let i=0 || true
+while true; do
+    if [[ $i -ge 10 ]]; then
+        echo "ERROR: git push failed"
+        exit 1
+    fi
+    if [[ $new_branch == 1 ]]; then
+        if git push -u $ssh_repo "$branch"; then break; fi
+    else
+        if git push    $ssh_repo "$branch"; then break; fi
+    fi
+    git branch -a -v
+    git fetch -v origin "$branch"
+    git branch -a -v
+    git rebase FETCH_HEAD
+    git branch -a -v
+    sleep $((RANDOM % 5 + 1))
+    let i+=1
+done
+
+exit 0
@@ -0,0 +1,256 @@
+## vim:set ts=4 sw=4 et:
+
+# Support for Travis CI -- https://travis-ci.org/upx/upx/builds
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+#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")
+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 egrep -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 egrep -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
+    fi
+fi # BM_CROSS
+if [[ "$CC" == "false" ]]; then # generic
+if [[ -z $BM_CROSS ]]; then
+    case $BM_C in
+        clang | clang-m?? | clang-3.4-m?? | clang-[678][0-9][0-9]-m??)
+            CC="clang"; CXX="clang++" ;; # standard system compiler
+        clang-[3].[0-9]-m??)
+            v=${BM_C:6:3}; 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-[56]-m?? | gcc-[56]-mx32)
+            v=${BM_C:4:1}; CC="gcc-$v"; CXX="g++-$v" ;;
+    esac
+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.8)
+
+# 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 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.8")
+[[ -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
+}
+
+fix_home_ssh_perms() {
+    if [[ -d ~/.ssh ]]; then
+        if [[ -x /usr/sbin/restorecon ]]; then
+            /usr/sbin/restorecon -v -R ~/.ssh || true
+        fi
+        chmod -c -R go-rwx ~/.ssh || true
+    fi
+}
+
+true
@@ -0,0 +1,380 @@
+#! /bin/bash
+## vim:set ts=4 sw=4 et:
+set -e; set -o pipefail
+
+# Support for Travis CI -- https://travis-ci.org/upx/upx/builds
+# 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
+[[ -f $upx_exe ]] && upx_exe=$(readlink -en -- "$upx_exe")
+
+# create dirs
+cd / || exit 1
+mkbuilddirs $upx_testsuite_BUILDDIR
+cd / && cd $upx_testsuite_BUILDDIR || exit 1
+if [[ ! -d $upx_testsuite_SRCDIR/files/packed ]]; then exit 1; fi
+
+# /***********************************************************************
+# // 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=1
+        let num_errors+=1 || true
+        all_errors="${all_errors} $1"
+        #exit 1
+    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 1
+    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"
+}
+
+########## begin .sha256sums.recreate
+expected_sha256sums__t010_decompressed="\
+24158f78c34c4ef94bb7773a6dda7231d289be76c2f5f60e8b9ddb3f800c100e *amd64-linux.elf/upx-3.91
+28d7ca8f0dfca8159e637eaf2057230b6e6719e07751aca1d19a45b5efed817c *arm-wince.pe/upx-3.91.exe
+b1c1c38d50007616aaf8e942839648c80a6111023e0b411e5fa7a06c543aeb4a *armeb-linux.elf/upx-3.91
+bcac77a287289301a45fde9a75e4e6c9ad7f8d57856bae6eafaae12ae4445a34 *i386-dos32.djgpp2.coff/upx-3.91.exe
+730a513b72a094697f827e4ac1a4f8ef58a614fc7a7ad448fa58d60cd89af7ed *i386-linux.elf/upx-3.91
+0dbc3c267ca8cd35ee3ea138b59c8b1ae35872c918be6d17df1a892b75710f9b *i386-win32.pe/upx-3.91.exe
+8e5333ea040f5594d3e67d5b09e005d52b3a52ef55099a7c11d7e39ead38e66d *m68k-atari.tos/upx-3.91.ttp
+c3f44b4d00a87384c03a6f9e7aec809c1addfe3e271244d38a474f296603088c *mipsel-linux.elf/upx-3.91
+b8c35fa2956da17ca505956e9f5017bb5f3a746322647e24ccb8ff28059cafa4 *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t020_canonicalized="\
+24158f78c34c4ef94bb7773a6dda7231d289be76c2f5f60e8b9ddb3f800c100e *amd64-linux.elf/upx-3.91
+28d7ca8f0dfca8159e637eaf2057230b6e6719e07751aca1d19a45b5efed817c *arm-wince.pe/upx-3.91.exe
+b1c1c38d50007616aaf8e942839648c80a6111023e0b411e5fa7a06c543aeb4a *armeb-linux.elf/upx-3.91
+bcac77a287289301a45fde9a75e4e6c9ad7f8d57856bae6eafaae12ae4445a34 *i386-dos32.djgpp2.coff/upx-3.91.exe
+730a513b72a094697f827e4ac1a4f8ef58a614fc7a7ad448fa58d60cd89af7ed *i386-linux.elf/upx-3.91
+0dbc3c267ca8cd35ee3ea138b59c8b1ae35872c918be6d17df1a892b75710f9b *i386-win32.pe/upx-3.91.exe
+8e5333ea040f5594d3e67d5b09e005d52b3a52ef55099a7c11d7e39ead38e66d *m68k-atari.tos/upx-3.91.ttp
+c3f44b4d00a87384c03a6f9e7aec809c1addfe3e271244d38a474f296603088c *mipsel-linux.elf/upx-3.91
+b8c35fa2956da17ca505956e9f5017bb5f3a746322647e24ccb8ff28059cafa4 *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t110_compress_ucl_nrv2b_3_no_filter="\
+c82d400d99a78f21b594ad9900208ee89b3df5b67723c06dbb374dc3f42ca934 *amd64-linux.elf/upx-3.91
+5b9ec916beae0eadc665235158a9ae5bce1309823a344503268a88e32e77824a *arm-wince.pe/upx-3.91.exe
+a099aedddbaa960247209e08ed922b43f4bbd6559ad646a6ff801384e2f661eb *armeb-linux.elf/upx-3.91
+960dc15876221832510142816605b9ef568c0de3050ca0a79f3553643c5d5e0f *i386-dos32.djgpp2.coff/upx-3.91.exe
+43ec77282bbe73eb5d6f5471e9593127928bcfc2ebaedd93dd86969b12c9c61d *i386-linux.elf/upx-3.91
+ca6925a15c1ab8931f0a8fe9ef87f5893403d6e46098f4cd1a5f6f6f0fbdeb44 *i386-win32.pe/upx-3.91.exe
+14ff2a4e215a25ed7442b004bca3d82094f7c01784fc4876eb50d365441f35c3 *m68k-atari.tos/upx-3.91.ttp
+4163afbb2475b669e131265c0f7ea179c35f19ccce66732feee08fe20c33775e *mipsel-linux.elf/upx-3.91
+00c9d16157a734e1b386e5fe01dbae76c7f8ab7d6035dfa6975d656b43ef4e67 *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t120_compress_ucl_nrv2d_3_no_filter="\
+27b530885ccb425cf14963feea677c4177cce5324821c277823b3262a7a6ced4 *amd64-linux.elf/upx-3.91
+22216286b1bf3066d9022b921f37beff6712b5f3fc8c092f2dc1477638d9f8cc *arm-wince.pe/upx-3.91.exe
+90e2960d01214b3e2f62f76effa2360fed655e72392acfa8096d1d9a729ade21 *armeb-linux.elf/upx-3.91
+b6e98d36bd916fa63ec799e47dd7cac3674154370a9680492d84f1853bf14c3e *i386-dos32.djgpp2.coff/upx-3.91.exe
+483e4a7eba0b88302658fcaacb7ee1de32fb514dac5dccb010a55a5202918c0c *i386-linux.elf/upx-3.91
+d2692b3e4a278559456e299164714c4bb8ebbcf230ab12521619e2e94580597d *i386-win32.pe/upx-3.91.exe
+cd1ae0f2781787bf7c61f3600cc889313e6027615d78e562d624d717671e55c3 *m68k-atari.tos/upx-3.91.ttp
+26b30c10ba8980fa6fc564b79eb2931e07bb7b2f89f07a0656c28be71185a3ea *mipsel-linux.elf/upx-3.91
+bbce9449d105e4ac7e9a04d56b286cbba3b34c1bf8ee928e9e97a4943ae3c5ac *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t130_compress_ucl_nrv2e_3_no_filter="\
+81a528ed6f678bdbb1c18a9ee69b7d04169466e756a71baa98c7651ad1c40bec *amd64-linux.elf/upx-3.91
+08c55815175ce0d34fca3b368336dd346a2354dbe4f046210c82f6961350a50f *arm-wince.pe/upx-3.91.exe
+6dae3b18770e6af45e074b092c1f2f3632bef1996ce71af0f6e252caf34555a1 *armeb-linux.elf/upx-3.91
+45f50d69e685f7ea752f76c05554d4c2ce023c0218465a4f8919138a76ae6c71 *i386-dos32.djgpp2.coff/upx-3.91.exe
+f1db16f6be23b0bd96226e7e57f8b41ddfb93ede5ca0750ae680bbd615523083 *i386-linux.elf/upx-3.91
+eb7c2f74979c11b35193a0a9d428596bda46420d9363666fe1b967f5cd1610c6 *i386-win32.pe/upx-3.91.exe
+cefb13395220fb2e931d0fb32e27663c4a27035f9e79131bbabc44fa54e6336e *m68k-atari.tos/upx-3.91.ttp
+602be188fca1dd63593a2ace68ea221d720fd2ddf9df85c1ab019feda69f1cad *mipsel-linux.elf/upx-3.91
+2f299fdbc37bf6675559c5b1245aecf56de268bc074bd558bd7d9f84f7be5eae *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t140_compress_lzma_2_no_filter="\
+12d2ec20370655396711fc794db41745c21f51c998b766e6aa96283feb00eb48 *amd64-linux.elf/upx-3.91
+9759deb5aa8fb004c4b23bbe174042e45869aedeea1a1dd1b729be0e736814da *arm-wince.pe/upx-3.91.exe
+9b25bcc69fcdbdf4b4adc54e5c6508749c918179644ff9fa34b437bc7e42eca5 *armeb-linux.elf/upx-3.91
+a2a800d2ba5cfc1b6bb2b48c91adccb5d3c3b6c0b5c548affccac9244197a312 *i386-dos32.djgpp2.coff/upx-3.91.exe
+1865bc9b76579e33df4038f3d0abf848993b0c865b687f4b4bd482099416ef80 *i386-linux.elf/upx-3.91
+80aba41aad8268085e853ec872f885981838a625c14095d21ba70cb7abe045a5 *i386-win32.pe/upx-3.91.exe
+bbed61e42fa7b330b5cde66e4614329f41e21facff1f3667edc03495219c29f9 *m68k-atari.tos/upx-3.91.ttp
+57b47244a3a0d01725cbdc9af8572cbe20e2d173857015ad4d32245b52577dc2 *mipsel-linux.elf/upx-3.91
+6b02b01fa48910a104b523b265503131e4259ef83765464d002614e1a4eba38f *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t150_compress_ucl_2_all_filters="\
+3e0df832830a4a0cca77da16868a2655f85b2b36f783123b6f067f5586460704 *amd64-linux.elf/upx-3.91
+c7b0f611e9941be58b700219e7a5d34cdbdbf972b6184b13dec5e98fe84de808 *arm-wince.pe/upx-3.91.exe
+ef7c6febc18d5ecf7d846f38d75f398a92b5b21eb5d35b1eac4935d0e6de92ac *armeb-linux.elf/upx-3.91
+425c9128285f49b41f9b736f48794f5bebba6981250f669e5a342016b89f2170 *i386-dos32.djgpp2.coff/upx-3.91.exe
+d6cb6d50dfda98ff8efbab2d2c8751adfb67df58652313c630d45db1b89e921e *i386-linux.elf/upx-3.91
+5565f8196d971feec261dc663ca7ec329fd82b1b18ad49593b865edbaa15765d *i386-win32.pe/upx-3.91.exe
+78f24d77855034d467568f05c22cb5e3abd167c90a4d89f4e2059c3e6faa3e2b *m68k-atari.tos/upx-3.91.ttp
+23d6856df8f31b9176e0f4709135ce81656ed94539bf909e873b787ce89821cd *mipsel-linux.elf/upx-3.91
+8dbf63b21d3ced1cceec71e507d3086de2612b8ce8ba35ee2d75acd06435baf1 *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t160_compress_all_methods_1_no_filter="\
+27a248133cd386332daa14ec25367b4f1ff5595df213a2d72c341bbb7f264033 *amd64-linux.elf/upx-3.91
+6b2333719a4fe6c8d2067f682d57cf6fc5fd928bffad4e61aaffcc31287772a7 *arm-wince.pe/upx-3.91.exe
+d094f3a0e80e579aa6afeac239aacb3d8210580acdb095c9fc5511d77da7aeaa *armeb-linux.elf/upx-3.91
+d09af3652aa601650f9cd0f125d54e50dfe57b45b9871567140e62a04d032407 *i386-dos32.djgpp2.coff/upx-3.91.exe
+110bb3344a27b2677085e130956371df43ca6c231c01070480bb3a9e519fed30 *i386-linux.elf/upx-3.91
+c3c8b428f7e57a528db89f1365b4f3fda60f0dc03eadb30775ecdbadaa19f0aa *i386-win32.pe/upx-3.91.exe
+53c77efbccf41072c4c206343ba3c838be04c47eab415d18c08f086d481612db *m68k-atari.tos/upx-3.91.ttp
+616cefa819c0e516c554faac20e6aaf9350a2aacf0041a2641d5809c0da220df *mipsel-linux.elf/upx-3.91
+04ad8f4a60de80bbba7953489d3ef4b74b89a3961ae764acee00bd6df814ed9a *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t170_compress_all_methods_no_lzma_5_no_filter="\
+c8f0808d9cd81ece5f04c33388e6c5a056e2ceeb03308a1aa390ea6afc22d6ba *amd64-linux.elf/upx-3.91
+685b7e419b8b0fe3cabdf338a5cad17da55edc608c1bb91c13580b5988d38908 *arm-wince.pe/upx-3.91.exe
+7344cf818e8a668c7364f47779742bf41b451ebb7db85abc917c463a5f9c9d9a *armeb-linux.elf/upx-3.91
+fd0652470c19ebb4a2d1a49e02e71acf9fadab78e513bb4f75d1dc26a0caa7a3 *i386-dos32.djgpp2.coff/upx-3.91.exe
+3b9dd7de613541f567b2573063399473deeaa015a1c3679fe0fb339d80724e0d *i386-linux.elf/upx-3.91
+5b334db8debd2d59470cad25c7b45e38f6195cdafe92dc8281e4edc9c51385ef *i386-win32.pe/upx-3.91.exe
+db1c6a70d990cb9a8e02db9b28054267658ce371b8a50e909efdd04cd3670279 *m68k-atari.tos/upx-3.91.ttp
+19b801ace68ca0ff034dd557d3ef0a8340d8f17d7b97f120727f67ce098a7d7a *mipsel-linux.elf/upx-3.91
+a0b3ba40848df9b3a8aac31bc20671992be179ec2d702337bd1addd15513c2e4 *powerpc-linux.elf/upx-3.91
+"
+########## end .sha256sums.recreate
+
+# /***********************************************************************
+# // 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"
+
+# let's go
+if ! $upx_run --version;          then echo "UPX-ERROR: FATAL: upx --version 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.91*; 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 checkums 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; then
+    echo "UPX-ERROR: upx --version 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
@@ -0,0 +1,68 @@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@@ -0,0 +1,58 @@
+/.bzr*
+/.hg*
+/.vscode*
+/Makevars.global*
+/build*
+/maint*
+
+.depend
+GNUmakefile
+MMakefile
+Makevars.local*
+tmp-testsuite*
+
+*.a
+*.dll
+*.lib
+*.py[cdo]
+*.so
+*.swp
+
+doc/*.1
+doc/*.doc
+doc/*.html
+doc/*.man
+doc/*.ps
+doc/*.tex
+
+src/compress_nrv*
+src/*.mft
+src/*.rc
+
+src/*.d
+src/*.exe
+src/*.map
+src/*.o
+src/*.obj
+src/*.out
+src/*.res
+src/*.ttp
+
+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
@@ -0,0 +1,4 @@
+[submodule "src/lzma-sdk"]
+    path = src/lzma-sdk
+    url = https://github.com/upx/upx-lzma-sdk.git
+    branch = master
@@ -0,0 +1,262 @@
+# Support for Travis CI -- https://travis-ci.org/upx/upx/builds
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+sudo: false
+language: cpp
+
+notifications: { email: { on_success: never, on_failure: change } }
+
+.ubuntu_toolchain_sources: &S
+  - ubuntu-toolchain-r-test
+  - llvm-toolchain-precise-3.5
+  - llvm-toolchain-precise-3.6
+  - llvm-toolchain-precise-3.7
+  - llvm-toolchain-precise-3.8
+  - llvm-toolchain-precise-3.9
+
+env:
+  global:
+    - CROSS= C= B= T= X=
+    - secure: "YXHLXK+CM5d8yELIUSSs+P0/CoefClO7/AUX1oBj5W75g+YzR5uS2doVsB8UH8S8/GdNxk4P9Jgn4EiEVnjfGgn2eAD9MVpDPIxyJs5vI+5G77asq3QNdSl6QFv3O9I/6yBoVCewgPFPqsMd7Yvs/Ea3LcQkqalVhrC8ybYtmfs6VL2w33gn2J3b3TCn/s21L0ijklM0xvP1GNMDtuUpTSish5wvGOHE/91rwtdUDbJR8u31QY7fTASDiNnL/7ihgEIZ5XxpDYXviX1GC+nemhX1fWpmVmuT8m30Ruodi0yJVGASw9i2SaKv/VX/fJ/w2vlCfspL5LMZKkVLlfpIo3mQGqmMHFxv7mNy+hRu50ptoWNSkWArcqifwveh2liHUpl4jTvWaVll5Tw5VUGJhAUdzCTnqLIbWFnKIgCedL3iRFi4+EbyWNxel8lFESMOTDZFfJG5yEiDJbgbLsUaT2GmrsOphwAG7zDcZzvYTdjg/lF4Wh0MUnQJ+0MhDpii8Ahjp49lAPdw8uRQyyY7d7ksYKXVIkbgl6dRCC5vZSPucJiFjq2BClqIoEmzZPvHveDbovzFkNhJX9tFLrHLcXbPPcegww1FGoQ3wBM6JwJ+TvSD6N4OdCmou05aDuuQeznHi3GxOScjGwxdMIU28fdJDCTDg2rOihm22kHVajo="
+    - secure: "JpSv3+QRmHcfN/bmT3mVkqET44NCPhM/qpcUssCVXnd2GW0qWURoyPHzVMn/gbeAkUjR6djtN3OzJ+M181QmlmTmE26pZC9Q6r1buNDWdkIH1FcpMCa67BBAjmq+yDwulDtvCMv0lbz60v57lzHBOLczF3yMxBVTjXxt1RsrzDLHzzVaDR5lEe+sQUNeRL7Vaq8crimPNTr4ZhMe59eweTO/3AWovuSPf250k1flfv7I8audZgrVZdbVKvj5C3Sziy1AGXcu8mDfET9/Ya2XBCQHWODjiKlnhSxqthhP3gQuacaLjpS2FjvQlamd+I9x6BBoLSeNbiXD9vgCydDUKvmUrU+zQs64U1hHk9WZWVC19kG7lTtTdanGDIUlIUtFZgqE4AQpJaIUWkUmHGyHi61JMvduzX21eL5c5j9DoJteX42FPb1n3xK/JSnUkLMpbFdQuy5inhzefhDfeNzaYxt8nPwHnJqrF73SW4PLDKeRyzvg/P+zqcou8nXrHfA1z9/FlnYzf7Qc9meai9Q/JARX3Q1ZKu5uyG+RuBLe2POq0192w6pflTr1ZlLJsKNSc1147PviKfmpla1lg3/6uVzMp5tgwbve/hx9SDXiRueGttKw/ymsY662+8G24NRKo4fxNklWFHaB4owM84edDzXDckPXbPgue8/HQT8BFio="
+
+matrix:
+  fast_finish: true
+  include:
+    - os: linux
+      sudo: required
+      dist: trusty
+      compiler: gcc
+      env: X=rebuild-stubs
+      addons: { apt: { packages: [ "g++-multilib", "lib32z1" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.4-m32
+      addons: { apt: { sources: *S, packages: [ "g++-4.4-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.4-m64
+      addons: { apt: { sources: *S, packages: [ "g++-4.4" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.5-m32
+      addons: { apt: { sources: *S, packages: [ "g++-4.5-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.5-m64
+      addons: { apt: { sources: *S, packages: [ "g++-4.5" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.6-m32
+      addons: { apt: { packages: [ "g++-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.6-m64
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.7-m32
+      addons: { apt: { sources: *S, packages: [ "g++-4.7-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.7-m64
+      addons: { apt: { sources: *S, packages: [ "g++-4.7" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.8-m32
+      addons: { apt: { sources: *S, packages: [ "g++-4.8-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.8-m64
+      addons: { apt: { sources: *S, packages: [ "g++-4.8" ] } }
+    - os: linux
+      sudo: required
+      dist: trusty
+      compiler: gcc
+      env: C=gcc-4.8-mx32
+      addons: { apt: { packages: [ "g++-multilib", "libx32stdc++-4.8-dev" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.9-m32
+      addons: { apt: { sources: *S, packages: [ "g++-4.9-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-4.9-m64
+      addons: { apt: { sources: *S, packages: [ "g++-4.9" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-5-m32
+      addons: { apt: { sources: *S, packages: [ "g++-5-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-5-m64
+      addons: { apt: { sources: *S, packages: [ "g++-5" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-6-m32
+      addons: { apt: { sources: *S, packages: [ "g++-6-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-6-m64
+      addons: { apt: { sources: *S, packages: [ "g++-6" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-6-m32 B=debug
+      addons: { apt: { sources: *S, packages: [ "g++-6-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-6-m64 B=debug
+      addons: { apt: { sources: *S, packages: [ "g++-6" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-6-m64 B=debug+sanitize
+      addons: { apt: { sources: *S, packages: [ "g++-6" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-6-m64 B=sanitize
+      addons: { apt: { sources: *S, packages: [ "g++-6" ] } }
+    - os: linux
+      compiler: gcc
+      env: C=gcc-6-m64 B=valgrind T=valgrind
+      addons: { apt: { sources: *S, packages: [ "g++-6", valgrind ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.4-m32
+      addons: { apt: { packages: [ "g++-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.4-m64
+    - os: linux
+      compiler: clang
+      env: C=clang-3.5-m32
+      addons: { apt: { sources: *S, packages: [ "clang-3.5", "g++-6-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.5-m64
+      addons: { apt: { sources: *S, packages: [ "clang-3.5" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.6-m32
+      addons: { apt: { sources: *S, packages: [ "clang-3.6", "g++-6-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.6-m64
+      addons: { apt: { sources: *S, packages: [ "clang-3.6" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.7-m32
+      addons: { apt: { sources: *S, packages: [ "clang-3.7", "g++-6-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.7-m64
+      addons: { apt: { sources: *S, packages: [ "clang-3.7" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.8-m32
+      addons: { apt: { sources: *S, packages: [ "clang-3.8", "g++-6-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.8-m64
+      addons: { apt: { sources: *S, packages: [ "clang-3.8" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.9-m32
+      addons: { apt: { sources: *S, packages: [ "clang-3.9", "g++-6-multilib", "zlib1g-dev:i386" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.9-m64
+      addons: { apt: { sources: *S, packages: [ "clang-3.9" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.9-m64 B=debug+sanitize
+      addons: { apt: { sources: *S, packages: [ "clang-3.9" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.9-m64 B=sanitize
+      addons: { apt: { sources: *S, packages: [ "clang-3.9" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.9-m64 B=debug+scan-build
+      addons: { apt: { sources: *S, packages: [ "clang-3.9" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.9-m64 B=scan-build
+      addons: { apt: { sources: *S, packages: [ "clang-3.9" ] } }
+    - os: linux
+      compiler: gcc
+      env: CROSS=arm-linux-gnueabi C=gcc-4.6 T=SKIP
+      addons: { apt: { packages: [ "g++-arm-linux-gnueabi", "qemu-user" ] } }
+    - os: linux
+      compiler: gcc
+      env: CROSS=arm-linux-gnueabihf C=gcc-4.6 T=SKIP
+      addons: { apt: { packages: [ "g++-arm-linux-gnueabihf", "qemu-user" ] } }
+    - os: linux
+      compiler: gcc
+      env: CROSS=i386-w64-mingw32 C=gcc-4.6 T=wine
+      addons: { apt: { packages: [ "binutils-mingw-w64-i686", "g++-mingw-w64-i686", "wine" ] } }
+    - os: linux
+      compiler: gcc
+      env: CROSS=x86_64-w64-mingw32 C=gcc-4.6 T=wine
+      addons: { apt: { packages: [ "binutils-mingw-w64-x86-64", "g++-mingw-w64-x86-64", "wine" ] } }
+    - os: osx
+      osx_image: xcode6.4
+      compiler: clang
+      # must use debug build or else we get "ld: internal error: atom not found" when linking
+      env: C=clang-602-m32 B=debug
+    - os: osx
+      osx_image: xcode6.4
+      compiler: clang
+      # must use debug build or else we get "ld: internal error: atom not found" when linking
+      env: C=clang-602-m64 B=debug
+    - os: osx
+      osx_image: xcode7.3
+      compiler: clang
+      env: C=clang-703-m32
+    - os: osx
+      osx_image: xcode7.3
+      compiler: clang
+      env: C=clang-703-m64
+    - os: osx
+      osx_image: xcode8.3
+      compiler: clang
+      env: C=clang-802-m32
+    - os: osx
+      osx_image: xcode8.3
+      compiler: clang
+      env: C=clang-802-m64
+
+install:
+  - uname -a; pwd; id; umask
+  - cat /etc/os-release || true
+  - |
+    cd /
+    if [[ $TRAVIS_OS_NAME == linux ]]; then
+      if [[ $B =~ (^|\+)coverage($|\+) ]]; then
+        travis_retry pip install --user cpp-coveralls
+      fi
+    fi
+    if [[ $TRAVIS_OS_NAME == osx ]]; then
+      if ! gsha256sum </bin/sh >/dev/null 2>/dev/null; then travis_retry brew install coreutils; fi
+      if [[ $B =~ (^|\+)coverage($|\+) ]]; then
+        travis_retry brew install lcov
+        travis_retry pip install --user cpp-coveralls
+      fi
+    fi
+  - git --version && bash --version
+  - umask 022; cd $TRAVIS_BUILD_DIR && mkdir -p ../deps ../build/travis
+  - cd ../deps && travis_retry wget -q -O - https://github.com/upx/upx/releases/download/v3.00/ucl-1.03.tar.xz | tar -xJ
+  - cd ../deps && travis_retry wget -q -O - https://github.com/upx/upx/releases/download/v3.00/zlib-1.2.8.tar.xz | tar -xJ
+  - cd ../deps && travis_retry git clone https://github.com/upx/upx-testsuite
+  - |
+    if [[ $X =~ (^|\+)rebuild-stubs($|\+) ]]; then
+      cd ../deps && travis_retry wget -q -O - https://github.com/upx/upx-stubtools/releases/download/v20160918/bin-upx-20160918.tar.xz | tar -xJ
+    fi
+
+script:
+  - success=1
+  - cd $TRAVIS_BUILD_DIR || success=0
+  - test $success = 0 || bash ./.github/travis_build.sh || success=0
+  - test $success = 0 || bash ./.github/travis_testsuite_1.sh || success=0
+  - test $success = 0 || bash ./.github/travis_deploy.sh || success=0
+  - test $success = 1
+
+# vim:set ts=2 sw=2 et:
@@ -8,9 +8,8 @@


                    The Ultimate Packer for eXecutables
-          Copyright (c) 1996-2000 Markus Oberhumer & Laszlo Molnar
-               http://wildsau.idv.uni-linz.ac.at/mfx/upx.html
-                            http://upx.tsx.org
+   Copyright (c) 1996-2017 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io


 Limitations and other things which are not (yet) supported:
@@ -29,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
@@ -45,7 +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
@@ -1,8 +1,8 @@
                    GNU GENERAL PUBLIC LICENSE
                       Version 2, June 1991

- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
-     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 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
-    along with this program; if not, write to the Free Software
-    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    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.
@@ -1,27 +1,36 @@
-# Toplevel Makefile for UPX
+#
+# UPX toplevel Makefile - needs GNU make 3.81 or better
+#
+# Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+#

-all:
-	$(MAKE) -C src/stub
-	$(MAKE) -C src
-	$(MAKE) -C doc
+MAKEFLAGS += -rR
+.SUFFIXES:
+export SHELL = /bin/sh

-mostlyclean clean distclean maintainer-clean:
+srcdir = .
+top_srcdir = .
+include $(wildcard $(top_srcdir)/Makevars.global ./Makevars.local)
+
+# info: src/stub needs special build tools from https://github.com/upx/upx-stubtools
+BUILD_STUB = 0
+ifneq ($(wildcard $(HOME)/local/bin/bin-upx/upx-stubtools-check-version),)
+BUILD_STUB = 1
+endif
+ifneq ($(wildcard $(HOME)/bin/bin-upx/upx-stubtools-check-version),)
+BUILD_STUB = 1
+endif
+
+default:
+	@echo "UPX info: please choose a target for 'make'"
+
+all mostlyclean clean distclean maintainer-clean:
+ifeq ($(BUILD_STUB),1)
 	$(MAKE) -C src/stub $@
+endif
 	$(MAKE) -C src $@
 	$(MAKE) -C doc $@

-dist: distclean
-	false
-
-cvs-admin-ko:
-	cvs admin -ko .
-	cvs update
-
-ChangeLog:
-	perl scripts/cvs2cl.pl --utc -f ChangeLog.cvs
-
-.PHONY: all mostlyclean clean distclean maintainer-clean
-.PHONY: dist cvs-admin-ko ChangeLog
-
-.NOEXPORT:
+.PHONY: default all mostlyclean clean distclean maintainer-clean

+# vim:set ts=8 sw=8 noet:
@@ -2,16 +2,301 @@
 User visible changes for UPX
 ==================================================================

+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):
+  * UPX has moved to GitHub - the new home page is https://upx.github.io
+  * Fixed some win32/pe and win64/pe regressions introduced in 3.92
+  * bug fixes - see https://github.com/upx/upx/milestone/1
+
+Changes in 3.92 (11 Dec 2016):
+  * 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 occuring 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
+  * major source code changes: 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
+
+Changes in 2.01 (06 Jun 2006):
+  * arm/pe: better DLL support
+  * dos/exe: device driver support added
+  * linux/386: Fix --force-execve for PaX, grSecurity, and strict SELinux.
+    /tmp must support execve(); therefore /tmp cannot be mounted 'noexec'.
+  * win32/pe & arm/pe: added new option '--keep-resource=' for
+    excluding selected resources from compression
+
+Changes in 2.00 (27 Apr 2006):
+  * linux/386: the stub now prints an error message if some strict
+    SELinux mode does prevent runtime decompression and execution
+    (for a fully SELinux-compatible but otherwise inferior compression
+    format you can use the '--force-execve' option)
+  * linux/386: worked around a problem where certain Linux kernels
+    clobber the %ebx register during a syscall
+  * win32/pe: disable filters for files with broken PE headers
+
+Changes in 1.96 beta (13 Apr 2006):
+  * arm/pe: added filter support
+  * win32/pe: removed an unnecessary check so that Delphi 2006 and
+    Digital Mars C++ programs finally are supported
+
+Changes in 1.95 beta (09 Apr 2006):
+  * arm/pe: added DLL support
+  * arm/pe: added thumb mode stub support
+  * arm/pe: added unpacking support
+  * win32/pe: really worked around R6002 runtime errors
+
+Changes in 1.94 beta (11 Mar 2006):
+  * new format: added support for arm/pe (ARM executables running on WinCE)
+  * new format: added support for linux elf/amd64
+  * new format: added support for linux elf/ppc32
+  * new format: added support for mach/ppc32 (Apple Mac OS X)
+  * win32/pe: hopefully working "load config" support
+  * win32/pe: R6002 runtime errors worked around
+  * win32/pe: the stub now clears the dirty stack
+
+Changes in 1.93 beta (07 Feb 2005):
+  * vmlinuz/386: fixes to support more kernels
+
+Changes in 1.92 beta (20 Jul 2004):
+  * win32/pe: added option '--strip-loadconf' to strip the SEH load
+    config section [NOTE: this option is obsolete since UPX 1.94]
+  * win32/pe: try to detect .NET (win32/net) files [not yet supported by UPX]
+  * vmlinux/386: new format that directly supports building Linux kernels
+  * source code: now compiles cleanly under Win64
+
+Changes in 1.91 beta (30 Jun 2004):
+  * djgpp2/coff: added support for recent binutils versions
+  * linux/elf386, linux/sh386: lots of improvements
+  * vmlinuz/386: added support for recent kernels
+  * watcom/le: don't crash on files without relocations
+  * win32/pe: stricter checks of some PE values
+  * option '--brute' now implies '--crp-ms=999999'.
+  * source code: much improved portability using ACC, the
+    Automatic Compiler Configuration
+  * source code: compile fixes for strict ISO C++ compilers
+  * source code: compile fixes for Win64
+  * re-synced with upx 1.25 branch
+
+Changes in 1.90 beta (11 Nov 2002):
+  * implemented several new options for finer compression control:
+    '--all-methods', '--all-filters' and '--brute'
+  * ps1/exe: new format - UPX now supports PlayStation One programs
+  * linux/386: added the option '--force-execve'
+  * vmlinuz/386: better kernel detection and sanity checks
+  * re-synced with upx 1.24 branch
+  * documentation updates
+
 Changes in 1.11 beta (20 Dec 2000):
-  * UNSTABLE BETA VERSION - DO NOT USE EXCEPT FOR TESTING!!! REALLY.
  * vmlinuz/386: new format - UPX now supports bootable linux kernels
-  * linux/386: added the new direct-to-memory executable formats - no
+  * linux/elf386: added the new ELF direct-to-memory executable format - no
+    more temp files are needed for decompression!
+  * linux/sh386: added the new shell direct-to-memory executable format - no
    more temp files are needed for decompression!
  * reduced overall memory requirements during packing
  * quite a number of internal source code rearrangements

+==================================================================
+
+Changes in 1.25 (29 Jun 2004)
+  * INFO: http://upx.sourceforge.net is the permanent UPX home page
+  * watcom/le: don't crash on files without relocations
+  * win32/pe: stricter checks of some PE values
+  * source code: much improved portability using ACC, the
+    Automatic Compiler Configuration
+  * source code: compile fixes for strict ISO C++ compilers
+  * source code: compile fixes for Win64
+
+Changes in 1.24 (07 Nov 2002)
+  * djgpp2/coff: stricter check of the COFF header to work around a
+    problem with certain binutils versions
+
+Changes in 1.23 (05 Sep 2002)
+  * atari/tos: fixed an unpacking problem where a buffer was too
+    small (introduced in 1.22)
+  * linux/386: don't give up too early if a single block turns out
+    to be incompressible
+  * documentation: added some quick tips how to achieve the best
+    compression ratio for the final release of your application
+  * fixed a rare situation where the exit code was not set correctly
+
+Changes in 1.22 (27 Jun 2002)
+  * atari/tos: the stub now flushes the CPU cache to avoid
+    problems on 68030+ machines
+  * source code: additional compiler support for Borland C++,
+    Digital Mars C++ and Watcom C++
+
+Changes in 1.21 (01 Jun 2002)
+  * New option '--crp-ms=' for slightly better compression at the cost
+    of higher memory requirements during compression.
+    Try 'upx --best --crp-ms=100000'. See the docs for more info.
+  * source code: portability fixes
+  * source code: compile fixes for g++ 3.0 and g++ 3.1
+
+Changes in 1.20 (23 May 2001)
+  * slightly faster compression
+  * work around a gcc problem in the latest djgpp2 distribution
+  * watcom/le: fixed detection of already compressed files
+  * win32/pe: do not compress RT_MANIFEST resource types
+  * win32/pe: improved the error message for empty resource sections
+  * [NOTE: the jump from 1.08 to 1.20 is to avoid confusion with
+           our unstable development releases 1.1x and 1.9x]
+
+Changes in 1.08 (30 Apr 2001)
+  * new native port to atari/tos
+  * win32/pe: shortened the identstring
+  * source code: portability fixes - UPX now builds cleanly under m68k CPUs
+
+Changes in 1.07 (20 Feb 2001)
+  * win32/pe: corrected the TLS callback check
+  * win32/pe: really fixed that rare bug in relocation handling
+  * win32/pe: experimental support for SizeOfHeaders > 0x1000
+  * win32/pe: check for superfluous data between sections
+  * win32/pe: compressing screensavers (.scr) should finally work
+
+Changes in 1.06 (27 Jan 2001)
+  * win32/pe: the check for TLS callbacks introduced in 1.05
+      was too strict - disabled for now
+  * dos/com: decreased the decompressor stack size a little bit
+
+Changes in 1.05 (24 Jan 2001)
+  * win32/pe: refuse to compress programs with TLS callbacks
+  * win32/pe: stub changes to avoid slowdowns with some virus monitors
+  * win32/pe: reverted the relocation handling changes in 1.04
+  * linux/386: dont try to compress Linux kernel images (have a look
+      at the unstable UPX 1.1x beta versions for that)
+
 Changes in 1.04 (19 Dec 2000)
-  * dos/exe: fixed an internal error when using `--no-reloc'
+  * dos/exe: fixed an internal error when using '--no-reloc'
  * win32/pe: fixed a rare bug in the relocation handling code
  * some tunings for the default compression level

@@ -19,7 +304,7 @@ Changes in 1.03 (30 Nov 2000)
  * linked with a new version of the NRV compression library:
      - improved compression ratio a little bit
      - overall significantly faster compression
-      - much faster when using high compression levels like `-9' or `--best'
+      - much faster when using high compression levels like '-9' or '--best'
      - much faster with large files
  * atari/tos: added support for FreeMiNT
  * the 32-bit DOS version now uses the new CWSDSTUB extender
@@ -27,7 +312,7 @@ Changes in 1.03 (30 Nov 2000)
 Changes in 1.02 (13 Sep 2000)
  * watcom/le: fixed a problem with the Causeway extender
  * win32/pe: don't automatically strip relocs if they seem needed
-  * support multiple backup generations when using `-k'
+  * support multiple backup generations when using '-k'
  * updated the console screen driver

 Changes in 1.01 (09 Apr 2000)
@@ -55,7 +340,7 @@ Changes in 0.99.1 (29 Feb 2000)

 Changes in 0.99 (25 Feb 2000)
  * FULL SOURCE CODE RELEASED UNDER THE TERMS OF THE GNU GPL
-  * win32/pe: changed default to `--strip-relocs=1'
+  * win32/pe: changed default to '--strip-relocs=1'
  * dos/com and dos/sys: fixed a bad decompressor problem
  * linux/386: the counter for the progress indicator was off by one

@@ -78,7 +363,7 @@ Changes in 0.91 (13 Nov 1999)
  * dos/exe: correctly restore cs when uncompressing

 Changes in 0.90 (10 Nov 1999)
-  * all formats: `--overlay=copy' now is the default overlay mode
+  * all formats: '--overlay=copy' now is the default overlay mode
  * improved compression ratio for most files
  * win32/pe: uncompression is finally supported
  * win32/pe: never compress REGISTRY resources
@@ -88,7 +373,7 @@ Changes in 0.90 (10 Nov 1999)
  * win32/pe: somewhat less memory is required during compression
  * linux/386: fixed compression of scripts which was broken since 0.71
  * linux/386: more FreeBSD compatibility issues
-  * changed option: `-i' now prints some more details during compression
+  * changed option: '-i' now prints some more details during compression
    (not finished yet)

 Changes in 0.84 (04 Oct 1999)
@@ -104,7 +389,7 @@ Changes in 0.83 (17 Sep 1999)
 Changes in 0.82 (16 Aug 1999)
  * dos/exe: fixed a decompressor bug which could cause crash on some files
  * linux/386: section headers are now stripped from the stub so that
-    `strip' won't ruin a compressed file any longer
+    'strip' won't ruin a compressed file any longer
  * wc/le: support for stack not in the last object disabled again
  * win32/pe: removed some unneeded data

@@ -113,32 +398,32 @@ Changes in 0.81 (04 Aug 1999)
  * dos/com: fixed an internal error that could happen with very small files

 Changes in 0.80 (03 Aug 1999)
-  * you can set some default options in the environment var `UPX'
+  * you can set some default options in the environment var 'UPX'
  * dos/com: the decompressor stub now checks for enough free memory
  * dos/exe: decompressor rewritten, some bugs are fixed
-  * dos/exe: new option `--no-reloc': no relocation data is put into
+  * dos/exe: new option '--no-reloc': no relocation data is put into
    the DOS header
  * tmt/adam: added support for more stubs, detect already packed files
-  * tmt/adam: new option `--copy-overlay'
+  * tmt/adam: new option '--copy-overlay'
  * wc/le: reduced memory requirement during uncompression
  * wc/le: support files which do not contain their stack in the last object
  * wc/le: fixed a bug which could cause a crash, improved relocation
    handling
-  * wc/le: new option `--copy-overlay'
-  * win32/pe: `--compress-icons=2' is now the default
+  * wc/le: new option '--copy-overlay'
+  * win32/pe: '--compress-icons=2' is now the default
  * 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
-    results in a usual Windows message, importing a nonexistant function
+  * win32/pe: other import improvements: importing a nonexistent DLL
+    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: new option: '--compress-resources=0'
  * win32/pe: reduced memory requirement during uncompression, some
    files might even require LESS memory when they're compressed
  * win32/pe: TYPELIBs should work now
  * win32/pe: improved relocation handling, 16-bit relocations should work
-  * win32/pe: new option `--strip-relocs' (only if you know what you are doing)
-  * win32/pe: new option `--copy-overlay'
+  * win32/pe: new option '--strip-relocs' (only if you know what you are doing)
+  * win32/pe: new option '--copy-overlay'
  * important internal changes: now the stubs are built at runtime

 Changes in 0.72 (12 May 1999)
@@ -152,20 +437,20 @@ Changes in 0.72 (12 May 1999)
  * linux/386: minor decompressor stub updates, nicer progress bar

 Changes in 0.71 (19 Apr 1999)
-  * dos/exe: added option `--no-overlay'
+  * dos/exe: added option '--no-overlay'
  * linux/386: various improvements in the stub, most notably the
    overhead for an extra cleanup process has been removed
  * win32/pe: added support for export forwarders
  * win32/pe: added support for DLLs without entry point or imports
  * win32/pe: yet another .bss fix
-  * win32/pe: new option `--compress-icons=2': compress all icons
+  * win32/pe: new option '--compress-icons=2': compress all icons
    which are not in the first icon directory
  * win32/pe: rearranged stub to avoid false alerts from some virus scanners

 Changes in 0.70 (30 Mar 1999)
  * added support for linux/386 executables
  * improved compression ratio quite a bit
-  * added new compression level `--best' to squeeze out even some more bytes
+  * added new compression level '--best' to squeeze out even some more bytes
  * win32/pe: TLS support is much better now
  * win32/pe: --compress-icons=0 should now work as well
  * the usual minor fixes for win32/pe
@@ -182,13 +467,13 @@ 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
    an illegal value
  * added some compression flags for the win32/pe format
-  * added support for Atari ST executables (atari/tos)
+  * added support for Atari ST/TT executables (atari/tos)
  * improved compression ratio
  * improved compression speed

@@ -206,7 +491,7 @@ Changes in 0.40 (05 Oct 1998)
  * fixed a small but fatal bug in dos/sys introduced in 0.30
  * fixed a rare bug in dos/exe
  * worked around a bug in djgpp's strip 2.8
-  * Allegro packfile support should work now
+  * djgpp/coff: Allegro packfile support should work now
  * added dos/exeh compression method (works on 386+)

 Changes in 0.30 (27 Jul 1998)
@@ -223,3 +508,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 -*-
@@ -8,9 +8,8 @@


                    The Ultimate Packer for eXecutables
-          Copyright (c) 1996-2000 Markus Oberhumer & Laszlo Molnar
-               http://wildsau.idv.uni-linz.ac.at/mfx/upx.html
-                            http://upx.tsx.org
+   Copyright (c) 1996-2017 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io


 Here are some possible projects from which you can choose if you'd like to
@@ -31,8 +30,17 @@ User interface:
 More formats:
 -------------

- - add more file formats / platforms (there were volunteers for FreeBSD,
-   BeOS, Windows CE, Amiga, C64, ...)
+ - 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")
@@ -41,32 +49,24 @@ More formats:
 Existing formats:
 -----------------

- - dos/com: add support for very long files - convert to exe if necessary
-
- - dos/sys: add support for sys/exe combos
-
- - dos/exe: implement filter support
-
 - 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...)
-     - etc...
- - linux/i386: add a special elf/i386 format that understands
-     ELF files and has filter support

 - 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: finer control over resource compression, per section
-     compression
- - win32/pe: compressing screensavers looses the description - probably
-     should not compress a special resource type
+ - win32/pe: per section compression


 Compression ratio:
@@ -8,34 +8,17 @@


                    The Ultimate Packer for eXecutables
-          Copyright (c) 1996-2000 Markus Oberhumer & Laszlo Molnar
-               http://wildsau.idv.uni-linz.ac.at/mfx/upx.html
-                            http://upx.tsx.org
+   Copyright (c) 1996-2017 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io



-WARNING - UNSTABLE BETA VERSION
-===============================
-
-All versions 1.1x are unstable beta releases - use them only for testing,
-and never distribute a program that is packed with them !
-There will be hidden bugs. Really.
-
-The current stable release is 1.04, and the next stable release
-will be called version 1.20.
-
-The main news since 1.04 are support for bootable Linux kernels ("vmlinuz/386")
-and direct Linux ELF-to-memory decompression ("linux/elf386"), so there's
-no reason to use the unstable versions unless you want to try the new formats.
-
-
 WELCOME
 =======

-Welcome to UPX 1.0x, the first production release after almost two years
-of beta testing.
+Welcome to UPX !

-Please don't forget to read the new LICENSE - UPX is now distributed
+Please don't forget to read the file LICENSE - UPX is distributed
 under the GNU General Public License (GPL) with special exceptions
 allowing the distribution of all compressed executables, including
 commercial programs.
@@ -54,8 +37,8 @@ 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
-Win95/98/ME/NT/2000 programs and DLLs, DOS programs, and Linux
-executables and kernels.
+Windows 95/98/ME/NT/2000/XP/CE programs and DLLs, DOS programs,
+and Linux executables and kernels.

 UPX is free software distributed under the term of the GNU General
 Public License. Full source code is available.
@@ -64,7 +47,7 @@ UPX may be distributed and used freely, even with commercial applications.
 See the UPX License Agreement for details.

 UPX is rated number one in the well known Archive Comparison Test. Visit
-http://web.act.by.net/~act/act-exepack.html
+http://compression.ca/ .

 UPX aims to be Commercial Quality Freeware.

@@ -72,8 +55,8 @@ UPX aims to be Commercial Quality Freeware.
 SHORT DOCUMENTATION
 ===================

-`upx program.exe' will compress a program or DLL. For best compression
-results try `upx --best program.exe'.
+'upx program.exe' will compress a program or DLL. For best compression
+results try '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.
@@ -87,7 +70,7 @@ 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 2 years since our first public beta.
+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.
@@ -98,12 +81,7 @@ Please report all problems or suggestions to the authors. Thanks.
 THE FUTURE
 ==========

-  - We'd really love to support handheld systems like the PalmPilot because
-    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.
+  - AArch64 (64-bit ARM) for Linux and iOS.

  - The Linux approach could probably get ported to a lot of other Unix
    variants, at least for other i386 architectures it shouldn't be too
@@ -113,9 +91,8 @@ THE FUTURE
  - 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.
-    And don't trust any advertisment of authors of other executable
-    compressors about this topic - just do a websearch on something
-    like "procdump"...
+    And don't trust any advertisement of authors of other executable
+    compressors about this topic - just do a websearch on "unpackers"...

  - Fix all remaining bugs - keep your reports coming ;-)

@@ -126,8 +103,9 @@ THE FUTURE
 COPYRIGHT
 =========

-Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-Copyright (C) 1996-2000 Laszlo Molnar
+Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+Copyright (C) 1996-2017 Laszlo Molnar
+Copyright (C) 2000-2017 John F. Reiser

 This program may be used freely, and you are welcome to
 redistribute it under certain conditions.
@@ -142,12 +120,14 @@ with this program; see the file 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@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <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
@@ -8,21 +8,17 @@


                    The Ultimate Packer for eXecutables
+   Copyright (c) 1996-2017 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io


+MAJOR NEWS IN UPX 3
+===================

-WARNING - UNSTABLE BETA VERSION
-===============================
+The main news since UPX 2 are:

-All versions 1.1x are unstable beta releases - use them only for testing,
-and never distribute a program that is packed with them !
-There will be hidden bugs. Really.
-
-The current stable release is 1.04, and the next stable release
-will be called version 1.20.
-
-The main news since 1.04 are support for bootable Linux kernels ("vmlinuz/386")
-and direct Linux ELF-to-memory decompression ("linux/elf386"), so there's
-no reason to use the unstable versions unless you want to try the new formats.
+  * new format: added support for linux elf/arm

+  * better compression using the LZMA algorithm (option '--lzma')

+  * better support for MacOS
@@ -60,55 +60,45 @@ Prerequisites
 -------------

  - first of all you need to build the UCL compression library
-    http://wildsau.idv.uni-linz.ac.at/mfx/ucl.html
+    http://www.oberhumer.com/opensource/ucl/


 Tools needed to build/modify the UPX sources
 --------------------------------------------

-  - A modern C++ compiler like gcc 2.95.2 or Visual C++ 6
-    (egcs 1.1.x may work, half-baked implementations like Borland C++ 5.5 won't)
+  - A C++ compiler: gcc >= 3.3 or clang.

-  - GNU make for Win32
-    http://wildsau.idv.uni-linz.ac.at/mfx/download/upx/tools/
+  - GNU make 3.81 or better

-  - GNU make for DOS
-    ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2gnu/
+  - zlib and zlib-devel [or zlib-dev] software packages for your
+    host environment
+
+  - LZMA SDK from https://github.com/upx/upx-lzma-sdk
+    When using git run 'git submodule update --init --recursive'.


 To compile the packer sources
 -----------------------------

-  set the environment variable UCLDIR to point to your UCL installation, e.g.
+  Set the environment variable UPX_UCLDIR to point to your
+  UCL build directory, e.g.

-     set UCLDIR=c:\src\ucl-0.92                       (DOS / Windows)
-     export UCLDIR=$HOME/local/src/ucl-0.92           (Unix)
+     set UPX_UCLDIR=c:\src\ucl-1.03                   (DOS / Windows)
+     export UPX_UCLDIR=$HOME/local/src/ucl-1.03       (Unix)

-  then type
+  Finally type

-     make target=linux         # on linux
-     make target=djgpp2        # for djgpp2
-     make target=mingw32       # for mingw32
-     make target=no-cygwin     # for mingw32 as included in cygwin
-     make target=msc           # for Visual C++ 6.0
+     make


 If you want to modify the stub sources you'll also need
 -------------------------------------------------------

-  - Nasm - the Netwide Assembler
-    http://www.cryogen.com/Nasm
+  - Perl & Python

-  - Perl 5.004 or better
-    ftp://ftp.simtel.net/pub/simtelnet/gnu/djgpp/v2gnu/perl*b.zip
-
-  - A68K - a 68000 macro assembler
-    http://wildsau.idv.uni-linz.ac.at/mfx/download/upx/tools/
-
-  - djasm - an assembler for the djgpp stub
-    http://wildsau.idv.uni-linz.ac.at/mfx/download/upx/tools/
-
-  - Linux (for the linux/i386 stubs)
+  - upx-stubtools - a number of cross-assemblers and cross-compilers.
+    Precompiled binaries for i386-linux hosts are available from
+    https://github.com/upx/upx-stubtools/releases


 Misc. notes
@@ -123,9 +113,6 @@ Misc. notes
    stream.
  - Use gcc extensions and other compiler specific stuff only through
    macros.
-  - Keep in mind that it should be possible to build UPX on braindead
-    file systems (FAT). Don't use long file names or other things
-    that break building under plain DOS.

 ***

@@ -150,3 +137,5 @@ Patches/Contributions

      diff -uNr olddirectory newdirectory

+
+# vim:set ts=4 sw=4 et:
@@ -8,9 +8,8 @@


                    The Ultimate Packer for eXecutables
-          Copyright (c) 1996-2000 Markus Oberhumer & Laszlo Molnar
-               http://wildsau.idv.uni-linz.ac.at/mfx/upx.html
-                            http://upx.tsx.org
+   Copyright (c) 1996-2017 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io


 .___..        .
@@ -40,12 +39,12 @@ Ice
  for debugging the PE headersize problem down
 Joergen Ibsen <jibz@hotmail.com> and d'b
  for the relocation & address optimization ideas
-John F. Reiser <jreiser@BitWagon.com>
-  for the new Linux executable formats
 John S. Fine <johnfine@erols.com>
  for the new version of the dos/exe decompressor
 Lukundoo <Lukundoo@softhome.net>
  for beta testing
+Michael Devore
+  for initial dos/exe device driver support
 Oleg V. Volkov <rover@lglobus.ru>
  for various FreeBSD specific informations
 The Owl & G-RoM
@@ -54,6 +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
@@ -1,187 +0,0 @@
-NOTE: this TODO list is completely out of date (~ Dec 1999)
-
-===================================================================
-
- Rearrange this TODO list, sort by categories, add a priority (1-5)
-
-
-For 0.95:
-
- FIXME: what do we want in 1.00 ???
-
- add NRV2D for dos/exe (use by default when >= 400 kB)
-
- implement switch `-m' for method: 1 NRV2B, 2 NRV2D
-
- DLL problem under NT ? is this fixed ???
-
-
-PE
-==
-
-2 - easy - mfx + ml) new switch(es) : do not compress resource types x,y,z
-    or resource names a,b,c
-3 - medium - ml) rebuild exports
-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
-
-
-COM
-===
-
-
-EXE
-===
-
-
-
-LE
-==
-
-4 - easy - ml) the decompressors are already aligned, no need for an
-    extra alignment
-
-4 - difficult - ml) handle holes in the file
-
-
-TMT
-===
-
-4 - easy - ml) the decompressors are already aligned, no need for an
-    extra alignment
-
-
-LINUX
-=====
-
-4 - ???)
-    - test with AOUT binaries
-    - test with Java binaries
-    - make a compressed program suid. what happens ?
-
-5 - difficult) rewrite the whole stub in assembly
-
-
-SPARC
-=====
-
-3 - easy - ml) finish support - should generate byte-identical versions
-  for all formats (except those which are using Packer::getRandomId())
-
-
-DJGPP2
-======
-
-1 - ???) do we support overlays at all ???
-
-5 - ???) fix file extension handling when the --coff option is set
-
-
-FOR 0.95
-========
-
- enable automatic dependency tracking
-
-1 - mfx) determine when to use NRV2D, find best c_flags values for
-  NRV2B & NRV2D (see util/runtest.sh)
-
-5 - boring - mfx) Finally fix all screen and UI problems. How boring...
-  Probably should think about the whole system (printf vs. fprintf vs.
-  con_fprintf...)
-
-5 - policy - ml+mfx) Discuss a default C++ style (GNU indent 2.2.3)
-    with Laszlo and use it. Or maybe Artistic Style?
-
-10) Examine why pod2text breaks lines within something like `B<--coff>'.
-    (pod sucks anyway. unfortunately all alternatives as well.)
-
-
-MISC
-====
-
-3 - difficult ml) The first two sentences of the README look too much like
-  those from the aspack docs. Laszlo, could you rewrite this ?
-
-1 - easy - mfx) Check whether the compressed size of the executable is
-  really smaller than the uncompressed
-
-1 - ??? - mfx) Implement a more informational interface.
-    Probably add some global functions in msg.cpp.
-    Should think about the requirements first, i.e. should there be
-    some simple hierarchies (header1, header2, ...) etc. ?
-    Could use the `-v' switch for enabling this (or `-i' ??).
-  - Something like this would be fine:  (with colors :-)
-    [Processing kernel32.dll]
-      [Import]
-        3 DLL.
-        Original size: 12345 bytes.
-        Preprocessed size: 6789 bytes.
-      [Relocations]
-        Original size: 50000 bytes.
-        Preprocessed size: 25000 bytes.
-      [Exports]
-        <warning> exports compressed (try --compress-export=0 if needed)
-      [TLS]
-        Added 56 bytes TLS data.
-        Added 5 fixup records.
-      [Resources]
-        Directory size: 1234 bytes.
-        Resource data size: 100000 bytes.
-        Compressed resources: 8 (99900 bytes).
-        Not compressed resources: 1 (100 bytes).
-
-3 - ???) delete temporary files when something wrong happens
-
-4 - easy - ml) Add a `--486' option to use bswap on the 32-bit formats.
-
-4 - easy - ml) consider removing 'sbb bp,bp' or "or ebp,-1" when not needed
-
-5 - ???) idea: --subfile=xx  compress xx. subfile: we'd need a list_subfiles
-  for this...
-
-
-FIXME: classify
-
-GOALS FOR 0.90
-==============
-
- Provide additional NRV2D stubs for all 32-bit formats. Try to do this
-    in a generic way so that we can possibly add more algorithms.
-    Start by adding a `--nrv2d' switch.
-
-FOR 0.90
-========
-
-/ update the output of `--help'
-
- filters: implement the missing scan() function for f_cto32.
-    Maybe could use this to try to find an optimal filter (e.g.
-    if level >= 9) based on the counts.
-
- filters: could we have use for a f->firstcall info field ?
-
-TODO
-====
-
- all formats: more thoroughly test the exe-header in canPack()
-  and throw exceptions when encountering bad values.
-
- experiment with filters
-
- for small programs (e.g. < 64k) try an additional algorithm (like
-  the non yet finished NRV2C) to see if it gives better compression ?
-
-/ make checkerg++ work -> test
-
- fix file extension handling when the --coff option is set
-
- set up an "official" test suite
-
- finish documentation
-
@@ -1,6 +0,0 @@
-upx.1
-upx.doc
-upx.html
-upx.man
-upx.ps
-upx.tex
@@ -1,34 +1,43 @@
+#
+# UPX doc Makefile - needs GNU make 3.81 or better
+#
+
+MAKEFLAGS += -rR
+.SUFFIXES:
 SHELL = /bin/sh

-top_srcdir = ..
+# internal make variables
+comma := ,
+empty :=
+space := $(empty) $(empty)
+tab   := $(empty)	$(empty)

-PACKAGE      = upx
-VERSION_DATE = 20 Dec 2000
-VERSION     := $(shell sed -n 's/^.*UPX_VERSION_STRING.*"\(.*\)".*/\1/p' $(top_srcdir)/src/version.h)

-TRIMSPACE = cat
-TRIMSPACE = sed -e 's/ *$$//'
+# /***********************************************************************
+# //
+# ************************************************************************/
+
+top_srcdir ?= ..
+
+PACKAGE       = upx
+VERSION_DATE := $(shell sed -n 's/^.*UPX_VERSION_DATE_ISO .*"\(.*\)".*/\1/p' $(top_srcdir)/src/version.h)
+VERSION      := $(shell sed -n 's/^.*UPX_VERSION_STRING .*"\(.*\)".*/\1/p' $(top_srcdir)/src/version.h)
+
+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 upx.html upx.man
+BUILT_SOURCES = upx.1 upx.doc upx.html


 ###
-###
+### targets
 ###

 all: $(BUILT_SOURCES)

-mostlyclean:
-	-rm -f $(BUILT_SOURCES) pod2htm*
-
-clean: mostlyclean
-
-distclean: clean
-
-maintainer-clean: distclean
-
-.SUFFIXES: .1 .doc .html .man .pod .ps .tex .texi
+mostlyclean clean distclean maintainer-clean:
+	rm -f $(BUILT_SOURCES) pod2htm*

 .PHONY: all mostlyclean clean distclean maintainer-clean

@@ -37,32 +46,32 @@ maintainer-clean: distclean
 ### rules
 ###

-.pod.1:
-	pod2man --center=" " --release="$(PACKAGE) $(VERSION)" --date="$(VERSION_DATE)" $< | $(TRIMSPACE) > $@
+.SUFFIXES: .1 .doc .html .man .pod .ps .tex

-.pod.html:
-###	pod2html $< | $(TRIMSPACE) > $@
-	pod2html --noindex $< | $(TRIMSPACE) > $@
-	@-rm -f pod2htm*
+%.1 : %.pod
+	pod2man --center=" " --release="$(PACKAGE) $(VERSION)" --date="$(VERSION_DATE)" $< | $(RTRIM) > $@

-.pod.tex:
+%.doc : %.pod
+	pod2text < $< | $(RTRIM) > $@
+
+%.html : %.pod
+	pod2html --noindex $< | $(RTRIM) | $(DETAB2) > $@
+	@rm -f pod2htm*
+
+%.man : %.1
+	nroff -man $< | $(RTRIM) > $@
+
+%.ps : %.1
+	groff -man $< | $(RTRIM) > $@
+
+%.tex : %.pod
 	pod2latex $<

-.pod.doc:
-	pod2text < $< | $(TRIMSPACE) > $@
-
-.1.man:
-	nroff -man $< | $(TRIMSPACE) > $@
-
-.1.ps:
-	groff -man $< | $(TRIMSPACE) > $@
-

 ###
 ### dependencies
 ###

-$(BUILT_SOURCES): $(top_srcdir)/src/version.h Makefile
-
-.NOEXPORT:
+$(BUILT_SOURCES): $(top_srcdir)/src/version.h $(MAKEFILE_LIST)
+.DELETE_ON_ERROR: $(BUILT_SOURCES)

@@ -1,5 +1,5 @@
           Decompressing ELF Directly to Memory on Linux/x86
-          Copyright 2000 John F. Reiser  jreiser@BitWagon.com
+        Copyright (C) 2000-2017 John F. Reiser  jreiser@BitWagon.com

 References:
  <elf.h>   definitions for the ELF file format
@@ -17,7 +17,7 @@ program itself.  So, the decompressor program (which contains the
 compressed version of the original executable) must have the same
 brk() as the original executable.  So, the second PT_LOAD
 ELF "segment" of the compressed program is used only to set the brk(0).
-See src/p_lx_elf.cpp, function PackLinuxI386elf::patchLoader().
+See src/p_lx_elf.cpp, function PackLinuxElf32::generateElfHdr.
 All of the decompressor's code, and all of the compressed image
 of the original executable, reside in the first PT_LOAD of the
 decompressor program.
@@ -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
-0x00401000 was chosen as 1 page up from a 64KB boundary, to
+page tables; one page of page tables covers 4 MiB. The address
+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,9 +57,51 @@ 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.
+
+As of upx-3.05, by default on Linux, upon decompression then one page
+of the compressed executable remains mapped into the address space
+of the process.  If all of the pages of the compressed executable are
+unmapped, then the Linux kernel erases the symlink /proc/self/exe,
+and this can cause trouble for the runtime shared library loader
+expanding $ORIGIN in -rpath, or for application code that relies on
+/proc/self/exe.  Use the compress-time command-line option
+--unmap-all-pages to achieve that effect at run time.  Upx-3.04
+and previous versions did this by default with no option.  However,
+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
+the runtime stub unmaps all its pages.  As of 2006-10-03 this works
+for linux/elf386 and linux/ElfAMD.
@@ -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
@@ -1,17 +1,9 @@
-This documentation was written for those brave souls who want to
+This documentation is written for those brave souls who want to
 understand and/or modify the UPX assembly stubs - the small snippets
 that do the runtime decompression when a compressed program is started.

-So, how the runtime stub/loader generation works?
-
-You might have already noticed that for some file formats the loaders
-are quite simple (linux/i386 & tos) while in the other cases the
-loaders look very suspicious: they're full of `%ifdef's and contain
-loads of cryptic comments like `__PERELOC2__'.
-
-If you look at the C++ source files, however you can notice that these
-comment strings (without the leading and trailing underscores) are used
-in the following way (they are all 8 character length strings):
+If you look at the C++ source files, you can find code fragments like
+this:

    addLoader("PEMAIN20",
              ih.entry ? "PEDOJUMP" : "PERETURN",
@@ -19,71 +11,40 @@ in the following way (they are all 8 character length strings):
              NULL
             );

-Basically that's all you have to know: when you want to add a section
-of assembly code to the runtime loader, you just write
+    linker->defineSymbol("original_entry", ih.entry);

-l_foo.asm
---------
-    ;__FOOBAR00__
+and in the assembly files fragments like this:

-    xor eax, eax
-    label1:
-    jmps label1
+    section         PEISDLL1
+                    cmpb    [esp + 8], 1
+                    jnz     reloc_end_jmp

-    ;__FOOBARZZ__
+    section         PEMAIN21
+    reloc_end_jmp:

-p_foo.cpp
---------
+    section         PERETURN
+                    xor     eax, eax
+                    inc     eax
+                    ret     0x0C
+    section         PEDOJUMP
+                    jmp    original_entry

-    addLoader("FOOBAR00", NULL);
-
-This will add the assembly section starting from __FOOBAR00__ and ending
-before __FOOBARZZ__ to the loader. You can add an %ifdef - %endif pair
-before these comments if you wish - but these conditionals will NOT be
-seen by the assembler, they are just syntactic sugar to make the code a
-little bit more readable and understandable. (Note however, that only
-%ifdefs which are started on the 1st column are removed by the upx
-assembly preprocessor program, so you can still use preprocessor
-conditionals if you wish - just write them starting from the 2nd
-column.)
+Everything works as you would expect. If you want to add the code
+fragment which is in `section PERETURN' to the runtime stub, then
+simply use `addLoader("PERETURN")' in the C++ source.

 That's nice, you could say, but how cross section jumps and calls are
 handled? Well, that is the nicest part of this stuff - they are handled
 automatically. All you have to do is to add the required sections to the
 loader using `addLoader()' and the rest is done by upx. It will resolve
-every conditional or unconditional jumps or subrutine calls for you.
+every conditional or unconditional jumps or subroutine calls for you.

-This functionality (we could say it's a simple linker) is achived by the
-assembly preprocessor (src/stub/scripts/app.pl) and a little C++ module
-(src/linker.cpp). And of course NASM - the Netwide Assembler. You can
-see what's going on behind the scenes - just do:
+You can also use (undefined) symbols in the assembly for values that
+can only be computed during compression time (like `original_entry').
+These symbols can be defined later in C++ using

-    cd src/stubs
-    make maintainer-clean
-    make all
+        linker->defineSymbol("xx", yy)

-This will rebuild all the loaders - and keep the temporary files (*.as[xy])
-which are seen by the assembler.
-
-Currently this loader/stub building method only works with ix86
-assembly - both app.pl and linker.cpp heavily rely on this when dealing
-with cross section references.
-
-And finally some important features/requirements you should be aware of:
-
- - as previously stated - preprocessor conditionals starting on the 1st
-   column are removed by app.pl
- - sections are separated by comments in the form `;__X1234567__'
- - jumps are recognized by searching for a word which starts with `j'
-   and followed by a label - this also means that `jmp short label1'
-   will NOT be recognized (but you can use a macro called `jmps' for it
-   by adding `%define jmps jmp short' to the beginning of the file)
- - at the end of the file you need something like this
-
-    eof:
-    ;       __XTHEENDX__
-            section .data
-            dd      -1
-            dw      eof
-
-That's all for now.
+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.
@@ -0,0 +1,43 @@
+                        UPX and SELinux
+                        March 6, 2006
+
+
+When a program that has been compressed by UPX is run, the decompressor
+must create and write new memory pages of executable instructions.
+SELinux (Security Enhanced Linux) directly controls the conditions
+under which generating and/or executing new instructions is allowed,
+so the configuration settings of SELinux affect the running of programs
+that have been compressed by UPX.
+
+In SELinux "strict enforcing" mode (the most restrictive), generating
+new instructions at runtime is not allowed at all: any page with
+PROT_EXEC permission must be mapped from a file in a mounted filesystem
+that has 'x' [eXecute] permission, and the generation of such files is
+also tightly controlled.  A program that was compressed by UPX will not
+run in SELinux strict enforcing mode.  Attempts will fail with exit
+code 127, and a record will be added to the history file
+/var/log/audit/audit.log.
+
+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 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
+elevation exploit, etc.)  Thus targeted enforcing mode notices and
+logs the use of "execmem" capability that is used by a program which
+was compressed by UPX.  In keeping with the goal of eventual prohibition,
+SELinux ordinarily would deny execmem.  However, most current SELinux
+systems, including Fedora Core 5 [set for release March 15, 2006],
+override this with "allow_exemem=1" in /etc/selinux/targeted/booleans.
+Thus a program compressed by UPX will run in the default installed
+configuration (targeted enforcing, allow_execmem=1) of SELinux under
+Fedora Core 5.  Each invocation will add a few lines to the log file
+/var/log/audit/audit.log, one line for each use of execmem.  If the
+SELinux policy becomes more restrictive in the future, then a special
+SELinux class or other mechanism must be created for compressed programs,
+or else UPX-compressed executables will not run then.
+
+In its "permissive" modes, SELinux just logs the potential problems,
+but otherwise does not interfere.  A program compressed by UPX will run
+in any permissive mode.
@@ -12,36 +12,30 @@ B<upx> S<[ I<command> ]> S<[ I<options> ]> I<filename>...

 =head1 ABSTRACT

-             The Ultimate Packer for eXecutables
-          Copyright (c) 1996, 1997, 1998, 1999, 2000
-     Markus F.X.J. Oberhumer, Laszlo Molnar & John F. Reiser
-        http://wildsau.idv.uni-linz.ac.at/mfx/upx.html
-                    http://upx.tsx.org
+                    The Ultimate Packer for eXecutables
+   Copyright (c) 1996-2017 Markus Oberhumer, Laszlo Molnar & John Reiser
+                        http://upx.sourceforge.net


 B<UPX> is a portable, extendable, high-performance executable packer for
 several different executable formats. It achieves an excellent compression
 ratio and offers I<*very*> fast decompression. Your executables suffer
-no memory overhead or other drawbacks for most of the formats supported.
+no memory overhead or other drawbacks for most of the formats supported,
+because of in-place decompression.

-While you may use UPX freely for both non-commercial and commercial
+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 UPX and ourselves in the documentation,
-possibly including a reference to the UPX home page. Thanks.
+appreciate if you credit B<UPX> and ourselves in the documentation,
+possibly including a reference to the B<UPX> home page. Thanks.

-[ Using UPX in non-OpenSource applications without proper credits
+[ Using B<UPX> in non-OpenSource applications without proper credits
 is considered not politically correct ;-) ]



 =head1 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 more than 2 1/2 years since our first public beta.
+B<UPX> comes with ABSOLUTELY NO WARRANTY; for details see the file LICENSE.

 This is the first production quality release, and we plan that future 1.xx
 releases will be backward compatible with this version.
@@ -57,7 +51,8 @@ B<UPX> is a versatile executable packer with the following features:
  - excellent compression ratio: compresses better than zip/gzip,
      use UPX to decrease the size of your distribution !

-  - very fast decompression: about 10 MB/sec even on my old Pentium 133
+  - very fast decompression: about 10 MiB/sec on an ancient Pentium 133,
+      about 200 MiB/sec on an Athlon XP 2000+.

  - no memory overhead for your compressed executables for most of the
      supported formats
@@ -76,11 +71,18 @@ B<UPX> is a versatile executable packer with the following features:
      * 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
+      * win32/pe (exe and dll)
+      * win64/pe (exe and dll)
+      * arm/pe (exe and dll)
+      * linux/elfamd64
+      * linux/elfppc32
+      * mach/elfppc32

  - portable: UPX is written in portable endian-neutral C++

@@ -91,7 +93,7 @@ B<UPX> is a versatile executable packer with the following features:
      the full source code of UPX is released under the GNU General Public
      License (GPL) !

-You probably understand now why we call UPX the "I<ultimate>"
+You probably understand now why we call B<UPX> the "I<ultimate>"
 executable packer.


@@ -105,7 +107,7 @@ specified on the command line.

 =head2 Decompress

-All UPX supported file formats can be unpacked using the B<-d> switch, eg.
+All B<UPX> supported file formats can be unpacked using the B<-d> switch, eg.
 B<upx -d yourfile.exe> will uncompress the file you've just compressed.

 =head2 Test
@@ -135,9 +137,14 @@ B<-q -q -q> (or B<-qqq>): produce no output at all

 B<--help>: prints the help

-B<--version>: print the version of UPX
+B<--version>: print the version of B<UPX>

-B<--stdout>: writes all output to stdout
+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.]

 [ ...to be written... - type `B<upx --help>' for now ]

@@ -147,7 +154,7 @@ B<--stdout>: writes all output to stdout

 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

@@ -169,21 +176,20 @@ Compression level B<--best> may take a long time.

 =back

-Note that compression level B<-9> can be somewhat slow for large
+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.

-Since UPX 0.70 there is also an extra compression level B<--best> which
-squeezes out even some more compression ratio. While it is usually fine
-to use this option with your favorite .com file it may take a long time
-to compress a multi-megabyte program. You have been warned.
-
-Tips for even better compression:
+Quick info for achieving the best compression ratio:

 =over 4

 =item *

+Try B<upx --brute myfile.exe> or even B<upx --ultra-brute myfile.exe>.
+
+=item *
+
 Try if B<--overlay=strip> works.

 =item *
@@ -196,12 +202,15 @@ For win32/pe programs there's B<--strip-relocs=0>. See notes below.

 =head1 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).
+
 B<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.
-
-Since version 0.90 UPX defaults to B<--overlay=copy> for
-all executable formats.
+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]

@@ -216,25 +225,22 @@ all executable formats.
 =head1 ENVIRONMENT

 The environment variable B<UPX> can hold a set of default
-options for UPX. These options are interpreted first and
+options for B<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#1
-    for sh/ksh/zsh:    UPX="-9 --compress-icons=1"; export UPX
-    for csh/tcsh:      setenv UPX "-9 --compress-icons=1"
+    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.

-On Vax/VMS, the name of the environment variable is
-UPX_OPT, to avoid a conflict with the symbol set for
-invocation of the program.
-
 Not all of the options are valid in the environment variable -
-UPX will tell you.
+B<UPX> will tell you.

-You can use the B<--no-env> option to turn this support off.
+You can explicitly use the B<--no-env> option to ignore the
+environment variable.



@@ -242,17 +248,21 @@ You can use the B<--no-env> option to turn this support off.

 =head2 NOTES FOR ATARI/TOS

-This is the executable format used by the Atari ST/TT, a 68000 based
-personal computer which was popular in the late '80s. Support
+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.

 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:

-  (none)
+  --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.



@@ -264,7 +274,7 @@ Same as vmlinuz/i386.

 =head2 NOTES FOR DOS/COM

-Obviously UPX won't work with executables that want to read data from
+Obviously B<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+.
@@ -277,13 +287,23 @@ 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.
+


 =head2 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
+Obviously B<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+.
@@ -294,13 +314,15 @@ Extra options available for this executable format:

  --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.
+


 =head2 NOTES FOR DOS/SYS

-You can only compress plain sys files, sys/exe (two in one)
-combos are not supported.
-
 Compressed programs only work on a 286+.

 Packed programs will be byte-identical to the original after uncompression.
@@ -311,33 +333,51 @@ 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.
+


 =head2 NOTES FOR DJGPP2/COFF

-First of all, it is recommended to use UPX *instead* of B<strip>. strip has
+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 UPX corrects a bug/feature in strip v2.8.x: it
-will fix the 4 KByte aligment of the stub.
+Additionally B<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
+B<UPX> includes the full functionality of stubify. This means it will
 automatically stubify your COFF files. Use the option B<--coff> to
-disable this behaviour (see below).
+disable this functionality (see below).

-UPX automatically handles Allegro packfiles.
+B<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.

-BTW, UPX is the successor of the DJP executable packer.
-
 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.
+


 =head2 NOTES FOR LINUX [general]
@@ -345,7 +385,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").

@@ -373,14 +413,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,
@@ -389,7 +429,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''
@@ -478,7 +518,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.

@@ -520,7 +560,7 @@ Extra options available for this executable format:
 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
+can use the Linux/sh386 format.  B<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.
@@ -566,8 +606,9 @@ Extra options available for this executable format:

 Please read the general Linux description first.

-The generic linux/386 format deompresses to /tmp
-and needs /proc filesystem support.
+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.
@@ -577,12 +618,12 @@ 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 exec(), which first requires decompressing to a
-  temporary file in the filesystem.  Interestingly -
+  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 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.
@@ -608,7 +649,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.
@@ -620,16 +661,69 @@ 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
-    is less than 1 MB when compressed :-).
+    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:

-  (none)
+  --force-execve      Force the use of the generic linux/386 "execve"
+                      format, i.e. do not try the linux/elf386 and
+                      linux/sh386 formats.



-=head2 NOTES FOR RTM32/PE
+=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.
+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 !
+
+
+
+=head2 NOTES FOR RTM32/PE and ARM/PE

 Same as win32/pe.

@@ -641,15 +735,23 @@ This format is used by the TMT Pascal compiler - see http://www.tmt.com/ .

 Extra options available for this executable format:

-  (none)
+  --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.



 =head2 NOTES FOR VMLINUZ/386

 The vmlinuz/386 and bvmlinuz/386 formats take a gzip-compressed
-bootable kernel image ("vmlinuz", "zImage", "bzImage"), gzip-decompress
-it and re-compress it with the UPX compression method.
+bootable Linux kernel image ("vmlinuz", "zImage", "bzImage"),
+gzip-decompress it and re-compress it with the B<UPX> compression method.

 vmlinuz/386 is completely unrelated to the other Linux executable
 formats, and it does not share any of their drawbacks.
@@ -665,14 +767,15 @@ 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
         641073  bzImage        [original]
         560755  bzImage.upx    [compressed by "upx -9"]

-  - Much faster decompression at kernel boot time.
+  - Much faster decompression at kernel boot time (but kernel
+    decompression speed is not really an issue these days).

 Drawbacks:

@@ -680,22 +783,26 @@ Drawbacks:

 Extra options available for this executable format:

-  (none)
+  --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.



 =head2 NOTES FOR WATCOM/LE

-UPX has been successfully tested with the following extenders:
+B<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).

-Yes, you can use your compressed executables with DOS4GW.
-
-The LX format is not yet supported.
-
-DLLs are not supported.
+DLLs and the LX format are not supported.

 Extra options available for this executable format:

@@ -706,14 +813,15 @@ Extra options available for this executable format:

 =head2 NOTES FOR WIN32/PE

-The PE support in UPX is quite stable now, but probably there are
-still some incompabilities with some files.
+The PE support in B<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. If you start
-several instances of huge compressed programs you're wasting memory
-because the common segements of the program won't get shared
-across the instances.
+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 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.
@@ -721,7 +829,18 @@ 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.
+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:

@@ -739,9 +858,26 @@ 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.

+  --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.
@@ -752,10 +888,20 @@ Extra options available for this executable format:
                      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 Win32s.
+                      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.
+


 =head1 DIAGNOSTICS
@@ -775,22 +921,26 @@ Please report all bugs immediately to the authors.

 =head1 AUTHORS

- Markus F.X.J. Oberhumer <markus.oberhumer@jk.uni-linz.ac.at>
- http://wildsau.idv.uni-linz.ac.at/mfx/
+ Markus F.X.J. Oberhumer <markus@oberhumer.com>
+ http://www.oberhumer.com

- Laszlo Molnar <ml1050@cdata.tvnet.hu>
+ Laszlo Molnar <ezerotven+github@gmail.com>

 John F. Reiser <jreiser@BitWagon.com>

+ Jens Medoch <jssg@users.sourceforge.net>
+


 =head1 COPYRIGHT

-Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
+Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer

-Copyright (C) 1996-2000 Laszlo Molnar
+Copyright (C) 1996-2017 Laszlo Molnar

-Copyright (C) 2000 John Reiser
+Copyright (C) 2000-2017 John F. Reiser
+
+Copyright (C) 2002-2017 Jens Medoch

 This program may be used freely, and you are welcome to
 redistribute it under certain conditions.
@@ -798,7 +948,7 @@ 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
-UPX License Agreement for more details.
+B<UPX License Agreement> for more details.

 You should have received a copy of the UPX License Agreement along
 with this program; see the file LICENSE. If not, visit the UPX home page.
@@ -1,101 +0,0 @@
-The GNU bfd binary file descriptor package, part of the GNU binutils package,
-contains code to recognize an Elf file by looking at fields in the file header.
-Many programs (such as gdb, size, objdump, objcopy, strip and others) use bfd.
-Unfortunately, bfd has been overly strict.  In releases
-   binutils-2.9.1.0.4, binutils-2.9.1.0.23, binutils-2.9.5.0.0,
-   binutils-2.10.1,
-   gdb-4.17, gdb-5.0,
-and probably others,
-bfd does not recognize a file with zero in Elf32_Ehdr.e_shoff, .e_shentsize,
-or .e_shnum, even though the operating system kernel does not care, and many
-bfd clients would work just fine in these cases.
-
-Because of its desire to create small size compressed executables, UPX
-generates and uses Elf files with zero in .e_shoff, .e_shentsizes, and .e_shnum.
-As a result, many widely-distributed instances of gdb, size, objdump, etc.,
-refuse to work on UPX-packed executables.
-
-Here is a patch to bfd/elfcode.h which enables many bfd clients to work
-with UPX-packed executables.  The last two lines of the patch are
-       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
- 	return -1;
-
-
--- elfcode.h.orig	Mon Jun 16 11:45:32 1997
-+++ elfcode.h	Sat Apr 22 10:18:56 2000
-@@ -1,5 +1,5 @@
- /* ELF executable support for BFD.
-   Copyright 1991, 92, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
-+   Copyright 1991, 92, 93, 94, 95, 96, 97, 1998 Free Software Foundation, Inc.
- 
-    Written by Fred Fish @ Cygnus Support, from information published
-    in "UNIX System V Release 4, Programmers Guide: ANSI C and
-@@ -517,14 +517,14 @@
-   elf_debug_file (i_ehdrp);
- #endif
- 
-  /* If there is no section header table, we're hosed. */
-  if (i_ehdrp->e_shoff == 0)
-+  /* If there is no section header table, and relocatable, then we're hosed. */
-+  if (i_ehdrp->e_shoff == 0 && i_ehdrp->e_type == ET_REL)
-     goto got_wrong_format_error;
- 
-   /* As a simple sanity check, verify that the what BFD thinks is the
-      size of each section header table entry actually matches the size
-     recorded in the file. */
-  if (i_ehdrp->e_shentsize != sizeof (x_shdr))
-+     recorded in the file, but only if there are any sections. */
-+  if (i_ehdrp->e_shentsize != sizeof (x_shdr) &&  i_ehdrp->e_shnum != 0)
-     goto got_wrong_format_error;
- 
-   ebd = get_elf_backend_data (abfd);
-@@ -579,6 +579,7 @@
-   /* Allocate space for a copy of the section header table in
-      internal form, seek to the section header table in the file,
-      read it in, and convert it to internal form.  */
-+ if (i_ehdrp->e_shnum!=0) {
-   i_shdrp = ((Elf_Internal_Shdr *)
- 	     bfd_alloc (abfd, sizeof (*i_shdrp) * i_ehdrp->e_shnum));
-   elf_elfsections (abfd) = ((Elf_Internal_Shdr **)
-@@ -609,6 +610,7 @@
-       if (! bfd_section_from_shdr (abfd, i_ehdrp->e_shstrndx))
- 	goto got_no_match;
-     }
-+ }
- 
-   /* Read in the program headers.  */
-   if (i_ehdrp->e_phnum == 0)
-@@ -644,6 +646,7 @@
-      bfd_section_from_shdr with it (since this particular strtab is
-      used to find all of the ELF section names.) */
- 
-+ if (i_ehdrp->e_shstrndx != 0) {
-   shstrtab = bfd_elf_get_str_section (abfd, i_ehdrp->e_shstrndx);
-   if (!shstrtab)
-     goto got_no_match;
-@@ -657,6 +660,7 @@
-       if (! bfd_section_from_shdr (abfd, shindex))
- 	goto got_no_match;
-     }
-+ }
- 
-   /* Let the backend double check the format and override global
-      information.  */
-@@ -930,7 +934,7 @@
- {
-   Elf_Internal_Shdr *hdr;
-   Elf_Internal_Shdr *verhdr;
-  long symcount;		/* Number of external ELF symbols */
-+  unsigned long symcount;	/* Number of external ELF symbols */
-   elf_symbol_type *sym;		/* Pointer to current bfd symbol */
-   elf_symbol_type *symbase;	/* Buffer for generated bfd symbols */
-   Elf_Internal_Sym i_sym;
-@@ -978,7 +982,7 @@
-     sym = symbase = NULL;
-   else
-     {
-      long i;
-+      unsigned long i;
- 
-       if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) == -1)
- 	return -1;
@@ -1,12 +0,0 @@
-*.0??
-*.idb
-*.map
-*.pdb
-*.upx
-.gdbinit
-.Attic
-upx
-upx_nrv
-upx_nrv.*
-upx_ucl
-upx_ucl.*
@@ -1,482 +1,176 @@
-# UPX Makefile (GNU make) - works with djgpp2/win32/unix
 #
-# usage:
-#   `make target=linux'         # linux
-#   `make target=djggp2'        # djggp2 2.03
-#   `make target=cygwin'        # cygwin 1.1.x
-#   `make target=mingw32'       # mingw32
-#   `make target=no-cygwin'     # mingw32 as included in cygwin 1.1.x
-#   `make target=vc6'           # Visual C++ 6.0
+# UPX Makefile - needs GNU make 3.81 or better
+#
+# Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
 #

+# build configuration options for this Makefile
+BUILD_TYPE_DEBUG    ?= 0
+BUILD_TYPE_SANITIZE ?= 0
+BUILD_USE_DEPEND    ?= 1

-# configuration section
-
-ifeq ($(strip $(UCLDIR)),)
-# change this to reflect where the UCL library is
-UCLDIR = $(HOME)/local/src/ucl-0.92
-endif
-
-DEBUG = 0
-
-
-# -------------------------------------------------------
-# You should not have to change anything below this line.
-# -------------------------------------------------------
-
-SHELL = /bin/sh
-
-
+MAKEFLAGS += -r
 .SUFFIXES:
-.SUFFIXES: .a .c .cpp .exe .lib .o .obj
+export SHELL = /bin/sh
+override ee = $($1) $(EXTRA_$1) $(upx_$1) $(upx_EXTRA_$1) $($(basename $(notdir $@)).$1)

-
-srcdir = .
-top_srcdir = ..
-
-
-# auto-detect the target unless given on the commandline
-target = djgpp2
-ifneq ($(strip $(wildcard /usr/include/linux)),)
-target = linux
+ifndef srcdir
+srcdir := $(dir $(lastword $(MAKEFILE_LIST)))
+srcdir := $(shell echo '$(srcdir)' | sed 's,/*$$,,' || echo 'ERROR')
 endif
-ifneq ($(strip $(wildcard /platform/sun4?/kernel/unix)),)
-target = sparc
+ifndef top_srcdir
+top_srcdir := $(srcdir)/..
 endif
-ifeq ($(target),msc)
-override target = vc6
+include $(wildcard $(top_srcdir)/Makevars.global ./Makevars.local)
+ifneq ($(srcdir),.)
+vpath %.cpp .:$(srcdir)
+vpath %.h   .:$(srcdir)
 endif

+# toolchain
+CXX    ?= g++
+CXXLD   = $(CXX)
+exeext ?= .out
+libext ?= .a
+objext ?= .o

-# util var for use in the rules - basename of the current target
-override T = $(basename $@)
+upx_SOURCES := $(sort $(wildcard $(srcdir)/*.cpp))
+upx_OBJECTS := $(notdir $(upx_SOURCES:.cpp=$(objext)))

-
-# /***********************************************************************
-# // object files
-# ************************************************************************/
-
-# these use exceptions & RTTI
-OBJECTS1 = \
-	compress$o except$o file$o lefile$o \
-	filter$o mem$o msg$o stdcxx$o work$o ui$o \
-	packer$o packhead$o packmast$o \
-	p_com$o p_djgpp2$o p_exe$o p_lx_elf$o p_lx_sep$o p_lx_sh$o \
-	p_sys$o p_tmt$o p_tos$o \
-	p_unix$o p_vmlinz$o p_w32pe$o p_wcle$o
-
-# no exceptions or RTTI
-OBJECTS2 = \
-	filteri$o help$o main$o mygetopt$o util$o linker$o \
-	c_init$o c_file$o c_none$o c_screen$o \
-	s_object$o s_djgpp2$o s_vcsa$o s_win32$o
-
-# pure C sources
-OBJECTS3 =
-
-OBJECTS = $(OBJECTS1) $(OBJECTS2) $(OBJECTS3)
-
-
-# /***********************************************************************
-# // compiler settings
-# ************************************************************************/
-
-# default to a gcc unix-type compiler
-CC = gcc
-CXX = $(CC)
-DEFS =
-INCLUDES = -I$(srcdir)
-CFLAGS_OUTPUT = -o $@
-CXXFLAGS_OUTPUT = $(CFLAGS_OUTPUT)
-
-LINK_EXE = $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) -o $@ $^ $(LDLIBS)
-STUBEDIT_EXE =
-
-o = .o
-a = .a
-e = .exe
-
-
-###
-### gcc defaults
-###
-
-##CFLAGS_O  = -Os
-CFLAGS_O  = -O2
-##CFLAGS_WERROR = -Werror
-CFLAGS_W  = $(CFLAGS_WERROR)
-CFLAGS_W += -Wall -W -Wcast-align -Wcast-qual -Wmissing-declarations -Wmissing-prototypes -Wshadow -Wwrite-strings
-##CFLAGS_M  = -fno-builtin
-## CFLAGS_M += -malign-functions=0 -malign-jumps=0 -malign-loops=0
-
-CFLAGS    = $(CFLAGS_W) $(CFLAGS_O) $(CFLAGS_M)
-CXXFLAGS  = $(CFLAGS) -Wsynth -fconserve-space
-CXXFLAGS1 = $(CXXFLAGS)
-CXXFLAGS2 = $(CXXFLAGS) -fno-exceptions -fno-rtti
-
-ifeq ($(DEBUG),1)
-DEFS += -DDEBUG
-## DEFS += -DTESTING
+ifneq ($(wildcard $(top_srcdir)/.git/.),)
+UPX_VERSION_GITREV := $(strip $(shell cd '$(top_srcdir)' && git rev-parse --short=12 HEAD || echo 'ERROR'))
+ifneq ($(UPX_VERSION_GITREV),)
+GITREV_PLUS := $(strip $(shell cd '$(top_srcdir)' && git diff --exit-code HEAD >/dev/null && echo '' || echo '+'))
+DEFS += '-DUPX_VERSION_GITREV="$(UPX_VERSION_GITREV)$(GITREV_PLUS)"'
+endif
 endif

-ifeq ($(DEBUG),1)
-LDFLAGS = -g
+# we need UCL and zlib - you can set envvar UPX_UCLDIR
+ifneq ($(wildcard $(UPX_UCLDIR)/include/ucl/ucl.h),)
+INCLUDES += -I$(UPX_UCLDIR)/include
+LIBS += $(addprefix -L,$(dir $(wildcard $(UPX_UCLDIR)/libucl$(libext) $(UPX_UCLDIR)/src/.libs/libucl$(libext))))
+endif
+LIBS += -lucl -lz
+# LZMA from https://github.com/upx/upx-lzma-sdk
+include $(top_srcdir)/src/stub/src/c/Makevars.lzma
+
+CPPFLAGS += $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
+ifeq ($(BUILD_TYPE_DEBUG),1)
+CXXFLAGS_OPTIMIZE ?= -O0 -g
 else
-LDFLAGS = -s
+CXXFLAGS_OPTIMIZE ?= -O2
 endif
-LDFLAGS += -Wl,-Map,$T.map
-LDLIBS =
-LDLIBS = -lz
-LIBDIRS =
-DOS_LIBDIRS =
+CXXFLAGS += $(CXXFLAGS_OPTIMIZE)
+# protect against security threats caused by misguided C++ compiler "optimizations"
+ifeq ($(findstring clang,$(CXX)),)
+CXXFLAGS += -fno-delete-null-pointer-checks
+endif
+CXXFLAGS += -fno-strict-aliasing -fwrapv
+CXXFLAGS += -funsigned-char
+CXXFLAGS += -Wall -W -Wcast-align -Wcast-qual -Wmissing-declarations -Wpointer-arith -Wshadow -Wvla -Wwrite-strings
+CXXFLAGS_WERROR ?= -Werror
+CXXFLAGS += $(CXXFLAGS_WERROR)

-
-###
-### compression library
-###
-
-UCLDIR:=$(strip $(subst \,/,$(UCLDIR)))
-NRVDIR:=$(strip $(subst \,/,$(NRVDIR)))
-u = ucl
-U = UCL
-upx_exe = upx$e
-include $(srcdir)/Makefile.inc
-ifneq ($(strip $(wildcard $(NRVDIR)/include/nrv)),)
-  u = nrv
-  U = NRV
-  upx_exe = upx_$u$e
-  include $(srcdir)/Makefile.inc
+ifeq ($(BUILD_TYPE_SANITIZE),1)
+CXXFLAGS_SANITIZE ?= -fsanitize=address,undefined -fno-omit-frame-pointer -DACC_CFG_NO_UNALIGNED
+CXXFLAGS += $(CXXFLAGS_SANITIZE)
+# these are the only 2 objects that are actually speed-sensitive
+compress_lzma$(objext) filteri$(objext) : override CXXFLAGS_SANITIZE =
 endif

-tmp := -Wl,--rpath,
-LDRPATH := $(addprefix $(tmp),$(LIBDIRS))
-LIBDIRS += .
-LDLIBDIRS := $(addprefix -L,$(LIBDIRS))
+# rules
+all: upx$(exeext) | ./.depend
+.DELETE_ON_ERROR: upx$(exeext) $(upx_OBJECTS) ./.depend

-##LDFLAGS += $(LDRPATH)
-LDFLAGS += $(LDLIBDIRS)
+upx$(exeext): $(upx_OBJECTS) $(upx_DEPENDENCIES)
+	$($(notdir $@).PRE_LINK_STEP)
+	$(strip $(CXXLD) $(call ee,CXXFLAGS) $(call ee,LDFLAGS) -o $@ $(upx_OBJECTS) $(call ee,LDADD) $(call ee,LIBS))
+	$($(notdir $@).POST_LINK_STEP)
+	$(CHECK_WHITESPACE)

+%.o : %.cpp | ./.depend
+	$(strip $(CXX) $(call ee,CPPFLAGS) $(call ee,CXXFLAGS) -o $@ -c $<)
+%.cpp.ii : %.cpp
+	$(strip $(CXX) $(call ee,CPPFLAGS) $(call ee,CXXFLAGS) -o $@ -E $<)

-###
-### linux/i386
-###
-
-ifeq ($(target),linux)
-e =
-###CC = /usr/local/packages/gcc-cvs/bin/g++
-DEFS += '-DUPX_CONFIG_H="config_h/linux.h"'
-##CFLAGS_M += -mno-schedule-prologue
-CFLAGS_M += -march=i386 -mcpu=pentium
-CFLAGS_WERROR = -Werror
-LDLIBS += -lmcheck
-
-ifeq (1,2) 	# checkergcc
-  CC = checkergcc
-  CXX = checkerg++
+ifeq ($(BUILD_USE_DEPEND),1)
+./.depend: $(sort $(wildcard $(srcdir)/*.cpp $(srcdir)/*.h)) $(MAKEFILE_LIST)
+	@rm -f $@
+	@echo "Updating $@"
+	@$(strip $(CXX) $(call ee,CPPFLAGS) $(call ee,CXXFLAGS) -MM) $(filter %.cpp,$^) > $@
 else
-ifeq ($(DEBUG),1)
-  ##CFLAGS += -O0 -gstabs+3
-  CFLAGS += -O0 -gdwarf-2
+./.depend:
+.PHONY: ./.depend
+endif
+
+CHECK_WHITESPACE =
+ifeq ($(shell uname),Linux)
+CHECK_WHITESPACE = $(top_srcdir)/src/stub/scripts/check_whitespace.sh $(top_srcdir)
+ifneq ($(wildcard $(top_srcdir)/.git/.),)
+CHECK_WHITESPACE = $(top_srcdir)/src/stub/scripts/check_whitespace_git.sh $(top_srcdir)
+endif
+check-whitespace : ; $(CHECK_WHITESPACE)
+endif
+.PHONY: check-whitespace
+
+mostlyclean clean distclean maintainer-clean:
+	rm -f *.d *.ii *.map *.o *.obj *.res ./.depend upx.exe upx.out upx.ttp upx$(exeext)
+
+./.depend compress_lzma$(objext) : INCLUDES += -I$(UPX_LZMADIR)
+
+compress_lzma$(objext) : CXXFLAGS += -Wno-shadow
+p_mach$(objext)        : CXXFLAGS += -Wno-cast-align
+
+.PHONY: all mostlyclean clean distclean maintainer-clean
+
+ifeq ($(MAKECMDGOALS),mostlyclean)
+else ifeq ($(MAKECMDGOALS),clean)
+else ifeq ($(MAKECMDGOALS),distclean)
+else ifeq ($(MAKECMDGOALS),maintainer-clean)
+else ifeq ($(MAKECMDGOALS),clang-format)
+else ifeq ($(MAKECMDGOALS),check-whitespace)
 else
-  ##LDFLAGS += -static
-  STUBEDIT_EXE = objcopy -S -R .comment -R .note $@ && perl $(srcdir)/stub/scripts/brandelf.pl $@ && chmod 755 $@
+ifeq ($(BUILD_USE_DEPEND),1)
+-include ./.depend
+endif
+help$(objext): $(MAKEFILE_LIST)
+endif
+
+# "make run-testsuite"
+# search for the UPX testsuite -- git clone https://github.com/upx/upx-testsuite.git
+# you also can override upx_testsuite_SRCDIR
+ifndef upx_testsuite_SRCDIR
+# search standard locations below $(top_srcdir)
+ifneq ($(wildcard $(top_srcdir)/../upx-testsuite.git/files/packed/.),)
+upx_testsuite_SRCDIR := $(top_srcdir)/../upx-testsuite.git
+else ifneq ($(wildcard $(top_srcdir)/../upx-testsuite/files/packed/.),)
+upx_testsuite_SRCDIR := $(top_srcdir)/../upx-testsuite
+endif
+endif
+# run the UPX testsuite
+# The expected (old) checksums are in $(top_srcdir)/.github/travis_testsuite_1.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                := ./upx$(exeext)
+run-testsuite: export upx_testsuite_SRCDIR   := $(upx_testsuite_SRCDIR)
+run-testsuite: export upx_testsuite_BUILDDIR := ./tmp-testsuite
+run-testsuite: ./upx$(exeext)
+	time -p bash $(top_srcdir)/.github/travis_testsuite_1.sh
+.PHONY: run-testsuite
 endif
 endif

-endif	# linux
-
-
-###
-### djgpp2
-###
-
-ifeq ($(target),djgpp2)
-CFLAGS_M += -mno-schedule-prologue
-CFLAGS_M += -march=i386 -mcpu=pentium
-CFLAGS_WERROR = -Werror
-STUBEDIT_EXE = stubedit $@ bufsize=0xfc00
-endif	# djgpp2
-
-
-###
-### cygwin / mingw32
-###
-
-ifeq ($(target),cygwin)
-CFLAGS_M += -mno-schedule-prologue
-CFLAGS_M += -march=i386 -mcpu=pentium
-CFLAGS_WERROR = -Werror
+# automatically format some C++ source code files
+ifeq ($(shell uname),Linux)
+CLANG_FORMAT_FILES += linker.cpp linker.h packhead.cpp packmast.cpp
+CLANG_FORMAT_FILES += s_djgpp2.cpp s_object.cpp s_vcsa.cpp s_win32.cpp screen.h
+CLANG_FORMAT_FILES += snprintf.cpp
+CLANG_FORMAT_FILES += stdcxx.cpp stdcxx.h
+CLANG_FORMAT_FILES += ui.cpp ui.h util.h
+clang-format:
+	$(top_srcdir)/src/stub/scripts/upx-clang-format -i $(addprefix $(top_srcdir)/src/,$(CLANG_FORMAT_FILES))
+.PHONY: clang-format
 endif

-ifeq ($(target),mingw32)
-CFLAGS_M += -mno-schedule-prologue
-CFLAGS_M += -march=i386 -mcpu=pentium
-endif
-
-# mingw32 as included in cygwin
-ifeq ($(target),no-cygwin)
-CC = gcc -mno-cygwin
-CFLAGS_M += -mno-schedule-prologue
-CFLAGS_M += -march=i386 -mcpu=pentium
-CFLAGS_WERROR = -Werror
-endif
-
-
-###
-### Microsoft 32-bit C/C++ Compiler 12.00 (aka Visual C++ 6)
-###
-
-ifeq ($(target),vc6)
-o = .obj
-a = .lib
-CC = cl -nologo
-CFLAGS = -W4 -WX
-CXXFLAGS1 = $(CFLAGS) -GR -GX -EHa
-CXXFLAGS2 = $(CFLAGS)
-LDFLAGS =
-LINK_LDFLAGS = /link /map:$T.map
-
-ifneq ($(strip $(DOS_LIBDIRS)),)
-LIB := $(DOS_LIBDIRS);$(LIB)
-endif
-export LIB
-
-ifeq (1,2)
-  # statically link libc.lib
-  CC += -ML
-  ##LDLIBS = $(u)_s.lib zlib_s.lib setargv.obj
-  LDLIBS = $(u)_s.lib setargv.obj
-else
-  # link against msvcrt.dll
-  CC += -MD
-  LDLIBS = $(DOS_LDLIBS) zlib.lib setargv.obj
-endif
-ifeq ($(DEBUG),1)
-  CFLAGS += -Od -ZI
-  LINK_LDFLAGS += /debug
-else
-  CFLAGS += -O2 -GF
-  LINK_LDFLAGS += /release
-endif
-
-##LINK_LDFLAGS += /verbose
-LINK_EXE = $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) -Fe$@ $^ $(LDLIBS) $(LINK_LDFLAGS)
-
-endif	# vc6
-
-
-###
-### sparc
-###
-
-ifeq ($(target),sparc)
-e =
-DEFS += '-DUPX_CONFIG_H="config_h/sparc.h"'
-INCLUDES += -I/home/ethmola/local/include
-
-ifeq (1,2) # native compiler
-  CFLAGS = -O0 -g
-  CXXFLAGS1 =
-  CXXFLAGS2 =
-  CFLAGS_M =
-  DEFS += -DUSE_STDNAMESPACE
-else # gcc
-  CFLAGS += -O0 -gstabs+
-endif
-
-ifeq (1,2) # purify
-  DEFS += -D__PURIFY__
-  LDFLAGS = -g -L/home/ethmola/local/lib
-  LINK_EXE = purify $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) -o $@ $^ $(LDLIBS)
-else
-  LDFLAGS += -g -L/home/ethmola/local/lib
-  LINK_EXE = $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) -o $@ $^ $(LDLIBS)
-endif
-
-endif	# sparc
-
-
-###
-### Borland C++ 5.5 (DOES NOT WORK - INCOMPLETE C++ IMPLEMENTATION)
-###
-
-ifeq ($(target),bcc)
-o = .obj
-a = .lib
-CC = bcc32
-CFLAGS = -w -w-par
-CXXFLAGS1 = $(CFLAGS)
-CXXFLAGS2 = $(CFLAGS)
-CFLAGS_OUTPUT = -o$@
-LDFLAGS =
-LDLIBS = $(DOS_LDLIBS) zlib.lib
-
-ifneq ($(strip $(DOS_LIBDIRS)),)
-LIB := $(DOS_LIBDIRS);$(LIB)
-endif
-export LIB
-
-ifeq ($(DEBUG),1)
-  CFLAGS += -Od -d
-else
-  CFLAGS += -O2 -d
-endif
-
-LINK_EXE = $(CC) $(LDFLAGS) $(EXTRA_LDFLAGS) -e$@ $^ $(LDLIBS)
-
-endif	# bcc
-
-
-###
-### malloc debuggers (Linux only)
-###
-
-ifeq (1,2)
-  LDLIBS += -lefence
-endif
-
-ifeq (1,2)
-  CFLAGS += -DWITH_DMALLOC
-  LDLIBS += -ldmalloc
-endif
-
-ifeq (1,2)
-  CFLAGS += -DWITH_GC -DLINUX_THREADS -D_REENTRANT
-  LDLIBS += -lgc -lpthread
-  # only needed when using -static:
-  ##LDFLAGS += -Wl,-defsym,_DYNAMIC=0
-endif
-
-ifeq (1,2)
-  CFLAGS += -DWITH_MSS
-  LDLIBS += -lmss
-endif
-
-
-# /***********************************************************************
-# // main targets
-# ************************************************************************/
-
-all: $(upx_exe)
-
-.PHONY: all unupx mostlyclean clean distclean maintainer-clean untabify tags
-
-$(upx_exe): $(OBJECTS) $(LIBS)
-	$(LINK_EXE)
-	$(STUBEDIT_EXE)
-
-
-ifeq ($(target),djgpp2)
-cwsbind: $(upx_exe)
-	-rm -f $T.cof
-	$(upx_exe) -1 --coff -o $T.cof $(upx_exe)
-	cat $(DJDIR)/bin/cwsdstub.exe $T.cof > $(upx_exe)
-	$(upx_exe) -d $(upx_exe)
-	$(upx_exe) --best $(upx_exe)
-endif
-
-
-unupx:
-	$(MAKE) target=vc6 unupx.dll
-
-unupx.dll: $(OBJECTS) $(LIBS)
-	$(LINK_DLL)
-
-
-mostlyclean:
-	-rm -f *.d *.err *.i *.log *.map *~ gdb-trans*
-
-clean: mostlyclean
-	-rm -f *.a *.lib *.o *.obj tags TAGS ID
-	-rm -f *.idb *.pdb
-	-rm -f upx upx.exe upx_nrv upx_nrv.exe upx_ucl upx_ucl.exe
-
-distclean: clean
-
-maintainer-clean: distclean
-
-
-untabify:
-	mfxtu -d4 -t *.h *.cpp *.ch
-	mfxtu -d8 -t stub/[ln]*.asm stub/*.ash stub/*.[cs]
-
-tags TAGS:
-	ctags *.h *.cpp *.ch
-
-ID:
-	mkid *.h *.cpp *.ch
-
-
-# /***********************************************************************
-# // rules
-# ************************************************************************/
-
-.c$o:
-	$(CC) $(DEFS) $(INCLUDES) $(CFLAGS) $(CFLAGS_OUTPUT) -c $<
-
-.cpp$o:
-	$(CXX) $(DEFS) $(INCLUDES) $(CXXFLAGS1) $(CXXFLAGS_OUTPUT) -c $<
-
-$(OBJECTS1): %$o : %.cpp
-	$(CXX) $(DEFS) $(INCLUDES) $(CXXFLAGS1) $(CXXFLAGS_OUTPUT) -c $<
-
-$(OBJECTS2): %$o : %.cpp
-	$(CXX) $(DEFS) $(INCLUDES) $(CXXFLAGS2) $(CXXFLAGS_OUTPUT) -c $<
-
-ifneq ($(strip $(OBJECTS3)),)
-$(OBJECTS3): %$o : %.c
-	$(CC) $(DEFS) $(INCLUDES) $(CFLAGS) $(CFLAGS_OUTPUT) -c $<
-endif
-
-
-# /***********************************************************************
-# // dependencies
-# ************************************************************************/
-
-# FIXME: use automated dependencies
-
-main$o:     mygetopt.h version.h
-filter$o:   filter.h
-filteri$o:  filter.h fcto_ml.ch fcto_ml2.ch fcto_ml3.ch
-help$o:     version.h
-msg$o:      ui.h
-lefile$o:   lefile.h
-linker$o:   linker.h
-mygetopt$o: mygetopt.h
-packer$o:   packer.h filter.h linker.h ui.h version.h
-packhead$o: packer.h
-packmast$o: packmast.h packer.h lefile.h \
-		p_com.h p_djgpp2.h p_exe.h p_lx_elf.h p_lx_sep.h p_lx_sh.h \
-		p_sys.h p_tmt.h p_tos.h \
-		p_unix.h p_vmlinz.h p_vxd.h p_w32pe.h p_wcle.h
-ui$o:       packer.h ui.h
-work$o:     packer.h ui.h packmast.h
-
-p_com$o:    packer.h p_com.h \
-		stub/l_com.h
-p_djgpp2$o: packer.h p_djgpp2.h stub/stubify.h \
-		stub/l_djgpp2.h
-p_exe$o:    packer.h p_exe.h \
-		stub/l_exe.h
-p_lx_elf$o: packer.h p_lx_elf.h p_unix.h p_elf.h \
-		stub/l_le_n2b.h stub/l_le_n2d.h
-p_lx_sep$o: packer.h p_lx_sep.h p_lx_elf.h p_unix.h p_elf.h
-p_lx_sh$o:  packer.h p_lx_sh.h p_lx_elf.h p_unix.h p_elf.h \
-		stub/l_sh_n2b.h stub/l_sh_n2d.h
-p_sys$o:    packer.h p_sys.h p_com.h \
-		stub/l_sys.h
-p_tmt$o:    packer.h p_tmt.h \
-		stub/l_tmt.h
-p_tos$o:    packer.h p_tos.h \
-		stub/l_t_n2b.h stub/l_t_n2bs.h \
-		stub/l_t_n2d.h stub/l_t_n2ds.h
-p_unix$o:   packer.h p_unix.h p_elf.h \
-		stub/l_lx_n2b.h stub/l_lx_n2d.h
-p_vmlinz$o: packer.h p_vmlinz.h \
-		stub/l_vmlinz.h
-p_w32pe$o:  packer.h p_w32pe.h \
-		stub/l_w32pe.h
-p_wcle$o:   packer.h p_wcle.h lefile.h \
-		stub/l_wcle.h
-
-# vi:nowrap
+# vim:set ts=8 sw=8 noet:
@@ -1,37 +0,0 @@
-UDIR := $($(U)DIR)
-
-DEFS += -DWITH_$(U)
-
-ifneq ($(strip $(wildcard $(UDIR)/include)),)
-INCLUDES += -I$(UDIR)/include
-endif
-
-ifneq ($(strip $(wildcard $(UDIR)/src/.libs)),)
-LIBDIRS += $(UDIR)/src/.libs
-endif
-ifeq ($(DEBUG),1)
-ifneq ($(strip $(wildcard $(UDIR)/build/debug/src/.libs)),)
-LIBDIRS += $(UDIR)/build/debug/src/.libs
-endif
-endif
-ifneq ($(strip $(wildcard $(UDIR)/build/release/src/.libs)),)
-LIBDIRS += $(UDIR)/build/release/src/.libs
-endif
-ifneq ($(strip $(wildcard $(UDIR)/build/src/.libs)),)
-LIBDIRS += $(UDIR)/build/src/.libs
-endif
-ifneq ($(strip $(wildcard $(UDIR))),)
-LIBDIRS += $(UDIR)
-DOS_LIBDIRS := $(DOS_LIBDIRS);$(UDIR)
-endif
-
-LDLIBS += -l$(u)
-DOS_LDLIBS += $(u).lib
-
-
-DEFS := $(DEFS)
-INCLUDES := $(INCLUDES)
-LIBDIRS := $(LIBDIRS)
-LDLIBS := $(LDLIBS)
-DOS_LDLIBS := $(DOS_LDLIBS)
-
@@ -1,9 +1,9 @@
-/* bele.h --
+/* bele.h -- access memory in BigEndian and LittleEndian byte order

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,225 +21,496 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_BELE_H
-#define __UPX_BELE_H
+#define __UPX_BELE_H 1


 /*************************************************************************
-// access memory in BigEndian and LittleEndian byte order
+// core
 **************************************************************************/

-inline unsigned short get_be16(const void *bb, int off=0)
+inline unsigned get_be16(const void *p)
 {
-    const upx_bytep const b = reinterpret_cast<const upx_bytep>(bb) + off;
-    unsigned v;
-    v  = (unsigned) b[1] <<  0;
-    v |= (unsigned) b[0] <<  8;
-    return (unsigned short) v;
-}
-
-inline void set_be16(void *bb, unsigned v, int off=0)
-{
-    upx_bytep const b = reinterpret_cast<upx_bytep>(bb) + off;
-    b[1] = (unsigned char) (v >>  0);
-    b[0] = (unsigned char) (v >>  8);
-}
-
-
-inline unsigned get_be32(const void *bb, int off=0)
-{
-    const upx_bytep const b = reinterpret_cast<const upx_bytep>(bb) + off;
-    unsigned v;
-    v  = (unsigned) b[3] <<  0;
-    v |= (unsigned) b[2] <<  8;
-    v |= (unsigned) b[1] << 16;
-    v |= (unsigned) b[0] << 24;
-    return v;
-}
-
-inline void set_be32(void *bb, unsigned v, int off=0)
-{
-    upx_bytep const b = reinterpret_cast<upx_bytep>(bb) + off;
-    b[3] = (unsigned char) (v >>  0);
-    b[2] = (unsigned char) (v >>  8);
-    b[1] = (unsigned char) (v >> 16);
-    b[0] = (unsigned char) (v >> 24);
-}
-
-
-inline unsigned short get_le16(const void *bb, int off=0)
-{
-    const upx_bytep const b = reinterpret_cast<const upx_bytep>(bb) + off;
-    unsigned v;
-#if defined(__i386__)
-    v = * (const unsigned short *) b;
+#if defined(ACC_UA_GET_BE16)
+    return ACC_UA_GET_BE16(p);
 #else
-    v  = (unsigned) b[0] <<  0;
-    v |= (unsigned) b[1] <<  8;
+    return acc_ua_get_be16(p);
 #endif
-    return (unsigned short) v;
 }

-inline void set_le16(void *bb, unsigned v, int off=0)
+inline void set_be16(void *p, unsigned v)
 {
-    upx_bytep const b = reinterpret_cast<upx_bytep>(bb) + off;
-#if defined(__i386__)
-    (* (unsigned short *) b) = (unsigned short) v;
+#if defined(ACC_UA_SET_BE16)
+    ACC_UA_SET_BE16(p, v);
 #else
-    b[0] = (unsigned char) (v >>  0);
-    b[1] = (unsigned char) (v >>  8);
+    acc_ua_set_be16(p, v);
+#endif
+}
+
+inline unsigned get_be24(const void *p)
+{
+#if defined(ACC_UA_GET_BE24)
+    return ACC_UA_GET_BE24(p);
+#else
+    return acc_ua_get_be24(p);
+#endif
+}
+
+inline void set_be24(void *p, unsigned v)
+{
+#if defined(ACC_UA_SET_BE24)
+    ACC_UA_SET_BE24(p, v);
+#else
+    acc_ua_set_be24(p, v);
+#endif
+}
+
+inline unsigned get_be32(const void *p)
+{
+#if defined(ACC_UA_GET_BE32)
+    return ACC_UA_GET_BE32(p);
+#else
+    return acc_ua_get_be32(p);
+#endif
+}
+
+inline void set_be32(void *p, unsigned v)
+{
+#if defined(ACC_UA_SET_BE32)
+    ACC_UA_SET_BE32(p, v);
+#else
+    acc_ua_set_be32(p, v);
+#endif
+}
+
+inline upx_uint64_t get_be64(const void *p)
+{
+#if defined(ACC_UA_GET_BE64)
+    return ACC_UA_GET_BE64(p);
+#else
+    return acc_ua_get_be64(p);
+#endif
+}
+
+inline void set_be64(void *p, upx_uint64_t v)
+{
+#if defined(ACC_UA_SET_BE64)
+    ACC_UA_SET_BE64(p, v);
+#else
+    acc_ua_set_be64(p, v);
+#endif
+}
+
+inline unsigned get_le16(const void *p)
+{
+#if defined(ACC_UA_GET_LE16)
+    return ACC_UA_GET_LE16(p);
+#else
+    return acc_ua_get_le16(p);
+#endif
+}
+
+inline void set_le16(void *p, unsigned v)
+{
+#if defined(ACC_UA_SET_LE16)
+    ACC_UA_SET_LE16(p, v);
+#else
+    acc_ua_set_le16(p, v);
+#endif
+}
+
+inline unsigned get_le24(const void *p)
+{
+#if defined(ACC_UA_GET_LE24)
+    return ACC_UA_GET_LE24(p);
+#else
+    return acc_ua_get_le24(p);
+#endif
+}
+
+inline void set_le24(void *p, unsigned v)
+{
+#if defined(ACC_UA_SET_LE24)
+    ACC_UA_SET_LE24(p, v);
+#else
+    acc_ua_set_le24(p, v);
+#endif
+}
+
+inline unsigned get_le26(const void *p)
+{
+    const acc_hbyte_p b = ACC_CCAST(const acc_hbyte_p, p);
+    return ACC_ICONV(acc_uint32l_t, b[0]       ) | (  ACC_ICONV(acc_uint32l_t, b[1])     <<  8) |
+          (ACC_ICONV(acc_uint32l_t, b[2]) << 16) | (((ACC_ICONV(acc_uint32l_t, b[3]) & 3)<< 24));
+}
+
+inline void set_le26(void *p, unsigned v)
+{
+    acc_hbyte_p b = ACC_PCAST(acc_hbyte_p, p);
+    b[0] = ACC_ICONV(unsigned char, (v >>  0) & 0xff);
+    b[1] = ACC_ICONV(unsigned char, (v >>  8) & 0xff);
+    b[2] = ACC_ICONV(unsigned char, (v >> 16) & 0xff);
+    b[3] = ACC_ICONV(unsigned char, (v >> 24) & 0x03) | (0xFC & b[3]);
+}
+
+inline unsigned get_le32(const void *p)
+{
+#if defined(ACC_UA_GET_LE32)
+    return ACC_UA_GET_LE32(p);
+#else
+    return acc_ua_get_le32(p);
+#endif
+}
+
+inline void set_le32(void *p, unsigned v)
+{
+#if defined(ACC_UA_SET_LE32)
+    ACC_UA_SET_LE32(p, v);
+#else
+    acc_ua_set_le32(p, v);
+#endif
+}
+
+inline upx_uint64_t get_le64(const void *p)
+{
+#if defined(ACC_UA_GET_LE64)
+    return ACC_UA_GET_LE64(p);
+#else
+    return acc_ua_get_le64(p);
+#endif
+}
+
+inline void set_le64(void *p, upx_uint64_t v)
+{
+#if defined(ACC_UA_SET_LE64)
+    ACC_UA_SET_LE64(p, v);
+#else
+    acc_ua_set_le64(p, v);
 #endif
 }


-inline unsigned get_le24(const void *bb, int off=0)
+/*************************************************************************
+// get signed values, i.e. sign-extend
+**************************************************************************/
+
+inline int sign_extend(unsigned v, unsigned bits)
 {
-    const upx_bytep const b = reinterpret_cast<const upx_bytep>(bb) + off;
-    unsigned v;
-    v  = (unsigned) b[0] <<  0;
-    v |= (unsigned) b[1] <<  8;
-    v |= (unsigned) b[2] << 16;
-    return v;
+    const unsigned sign_bit = 1u << (bits - 1);
+    v &= sign_bit | (sign_bit - 1);
+    v |= 0 - (v & sign_bit);
+    return ACC_ICAST(int, v);
 }

-inline void set_le24(void *bb, unsigned v, int off=0)
+inline upx_int64_t sign_extend(upx_uint64_t v, unsigned bits)
 {
-    upx_bytep const b = reinterpret_cast<upx_bytep>(bb) + off;
-    b[0] = (unsigned char) (v >>  0);
-    b[1] = (unsigned char) (v >>  8);
-    b[2] = (unsigned char) (v >> 16);
+    const upx_uint64_t sign_bit = UPX_UINT64_C(1) << (bits - 1);
+    v &= sign_bit | (sign_bit - 1);
+    v |= 0 - (v & sign_bit);
+    return ACC_ICAST(upx_int64_t, v);
+}
+
+inline int get_be16_signed(const void *p)
+{
+    unsigned v = get_be16(p);
+    return sign_extend(v, 16);
+}
+
+inline int get_be24_signed(const void *p)
+{
+    unsigned v = get_be24(p);
+    return sign_extend(v, 24);
+}
+
+inline int get_be32_signed(const void *p)
+{
+    unsigned v = get_be32(p);
+    return sign_extend(v, 32);
+}
+
+inline upx_int64_t get_be64_signed(const void *p)
+{
+    upx_uint64_t v = get_be64(p);
+    return sign_extend(v, 64);
+}
+
+inline int get_le16_signed(const void *p)
+{
+    unsigned v = get_le16(p);
+    return sign_extend(v, 16);
+}
+
+inline int get_le24_signed(const void *p)
+{
+    unsigned v = get_le24(p);
+    return sign_extend(v, 24);
+}
+
+inline int get_le32_signed(const void *p)
+{
+    unsigned v = get_le32(p);
+    return sign_extend(v, 32);
+}
+
+inline upx_int64_t get_le64_signed(const void *p)
+{
+    upx_uint64_t v = get_le64(p);
+    return sign_extend(v, 64);
 }


-inline unsigned get_le32(const void *bb, int off=0)
+/*************************************************************************
+// swab (bswap)
+**************************************************************************/
+
+inline unsigned acc_swab16(unsigned v)
 {
-    const upx_bytep const b = reinterpret_cast<const upx_bytep>(bb) + off;
-    unsigned v;
-#if defined(__i386__)
-    v = * (const unsigned *) b;
-#else
-    v  = (unsigned) b[0] <<  0;
-    v |= (unsigned) b[1] <<  8;
-    v |= (unsigned) b[2] << 16;
-    v |= (unsigned) b[3] << 24;
-#endif
-    return v;
+    return ((v & 0x00ff) << 8) |
+           ((v & 0xff00) >> 8);
 }

-inline void set_le32(void *bb, unsigned v, int off=0)
+inline unsigned acc_swab32(unsigned v)
 {
-    upx_bytep const b = reinterpret_cast<upx_bytep>(bb) + off;
-#if defined(__i386__)
-    (* (unsigned *) b) = v;
-#else
-    b[0] = (unsigned char) (v >>  0);
-    b[1] = (unsigned char) (v >>  8);
-    b[2] = (unsigned char) (v >> 16);
-    b[3] = (unsigned char) (v >> 24);
-#endif
+    return ((v & 0x000000ff) << 24) |
+           ((v & 0x0000ff00) <<  8) |
+           ((v & 0x00ff0000) >>  8) |
+           ((v & 0xff000000) >> 24);
+}
+
+
+inline unsigned acc_swab16p(const upx_uint16_t *p)
+{
+    return acc_swab16(*p);
+}
+
+inline unsigned acc_swap32p(const upx_uint32_t *p)
+{
+    return acc_swab32(*p);
+}
+
+
+inline void acc_swab16s(upx_uint16_t *p)
+{
+    *p = ACC_ICONV(upx_uint16_t, acc_swab16(*p));
+}
+
+inline void acc_swab32s(upx_uint32_t *p)
+{
+    *p = ACC_ICONV(upx_uint32_t, acc_swab32(*p));
+}
+
+
+inline void acc_ua_swab16s(void *p)
+{
+    set_be16(p, get_le16(p));
+}
+
+inline void acc_ua_swab32s(void *p)
+{
+    set_be32(p, get_le32(p));
 }


 /*************************************************************************
 // classes for portable unaligned access
+//
+// Important: these classes must be PODs (Plain Old Data), i.e. no
+//   constructor, no destructor, no virtual functions and no default
+//   assignment operator, and all fields must be public(!).
+//
+// [Actually we _can_ use a safe non-POD subset, but for this we need
+//  to have gcc bug 17519 fixed - see http://gcc.gnu.org/PR17519 ]
 **************************************************************************/

-class BE16
-{
+__packed_struct(BE16)
    unsigned char d[2];

-public:
-    BE16& operator =  (const BE16 &v) { memcpy(d, v.d, sizeof(d)); return *this; }
+    BE16& operator =  (unsigned v) { set_be16(d, v); return *this; }
+    BE16& operator += (unsigned v) { set_be16(d, get_be16(d) + v); return *this; }
+    BE16& operator -= (unsigned v) { set_be16(d, get_be16(d) - v); return *this; }
+    BE16& operator *= (unsigned v) { set_be16(d, get_be16(d) * v); return *this; }
+    BE16& operator /= (unsigned v) { set_be16(d, get_be16(d) / v); return *this; }
+    BE16& operator &= (unsigned v) { set_be16(d, get_be16(d) & v); return *this; }
+    BE16& operator |= (unsigned v) { set_be16(d, get_be16(d) | v); return *this; }
+    BE16& operator ^= (unsigned v) { set_be16(d, get_be16(d) ^ v); return *this; }
+    BE16& operator <<= (unsigned v) { set_be16(d, get_be16(d) << v); return *this; }
+    BE16& operator >>= (unsigned v) { set_be16(d, get_be16(d) >> v); return *this; }

-    BE16& operator =  (unsigned v)    { set_be16(d, v); return *this; }
-    BE16& operator += (unsigned v)    { set_be16(d, get_be16(d) + v); return *this; }
-    BE16& operator -= (unsigned v)    { set_be16(d, get_be16(d) - v); return *this; }
-    BE16& operator &= (unsigned v)    { set_be16(d, get_be16(d) & v); return *this; }
-    BE16& operator |= (unsigned v)    { set_be16(d, get_be16(d) | v); return *this; }
-
-    operator const unsigned () const  { return get_be16(d); }
-};
+    operator unsigned () const { return get_be16(d); }
+__packed_struct_end()


-class BE32
-{
+__packed_struct(BE32)
    unsigned char d[4];

-public:
-    BE32& operator =  (const BE32 &v) { memcpy(d, v.d, sizeof(d)); return *this; }
+    BE32& operator =  (unsigned v) { set_be32(d, v); return *this; }
+    BE32& operator += (unsigned v) { set_be32(d, get_be32(d) + v); return *this; }
+    BE32& operator -= (unsigned v) { set_be32(d, get_be32(d) - v); return *this; }
+    BE32& operator *= (unsigned v) { set_be32(d, get_be32(d) * v); return *this; }
+    BE32& operator /= (unsigned v) { set_be32(d, get_be32(d) / v); return *this; }
+    BE32& operator &= (unsigned v) { set_be32(d, get_be32(d) & v); return *this; }
+    BE32& operator |= (unsigned v) { set_be32(d, get_be32(d) | v); return *this; }
+    BE32& operator ^= (unsigned v) { set_be32(d, get_be32(d) ^ v); return *this; }
+    BE32& operator <<= (unsigned v) { set_be32(d, get_be32(d) << v); return *this; }
+    BE32& operator >>= (unsigned v) { set_be32(d, get_be32(d) >> v); return *this; }

-    BE32& operator =  (unsigned v)    { set_be32(d, v); return *this; }
-    BE32& operator += (unsigned v)    { set_be32(d, get_be32(d) + v); return *this; }
-    BE32& operator -= (unsigned v)    { set_be32(d, get_be32(d) - v); return *this; }
-    BE32& operator &= (unsigned v)    { set_be32(d, get_be32(d) & v); return *this; }
-    BE32& operator |= (unsigned v)    { set_be32(d, get_be32(d) | v); return *this; }
-
-    operator const unsigned () const  { return get_be32(d); }
-};
+    operator unsigned () const { return get_be32(d); }
+__packed_struct_end()


-class LE16
-{
+__packed_struct(BE64)
+    unsigned char d[8];
+
+    BE64& operator =  (upx_uint64_t v) { set_be64(d, v); return *this; }
+    BE64& operator += (upx_uint64_t v) { set_be64(d, get_be64(d) + v); return *this; }
+    BE64& operator -= (upx_uint64_t v) { set_be64(d, get_be64(d) - v); return *this; }
+    BE64& operator *= (upx_uint64_t v) { set_be64(d, get_be64(d) * v); return *this; }
+    BE64& operator /= (upx_uint64_t v) { set_be64(d, get_be64(d) / v); return *this; }
+    BE64& operator &= (upx_uint64_t v) { set_be64(d, get_be64(d) & v); return *this; }
+    BE64& operator |= (upx_uint64_t v) { set_be64(d, get_be64(d) | v); return *this; }
+    BE64& operator ^= (upx_uint64_t v) { set_be64(d, get_be64(d) ^ v); return *this; }
+    BE64& operator <<= (unsigned v) { set_be64(d, get_be64(d) << v); return *this; }
+    BE64& operator >>= (unsigned v) { set_be64(d, get_be64(d) >> v); return *this; }
+
+    operator upx_uint64_t () const { return get_be64(d); }
+__packed_struct_end()
+
+
+__packed_struct(LE16)
    unsigned char d[2];

-public:
-    LE16& operator =  (const LE16 &v) { memcpy(d, v.d, sizeof(d)); return *this; }
+    LE16& operator =  (unsigned v) { set_le16(d, v); return *this; }
+    LE16& operator += (unsigned v) { set_le16(d, get_le16(d) + v); return *this; }
+    LE16& operator -= (unsigned v) { set_le16(d, get_le16(d) - v); return *this; }
+    LE16& operator *= (unsigned v) { set_le16(d, get_le16(d) * v); return *this; }
+    LE16& operator /= (unsigned v) { set_le16(d, get_le16(d) / v); return *this; }
+    LE16& operator &= (unsigned v) { set_le16(d, get_le16(d) & v); return *this; }
+    LE16& operator |= (unsigned v) { set_le16(d, get_le16(d) | v); return *this; }
+    LE16& operator ^= (unsigned v) { set_le16(d, get_le16(d) ^ v); return *this; }
+    LE16& operator <<= (unsigned v) { set_le16(d, get_le16(d) << v); return *this; }
+    LE16& operator >>= (unsigned v) { set_le16(d, get_le16(d) >> v); return *this; }

-    LE16& operator =  (unsigned v)    { set_le16(d, v); return *this; }
-    LE16& operator += (unsigned v)    { set_le16(d, get_le16(d) + v); return *this; }
-    LE16& operator -= (unsigned v)    { set_le16(d, get_le16(d) - v); return *this; }
-    LE16& operator &= (unsigned v)    { set_le16(d, get_le16(d) & v); return *this; }
-    LE16& operator |= (unsigned v)    { set_le16(d, get_le16(d) | v); return *this; }
-
-    operator const unsigned () const  { return get_le16(d); }
-};
+    operator unsigned () const { return get_le16(d); }
+__packed_struct_end()


-class LE32
-{
+__packed_struct(LE32)
    unsigned char d[4];

-public:
-    LE32& operator =  (const LE32 &v) { memcpy(d, v.d, sizeof(d)); return *this; }
+    LE32& operator =  (unsigned v) { set_le32(d, v); return *this; }
+    LE32& operator += (unsigned v) { set_le32(d, get_le32(d) + v); return *this; }
+    LE32& operator -= (unsigned v) { set_le32(d, get_le32(d) - v); return *this; }
+    LE32& operator *= (unsigned v) { set_le32(d, get_le32(d) * v); return *this; }
+    LE32& operator /= (unsigned v) { set_le32(d, get_le32(d) / v); return *this; }
+    LE32& operator &= (unsigned v) { set_le32(d, get_le32(d) & v); return *this; }
+    LE32& operator |= (unsigned v) { set_le32(d, get_le32(d) | v); return *this; }
+    LE32& operator ^= (unsigned v) { set_le32(d, get_le32(d) ^ v); return *this; }
+    LE32& operator <<= (unsigned v) { set_le32(d, get_le32(d) << v); return *this; }
+    LE32& operator >>= (unsigned v) { set_le32(d, get_le32(d) >> v); return *this; }

-    LE32& operator =  (unsigned v)    { set_le32(d, v); return *this; }
-    LE32& operator += (unsigned v)    { set_le32(d, get_le32(d) + v); return *this; }
-    LE32& operator -= (unsigned v)    { set_le32(d, get_le32(d) - v); return *this; }
-    LE32& operator &= (unsigned v)    { set_le32(d, get_le32(d) & v); return *this; }
-    LE32& operator |= (unsigned v)    { set_le32(d, get_le32(d) | v); return *this; }
+    operator unsigned () const { return get_le32(d); }
+__packed_struct_end()

-    operator const unsigned () const  { return get_le32(d); }
-};
+
+__packed_struct(LE64)
+    unsigned char d[8];
+
+    LE64& operator =  (upx_uint64_t v) { set_le64(d, v); return *this; }
+    LE64& operator += (upx_uint64_t v) { set_le64(d, get_le64(d) + v); return *this; }
+    LE64& operator -= (upx_uint64_t v) { set_le64(d, get_le64(d) - v); return *this; }
+    LE64& operator *= (upx_uint64_t v) { set_le64(d, get_le64(d) * v); return *this; }
+    LE64& operator /= (upx_uint64_t v) { set_le64(d, get_le64(d) / v); return *this; }
+    LE64& operator &= (upx_uint64_t v) { set_le64(d, get_le64(d) & v); return *this; }
+    LE64& operator |= (upx_uint64_t v) { set_le64(d, get_le64(d) | v); return *this; }
+    LE64& operator ^= (upx_uint64_t v) { set_le64(d, get_le64(d) ^ v); return *this; }
+    LE64& operator <<= (unsigned v) { set_le64(d, get_le64(d) << v); return *this; }
+    LE64& operator >>= (unsigned v) { set_le64(d, get_le64(d) >> v); return *this; }
+
+    operator upx_uint64_t () const { return get_le64(d); }
+__packed_struct_end()


 /*************************************************************************
 // global operators
 **************************************************************************/

-inline bool operator < (const BE16& v1, const BE16& v2)
-{
-    return (const unsigned)v1 < (const unsigned)v2;
-}
+template <class T>
+inline T* operator + (T* ptr, const BE16& v) { return ptr + (unsigned) v; }
+template <class T>
+inline T* operator + (const BE16& v, T* ptr) { return ptr + (unsigned) v; }
+template <class T>
+inline T* operator - (T* ptr, const BE16& v) { return ptr - (unsigned) v; }

-inline bool operator < (const BE32& v1, const BE32& v2)
-{
-    return (const unsigned)v1 < (const unsigned)v2;
-}
+template <class T>
+inline T* operator + (T* ptr, const BE32& v) { return ptr + (unsigned) v; }
+template <class T>
+inline T* operator + (const BE32& v, T* ptr) { return ptr + (unsigned) v; }
+template <class T>
+inline T* operator - (T* ptr, const BE32& v) { return ptr - (unsigned) v; }

-inline bool operator < (const LE16& v1, const LE16& v2)
-{
-    return (const unsigned)v1 < (const unsigned)v2;
-}
+// these are not implemented on purpose and will cause link-time errors
+template <class T> T* operator + (T* ptr, const BE64& v);
+template <class T> T* operator + (const BE64& v, T* ptr);
+template <class T> T* operator - (T* ptr, const BE64& v);

-inline bool operator < (const LE32& v1, const LE32& v2)
-{
-    return (const unsigned)v1 < (const unsigned)v2;
-}
+template <class T>
+inline T* operator + (T* ptr, const LE16& v) { return ptr + (unsigned) v; }
+template <class T>
+inline T* operator + (const LE16& v, T* ptr) { return ptr + (unsigned) v; }
+template <class T>
+inline T* operator - (T* ptr, const LE16& v) { return ptr - (unsigned) v; }
+
+template <class T>
+inline T* operator + (T* ptr, const LE32& v) { return ptr + (unsigned) v; }
+template <class T>
+inline T* operator + (const LE32& v, T* ptr) { return ptr + (unsigned) v; }
+template <class T>
+inline T* operator - (T* ptr, const LE32& v) { return ptr - (unsigned) v; }
+
+// these are not implemented on purpose and will cause link-time errors
+template <class T> T* operator + (T* ptr, const LE64& v);
+template <class T> T* operator + (const LE64& v, T* ptr);
+template <class T> T* operator - (T* ptr, const LE64& v);
+
+
+/*************************************************************************
+// global overloads
+**************************************************************************/
+
+inline unsigned ALIGN_DOWN(unsigned a, const BE32& b) { return ALIGN_DOWN(a, (unsigned) b); }
+inline unsigned ALIGN_DOWN(const BE32& a, unsigned b) { return ALIGN_DOWN((unsigned) a, b); }
+inline unsigned ALIGN_UP  (unsigned a, const BE32& b) { return ALIGN_UP  (a, (unsigned) b); }
+inline unsigned ALIGN_UP  (const BE32& a, unsigned b) { return ALIGN_UP  ((unsigned) a, b); }
+
+inline unsigned ALIGN_DOWN(unsigned a, const LE32& b) { return ALIGN_DOWN(a, (unsigned) b); }
+inline unsigned ALIGN_DOWN(const LE32& a, unsigned b) { return ALIGN_DOWN((unsigned) a, b); }
+inline unsigned ALIGN_UP  (unsigned a, const LE32& b) { return ALIGN_UP  (a, (unsigned) b); }
+inline unsigned ALIGN_UP  (const LE32& a, unsigned b) { return ALIGN_UP  ((unsigned) a, b); }
+
+inline unsigned UPX_MAX(unsigned a, const BE16& b)    { return UPX_MAX(a, (unsigned) b); }
+inline unsigned UPX_MAX(const BE16& a, unsigned b)    { return UPX_MAX((unsigned) a, b); }
+inline unsigned UPX_MIN(unsigned a, const BE16& b)    { return UPX_MIN(a, (unsigned) b); }
+inline unsigned UPX_MIN(const BE16& a, unsigned b)    { return UPX_MIN((unsigned) a, b); }
+
+inline unsigned UPX_MAX(unsigned a, const BE32& b)    { return UPX_MAX(a, (unsigned) b); }
+inline unsigned UPX_MAX(const BE32& a, unsigned b)    { return UPX_MAX((unsigned) a, b); }
+inline unsigned UPX_MIN(unsigned a, const BE32& b)    { return UPX_MIN(a, (unsigned) b); }
+inline unsigned UPX_MIN(const BE32& a, unsigned b)    { return UPX_MIN((unsigned) a, b); }
+
+inline unsigned UPX_MAX(unsigned a, const LE16& b)    { return UPX_MAX(a, (unsigned) b); }
+inline unsigned UPX_MAX(const LE16& a, unsigned b)    { return UPX_MAX((unsigned) a, b); }
+inline unsigned UPX_MIN(unsigned a, const LE16& b)    { return UPX_MIN(a, (unsigned) b); }
+inline unsigned UPX_MIN(const LE16& a, unsigned b)    { return UPX_MIN((unsigned) a, b); }
+
+inline unsigned UPX_MAX(unsigned a, const LE32& b)    { return UPX_MAX(a, (unsigned) b); }
+inline unsigned UPX_MAX(const LE32& a, unsigned b)    { return UPX_MAX((unsigned) a, b); }
+inline unsigned UPX_MIN(unsigned a, const LE32& b)    { return UPX_MIN(a, (unsigned) b); }
+inline unsigned UPX_MIN(const LE32& a, unsigned b)    { return UPX_MIN((unsigned) a, b); }


 /*************************************************************************
@@ -247,16 +518,68 @@ inline bool operator < (const LE32& v1, const LE32& v2)
 **************************************************************************/

 // for use with qsort()
-int be16_compare(const void *e1, const void *e2);
-int be32_compare(const void *e1, const void *e2);
-int le16_compare(const void *e1, const void *e2);
-int le32_compare(const void *e1, const void *e2);
+extern "C" {
+int __acc_cdecl_qsort be16_compare(const void *, const void *);
+int __acc_cdecl_qsort be24_compare(const void *, const void *);
+int __acc_cdecl_qsort be32_compare(const void *, const void *);
+int __acc_cdecl_qsort be64_compare(const void *, const void *);
+int __acc_cdecl_qsort le16_compare(const void *, const void *);
+int __acc_cdecl_qsort le24_compare(const void *, const void *);
+int __acc_cdecl_qsort le32_compare(const void *, const void *);
+int __acc_cdecl_qsort le64_compare(const void *, const void *);
+int __acc_cdecl_qsort be16_compare_signed(const void *, const void *);
+int __acc_cdecl_qsort be24_compare_signed(const void *, const void *);
+int __acc_cdecl_qsort be32_compare_signed(const void *, const void *);
+int __acc_cdecl_qsort be64_compare_signed(const void *, const void *);
+int __acc_cdecl_qsort le16_compare_signed(const void *, const void *);
+int __acc_cdecl_qsort le24_compare_signed(const void *, const void *);
+int __acc_cdecl_qsort le32_compare_signed(const void *, const void *);
+int __acc_cdecl_qsort le64_compare_signed(const void *, const void *);
+} // extern "C"
+
+
+/*************************************************************************
+// Provide namespaces and classes to abstract endianness policies.
+//
+// CTP - Compile-Time Polymorphism (templates)
+// RTP - Run-Time Polymorphism (virtual functions)
+**************************************************************************/
+
+// forward declarations
+namespace N_BELE_CTP {
+struct BEPolicy;
+struct LEPolicy;
+extern const BEPolicy be_policy;
+extern const LEPolicy le_policy;
+}
+namespace N_BELE_RTP {
+struct AbstractPolicy;
+struct BEPolicy;
+struct LEPolicy;
+extern const BEPolicy be_policy;
+extern const LEPolicy le_policy;
+}
+
+namespace N_BELE_CTP {
+#define BELE_CTP 1
+#include "bele_policy.h"
+#undef BELE_CTP
+}
+
+namespace N_BELE_RTP {
+#define BELE_RTP 1
+#include "bele_policy.h"
+#undef BELE_RTP
+}
+
+namespace N_BELE_CTP {
+inline const N_BELE_RTP::AbstractPolicy* getRTP(const BEPolicy*)
+    { return &N_BELE_RTP::be_policy; }
+inline const N_BELE_RTP::AbstractPolicy* getRTP(const LEPolicy*)
+    { return &N_BELE_RTP::le_policy; }
+}


 #endif /* already included */

-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,279 @@
+/* bele_policy.h -- access memory in BigEndian and LittleEndian byte order
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   All Rights Reserved.
+
+   UPX and the UCL library are free software; you can redistribute them
+   and/or modify them under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
+ */
+
+
+#ifndef __UPX_BELE_H
+#  error "this is an internal include file"
+#endif
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+#if defined(BELE_CTP)
+   // CTP - Compile-Time Polymorphism (templates)
+#  define V     static inline
+#  define S     static int __acc_cdecl_qsort
+#  define C     /*empty*/
+#elif defined(BELE_RTP)
+   // RTP - Run-Time Polymorphism (virtual functions)
+#  define V     virtual
+#  define S     virtual int
+#  define C     const
+#else
+#  error
+#endif
+
+
+#if defined(BELE_RTP)
+struct AbstractPolicy
+{
+    inline AbstractPolicy() { }
+    virtual inline ~AbstractPolicy() { }
+    V bool isBE() C = 0;
+    V bool isLE() C = 0;
+
+    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 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, upx_uint64_t v) C = 0;
+
+    V unsigned get16_signed(const void *p) C = 0;
+    V unsigned get24_signed(const void *p) C = 0;
+    V unsigned get32_signed(const void *p) C = 0;
+    V upx_uint64_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;
+    S u32_compare(const void *a, const void *b) C = 0;
+    S u64_compare(const void *a, const void *b) C = 0;
+
+    S u16_compare_signed(const void *a, const void *b) C = 0;
+    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;
+
+    // disable dynamic allocation
+    DISABLE_NEW_DELETE
+};
+#endif
+
+
+struct BEPolicy
+#if defined(BELE_RTP)
+    : public AbstractPolicy
+#endif
+{
+    inline BEPolicy() { }
+#if defined(BELE_CTP)
+    typedef N_BELE_RTP::BEPolicy RTP_Policy;
+#elif defined(BELE_RTP)
+    typedef N_BELE_CTP::BEPolicy CTP_Policy;
+#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
+        { return get_be16(p); }
+    V unsigned get24(const void *p) C
+        { return get_be24(p); }
+    V unsigned get32(const void *p) C
+        { return get_be32(p); }
+    V upx_uint64_t get64(const void *p) C
+        { return get_be64(p); }
+
+    V void set16(void *p, unsigned v) C
+        { set_be16(p, v); }
+    V void set24(void *p, unsigned v) C
+        { set_be24(p, v); }
+    V void set32(void *p, unsigned v) C
+        { set_be32(p, v); }
+    V void set64(void *p, upx_uint64_t v) C
+        { set_be64(p, v); }
+
+    V unsigned get16_signed(const void *p) C
+        { return get_be16_signed(p); }
+    V unsigned get24_signed(const void *p) C
+        { return get_be24_signed(p); }
+    V unsigned get32_signed(const void *p) C
+        { return get_be32_signed(p); }
+    V upx_uint64_t get64_signed(const void *p) C
+        { return get_be64_signed(p); }
+
+    S u16_compare(const void *a, const void *b) C
+        { return be16_compare(a, b); }
+    S u24_compare(const void *a, const void *b) C
+        { return be24_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
+        { return be16_compare_signed(a, b); }
+    S u24_compare_signed(const void *a, const void *b) C
+        { return be24_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_ALIGNED1(U16)
+        COMPILE_TIME_ASSERT_ALIGNED1(U32)
+        COMPILE_TIME_ASSERT_ALIGNED1(U64)
+    }
+
+    // disable dynamic allocation
+    DISABLE_NEW_DELETE
+};
+
+
+struct LEPolicy
+#if defined(BELE_RTP)
+    : public AbstractPolicy
+#endif
+{
+    inline LEPolicy() { }
+#if defined(BELE_CTP)
+    typedef N_BELE_RTP::LEPolicy RTP_Policy;
+#elif defined(BELE_RTP)
+    typedef N_BELE_CTP::LEPolicy CTP_Policy;
+#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
+        { return get_le16(p); }
+    V unsigned get24(const void *p) C
+        { return get_le24(p); }
+    V unsigned get32(const void *p) C
+        { return get_le32(p); }
+    V upx_uint64_t get64(const void *p) C
+        { return get_le64(p); }
+
+    V void set16(void *p, unsigned v) C
+        { set_le16(p, v); }
+    V void set24(void *p, unsigned v) C
+        { set_le24(p, v); }
+    V void set32(void *p, unsigned v) C
+        { set_le32(p, v); }
+    V void set64(void *p, upx_uint64_t v) C
+        { set_le64(p, v); }
+
+    V unsigned get16_signed(const void *p) C
+        { return get_le16_signed(p); }
+    V unsigned get24_signed(const void *p) C
+        { return get_le24_signed(p); }
+    V unsigned get32_signed(const void *p) C
+        { return get_le32_signed(p); }
+    V upx_uint64_t get64_signed(const void *p) C
+        { return get_le64_signed(p); }
+
+    S u16_compare(const void *a, const void *b) C
+        { return le16_compare(a, b); }
+    S u24_compare(const void *a, const void *b) C
+        { return le24_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
+        { return le16_compare_signed(a, b); }
+    S u24_compare_signed(const void *a, const void *b) C
+        { return le24_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_ALIGNED1(U16)
+        COMPILE_TIME_ASSERT_ALIGNED1(U32)
+        COMPILE_TIME_ASSERT_ALIGNED1(U64)
+    }
+
+    // disable dynamic allocation
+    DISABLE_NEW_DELETE
+};
+
+
+#if (ACC_ABI_BIG_ENDIAN)
+typedef BEPolicy HostPolicy;
+#elif (ACC_ABI_LITTLE_ENDIAN)
+typedef LEPolicy HostPolicy;
+#else
+#  error "ACC_ABI_ENDIAN"
+#endif
+
+
+#if 0 /* UNUSED */
+struct HostAlignedPolicy
+{
+#if defined(BELE_CTP)
+    enum { isBE = HostPolicy::isBE, isLE = HostPolicy::isLE };
+#endif
+
+    typedef upx_uint16_t U16;
+    typedef upx_uint32_t U32;
+    typedef upx_uint64_t U64;
+
+    static void compileTimeAssertions() {
+        COMPILE_TIME_ASSERT(sizeof(U16) == 2)
+        COMPILE_TIME_ASSERT(sizeof(U32) == 4)
+        COMPILE_TIME_ASSERT(sizeof(U64) == 8)
+    }
+};
+#endif
+
+
+#undef V
+#undef S
+#undef C
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,106 @@
+/* bptr.h --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   All Rights Reserved.
+
+   UPX and the UCL library are free software; you can redistribute them
+   and/or modify them under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
+ */
+
+
+#ifndef __UPX_BPTR_H
+#define __UPX_BPTR_H 1
+
+
+/*************************************************************************
+// BoundedPtr
+**************************************************************************/
+
+template <class T>
+class BoundedPtr
+{
+public:
+    //typedef T* StoredType;
+    //typedef T* PointerType;
+    //typedef T& ReferenceType;
+
+    ~BoundedPtr() { }
+
+    explicit BoundedPtr(void* base, size_t size_in_bytes, T* ptr=0)
+        : ptr_(ptr), base_(base), size_in_bytes_(0)
+    {
+        assert(base_ != NULL);
+        size_in_bytes_ = mem_size(1, size_in_bytes);
+        check();
+    }
+
+    // assignment
+    BoundedPtr& operator= (const BoundedPtr& other) {
+        assert(base_ == other.base_);
+        assert(size_in_bytes_ == other.size_in_bytes_);
+        ptr_ = other.ptr_; check(); return *this;
+    }
+    BoundedPtr& operator= (T* other) {
+        ptr_ = other; check(); return *this;
+    }
+
+    operator       T* ()       { return ptr_; }
+    operator const T* () const { return ptr_; }
+
+    BoundedPtr& operator += (size_t n) {
+        checkNULL(); ptr_ += n; checkRange(); return *this;
+    }
+    BoundedPtr& operator -= (size_t n) {
+        checkNULL(); ptr_ -= n; checkRange(); return *this;
+    }
+    BoundedPtr& operator ++ (void) {
+        checkNULL(); ptr_ += 1; checkRange(); return *this;
+    }
+
+private:
+    void checkNULL() const {
+        if __acc_very_unlikely(!ptr_)
+            throwCantUnpack("unexpected NULL pointer; take care!");
+    }
+    void checkRange() const {
+        size_t off = (const char *) ptr_ - (const char *) base_;
+        if __acc_very_unlikely(off > size_in_bytes_)
+            throwCantUnpack("pointer out of range; take care!");
+    }
+    void check() const { // check ptr_ invariant: either NULL or valid checkRange()
+        if (ptr_ != NULL)
+            checkRange();
+    }
+
+    T* ptr_;
+    void* base_;
+    size_t size_in_bytes_;
+
+    // disable copy
+    BoundedPtr(const BoundedPtr&); // {}
+    // disable dynamic allocation
+    DISABLE_NEW_DELETE
+};
+
+
+#endif /* already included */
+
+/* vim:set ts=4 sw=4 et: */
@@ -1,9 +1,9 @@
-/* c_file.cpp -- file console output
+/* c_file.cpp --

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,14 +21,14 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #include "conf.h"

-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)

 /*************************************************************************
 //
@@ -72,7 +72,7 @@ static void print0(FILE *f, const char *s)
 }


-static upx_bool intro(FILE *f)
+static bool intro(FILE *f)
 {
    UNUSED(f);
    return 0;
@@ -89,8 +89,4 @@ console_t console_file =

 #endif /* USE_CONSOLE */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -1,9 +1,9 @@
-/* c_init.cpp -- console initialization
+/* c_init.cpp --

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,8 +21,8 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


@@ -30,7 +30,7 @@

 FILE *con_term = NULL;

-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)

 /*************************************************************************
 //
@@ -81,17 +81,17 @@ static int do_init(FILE *f)
    if (opt->console == CON_NONE || opt->to_stdout)
        return con_mode;
    try_init(&console_file,f);
-    if (!isatty(STDIN_FILENO) || !isatty(STDOUT_FILENO) || !isatty(STDERR_FILENO))
+    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

@@ -124,7 +124,7 @@ static int set_fg(FILE *f, int fg)
 }


-static upx_bool intro(FILE *f)
+static bool intro(FILE *f)
 {
    if (con == me)
        init(f,-1,-1);
@@ -142,13 +142,13 @@ console_t console_init =
 };


-void con_fprintf(FILE *f, const char *format, ...)
+void __acc_cdecl_va 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);
+    va_start(args, format);
+    upx_vsnprintf(buf, sizeof(buf), format,args);
    va_end(args);

    if (con == me)
@@ -159,8 +159,4 @@ void con_fprintf(FILE *f, const char *format, ...)

 #endif /* USE_CONSOLE */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -1,9 +1,9 @@
-/* c_none.cpp -- dummy console output
+/* c_none.cpp --

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,14 +21,14 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #include "conf.h"

-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)

 /*************************************************************************
 //
@@ -58,7 +58,7 @@ static void print0(FILE *f, const char *s)
 }


-static upx_bool intro(FILE *f)
+static bool intro(FILE *f)
 {
    UNUSED(f);
    return 0;
@@ -75,8 +75,4 @@ console_t console_none =

 #endif /* USE_CONSOLE */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,14 +21,14 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #include "conf.h"

-#if defined(USE_SCREEN)
+#if (USE_SCREEN)

 #include "screen.h"

@@ -88,7 +88,7 @@ static screen_t *do_construct(screen_t *s, int fd)

 static screen_t *screen = NULL;

-static void do_destroy(void)
+static void __acc_cdecl_atexit do_destroy(void)
 {
    if (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(__MFX_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
@@ -196,7 +196,7 @@ static void print0(FILE *f, const char *ss)

    // Note:
    //   We use 2 passes to avoid unnecessary system calls because
-    //   scrollUp() under Win95/98 is *extremely* slow.
+    //   scrollUp() under Win32 is *extremely* slow.
    UNUSED(f);

    screen->getCursor(screen,&old_cx,&old_cy);
@@ -295,10 +295,10 @@ static void print0(FILE *f, const char *ss)
 }


-static upx_bool intro(FILE *f)
+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 */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -1,9 +1,9 @@
-/* compress.cpp -- interface to the compression library
+/* compress.cpp --

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,174 +21,153 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #include "conf.h"
-
-#if defined(WITH_UCL) && !defined(WITH_NRV)
-#  define nrv2b_99_compress_internal    ucl_nrv2b_99_compress
-#  define nrv2d_99_compress_internal    ucl_nrv2d_99_compress
-#  if 0 && defined(__i386__)
-#    include <ucl/ucl_asm.h>
-#    define nrv2b_decompress_safe_8     ucl_nrv2b_decompress_asm_safe_8
-#    define nrv2b_decompress_safe_le16  ucl_nrv2b_decompress_asm_safe_le16
-#    define nrv2b_decompress_safe_le32  ucl_nrv2b_decompress_asm_safe_le32
-#    define nrv2d_decompress_safe_8     ucl_nrv2d_decompress_asm_safe_8
-#    define nrv2d_decompress_safe_le16  ucl_nrv2d_decompress_asm_safe_le16
-#    define nrv2d_decompress_safe_le32  ucl_nrv2d_decompress_asm_safe_le32
-#  else
-#    define nrv2b_decompress_safe_8     ucl_nrv2b_decompress_safe_8
-#    define nrv2b_decompress_safe_le16  ucl_nrv2b_decompress_safe_le16
-#    define nrv2b_decompress_safe_le32  ucl_nrv2b_decompress_safe_le32
-#    define nrv2d_decompress_safe_8     ucl_nrv2d_decompress_safe_8
-#    define nrv2d_decompress_safe_le16  ucl_nrv2d_decompress_safe_le16
-#    define nrv2d_decompress_safe_le32  ucl_nrv2d_decompress_safe_le32
-#  endif
-#endif
-
-#if defined(WITH_NRV)
-#  include <nrv/nrv2b.h>
-#  include <nrv/nrv2d.h>
-#  if !defined(NRV_VERSION) || (NRV_VERSION < 0x007300L)
-#    error
-#  endif
-#  if 1 && defined(__i386__)
-#    define nrv2b_decompress_safe_8     nrv2b_decompress_asm_safe_8
-#    define nrv2b_decompress_safe_le16  nrv2b_decompress_asm_safe_le16
-#    define nrv2d_decompress_safe_8     nrv2d_decompress_asm_safe_8
-#    define nrv2d_decompress_safe_le16  nrv2d_decompress_asm_safe_le16
-#    if (NRV_VERSION < 0x008000L)
-#    define nrv2b_decompress_safe_le32  nrv2b_decompress_asm_safe
-#    define nrv2d_decompress_safe_le32  nrv2d_decompress_asm_safe
-#    else
-#    define nrv2b_decompress_safe_le32  nrv2b_decompress_asm_safe_le32
-#    define nrv2d_decompress_safe_le32  nrv2d_decompress_asm_safe_le32
-#    endif
-#  endif
-   NRV_EXTERN_CDECL(int) nrv2b_99_compress_internal(...);
-   NRV_EXTERN_CDECL(int) nrv2d_99_compress_internal(...);
-   NRV_EXTERN_CDECL(int) nrv2b_decompress_safe_8(...);
-   NRV_EXTERN_CDECL(int) nrv2b_decompress_safe_le16(...);
-   NRV_EXTERN_CDECL(int) nrv2b_decompress_safe_le32(...);
-   NRV_EXTERN_CDECL(int) nrv2d_decompress_safe_8(...);
-   NRV_EXTERN_CDECL(int) nrv2d_decompress_safe_le16(...);
-   NRV_EXTERN_CDECL(int) nrv2d_decompress_safe_le32(...);
-#endif
-
-#if 0 && defined(WITH_ZLIB) && defined(M_ZLIB)
-#  include <zlib.h>
-#endif
+#include "compress.h"
+#include "mem.h"


 /*************************************************************************
 //
 **************************************************************************/

-int upx_compress           ( const upx_byte *src, upx_uint  src_len,
-                                   upx_byte *dst, upx_uint *dst_len,
-                                   upx_progress_callback_t *cb,
+unsigned upx_adler32(const void *buf, unsigned len, unsigned adler)
+{
+    if (len == 0)
+        return adler;
+    assert(buf != NULL);
+#if 1
+    return upx_ucl_adler32(buf, len, adler);
+#else
+    return upx_zlib_adler32(buf, len, adler);
+#endif
+}
+
+
+#if 0 /* UNUSED */
+unsigned upx_crc32(const void *buf, unsigned len, unsigned crc)
+{
+    if (len == 0)
+        return crc;
+    assert(buf != NULL);
+#if 1
+    return upx_ucl_crc32(buf, len, crc);
+#else
+    return upx_zlib_crc32(buf, len, crc);
+#endif
+}
+#endif /* UNUSED */
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+int upx_compress           ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   upx_callback_p cb,
                                   int method, int level,
-                             const struct upx_compress_config_t *conf_parm,
-                                   upx_uintp result)
+                             const upx_compress_config_t *cconf,
+                                   upx_compress_result_t *cresult )
+{
+    int r = UPX_E_ERROR;
+    upx_compress_result_t cresult_buffer;
+
+    assert(method > 0); assert(level > 0);
+
+#if 1
+    // set available bytes in dst
+    if (*dst_len == 0)
+        *dst_len = MemBuffer::getSizeForCompression(src_len);
+#else
+    // force users to provide *dst_len
+    assert(*dst_len != 0);
+#endif
+    // for UPX, we always require a reasonably sized outbut buffer
+    assert(*dst_len >= MemBuffer::getSizeForCompression(src_len));
+
+    if (!cresult)
+        cresult = &cresult_buffer;
+    memset(cresult, 0, sizeof(*cresult));
+#if 1
+    // debug
+    cresult->method = method;
+    cresult->level = level;
+    cresult->u_len = src_len;
+    cresult->c_len = 0;
+#endif
+
+    if __acc_cte(0) {
+    }
+#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 (WITH_NRV)
+    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 (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);
+#endif
+    else {
+        throwInternalError("unknown compression method");
+    }
+
+#if 1
+    // debug
+    cresult->c_len = *dst_len;
+#endif
+    return r;
+}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+int upx_decompress         ( const upx_bytep src, unsigned  src_len,
+                                   upx_bytep dst, unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult )
 {
-    struct upx_compress_config_t conf;
-    upx_uint result_buffer[16];
    int r = UPX_E_ERROR;

-    assert(level > 0);
-    memset(&conf, 0xff, sizeof(conf));
-    if (conf_parm)
-        conf = *conf_parm;     // struct copy
-    if (!result)
-        result = result_buffer;
+    assert(*dst_len > 0);
+    assert(src_len < *dst_len); // must be compressed

-    // assume no info available - fill in worst case results
-    //result[0] = 1;            // min_offset_found - NOT USED
-    result[1] = src_len - 1;    // max_offset_found
-    //result[2] = 2;            // min_match_found - NOT USED
-    result[3] = src_len - 1;    // max_match_found
-    //result[4] = 1;            // min_run_found - NOT USED
-    result[5] = src_len;        // max_run_found
-    result[6] = 1;              // first_offset_found
-    //result[7] = 999999;       // same_match_offsets_found - NOT USED
+    if (cresult && cresult->method == 0)
+        cresult = NULL;

-#if 0 && defined(WITH_ZLIB) && defined(M_ZLIB)
-    if (method == M_ZLIB)
-    {
-        uLong destLen = src_len + src_len / 8 + 256;
-        r = compress2(dst, &destLen, src, src_len, UPX_MIN(level, 9));
-        *dst_len = destLen;
-        if (r == Z_MEM_ERROR)
-            return UPX_E_OUT_OF_MEMORY;
-        if (r != Z_OK)
-            return UPX_E_ERROR;
-        return UPX_E_OK;
+    if __acc_cte(0) {
    }
+#if (WITH_LZMA)
+    else if (M_IS_LZMA(method))
+        r = upx_lzma_decompress(src, src_len, dst, dst_len, method, cresult);
 #endif
-
-    // prepare bit-buffer settings
-    conf.bb_endian = 0;
-    conf.bb_size = 0;
-    if (method == M_NRV2B_LE32 || method == M_NRV2D_LE32)
-        conf.bb_size = 32;
-    else if (method == M_NRV2B_8 || method == M_NRV2D_8)
-        conf.bb_size = 8;
-    else if (method == M_NRV2B_LE16 || method == M_NRV2D_LE16)
-        conf.bb_size = 16;
-    else
-        throwInternalError("unknown compression method");
-
-#if 1 && defined(WITH_NRV)
-    if (level == 1 && conf.bb_size == 32 &&
-        conf.max_offset == UPX_UINT_MAX && conf.max_match == UPX_UINT_MAX)
-    {
-        if (method == M_NRV2B_LE32)
-        {
-            upx_byte wrkmem[NRV2B_1_16_MEM_COMPRESS];
-#if defined(__UPX_CHECKER)
-            memset(wrkmem,0,NRV2B_1_16_MEM_COMPRESS);
+#if (WITH_NRV)
+    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
-            r = nrv2b_1_16_compress(src, src_len, dst, dst_len, wrkmem);
-        }
-        else if (method == M_NRV2D_LE32)
-        {
-            upx_byte wrkmem[NRV2D_1_16_MEM_COMPRESS];
-#if defined(__UPX_CHECKER)
-            memset(wrkmem,0,NRV2D_1_16_MEM_COMPRESS);
+#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
-            r = nrv2d_1_16_compress(src, src_len, dst, dst_len, wrkmem);
-        }
-        else
-            throwInternalError("unknown compression method");
-        return r;
+#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");
    }
-#endif
-
-    // optimize compression parms
-    if (level <= 3 && conf.max_offset == UPX_UINT_MAX)
-        conf.max_offset = 8*1024-1;
-    else if (level == 4 && conf.max_offset == UPX_UINT_MAX)
-        conf.max_offset = 32*1024-1;
-#if defined(WITH_NRV)
-    else if (level <= 7 && conf.max_offset == UPX_UINT_MAX)
-        conf.max_offset = 1024*1024-1;
-    else if (level <= 8 && conf.max_offset == UPX_UINT_MAX)
-        conf.max_offset = 2048*1024-1;
-    else if (level <= 10 && conf.max_offset == UPX_UINT_MAX)
-        conf.max_offset = 4096*1024-1;
-#endif
-
-    if M_IS_NRV2B(method)
-        r = nrv2b_99_compress_internal(src, src_len, dst, dst_len,
-                                       cb, level, &conf, result);
-    else if M_IS_NRV2D(method)
-        r = nrv2d_99_compress_internal(src, src_len, dst, dst_len,
-                                       cb, level, &conf, result);
-    else
-        throwInternalError("unknown compression method");

    return r;
 }
@@ -198,73 +177,42 @@ int upx_compress           ( const upx_byte *src, upx_uint  src_len,
 //
 **************************************************************************/

-int upx_decompress         ( const upx_byte *src, upx_uint  src_len,
-                                   upx_byte *dst, upx_uint *dst_len,
-                                   int method )
+int upx_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 )
 {
    int r = UPX_E_ERROR;

-#if 0 && defined(WITH_ZLIB) && defined(M_ZLIB)
-    if (method == M_ZLIB)
-    {
-        uLong destLen = *dst_len;
-        r = uncompress(dst, &destLen, src, src_len);
-        *dst_len = destLen;
-        if (r == Z_MEM_ERROR)
-            return UPX_E_OUT_OF_MEMORY;
-        if (r != Z_OK)
-            return UPX_E_ERROR;
-        return UPX_E_OK;
+    if (cresult && cresult->method == 0)
+        cresult = NULL;
+
+    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 __acc_cte(0) {
    }
+#if (WITH_LZMA)
+    else if (M_IS_LZMA(method))
+        r = upx_lzma_test_overlap(buf, tbuf, src_off, src_len, dst_len, method, cresult);
 #endif
-
-    if (method == M_NRV2B_LE32)
-        r = nrv2b_decompress_safe_le32(src,src_len,dst,dst_len,NULL);
-    else if (method == M_NRV2B_8)
-        r = nrv2b_decompress_safe_8(src,src_len,dst,dst_len,NULL);
-    else if (method == M_NRV2B_LE16)
-        r = nrv2b_decompress_safe_le16(src,src_len,dst,dst_len,NULL);
-    else if (method == M_NRV2D_LE32)
-        r = nrv2d_decompress_safe_le32(src,src_len,dst,dst_len,NULL);
-    else if (method == M_NRV2D_8)
-        r = nrv2d_decompress_safe_8(src,src_len,dst,dst_len,NULL);
-    else if (method == M_NRV2D_LE16)
-        r = nrv2d_decompress_safe_le16(src,src_len,dst,dst_len,NULL);
-    else
+#if (WITH_NRV)
+    else if ((M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method)) && !opt->prefer_ucl)
+        r = upx_nrv_test_overlap(buf, tbuf, src_off, src_len, dst_len, method, cresult);
+#endif
+#if (WITH_UCL)
+    else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
+        r = upx_ucl_test_overlap(buf, tbuf, src_off, src_len, dst_len, method, cresult);
+#endif
+    else {
        throwInternalError("unknown decompression method");
+    }
+
    return r;
 }

-
-/*************************************************************************
-//
-**************************************************************************/
-
-int upx_test_overlap       ( const upx_byte *buf, upx_uint src_off,
-                                   upx_uint  src_len, upx_uint *dst_len,
-                                   int method )
-{
-    int r = UPX_E_ERROR;
-
-    if (method == M_NRV2B_LE32)
-        r = ucl_nrv2b_test_overlap_le32(buf,src_off,src_len,dst_len,NULL);
-    else if (method == M_NRV2B_8)
-        r = ucl_nrv2b_test_overlap_8(buf,src_off,src_len,dst_len,NULL);
-    else if (method == M_NRV2B_LE16)
-        r = ucl_nrv2b_test_overlap_le16(buf,src_off,src_len,dst_len,NULL);
-    else if (method == M_NRV2D_LE32)
-        r = ucl_nrv2d_test_overlap_le32(buf,src_off,src_len,dst_len,NULL);
-    else if (method == M_NRV2D_8)
-        r = ucl_nrv2d_test_overlap_8(buf,src_off,src_len,dst_len,NULL);
-    else if (method == M_NRV2D_LE16)
-        r = ucl_nrv2d_test_overlap_le16(buf,src_off,src_len,dst_len,NULL);
-    else
-        throwInternalError("unknown decompression method");
-    return r;
-}
-
-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,131 @@
+/* compress.h --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   All Rights Reserved.
+
+   UPX and the UCL library are free software; you can redistribute them
+   and/or modify them under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
+ */
+
+
+#ifndef __UPX_COMPRESS_H
+#define __UPX_COMPRESS_H 1
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+#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,
+                                   int method, int level,
+                             const upx_compress_config_t *cconf,
+                                   upx_compress_result_t *cresult );
+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,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult );
+#endif
+
+
+#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,
+                                   int method, int level,
+                             const upx_compress_config_t *cconf,
+                                   upx_compress_result_t *cresult );
+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,
+                             const upx_bytep tbuf,
+                                   unsigned  src_off, unsigned src_len,
+                                   unsigned* dst_len,
+                                   int method,
+                             const upx_compress_result_t *cresult );
+#endif
+
+
+#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,
+                                   int method, int level,
+                             const upx_compress_config_t *cconf,
+                                   upx_compress_result_t *cresult );
+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,
+                             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: */
@@ -0,0 +1,528 @@
+/* compress_lzma.cpp --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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 "mem.h"
+
+#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()
+{
+    memset(this, 0, sizeof(*this));
+
+    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
+//   using unmodified LZMA source code in UPX and the UPX stubs.
+//   See SPECIAL EXCEPTION below.
+//
+// Quoting from lzma-4.43/lzma.txt:
+//
+//   LICENSE
+//   -------
+//
+//   LZMA SDK is available under any of the following licenses:
+//
+//   1) GNU Lesser General Public License (GNU LGPL)
+//   2) Common Public License (CPL)
+//   3) Simplified license for unmodified code (read SPECIAL EXCEPTION)
+//   4) Proprietary license
+//
+//   It means that you can select one of these four options and follow rules
+//   of that license.
+//
+//   1,2) GNU LGPL and CPL licenses are pretty similar and both these
+//   licenses are classified as
+//    - "Free software licenses" at http://www.gnu.org/
+//    - "OSI-approved" at http://www.opensource.org/
+//
+//   3) SPECIAL EXCEPTION
+//
+//   Igor Pavlov, as the author of this code, expressly permits you
+//   to statically or dynamically link your code (or bind by name)
+//   to the files from LZMA SDK without subjecting your linked
+//   code to the terms of the CPL or GNU LGPL.
+//   Any modifications or additions to files from LZMA SDK, however,
+//   are subject to the GNU LGPL or CPL terms.
+//
+//   SPECIAL EXCEPTION allows you to use LZMA SDK in applications with closed code,
+//   while you keep LZMA SDK code unmodified.
+
+
+/*************************************************************************
+// compress defaults
+**************************************************************************/
+
+static int prepare(lzma_compress_result_t *res,
+                   unsigned src_len, int method, int level,
+                   const lzma_compress_config_t *lcconf)
+{
+    // setup defaults
+    res->pos_bits            = 2;                   // 0 .. 4
+    res->lit_pos_bits        = 0;                   // 0 .. 4
+    res->lit_context_bits    = 3;                   // 0 .. 8
+    res->dict_size           = 4 * 1024 * 1024;     // 1 .. 2**30
+    res->fast_mode           = 2;
+    res->num_fast_bytes      = 64;                  // 5 .. 273
+    res->match_finder_cycles = 0;
+    // UPX overrides
+    res->pos_bits            = lzma_compress_config_t::pos_bits_t::default_value_c;
+    res->lit_pos_bits        = lzma_compress_config_t::lit_pos_bits_t::default_value_c;
+    res->lit_context_bits    = lzma_compress_config_t::lit_context_bits_t::default_value_c;
+    res->dict_size           = lzma_compress_config_t::dict_size_t::default_value_c;
+    res->num_fast_bytes      = lzma_compress_config_t::num_fast_bytes_t::default_value_c;
+    // 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 MiB of stack during runtime decompression.
+    res->lit_pos_bits     = 4;
+    res->lit_context_bits = 8;
+#endif
+
+    // TODO: tune these settings according to level
+    switch (level)
+    {
+    case 1:
+        res->dict_size      = 256 * 1024;
+        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;
+    case 4:
+        break;
+    case 5:
+        break;
+    case 6:
+        break;
+    case 7:
+        break;
+    case 8:
+        break;
+    case 9:
+        res->dict_size      = 8 * 1024 * 1024;
+        break;
+    case 10:
+        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 (res->dict_size > src_len)
+        res->dict_size = src_len;
+
+    // limit num_probs
+    if (lcconf && lcconf->max_num_probs)
+    {
+        for (;;)
+        {
+            unsigned n = 1846 + (768 << (res->lit_context_bits + res->lit_pos_bits));
+            if (n <= lcconf->max_num_probs)
+                break;
+            if (res->lit_pos_bits > res->lit_context_bits)
+            {
+                if (res->lit_pos_bits == 0)
+                    goto error;
+                res->lit_pos_bits -= 1;
+            }
+            else
+            {
+                if (res->lit_context_bits == 0)
+                    goto error;
+                res->lit_context_bits -= 1;
+            }
+        }
+    }
+
+    res->num_probs = 1846 + (768 << (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
+#include "C/Common/MyInitGuid.h"
+//#include "C/7zip/Compress/LZMA/LZMADecoder.h"
+#include "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);
+};
+
+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 != NULL) *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);
+};
+
+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 != NULL) *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);
+    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 "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
+
+
+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 != NULL);
+
+    int r = UPX_E_ERROR;
+    HRESULT rh;
+    const lzma_compress_config_t *lcconf = cconf_parm ? &cconf_parm->conf_lzma : NULL;
+    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;
+
+    try {
+
+    if (enc.SetCoderProperties(propIDs, pr, nprops) != S_OK)
+        goto error;
+    if (enc.WriteCoderProperties(&os) != S_OK)
+        goto error;
+    if (os.overflow) {
+        //r = UPX_E_OUTPUT_OVERRUN;
+        r = UPX_E_NOT_COMPRESSIBLE;
+        goto error;
+    }
+    assert(os.b_pos == 5);
+    os.b_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(Byte((t << 3) | res->pos_bits));
+    os.WriteByte(Byte((res->lit_pos_bits << 4) | (res->lit_context_bits)));
+
+    rh = enc.Code(&is, &os, NULL, NULL, &progress);
+
+    } catch (...) {
+        rh = E_OUTOFMEMORY;
+    }
+
+    assert(is.b_pos <=  src_len);
+    assert(os.b_pos <= *dst_len);
+    if (rh == E_OUTOFMEMORY)
+        r = UPX_E_OUT_OF_MEMORY;
+    else if (os.overflow)
+    {
+        assert(os.b_pos == *dst_len);
+        //r = UPX_E_OUTPUT_OVERRUN;
+        r = UPX_E_NOT_COMPRESSIBLE;
+    }
+    else if (rh == S_OK)
+    {
+        assert(is.b_pos == src_len);
+        r = UPX_E_OK;
+    }
+
+error:
+    *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;
+}
+
+
+/*************************************************************************
+// decompress
+**************************************************************************/
+
+#undef _LZMA_IN_CB
+#undef _LZMA_OUT_READ
+#undef _LZMA_PROB32
+#undef _LZMA_LOC_OPT
+#include "C/7zip/Compress/LZMA_C/LzmaDecode.h"
+#include "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(M_IS_LZMA(method));
+    // see res->num_probs above
+    COMPILE_TIME_ASSERT(sizeof(CProb) == 2)
+    COMPILE_TIME_ASSERT(LZMA_BASE_SIZE == 1846)
+    COMPILE_TIME_ASSERT(LZMA_LIT_SIZE == 768)
+
+    CLzmaDecoderState s; memset(&s, 0, sizeof(s));
+    SizeT src_out = 0, dst_out = 0;
+    int r = UPX_E_ERROR;
+    int rh;
+
+    if (src_len < 3)
+        goto error;
+    s.Properties.pb = src[0] & 7;
+    s.Properties.lp = (src[1] >> 4);
+    s.Properties.lc = src[1] & 15;
+    if (s.Properties.pb >= 5) goto error;
+    if (s.Properties.lp >= 5) goto error;
+    if (s.Properties.lc >= 9) goto error;
+    // extra
+    if ((src[0] >> 3) != s.Properties.lc + s.Properties.lp) goto error;
+    src += 2; src_len -= 2;
+
+    if (cresult)
+    {
+        assert(cresult->method == method);
+        assert(cresult->result_lzma.pos_bits == (unsigned) s.Properties.pb);
+        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)
+    {
+        r = UPX_E_OUT_OF_MEMORY;
+        goto error;
+    }
+    rh = LzmaDecode(&s, src, src_len, &src_out, dst, *dst_len, &dst_out);
+    assert(src_out <=  src_len);
+    assert(dst_out <= *dst_len);
+    if (rh == 0)
+    {
+        r = UPX_E_OK;
+        if (src_out != src_len)
+            r = UPX_E_INPUT_NOT_CONSUMED;
+    }
+
+error:
+    *dst_len = dst_out;
+    free(s.Probs);
+    return r;
+}
+
+
+/*************************************************************************
+// test_overlap - see <ucl/ucl.h> for semantics
+**************************************************************************/
+
+int upx_lzma_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(M_IS_LZMA(method));
+
+    MemBuffer b(src_off + src_len);
+    memcpy(b + src_off, buf + src_off, src_len);
+    unsigned saved_dst_len = *dst_len;
+    int r = upx_lzma_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 != NULL && memcmp(tbuf, b, *dst_len) != 0)
+        return UPX_E_ERROR;
+    return UPX_E_OK;
+}
+
+
+/*************************************************************************
+// misc
+**************************************************************************/
+
+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 NULL;
+#endif
+}
+
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,320 @@
+/* compress_ucl.cpp --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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"
+#if !(WITH_UCL)
+extern int compress_ucl_dummy;
+int compress_ucl_dummy = 0;
+#else
+
+#if 1 && !(UCL_USE_ASM) && (ACC_ARCH_I386)
+#  if (ACC_CC_CLANG || ACC_CC_GNUC || ACC_CC_INTELC || ACC_CC_MSC || ACC_CC_WATCOMC)
+#    define UCL_USE_ASM 1
+#  endif
+#endif
+#if (UCL_NO_ASM)
+#  undef UCL_USE_ASM
+#endif
+#if (ACC_CFG_NO_UNALIGNED)
+#  undef UCL_USE_ASM
+#endif
+#if 1 && (UCL_USE_ASM)
+#  include <ucl/ucl_asm.h>
+#  define ucl_nrv2b_decompress_safe_8       ucl_nrv2b_decompress_asm_safe_8
+#  define ucl_nrv2b_decompress_safe_le16    ucl_nrv2b_decompress_asm_safe_le16
+#  define ucl_nrv2b_decompress_safe_le32    ucl_nrv2b_decompress_asm_safe_le32
+#  define ucl_nrv2d_decompress_safe_8       ucl_nrv2d_decompress_asm_safe_8
+#  define ucl_nrv2d_decompress_safe_le16    ucl_nrv2d_decompress_asm_safe_le16
+#  define ucl_nrv2d_decompress_safe_le32    ucl_nrv2d_decompress_asm_safe_le32
+#  define ucl_nrv2e_decompress_safe_8       ucl_nrv2e_decompress_asm_safe_8
+#  define ucl_nrv2e_decompress_safe_le16    ucl_nrv2e_decompress_asm_safe_le16
+#  define ucl_nrv2e_decompress_safe_le32    ucl_nrv2e_decompress_asm_safe_le32
+#endif
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+static int convert_errno_from_ucl(int r)
+{
+    switch (r)
+    {
+    case UCL_E_OK:                  return UPX_E_OK;
+    case UCL_E_ERROR:               return UPX_E_ERROR;
+    case UCL_E_OUT_OF_MEMORY:       return UPX_E_OUT_OF_MEMORY;
+    case UCL_E_NOT_COMPRESSIBLE:    return UPX_E_NOT_COMPRESSIBLE;
+    case UCL_E_INPUT_OVERRUN:       return UPX_E_INPUT_OVERRUN;
+    case UCL_E_OUTPUT_OVERRUN:      return UPX_E_OUTPUT_OVERRUN;
+    case UCL_E_LOOKBEHIND_OVERRUN:  return UPX_E_LOOKBEHIND_OVERRUN;
+    case UCL_E_EOF_NOT_FOUND:       return UPX_E_EOF_NOT_FOUND;
+    case UCL_E_INPUT_NOT_CONSUMED:  return UPX_E_INPUT_NOT_CONSUMED;
+//  case UCL_E_NOT_YET_IMPLEMENTED: return UPX_E_NOT_YET_IMPLEMENTED;
+    case UCL_E_INVALID_ARGUMENT:    return UPX_E_INVALID_ARGUMENT;
+    // UCL extra:
+    case UCL_E_OVERLAP_OVERRUN:     return UPX_E_ERROR;
+    }
+    return UPX_E_ERROR;
+}
+
+
+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);
+}}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+int upx_ucl_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 )
+{
+    int r;
+    assert(level > 0); assert(cresult != NULL);
+
+    COMPILE_TIME_ASSERT(sizeof(ucl_compress_config_t) == sizeof(REAL_ucl_compress_config_t))
+
+    ucl_progress_callback_t cb;
+    cb.callback = 0;
+    cb.user = NULL;
+    if (cb_parm && cb_parm->nprogress) {
+        cb.callback = wrap_nprogress_ucl;
+        cb.user = cb_parm;
+    }
+
+    ucl_compress_config_t cconf; cconf.reset();
+    if (cconf_parm)
+        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
+    //res[0] = 1;                 // min_offset_found - NOT USED
+    res[1] = src_len - 1;       // max_offset_found
+    //res[2] = 2;                 // min_match_found - NOT USED
+    res[3] = src_len - 1;       // max_match_found
+    //res[4] = 1;                 // min_run_found - NOT USED
+    res[5] = src_len;           // max_run_found
+    res[6] = 1;                 // first_offset_found
+    //res[7] = 999999;            // same_match_offsets_found - NOT USED
+
+    // prepare bit-buffer settings
+    cconf.bb_endian = 0;
+    cconf.bb_size = 0;
+    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];
+    }
+    else {
+        throwInternalError("unknown compression method");
+        return UPX_E_ERROR;
+    }
+
+    // optimize compression parms
+    if (level <= 3 && cconf.max_offset == UCL_UINT_MAX)
+        cconf.max_offset = 8*1024-1;
+    else if (level == 4 && cconf.max_offset == UCL_UINT_MAX)
+        cconf.max_offset = 32*1024-1;
+
+    if M_IS_NRV2B(method)
+        r = ucl_nrv2b_99_compress(src, src_len, dst, dst_len,
+                                  &cb, level, &cconf, res);
+    else if M_IS_NRV2D(method)
+        r = ucl_nrv2d_99_compress(src, src_len, dst, dst_len,
+                                  &cb, level, &cconf, res);
+    else if M_IS_NRV2E(method)
+        r = ucl_nrv2e_99_compress(src, src_len, dst, dst_len,
+                                  &cb, level, &cconf, res);
+    else {
+        throwInternalError("unknown compression method");
+        return UPX_E_ERROR;
+    }
+
+    // make sure first_offset_found is set
+    if (res[6] == 0)
+        res[6] = 1;
+
+    return convert_errno_from_ucl(r);
+}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+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 r;
+
+    switch (method)
+    {
+    case M_NRV2B_8:
+        r = ucl_nrv2b_decompress_safe_8(src,src_len,dst,dst_len,NULL);
+        break;
+    case M_NRV2B_LE16:
+        r = ucl_nrv2b_decompress_safe_le16(src,src_len,dst,dst_len,NULL);
+        break;
+    case M_NRV2B_LE32:
+        r = ucl_nrv2b_decompress_safe_le32(src,src_len,dst,dst_len,NULL);
+        break;
+    case M_NRV2D_8:
+        r = ucl_nrv2d_decompress_safe_8(src,src_len,dst,dst_len,NULL);
+        break;
+    case M_NRV2D_LE16:
+        r = ucl_nrv2d_decompress_safe_le16(src,src_len,dst,dst_len,NULL);
+        break;
+    case M_NRV2D_LE32:
+        r = ucl_nrv2d_decompress_safe_le32(src,src_len,dst,dst_len,NULL);
+        break;
+    case M_NRV2E_8:
+        r = ucl_nrv2e_decompress_safe_8(src,src_len,dst,dst_len,NULL);
+        break;
+    case M_NRV2E_LE16:
+        r = ucl_nrv2e_decompress_safe_le16(src,src_len,dst,dst_len,NULL);
+        break;
+    case M_NRV2E_LE32:
+        r = ucl_nrv2e_decompress_safe_le32(src,src_len,dst,dst_len,NULL);
+        break;
+    default:
+        throwInternalError("unknown decompression method");
+        return UPX_E_ERROR;
+    }
+
+    UNUSED(cresult);
+    return convert_errno_from_ucl(r);
+}
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+int upx_ucl_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 )
+{
+    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);
+        break;
+    case M_NRV2B_LE16:
+        r = ucl_nrv2b_test_overlap_le16(buf,src_off,src_len,dst_len,NULL);
+        break;
+    case M_NRV2B_LE32:
+        r = ucl_nrv2b_test_overlap_le32(buf,src_off,src_len,dst_len,NULL);
+        break;
+    case M_NRV2D_8:
+        r = ucl_nrv2d_test_overlap_8(buf,src_off,src_len,dst_len,NULL);
+        break;
+    case M_NRV2D_LE16:
+        r = ucl_nrv2d_test_overlap_le16(buf,src_off,src_len,dst_len,NULL);
+        break;
+    case M_NRV2D_LE32:
+        r = ucl_nrv2d_test_overlap_le32(buf,src_off,src_len,dst_len,NULL);
+        break;
+    case M_NRV2E_8:
+        r = ucl_nrv2e_test_overlap_8(buf,src_off,src_len,dst_len,NULL);
+        break;
+    case M_NRV2E_LE16:
+        r = ucl_nrv2e_test_overlap_le16(buf,src_off,src_len,dst_len,NULL);
+        break;
+    case M_NRV2E_LE32:
+        r = ucl_nrv2e_test_overlap_le32(buf,src_off,src_len,dst_len,NULL);
+        break;
+    default:
+        throwInternalError("unknown decompression method");
+        return UPX_E_ERROR;
+    }
+
+    UNUSED(cresult);
+    return convert_errno_from_ucl(r);
+}
+
+
+/*************************************************************************
+// misc
+**************************************************************************/
+
+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 defined(UPX_OFFICIAL_BUILD)
+    if (UCL_VERSION != ucl_version())
+        return -2;
+#endif
+    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
+
+#endif /* WITH_UCL */
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,256 @@
+/* compress_zlib.cpp --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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 "mem.h"
+
+
+void zlib_compress_config_t::reset()
+{
+    memset(this, 0, sizeof(*this));
+
+    mem_level.reset();
+    window_bits.reset();
+    strategy.reset();
+}
+
+
+#if !(WITH_ZLIB)
+extern int compress_zlib_dummy;
+int compress_zlib_dummy = 0;
+#else
+
+#include <zlib.h>
+
+
+static int convert_errno_from_zlib(int zr)
+{
+    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 != NULL);
+    UNUSED(cb_parm);
+    int r = UPX_E_ERROR;
+    int zr;
+    const zlib_compress_config_t *lcconf = cconf_parm ? &cconf_parm->conf_zlib : NULL;
+    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) 0;
+    s.zfree = (free_func) 0;
+    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 = deflateInit2(&s, level, Z_DEFLATED, 0 - (int)window_bits,
+                      mem_level, strategy);
+    if (zr != Z_OK)
+        goto error;
+    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) 0;
+    s.zfree = (free_func) 0;
+    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 != NULL && memcmp(tbuf, b, *dst_len) != 0)
+        return UPX_E_ERROR;
+    return UPX_E_OK;
+}
+
+
+/*************************************************************************
+// misc
+**************************************************************************/
+
+int upx_zlib_init(void)
+{
+#if defined(UPX_OFFICIAL_BUILD)
+    if (strcmp(ZLIB_VERSION, zlibVersion()) != 0)
+        return -2;
+#endif
+    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
+
+
+#endif /* WITH_ZLIB */
+
+/* vim:set ts=4 sw=4 et: */
@@ -1,240 +0,0 @@
-/* pseudo <config.h> for Linux */
-
-#ifndef __UPX_CONFIG_H
-#define __UPX_CONFIG_H
-
-/* $TOP$ */
-
-/* Define to empty if the keyword does not work.  */
-/* #undef const */
-
-/* Define if your C compiler doesn't accept -c and -o together.  */
-/* #undef NO_MINUS_C_MINUS_O */
-
-/* Define as the return type of signal handlers (int or void).  */
-#define RETSIGTYPE void
-
-/* Define to `unsigned' if <sys/types.h> doesn't define.  */
-/* #undef size_t */
-
-/* Define if you have the ANSI C header files.  */
-#define STDC_HEADERS 1
-
-/* Define if you can safely include both <sys/time.h> and <time.h>.  */
-#define TIME_WITH_SYS_TIME 1
-
-/* Define if your memcmp is broken.  */
-/* #undef NO_MEMCMP */
-
-/* Define to `long' if <stddef.h> doesn't define.  */
-/* #undef ptrdiff_t */
-
-/* The number of bytes in a ptrdiff_t.  */
-#define SIZEOF_PTRDIFF_T 4
-
-/* The number of bytes in a size_t.  */
-#define SIZEOF_SIZE_T 4
-
-/* Define when using the dmalloc package.  */
-/* #undef WITH_DMALLOC */
-
-/* Define if you have the access function.  */
-#define HAVE_ACCESS 1
-
-/* Define if you have the atoi function.  */
-#define HAVE_ATOI 1
-
-/* Define if you have the chmod function.  */
-#define HAVE_CHMOD 1
-
-/* Define if you have the chown function.  */
-#define HAVE_CHOWN 1
-
-/* Define if you have the ctime function.  */
-#define HAVE_CTIME 1
-
-/* Define if you have the difftime function.  */
-#define HAVE_DIFFTIME 1
-
-/* Define if you have the fchmod function.  */
-#define HAVE_FCHMOD 1
-
-/* Define if you have the fileno function.  */
-#define HAVE_FILENO 1
-
-/* Define if you have the fstat function.  */
-#define HAVE_FSTAT 1
-
-/* Define if you have the XXX function.  */
-#define HAVE_GETPID 1
-
-/* Define if you have the XXX function.  */
-#define HAVE_GETTIMEOFDAY 1
-
-/* Define if you have the getumask function.  */
-/* #undef HAVE_GETUMASK */
-
-/* Define if you have the gmtime function.  */
-#define HAVE_GMTIME 1
-
-/* Define if you have the index function.  */
-#define HAVE_INDEX 1
-
-/* Define if you have the isatty function.  */
-#define HAVE_ISATTY 1
-
-/* Define if you have the lstat function.  */
-#define HAVE_LSTAT 1
-
-/* Define if you have the localtime function.  */
-#define HAVE_LOCALTIME 1
-
-/* Define if you have the memcmp function.  */
-#define HAVE_MEMCMP 1
-
-/* Define if you have the memcpy function.  */
-#define HAVE_MEMCPY 1
-
-/* Define if you have the memmove function.  */
-#define HAVE_MEMMOVE 1
-
-/* Define if you have the memset function.  */
-#define HAVE_MEMSET 1
-
-/* Define if you have the mktime function.  */
-#define HAVE_MKTIME 1
-
-/* Define if you have the setmode function.  */
-/* #undef HAVE_SETMODE */
-
-/* Define if you have the stat function.  */
-#define HAVE_STAT 1
-
-/* Define if you have the strcasecmp function.  */
-#define HAVE_STRCASECMP 1
-
-/* Define if you have the strchr function.  */
-#define HAVE_STRCHR 1
-
-/* Define if you have the strdup function.  */
-#define HAVE_STRDUP 1
-
-/* Define if you have the strftime function.  */
-#define HAVE_STRFTIME 1
-
-/* Define if you have the stricmp function.  */
-/* #undef HAVE_STRICMP */
-
-/* Define if you have the strncasecmp function.  */
-#define HAVE_STRNCASECMP 1
-
-/* Define if you have the strnicmp function.  */
-/* #undef HAVE_STRNICMP */
-
-/* Define if you have the strstr function.  */
-#define HAVE_STRSTR 1
-
-/* Define if you have the tzset function.  */
-#define HAVE_TZSET 1
-
-/* Define if you have the umask function.  */
-#define HAVE_UMASK 1
-
-/* Define if you have the utime function.  */
-#define HAVE_UTIME 1
-
-/* Define if you have the vsnprintf function.  */
-#define HAVE_VSNPRINTF 1
-
-/* Define if you have the <assert.h> header file.  */
-#define HAVE_ASSERT_H 1
-
-/* Define if you have the <ctype.h> header file.  */
-#define HAVE_CTYPE_H 1
-
-/* Define if you have the <curses.h> header file.  */
-#define HAVE_CURSES_H 1
-
-/* Define if you have the <limits.h> header file.  */
-#define HAVE_LIMITS_H 1
-
-/* Define if you have the <linux/kd.h> header file.  */
-#define HAVE_LINUX_KD_H 1
-
-/* Define if you have the <linux/kdev_t.h> header file.  */
-#define HAVE_LINUX_KDEV_T_H 1
-
-/* Define if you have the <linux/major.h> header file.  */
-#define HAVE_LINUX_MAJOR_H 1
-
-/* Define if you have the <memory.h> header file.  */
-#define HAVE_MEMORY_H 1
-
-/* Define if you have the <ncurses.h> header file.  */
-#define HAVE_NCURSES_H 1
-
-/* Define if you have the <signal.h> header file.  */
-#define HAVE_SIGNAL_H 1
-
-/* Define if you have the <stddef.h> header file.  */
-#define HAVE_STDDEF_H 1
-
-/* Define if you have the <sys/param.h> header file.  */
-#define HAVE_SYS_PARAM_H 1
-
-/* Define if you have the <sys/resource.h> header file.  */
-#define HAVE_SYS_RESOURCE_H 1
-
-/* Define if you have the <sys/time.h> header file.  */
-#define HAVE_SYS_TIME_H 1
-
-/* Define if you have the <sys/times.h> header file.  */
-#define HAVE_SYS_TIMES_H 1
-
-/* Define if you have the <sys/utime.h> header file.  */
-/* #undef HAVE_SYS_UTIME_H */
-
-/* Define if you have the <time.h> header file.  */
-#define HAVE_TIME_H 1
-
-/* Define if you have the <unistd.h> header file.  */
-#define HAVE_UNISTD_H 1
-
-/* Define if you have the <utime.h> header file.  */
-#define HAVE_UTIME_H 1
-
-/* $BOTTOM$ */
-
-#if defined(HAVE_GMTIME) && !defined(TIME_WITH_SYS_TIME)
-#  undef /**/ HAVE_GMTIME
-#endif
-
-#if defined(HAVE_LOCALTIME) && !defined(TIME_WITH_SYS_TIME)
-#  undef /**/ HAVE_LOCALTIME
-#endif
-
-#if defined(HAVE_STRFTIME) && !defined(TIME_WITH_SYS_TIME)
-#  undef /**/ HAVE_STRFTIME
-#endif
-
-#if defined(HAVE_SYS_RESOURCE_H) && !defined(TIME_WITH_SYS_TIME)
-#  undef /**/ HAVE_SYS_RESOURCE_H
-#endif
-
-#if defined(HAVE_SYS_TIMES_H) && !defined(TIME_WITH_SYS_TIME)
-#  undef /**/ HAVE_SYS_TIMES_H
-#endif
-
-#if (SIZEOF_PTRDIFF_T <= 0)
-#  undef /**/ SIZEOF_PTRDIFF_T
-#endif
-
-#if (SIZEOF_SIZE_T <= 0)
-#  undef /**/ SIZEOF_SIZE_T
-#endif
-
-#endif /* already included */
-
-/*
-vi:ts=4
-*/
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,8 +21,8 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


@@ -34,43 +34,46 @@
 #undef USE_CONSOLE
 #undef USE_ANSI
 #undef USE_SCREEN
-#undef USE_SCREEN_VCSA
 #undef USE_SCREEN_CURSES
+#undef USE_SCREEN_VCSA
+#undef USE_SCREEN_WIN32
 #undef USE_FRAMES

-#if defined(WITH_GUI) && !defined(NO_CONSOLE)
-#  define NO_CONSOLE
+#if 1 && (WITH_GUI) && !defined(NO_CONSOLE)
+#  define NO_CONSOLE 1
 #endif

 #if 1 && defined(__linux__)
-#  define USE_SCREEN
-#  define USE_SCREEN_VCSA
-#  if !defined(HAVE_LINUX_KD_H)
+#  define USE_SCREEN 1
+#  define USE_SCREEN_VCSA 1
+#  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__)
-#  define USE_SCREEN
-#endif
-
-#if 1 && defined(__MFX_WIN32)
-#  define USE_SCREEN
+#if 1 && (ACC_OS_DOS32) && defined(__DJGPP__)
+#  define USE_SCREEN 1
+#elif 1 && (ACC_OS_CYGWIN || ACC_OS_WIN32 || ACC_OS_WIN64)
+#  define USE_SCREEN 1
+#  define USE_SCREEN_WIN32 1
+#elif 1 && (ACC_OS_EMX && defined(__RSXNT__))
+#  define USE_SCREEN 1
+#  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
@@ -78,11 +81,11 @@
 #endif


-#if 0 || defined(USE_ANSI) || defined(USE_SCREEN)
-#  define USE_CONSOLE
+#if 0 || (USE_ANSI) || (USE_SCREEN)
+#  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
@@ -107,23 +110,23 @@ enum {
 };


-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)

 typedef struct
 {
    int (*init)(FILE *f, int, int);
    int (*set_fg)(FILE *f, int fg);
    void (*print0)(FILE *f, const char *s);
-    upx_bool (*intro)(FILE *f);
+    bool (*intro)(FILE *f);
 }
 console_t;


 #if defined(__GNUC__)
-void con_fprintf(FILE *f, const char *format, ...)
-        __attribute__((format(printf,2,3)));
+void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...)
+        __attribute__((__format__(printf,2,3)));
 #else
-void con_fprintf(FILE *f, const char *format, ...);
+void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...);
 #endif


@@ -162,7 +165,7 @@ void 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;
@@ -184,8 +187,4 @@ extern console_t console_screen;

 #endif /* USE_CONSOLE */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,14 +21,55 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #include "conf.h"


+/*************************************************************************
+//
+**************************************************************************/
+
+unsigned long Throwable::counter = 0;
+
+Throwable::Throwable(const char *m, int e, bool w) NOTHROW
+    : super(), msg(NULL), err(e), is_warning(w)
+{
+    if (m)
+        msg = strdup(m);
+#if 0
+    fprintf(stderr, "construct exception: %s %lu\n", msg, counter);
+    counter++;
+#endif
+}
+
+
+Throwable::Throwable(const Throwable &other) NOTHROW
+    : super(other), msg(NULL), err(other.err), is_warning(other.is_warning)
+{
+    if (other.msg)
+        msg = strdup(other.msg);
+#if 0
+    fprintf(stderr, "copy exception: %s %lu\n", msg, counter);
+    counter++;
+#endif
+}
+
+
+Throwable::~Throwable() NOTHROW
+{
+#if 0
+    counter--;
+    fprintf(stderr, "destruct exception: %s %lu\n", msg, counter);
+#endif
+    if (msg)
+        free(msg);
+}
+
+
 /*************************************************************************
 // compression
 **************************************************************************/
@@ -44,6 +85,11 @@ void throwCantPack(const char *msg)
        throw CantUnpackException(msg);
 }

+void throwCantPackExact()
+{
+    throwCantPack("option '--exact' does not work with this file");
+}
+
 void throwFilterException()
 {
    throwCantPack("filter problem");
@@ -115,6 +161,14 @@ void throwBadLoader()
 }


+void throwOutOfMemoryException(const char *msg)
+{
+    if (msg == NULL)
+        msg = "out of memory";
+    throw OutOfMemoryException(msg);
+}
+
+
 void throwIOException(const char *msg, int e)
 {
    throw IOException(msg, e);
@@ -133,22 +187,22 @@ void throwEOFException(const char *msg, int e)
 //
 **************************************************************************/

-const char *prettyName(const char *n)
+const char *prettyName(const char *n) NOTHROW
 {
-    while (*n >= '0' && *n <= '9')              // gcc / egcs
-        n++;
-    if (strncmp(n, "class ", 6) == 0)           // Visual C++
-        n += 6;
+    if (n == NULL)
+        return "(null)";
+    while (*n)
+    {
+        if (*n >= '0' && *n <= '9')             // Linux ABI
+            n++;
+        else if (*n == ' ')
+            n++;
+        else if (strncmp(n, "class ", 6) == 0)  // Visual C++
+            n += 6;
+        else
+            break;
+    }
    return n;
 }

-const char *prettyName(const type_info &ti)
-{
-    return prettyName(ti.name());
-}
-
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,42 +21,48 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_EXCEPT_H
-#define __UPX_EXCEPT_H
+#define __UPX_EXCEPT_H 1

 #ifdef __cplusplus

-const char *prettyName(const char *n);
-const char *prettyName(const type_info &ti);
+const char *prettyName(const char *n) NOTHROW;


 /*************************************************************************
 // exceptions
 **************************************************************************/

-class Throwable : public exception
+class Throwable : public std::exception
 {
+    typedef std::exception super;
 protected:
-    Throwable(const char *m = 0, int e = 0, bool w = false)
-        : msg(m), err(e), is_warning(w) { }
+    Throwable(const char *m = 0, int e = 0, bool w = false) NOTHROW;
 public:
-    virtual ~Throwable() { }
-    const char *getMsg() const { return msg; }
-    int getErrno() const { return err; }
-    bool isWarning() const { return is_warning; }
+    Throwable(const Throwable &) NOTHROW;
+    virtual ~Throwable() NOTHROW;
+    const char *getMsg() const NOTHROW { return msg; }
+    int getErrno() const NOTHROW { return err; }
+    bool isWarning() const NOTHROW { return is_warning; }
 private:
-    //Throwable(const Throwable &);
-private:
-//  void * operator new(size_t);        // ...
-    const char *msg;
+    char *msg;
    int err;
 protected:
    bool is_warning;                    // can be set by subclasses
+
+private:
+    // disable assignment
+    Throwable& operator= (const Throwable &);
+    // disable dynamic allocation
+    DISABLE_NEW_DELETE
+
+private:
+    static unsigned long counter;       // for debugging
 };


@@ -65,7 +71,7 @@ class Exception : public Throwable
 {
    typedef Throwable super;
 public:
-    Exception(const char *m = 0, int e = 0, bool w = false) : super(m,e,w) { }
+    Exception(const char *m = 0, int e = 0, bool w = false) NOTHROW : super(m,e,w) { }
 };


@@ -74,7 +80,7 @@ class Error : public Throwable
 {
    typedef Throwable super;
 public:
-    Error(const char *m = 0, int e = 0) : super(m,e) { }
+    Error(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
 };


@@ -86,7 +92,7 @@ class OutOfMemoryException : public Exception
 {
    typedef Exception super;
 public:
-    OutOfMemoryException(const char *m = 0, int e = 0) : super(m,e) { }
+    OutOfMemoryException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
 };


@@ -94,7 +100,7 @@ class IOException : public Exception
 {
    typedef Exception super;
 public:
-    IOException(const char *m = 0, int e = 0) : super(m,e) { }
+    IOException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
 };


@@ -102,7 +108,7 @@ class EOFException : public IOException
 {
    typedef IOException super;
 public:
-    EOFException(const char *m = 0, int e = 0) : super(m,e) { }
+    EOFException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
 };


@@ -110,7 +116,7 @@ class FileNotFoundException : public IOException
 {
    typedef IOException super;
 public:
-    FileNotFoundException(const char *m = 0, int e = 0) : super(m,e) { }
+    FileNotFoundException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
 };


@@ -118,7 +124,7 @@ class FileAlreadyExistsException : public IOException
 {
    typedef IOException super;
 public:
-    FileAlreadyExistsException(const char *m = 0, int e = 0) : super(m,e) { }
+    FileAlreadyExistsException(const char *m = 0, int e = 0) NOTHROW : super(m,e) { }
 };


@@ -130,35 +136,35 @@ class OverlayException : public Exception
 {
    typedef Exception super;
 public:
-    OverlayException(const char *m = 0, bool w = false) : super(m,0,w) { }
+    OverlayException(const char *m = 0, bool w = false) NOTHROW : super(m,0,w) { }
 };

 class CantPackException : public Exception
 {
    typedef Exception super;
 public:
-    CantPackException(const char *m = 0, bool w = false) : super(m,0,w) { }
+    CantPackException(const char *m = 0, bool w = false) NOTHROW : super(m,0,w) { }
 };

 class UnknownExecutableFormatException : public CantPackException
 {
    typedef CantPackException super;
 public:
-    UnknownExecutableFormatException(const char *m = 0, bool w = false) : super(m,w) { }
+    UnknownExecutableFormatException(const char *m = 0, bool w = false) NOTHROW : super(m,w) { }
 };

 class AlreadyPackedException : public CantPackException
 {
    typedef CantPackException super;
 public:
-    AlreadyPackedException(const char *m = 0) : super(m) { is_warning = true; }
+    AlreadyPackedException(const char *m = 0) NOTHROW : super(m) { is_warning = true; }
 };

 class NotCompressibleException : public CantPackException
 {
    typedef CantPackException super;
 public:
-    NotCompressibleException(const char *m = 0) : super(m) { }
+    NotCompressibleException(const char *m = 0) NOTHROW : super(m) { }
 };


@@ -166,14 +172,14 @@ class CantUnpackException : public Exception
 {
    typedef Exception super;
 public:
-    CantUnpackException(const char *m = 0, bool w = false) : super(m,0,w) { }
+    CantUnpackException(const char *m = 0, bool w = false) NOTHROW : super(m,0,w) { }
 };

 class NotPackedException : public CantUnpackException
 {
    typedef CantUnpackException super;
 public:
-    NotPackedException(const char *m = 0) : super(m,true) { }
+    NotPackedException(const char *m = 0) NOTHROW : super(m,true) { }
 };


@@ -185,7 +191,7 @@ class InternalError : public Error
 {
    typedef Error super;
 public:
-    InternalError(const char *m = 0) : super(m,0) { }
+    InternalError(const char *m = 0) NOTHROW : super(m,0) { }
 };


@@ -194,27 +200,28 @@ public:
 **************************************************************************/

 #undef NORET
-#if 0 && defined(__GNUC__)
-// (noreturn) is probably not the correct semantics for throwing exceptions
-#define NORET __attribute__((noreturn))
+#if 1 && defined(__GNUC__)
+#define NORET __attribute__((__noreturn__))
 #else
-#define NORET
+#define NORET /*empty*/
 #endif

 void throwCantPack(const char *msg) NORET;
-void throwUnknownExecutableFormat(const char *msg = 0, bool warn = false) NORET;
-void throwNotCompressible(const char *msg = 0) NORET;
-void throwAlreadyPacked(const char *msg = 0) NORET;
-void throwAlreadyPackedByUPX(const char *msg = 0) NORET;
+void throwCantPackExact() NORET;
+void throwUnknownExecutableFormat(const char *msg = NULL, bool warn = false) NORET;
+void throwNotCompressible(const char *msg = NULL) NORET;
+void throwAlreadyPacked(const char *msg = NULL) NORET;
+void throwAlreadyPackedByUPX(const char *msg = NULL) NORET;
 void throwCantUnpack(const char *msg) NORET;
-void throwNotPacked(const char *msg = 0) NORET;
+void throwNotPacked(const char *msg = NULL) NORET;
 void throwFilterException() NORET;
 void throwBadLoader() NORET;
 void throwChecksumError() NORET;
 void throwCompressedDataViolation() NORET;
 void throwInternalError(const char *msg) NORET;
-void throwIOException(const char *msg = 0, int e = 0) NORET;
-void throwEOFException(const char *msg = 0, int e = 0) NORET;
+void throwOutOfMemoryException(const char *msg = NULL) NORET;
+void throwIOException(const char *msg = NULL, int e = 0) NORET;
+void throwEOFException(const char *msg = NULL, int e = 0) NORET;

 #undef NORET

@@ -223,8 +230,4 @@ void throwEOFException(const char *msg = 0, int e = 0) NORET;

 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -1,125 +0,0 @@
-/* fctl_ml.ch -- filter CTO implementation
-
-   This file is part of the UPX executable compressor.
-
-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
-   All Rights Reserved.
-
-   UPX and the UCL library are free software; you can redistribute them
-   and/or modify them under the terms of the GNU General Public License as
-   published by the Free Software Foundation; either version 2 of
-   the License, or (at your option) any later version.
-
-   This program is distributed in the hope that it will be useful,
-   but WITHOUT ANY WARRANTY; without even the implied warranty of
-   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-   GNU General Public License for more details.
-
-   You should have received a copy of the GNU General Public License
-   along with this program; see the file COPYING.
-   If not, write to the Free Software Foundation, Inc.,
-   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-
-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
- */
-
-
-
-/*************************************************************************
-// these are not implemented here
-**************************************************************************/
-
-// filter: e8, e9, e8e9
-#define f_cto32_e8              NULL
-#define f_cto32_e9              NULL
-#define f_cto32_e8e9            NULL
-
-// unfilter: e8, e9, e8e9
-#define u_cto32_e8              NULL
-#define u_cto32_e9              NULL
-#define u_cto32_e8e9            NULL
-
-// scan: e8, e9, e8e9
-#define s_cto32_e8              NULL
-#define s_cto32_e9              NULL
-#define s_cto32_e8e9            NULL
-
-// filter: e8, e9, e8e9 with bswap be->le
-#define f_cto32_e8_bswap_be     NULL
-#define f_cto32_e9_bswap_be     NULL
-#define f_cto32_e8e9_bswap_be   NULL
-
-// unfilter: e8, e9, e8e9 with bswap be->le
-#define u_cto32_e8_bswap_be     NULL
-#define u_cto32_e9_bswap_be     NULL
-#define u_cto32_e8e9_bswap_be   NULL
-
-// scan: e8, e9, e8e9 with bswap be->le
-#define s_cto32_e8_bswap_be     NULL
-#define s_cto32_e9_bswap_be     NULL
-#define s_cto32_e8e9_bswap_be   NULL
-
-
-/*************************************************************************
-//
-**************************************************************************/
-
-#define COND(b,x)   (b[x] == 0xe8)
-#define F           f_cto32_e8_bswap_le
-#define U           u_cto32_e8_bswap_le
-#include "fcto_ml2.ch"
-#undef U
-#undef F
-#define F           s_cto32_e8_bswap_le
-#include "fcto_ml2.ch"
-#undef F
-#undef COND
-
-#define COND(b,x)   (b[x] == 0xe9)
-#define F           f_cto32_e9_bswap_le
-#define U           u_cto32_e9_bswap_le
-#include "fcto_ml2.ch"
-#undef U
-#undef F
-#define F           s_cto32_e9_bswap_le
-#include "fcto_ml2.ch"
-#undef F
-#undef COND
-
-#define COND(b,x)   (b[x] == 0xe8 || b[x] == 0xe9)
-#define F           f_cto32_e8e9_bswap_le
-#define U           u_cto32_e8e9_bswap_le
-#include "fcto_ml2.ch"
-#undef U
-#undef F
-#define F           s_cto32_e8e9_bswap_le
-#include "fcto_ml2.ch"
-#undef F
-#undef COND
-
-
-/*************************************************************************
-//
-**************************************************************************/
-
-#define COND(b,x,lastcall)  (b[x] == 0xe8 || b[x] == 0xe9 \
-                            || (lastcall!=(x) && 0xf==b[(x)-1] \
-                               && 0x80<=b[x] && b[x]<=0x8f) )
-#define F           f_ctjo32_e8e9_bswap_le
-#define U           u_ctjo32_e8e9_bswap_le
-#include "fcto_ml3.ch"
-#undef U
-#undef F
-#define F           s_ctjo32_e8e9_bswap_le
-#include "fcto_ml3.ch"
-#undef F
-#undef COND
-
-
-
-/*
-vi:ts=4:et
-*/
-
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,14 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #include "conf.h"
 #include "file.h"
+#include "mem.h"


 /*************************************************************************
@@ -36,16 +37,18 @@

 void File::chmod(const char *name, int mode)
 {
-#if defined(HAVE_CHMOD)
+#if (HAVE_CHMOD)
    if (::chmod(name,mode) != 0)
        throwIOException(name,errno);
+#else
+    UNUSED(name); UNUSED(mode);
 #endif
 }


 void File::rename(const char *old_, const char *new_)
 {
-#if 1 && defined(__DJGPP__)
+#if (ACC_OS_DOS32) && defined(__DJGPP__)
    if (::_rename(old_,new_) != 0)
 #else
    if (::rename(old_,new_) != 0)
@@ -66,7 +69,7 @@ void File::unlink(const char *name)
 **************************************************************************/

 FileBase::FileBase() :
-    _fd(-1), _flags(0), _shflags(0), _mode(0), _name(NULL)
+    _fd(-1), _flags(0), _shflags(0), _mode(0), _name(NULL), _offset(0), _length(0)
 {
    memset(&st,0,sizeof(st));
 }
@@ -85,6 +88,31 @@ FileBase::~FileBase()
 }


+bool FileBase::do_sopen()
+{
+    if (_shflags < 0)
+        _fd = ::open(_name, _flags, _mode);
+    else
+    {
+#if (ACC_OS_DOS32) && defined(__DJGPP__)
+        _fd = ::open(_name,_flags | _shflags, _mode);
+#elif defined(__MINT__)
+        _fd = ::open(_name,_flags | (_shflags & O_SHMODE), _mode);
+#elif defined(SH_DENYRW)
+        _fd = ::sopen(_name, _flags, _shflags, _mode);
+#else
+        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 ok = true;
@@ -95,6 +123,8 @@ bool FileBase::close()
    _flags = 0;
    _mode = 0;
    _name = NULL;
+    _offset = 0;
+    _length = 0;
    return ok;
 }

@@ -108,35 +138,19 @@ void FileBase::closex()

 int FileBase::read(void *buf, int len)
 {
-    int l;
    if (!isOpen() || len < 0)
        throwIOException("bad read");
-    if (len == 0)
-        return 0;
-    for (;;)
-    {
-#if 1 && defined(__DJGPP__)
-        l = ::_read(_fd,buf,len);
-#else
-        l = ::read(_fd,buf,len);
-#endif
-        if (l < 0)
-        {
-#if defined(EINTR)
-            if (errno == EINTR)
-                continue;
-#endif
-            throwIOException("read error",errno);
-        }
-        break;
-    }
-    return l;
+    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);
+    int l = this->read(buf, len);
    if (l != len)
        throwEOFException();
    return l;
@@ -145,46 +159,58 @@ int FileBase::readx(void *buf, int len)

 void FileBase::write(const void *buf, int len)
 {
-    int l;
    if (!isOpen() || len < 0)
        throwIOException("bad write");
-    if (len == 0)
-        return;
-    for (;;)
-    {
-#if 1 && defined(__DJGPP__)
-        l = ::_write(_fd,buf,len);
-#else
-        l = ::write(_fd,buf,len);
-#endif
-#if defined(EINTR)
-        if (l < 0 && errno == EINTR)
-            continue;
-#endif
-        if (l != len)
-            throwIOException("write error",errno);
-        break;
-    }
+    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)
+off_t FileBase::seek(upx_int64_t off64, int whence)
 {
+    mem_size_assert(1, off64 >= 0 ? off64 : -off64); // sanity check
+    off_t off = ACC_ICONV(off_t, off64);
    if (!isOpen())
-        throwIOException("bad seek");
+        throwIOException("bad seek 1");
+    if (whence == SEEK_SET) {
+        if (off < 0)
+            throwIOException("bad seek 2");
+        off += _offset;
+    }
+    if (whence == SEEK_END) {
+        if (off > 0)
+            throwIOException("bad seek 3");
+        off += _offset + _length;
+        whence = SEEK_SET;
+    }
    if (::lseek(_fd,off,whence) < 0)
        throwIOException("seek error",errno);
+    return off - _offset;
 }


-off_t FileBase::tell()
+off_t FileBase::tell() const
 {
    if (!isOpen())
        throwIOException("bad tell");
-    off_t l = ::lseek(_fd,0,SEEK_CUR);
+    off_t l = ::lseek(_fd, 0, SEEK_CUR);
    if (l < 0)
        throwIOException("tell error",errno);
-    return l;
+    return l - _offset;
+}
+
+
+void FileBase::set_extent(off_t offset, off_t length)
+{
+    _offset = offset;
+    _length = length;
+}
+
+off_t FileBase::st_size() const
+{
+    return _length;
 }


@@ -209,51 +235,76 @@ void InputFile::sopen(const char *name, int flags, int shflags)
    _flags = flags;
    _shflags = shflags;
    _mode = 0;
-    if (shflags < 0)
-        _fd = ::open(_name,_flags);
-    else
-#if defined(__DJGPP__)
-        _fd = ::open(_name,_flags | _shflags);
-#elif defined(SH_DENYRW)
-        _fd = ::sopen(_name,_flags,_shflags);
-#else
-        assert(0);
-#endif
-    if (!isOpen())
+    _offset = 0;
+    _length = 0;
+    if (!FileBase::do_sopen())
    {
        if (errno == ENOENT)
-            throw FileNotFoundException(_name,errno);
+            throw FileNotFoundException(_name, errno);
        else if (errno == EEXIST)
-            throw FileAlreadyExistsException(_name,errno);
+            throw FileAlreadyExistsException(_name, errno);
        else
-            throwIOException(_name,errno);
+            throwIOException(_name, errno);
    }
+    _length_orig = _length;
 }


 int InputFile::read(void *buf, int len)
 {
-    return super::read(buf,len);
+    return super::read(buf, len);
 }

-
 int InputFile::readx(void *buf, int len)
 {
-    return super::readx(buf,len);
+    return super::readx(buf, len);
 }


-void InputFile::seek(off_t off, int whence)
+int InputFile::read(MemBuffer *buf, int len)
 {
-    super::seek(off,whence);
+    buf->checkState();
+    assert((unsigned)len <= buf->getSize());
+    return read(buf->getVoidPtr(), len);
+}
+
+int InputFile::readx(MemBuffer *buf, int len)
+{
+    buf->checkState();
+    assert((unsigned)len <= buf->getSize());
+    return read(buf->getVoidPtr(), len);
 }


-off_t InputFile::tell()
+int InputFile::read(MemBuffer &buf, int len)
+{
+    return read(&buf, len);
+}
+
+int InputFile::readx(MemBuffer &buf, int len)
+{
+    return readx(&buf, len);
+}
+
+
+off_t InputFile::seek(upx_int64_t off64, int whence)
+{
+    off_t pos = super::seek(off64, whence);
+    if (_length < pos)
+        throwIOException("bad seek 4");
+    return pos;
+}
+
+
+off_t InputFile::tell() const
 {
    return super::tell();
 }

+off_t InputFile::st_size_orig() const
+{
+    return _length_orig;
+}

 /*************************************************************************
 //
@@ -277,17 +328,9 @@ void OutputFile::sopen(const char *name, int flags, int shflags, int mode)
    _flags = flags;
    _shflags = shflags;
    _mode = mode;
-    if (shflags < 0)
-        _fd = ::open(_name,_flags,_mode);
-    else
-#if defined(__DJGPP__)
-        _fd = ::open(_name,_flags | _shflags, _mode);
-#elif defined(SH_DENYRW)
-        _fd = ::sopen(_name,_flags,_shflags,_mode);
-#else
-        assert(0);
-#endif
-    if (!isOpen())
+    _offset = 0;
+    _length = 0;
+    if (!FileBase::do_sopen())
    {
 #if 0
        // don't throw FileNotFound here -- this is confusing
@@ -306,45 +349,120 @@ void OutputFile::sopen(const char *name, int flags, int shflags, int mode)
 bool OutputFile::openStdout(int flags, bool force)
 {
    close();
-    if (!force)
-    {
-        if (!isafile(STDOUT_FILENO))
-            return false;
-    }
-    _fd = STDOUT_FILENO;
+    int fd = STDOUT_FILENO;
+    if (!force && acc_isatty(fd))
+        return false;
    _name = "<stdout>";
    _flags = flags;
    _shflags = -1;
    _mode = 0;
-    if (flags != 0)
-    {
-        assert(flags == O_BINARY);
-#if defined(HAVE_SETMODE) && defined(USE_SETMODE)
-        if (setmode(_fd, O_BINARY) == -1)
-            throwIOException(_name,errno);
-#if defined(__DJGPP__)
-        __djgpp_set_ctrl_c(1);
-#endif
-#endif
-    }
+    _offset = 0;
+    _length = 0;
+    if (flags && acc_set_binmode(fd, 1) == -1)
+        throwIOException(_name, errno);
+    _fd = fd;
    return true;
 }


 void OutputFile::write(const void *buf, int len)
 {
-    super::write(buf,len);
+    super::write(buf, len);
    bytes_written += len;
 }

+off_t OutputFile::st_size() const
+{
+    if (opt->to_stdout) {  // might be a pipe ==> .st_size is invalid
+        return bytes_written;  // too big if seek()+write() instead of rewrite()
+    }
+    struct stat my_st;
+    my_st.st_size = 0;
+    if (::fstat(_fd, &my_st) != 0)
+        throwIOException(_name, errno);
+    return my_st.st_size;
+}
+
+
+void OutputFile::write(const MemBuffer *buf, int len)
+{
+    buf->checkState();
+    assert((unsigned)len <= buf->getSize());
+    write(buf->getVoidPtr(), len);
+}
+
+
+void OutputFile::write(const MemBuffer &buf, int len)
+{
+    write(&buf, len);
+}
+
+void OutputFile::rewrite(const void *buf, int len)
+{
+    assert(!opt->to_stdout);
+    write(buf, len);
+    bytes_written -= len;       // restore
+}
+
+off_t OutputFile::seek(upx_int64_t off64, int whence)
+{
+    mem_size_assert(1, off64 >= 0 ? off64 : -off64); // sanity check
+    off_t off = ACC_ICONV(off_t, off64);
+    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);
+}
+
+// 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(off_t offset, off_t length)
+{
+    super::set_extent(offset, length);
+    bytes_written = 0;
+    if (0==offset && (off_t)~0u==length) {
+        if (::fstat(_fd, &st) != 0)
+            throwIOException(_name, errno);
+        _length = st.st_size - offset;
+    }
+}
+
+off_t OutputFile::unset_extent()
+{
+    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, const void *buf, int len, int flags)
 {
    if (flags < 0)
-         flags = O_CREAT | O_BINARY | O_TRUNC;
-    flags |= O_WRONLY;
+         flags = O_CREAT | O_TRUNC;
+    flags |= O_WRONLY | O_BINARY;
    OutputFile f;
-    f.open(name, flags, 0666);
+    f.open(name, flags, 0600);
    f.write(buf, len);
    f.closex();
 }
@@ -354,6 +472,8 @@ void OutputFile::dump(const char *name, const void *buf, int len, int flags)
 //
 **************************************************************************/

+#if 0
+
 MemoryOutputFile::MemoryOutputFile() :
    b(NULL), b_size(0), b_pos(0), bytes_written(0)
 {
@@ -374,7 +494,6 @@ void MemoryOutputFile::write(const void *buf, int len)
 }


-/*
-vi:ts=4:et
-*/
+#endif /* if 0 */

+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,15 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_FILE_H
-#define __UPX_FILE_H
+#define __UPX_FILE_H 1
+
+class MemBuffer;


 /*************************************************************************
@@ -36,6 +38,9 @@

 class File
 {
+protected:
+    File() { }
+    virtual ~File() { }
 public:
    static void chmod(const char *name, int mode);
    static void rename(const char *old_, const char *new_);
@@ -54,19 +59,24 @@ public:
    virtual bool isOpen() const { return _fd >= 0; }
    int getFd() const { return _fd; }
    const char *getName() const { return _name; }
+    virtual off_t st_size() const;  // { return _length; }
+    virtual void set_extent(off_t offset, off_t length);

 protected:
+    bool do_sopen();
    virtual int read(void *buf, int len);
    virtual int readx(void *buf, int len);
    virtual void write(const void *buf, int len);
-    virtual void seek(off_t off, int whence);
-    virtual off_t tell();
+    virtual off_t seek(upx_int64_t off, int whence);
+    virtual off_t tell() const;

    int _fd;
    int _flags;
    int _shflags;
    int _mode;
    const char *_name;
+    off_t _offset;
+    off_t _length;
 public:
    struct stat st;
 };
@@ -89,11 +99,18 @@ public:
        sopen(name, flags, -1);
    }

-    virtual int read(void * buf, int len);
-    virtual int readx(void * buf, int len);
+    virtual int read(void *buf, int len);
+    virtual int readx(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 off_t tell();
+    virtual off_t seek(upx_int64_t off, int whence);
+    virtual off_t tell() const;
+    virtual off_t st_size_orig() const;
+protected:
+    off_t _length_orig;
 };


@@ -116,19 +133,17 @@ public:
    virtual bool openStdout(int flags=0, bool force=false);

    virtual void write(const void *buf, int len);
+    virtual void write(const MemBuffer *buf, int len);
+    virtual void write(const MemBuffer &buf, int len);
+    virtual void set_extent(off_t offset, off_t length);
+    virtual off_t unset_extent();  // returns actual length

    off_t getBytesWritten() const { return bytes_written; }
+    virtual off_t st_size() const;  // { return _length; }

-    // FIXME - these won't work when using the `--stdout' option
-    virtual void seek(off_t off, int whence)
-    {
-        super::seek(off,whence);
-    }
-    virtual void rewrite(const void *buf, int len)
-    {
-        write(buf, len);
-        bytes_written -= len;       // restore
-    }
+    // FIXME - these won't work when using the '--stdout' option
+    virtual off_t seek(upx_int64_t off, int whence);
+    virtual void rewrite(const void *buf, int len);

    // util
    static void dump(const char *name, const void *buf, int len, int flags=-1);
@@ -142,6 +157,7 @@ protected:
 //
 **************************************************************************/

+#if 0 /* NOT USED */
 class MemoryOutputFile : public FileBase
 {
    typedef FileBase super;
@@ -164,12 +180,9 @@ protected:
    unsigned b_pos;
    off_t bytes_written;
 };
+#endif /* if 0 */


 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,14 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #include "conf.h"
 #include "filter.h"
+#include "file.h"


 /*************************************************************************
@@ -40,7 +41,7 @@ void initFilter(Filter *f, upx_byte *buf, unsigned buf_len)
    f->buf = buf;
    f->buf_len = buf_len;
    // clear output parameters
-    f->calls = f->wrongcalls = f->noncalls = f->lastcall = 0;
+    f->calls = f->wrongcalls = f->noncalls = f->firstcall = f->lastcall = 0;
 }


@@ -60,10 +61,10 @@ 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;
-            assert(fid >= 0 && fid <= 255);
-            assert(filter_map[fid] == 0xff);
-            filter_map[fid] = (unsigned char) i;
+            int filter_id = filters[i].id;
+            assert(filter_id >= 0 && filter_id <= 255);
+            assert(filter_map[filter_id] == 0xff);
+            filter_map[filter_id] = (unsigned char) i;
        }
        done = true;
    }
@@ -78,6 +79,27 @@ 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;
+}
+
+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 == NULL)
+        return false;
+    while (*allowed_filters != FT_END)
+        if (*allowed_filters++ == filter_id)
+            return true;
+    return false;
+}
+
+
 /*************************************************************************
 // high level API
 **************************************************************************/
@@ -88,10 +110,10 @@ void Filter::init(int id_, unsigned addvalue_)
    initFilter(this, NULL, 0);
    // clear input parameters
    this->addvalue = addvalue_;
-    this->forced_cto = -1;
    this->preferred_ctos = NULL;
    // clear input/output parameters
    this->cto = 0;
+    this->n_mru = 0;
 }


@@ -112,13 +134,12 @@ bool Filter::filter(upx_byte *buf_, unsigned buf_len_)
        throwInternalError("filter-2");

    // save checksum
+    this->adler = 0;
    if (clevel != 1)
-    {
-        this->adler = upx_adler32(0,NULL,0);
-        this->adler = upx_adler32(this->adler, this->buf, this->buf_len);
-    }
+        this->adler = upx_adler32(this->buf, this->buf_len);

    //printf("filter: %02x %p %d\n", this->id, this->buf, this->buf_len);
+    //OutputFile::dump("filter.dat", buf, buf_len);
    int r = (*fe->do_filter)(this);
    //printf("filter: %02x %d\n", fe->id, r);
    if (r > 0)
@@ -129,7 +150,7 @@ bool Filter::filter(upx_byte *buf_, unsigned buf_len_)
 }


-bool Filter::unfilter(upx_byte *buf_, unsigned buf_len_, bool verify_checksum)
+void Filter::unfilter(upx_byte *buf_, unsigned buf_len_, bool verify_checksum)
 {
    initFilter(this, buf_, buf_len_);

@@ -137,11 +158,11 @@ bool Filter::unfilter(upx_byte *buf_, unsigned buf_len_, bool verify_checksum)
    if (fe == NULL)
        throwInternalError("unfilter-1");
    if (fe->id == 0)
-        return true;
+        return;
    if (buf_len < fe->min_buf_len)
-        return false;
+        return;
    if (fe->max_buf_len && buf_len > fe->max_buf_len)
-        return false;
+        return;
    if (!fe->do_unfilter)
        throwInternalError("unfilter-2");

@@ -150,20 +171,18 @@ bool Filter::unfilter(upx_byte *buf_, unsigned buf_len_, bool verify_checksum)
    //printf("unfilter: %02x %d\n", fe->id, r);
    if (r != 0)
        throwInternalError("unfilter-3");
+    //OutputFile::dump("unfilter.dat", buf, buf_len);

    // verify checksum
    if (verify_checksum && clevel != 1)
    {
-        unsigned a = upx_adler32(0,NULL,0);
-        if (this->adler != upx_adler32(a, this->buf, this->buf_len))
+        if (this->adler != upx_adler32(this->buf, this->buf_len))
            throwInternalError("unfilter-4");
    }
-
-    return true;
 }


-bool Filter::verifyUnfilter()
+void Filter::verifyUnfilter()
 {
    // Note:
    //   This verify is just because of complete paranoia that there
@@ -175,9 +194,8 @@ bool Filter::verifyUnfilter()
    //   Packer::verifyOverlappingDecompression()

    //printf("verifyUnfilter: %02x %p %d\n", this->id, this->buf, this->buf_len);
-    if (clevel == 1)
-        return true;
-    return unfilter(this->buf, this->buf_len, true);
+    if (clevel != 1)
+        unfilter(this->buf, this->buf_len, true);
 }


@@ -210,8 +228,4 @@ bool Filter::scan(const upx_byte *buf_, unsigned buf_len_)
    return false;
 }

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,13 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_FILTER_H
-#define __UPX_FILTER_H
+#define __UPX_FILTER_H 1

 class Filter;
 class FilterImp;
@@ -44,8 +44,7 @@ class FilterImp;
 // call throwFilterException() - this will cause the compression
 // to fail.
 //
-// The return value of unfilters can/should be ignored. They throw
-// exceptions in case of errors.
+// Unfilters throw exceptions in case of errors.
 //
 // The main idea behind filters is to convert relative jumps and calls
 // to absolute addresses so that the buffer compresses better.
@@ -58,10 +57,13 @@ public:
    void init(int id=0, unsigned addvalue=0);

    bool filter(upx_byte *buf, unsigned buf_len);
-    bool unfilter(upx_byte *buf, unsigned buf_len, bool verify_checksum=false);
-    bool verifyUnfilter();
+    void unfilter(upx_byte *buf, unsigned buf_len, bool verify_checksum=false);
+    void verifyUnfilter();
    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.
@@ -74,7 +76,6 @@ public:

    // Input parameters used by various filters.
    unsigned addvalue;
-    int forced_cto;
    const int *preferred_ctos;

    // Input/output parameters used by various filters
@@ -84,7 +85,9 @@ public:
    unsigned calls;
    unsigned noncalls;
    unsigned wrongcalls;
+    unsigned firstcall;
    unsigned lastcall;
+    unsigned n_mru;  // ctojr only

    // Read only.
    int id;
@@ -128,8 +131,4 @@ private:

 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,503 @@
+/* ct.h -- calltrick filter
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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>
+ */
+
+
+
+/*************************************************************************
+// 16-bit calltrick ("naive")
+**************************************************************************/
+
+#define CT16(f, cond, addvalue, get, set) \
+    upx_byte *b = f->buf; \
+    upx_byte *b_end = b + f->buf_len - 3; \
+    do { \
+        if (cond) \
+        { \
+            b += 1; \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b) + (addvalue)); \
+            f->calls++; \
+            b += 2 - 1; \
+        } \
+    } while (++b < b_end); \
+    if (f->lastcall) f->lastcall += 2; \
+    return 0;
+
+
+
+// filter: e8, e9, e8e9
+static int f_ct16_e8(Filter *f)
+{
+    CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_le16)
+}
+
+static int f_ct16_e9(Filter *f)
+{
+    CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_le16)
+}
+
+static int f_ct16_e8e9(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_le16)
+}
+
+
+// unfilter: e8, e9, e8e9
+static int u_ct16_e8(Filter *f)
+{
+    CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_le16, set_le16)
+}
+
+static int u_ct16_e9(Filter *f)
+{
+    CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_le16, set_le16)
+}
+
+static int u_ct16_e8e9(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le16, set_le16)
+}
+
+
+// scan: e8, e9, e8e9
+static int s_ct16_e8(Filter *f)
+{
+    CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_dummy)
+}
+
+static int s_ct16_e9(Filter *f)
+{
+    CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_dummy)
+}
+
+static int s_ct16_e8e9(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_dummy)
+}
+
+
+// filter: e8, e9, e8e9 with bswap le->be
+static int f_ct16_e8_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_be16)
+}
+
+static int f_ct16_e9_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_be16)
+}
+
+static int f_ct16_e8e9_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_be16)
+}
+
+
+// unfilter: e8, e9, e8e9 with bswap le->be
+static int u_ct16_e8_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_be16, set_le16)
+}
+
+static int u_ct16_e9_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16)
+}
+
+static int u_ct16_e8e9_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16)
+}
+
+
+// scan: e8, e9, e8e9 with bswap le->be
+static int s_ct16_e8_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe8), a + f->addvalue, get_be16, set_dummy)
+}
+
+static int s_ct16_e9_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe9), a + f->addvalue, get_be16, set_dummy)
+}
+
+static int s_ct16_e8e9_bswap_le(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be16, set_dummy)
+}
+
+
+// filter: e8, e9, e8e9 with bswap be->le
+static int f_ct16_e8_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe8), a + f->addvalue, get_be16, set_le16)
+}
+
+static int f_ct16_e9_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe9), a + f->addvalue, get_be16, set_le16)
+}
+
+static int f_ct16_e8e9_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be16, set_le16)
+}
+
+
+// unfilter: e8, e9, e8e9 with bswap be->le
+static int u_ct16_e8_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_le16, set_be16)
+}
+
+static int u_ct16_e9_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_le16, set_be16)
+}
+
+static int u_ct16_e8e9_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le16, set_be16)
+}
+
+
+// scan: e8, e9, e8e9 with bswap be->le
+static int s_ct16_e8_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_dummy)
+}
+
+static int s_ct16_e9_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_dummy)
+}
+
+static int s_ct16_e8e9_bswap_be(Filter *f)
+{
+    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_dummy)
+}
+
+
+#undef CT16
+
+
+/*************************************************************************
+// 32-bit calltrick ("naive")
+**************************************************************************/
+
+#define CT32(f, cond, addvalue, get, set) \
+    upx_byte *b = f->buf; \
+    upx_byte *b_end = b + f->buf_len - 5; \
+    do { \
+        if (cond) \
+        { \
+            b += 1; \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b) + (addvalue)); \
+            f->calls++; \
+            b += 4 - 1; \
+        } \
+    } while (++b < b_end); \
+    if (f->lastcall) f->lastcall += 4; \
+    return 0;
+
+
+// filter: e8, e9, e8e9
+static int f_ct32_e8(Filter *f)
+{
+    CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_le32)
+}
+
+static int f_ct32_e9(Filter *f)
+{
+    CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_le32)
+}
+
+static int f_ct32_e8e9(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_le32)
+}
+
+
+// unfilter: e8, e9, e8e9
+static int u_ct32_e8(Filter *f)
+{
+    CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_le32, set_le32)
+}
+
+static int u_ct32_e9(Filter *f)
+{
+    CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_le32, set_le32)
+}
+
+static int u_ct32_e8e9(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le32, set_le32)
+}
+
+
+// scan: e8, e9, e8e9
+static int s_ct32_e8(Filter *f)
+{
+    CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_dummy)
+}
+
+static int s_ct32_e9(Filter *f)
+{
+    CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_dummy)
+}
+
+static int s_ct32_e8e9(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_dummy)
+}
+
+
+// filter: e8, e9, e8e9 with bswap le->be
+static int f_ct32_e8_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_be32)
+}
+
+static int f_ct32_e9_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_be32)
+}
+
+static int f_ct32_e8e9_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_be32)
+}
+
+
+// unfilter: e8, e9, e8e9 with bswap le->be
+static int u_ct32_e8_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_be32, set_le32)
+}
+
+static int u_ct32_e9_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32)
+}
+
+static int u_ct32_e8e9_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32)
+}
+
+
+// scan: e8, e9, e8e9 with bswap le->be
+static int s_ct32_e8_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe8), a + f->addvalue, get_be32, set_dummy)
+}
+
+static int s_ct32_e9_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe9), a + f->addvalue, get_be32, set_dummy)
+}
+
+static int s_ct32_e8e9_bswap_le(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be32, set_dummy)
+}
+
+
+// filter: e8, e9, e8e9 with bswap be->le
+static int f_ct32_e8_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe8), a + f->addvalue, get_be32, set_le32)
+}
+
+static int f_ct32_e9_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe9), a + f->addvalue, get_be32, set_le32)
+}
+
+static int f_ct32_e8e9_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be32, set_le32)
+}
+
+
+// unfilter: e8, e9, e8e9 with bswap be->le
+static int u_ct32_e8_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_le32, set_be32)
+}
+
+static int u_ct32_e9_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_le32, set_be32)
+}
+
+static int u_ct32_e8e9_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le32, set_be32)
+}
+
+
+// scan: e8, e9, e8e9 with bswap be->le
+static int s_ct32_e8_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_dummy)
+}
+
+static int s_ct32_e9_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_dummy)
+}
+
+static int s_ct32_e8e9_bswap_be(Filter *f)
+{
+    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_dummy)
+}
+
+
+#undef CT32
+
+/*************************************************************************
+// 24-bit ARM calltrick ("naive")
+**************************************************************************/
+
+#define CT24ARM_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_le (((b[3] & 0x0f) == 0x0b))
+
+static int f_ct24arm_le(Filter *f)
+{
+    CT24ARM_LE(f, ARMCT_COND_le, a / 4 + f->addvalue, get_le24, set_le24)
+}
+
+static int u_ct24arm_le(Filter *f)
+{
+    CT24ARM_LE(f, ARMCT_COND_le, 0 - a / 4 - f->addvalue, get_le24, set_le24)
+}
+
+static int s_ct24arm_le(Filter *f)
+{
+    CT24ARM_LE(f, ARMCT_COND_le, a + f->addvalue, get_le24, set_dummy)
+}
+
+#undef CT24ARM_LE
+
+#define CT24ARM_BE(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(1+b, get(1+b) + (addvalue)); \
+            f->calls++; \
+        } \
+        b += 4; \
+    } while (b < b_end); \
+    if (f->lastcall) f->lastcall += 4; \
+    return 0;
+
+#define ARMCT_COND_be (((b[0] & 0x0f) == 0x0b))
+
+static int f_ct24arm_be(Filter *f)
+{
+    CT24ARM_BE(f, ARMCT_COND_be, a / 4 + f->addvalue, get_be24, set_be24)
+}
+
+static int u_ct24arm_be(Filter *f)
+{
+    CT24ARM_BE(f, ARMCT_COND_be, 0 - a / 4 - f->addvalue, get_be24, set_be24)
+}
+
+static int s_ct24arm_be(Filter *f)
+{
+    CT24ARM_BE(f, ARMCT_COND_be, a + f->addvalue, get_be24, set_dummy)
+}
+
+#undef CT24ARM_BE
+#undef ARMCT_COND
+
+/*************************************************************************
+// 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: */
@@ -1,9 +1,9 @@
-/* fctl_ml2.ch -- filter CTO implementation
+/* cto.h -- calltrick filter

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,14 +21,14 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */



 /*************************************************************************
-//
+// filter / scan
 **************************************************************************/

 static int F(Filter *f)
@@ -36,72 +36,48 @@ static int F(Filter *f)
 #ifdef U
    // filter
    upx_byte *b = f->buf;
-    const unsigned addvalue = f->addvalue;
 #else
    // scan
    const upx_byte *b = f->buf;
 #endif
+    const unsigned addvalue = f->addvalue;
    const unsigned size = f->buf_len;

    unsigned ic, jc, kc;
-    unsigned cto;
-    unsigned char cto8;
    unsigned calls = 0, noncalls = 0, noncalls2 = 0;
    unsigned lastnoncall = size, lastcall = 0;

-    // find a 16MB large empty address space
-    if (f->forced_cto >= 0 && f->forced_cto <= 255)
-        cto8 = (unsigned char) f->forced_cto;
-    else
+    // find a 16 MiB large empty address space
    {
        unsigned char buf[256];
        memset(buf,0,256);

-#if 1
+        // A call to a destination that is inside the buffer
+        // will be rewritten and marked with cto8 as first byte.
+        // So, a call to a destination that is outside the buffer
+        // 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;
-            }
-#else
-        {
-            int i = size - 6;
-            do {
-                if (COND(b,i) && get_le32(b+i+1)+i+1 >= size)
-                    buf[b[i+1]] |= 1;
-            } while (--i >= 0);
        }
-#endif

-        ic = 256;
-        if (f->preferred_ctos)
-        {
-            for (const int *pc = f->preferred_ctos; *pc >= 0; pc++)
-            {
-                if (buf[*pc & 255] == 0)
-                {
-                    ic = *pc & 255;
-                    break;
-                }
-            }
-        }
-#if 0
-        // just a test to see if certain ctos would improve compression
-        if (ic >= 256)
-            for (ic = 0; ic < 256; ic += 16)
-                if (buf[ic] == 0)
-                    break;
-#endif
-        if (ic >= 256)
-            for (ic = 0; ic < 256; ic++)
-                if (buf[ic] == 0)
-                    break;
-        if (ic >= 256)
-            //throwCantPack("call trick problem");
+        if (getcto(f, buf) < 0)
            return -1;
-        cto8 = (unsigned char) ic;
    }
-    cto = (unsigned)cto8 << 24;
+    const unsigned char cto8 = f->cto;
+#ifdef U
+    const unsigned cto = (unsigned)f->cto << 24;
+#endif

    for (ic = 0; ic < size - 5; ic++)
    {
@@ -111,6 +87,7 @@ static int F(Filter *f)
        // try to detect 'real' calls only
        if (jc < size)
        {
+            assert(jc + addvalue < (1u << 24)); // hi 8 bits won't be cto8
 #ifdef U
            set_be32(b+ic+1,jc+addvalue+cto);
 #endif
@@ -145,25 +122,28 @@ static int F(Filter *f)
        }
    }

-    f->cto = cto8;
    f->calls = calls;
    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
    return 0;
 }


+/*************************************************************************
+// unfilter
+**************************************************************************/
+
 #ifdef U
 static int U(Filter *f)
 {
    upx_byte *b = f->buf;
    const unsigned size5 = f->buf_len - 5;
    const unsigned addvalue = f->addvalue;
-    const unsigned cto = f->cto << 24;
+    const unsigned cto = (unsigned)f->cto << 24;

    unsigned ic, jc;

@@ -186,7 +166,7 @@ static int U(Filter *f)
 #endif


-/*
-vi:ts=4:et
-*/
+#undef F
+#undef U

+/* vim:set ts=4 sw=4 et: */
@@ -1,10 +1,10 @@
-/* fctl_ml3.ch -- filter CTO implementation
+/* ctoj.h -- filter CTO implementation

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
-   Copyright (C) 2000 John F. Reiser
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   Copyright (C) 2000-2017 John F. Reiser
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -22,14 +22,17 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
+
+   John F. Reiser
+   <jreiser@users.sourceforge.net>
 */



 /*************************************************************************
-//
+// filter / scan
 **************************************************************************/

 static int F(Filter *f)
@@ -37,72 +40,43 @@ static int F(Filter *f)
 #ifdef U
    // filter
    upx_byte *b = f->buf;
-    const unsigned addvalue = f->addvalue;
 #else
    // scan
    const upx_byte *b = f->buf;
 #endif
+    const unsigned addvalue = f->addvalue;
    const unsigned size = f->buf_len;

    unsigned ic, jc, kc;
-    unsigned cto;
-    unsigned char cto8;
    unsigned calls = 0, noncalls = 0, noncalls2 = 0;
    unsigned lastnoncall = size, lastcall = 0;

-    // find a 16MB large empty address space
-    if (f->forced_cto >= 0 && f->forced_cto <= 255)
-        cto8 = (unsigned char) f->forced_cto;
-    else
+    // find a 16 MiB large empty address space
    {
        unsigned char buf[256];
        memset(buf,0,256);

-#if 1
        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;
-            }
-#else
-        {
-            int i = size - 6;
-            do {
-                if (COND(b,i,lastcall) && get_le32(b+i+1)+i+1 >= size)
-                    buf[b[i+1]] |= 1;
-            } while (--i >= 0);
        }
-#endif

-        ic = 256;
-        if (f->preferred_ctos)
-        {
-            for (const int *pc = f->preferred_ctos; *pc >= 0; pc++)
-            {
-                if (buf[*pc & 255] == 0)
-                {
-                    ic = *pc & 255;
-                    break;
-                }
-            }
-        }
-#if 0
-        // just a test to see if certain ctos would improve compression
-        if (ic >= 256)
-            for (ic = 0; ic < 256; ic += 16)
-                if (buf[ic] == 0)
-                    break;
-#endif
-        if (ic >= 256)
-            for (ic = 0; ic < 256; ic++)
-                if (buf[ic] == 0)
-                    break;
-        if (ic >= 256)
-            //throwCantPack("call trick problem");
+        if (getcto(f, buf) < 0)
            return -1;
-        cto8 = (unsigned char) ic;
    }
-    cto = (unsigned)cto8 << 24;
+    const unsigned char cto8 = f->cto;
+#ifdef U
+    const unsigned cto = (unsigned)f->cto << 24;
+#endif

    for (ic = 0; ic < size - 5; ic++)
    {
@@ -112,6 +86,7 @@ static int F(Filter *f)
        // try to detect 'real' calls only
        if (jc < size)
        {
+            assert(jc + addvalue < (1u << 24)); // hi 8 bits won't be cto8
 #ifdef U
            set_be32(b+ic+1,jc+addvalue+cto);
 #endif
@@ -146,27 +121,29 @@ static int F(Filter *f)
        }
    }

-    f->cto = cto8;
    f->calls = calls;
    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
    return 0;
 }


+/*************************************************************************
+// unfilter
+**************************************************************************/
+
 #ifdef U
 static int U(Filter *f)
 {
    upx_byte *b = f->buf;
    const unsigned size5 = f->buf_len - 5;
    const unsigned addvalue = f->addvalue;
-    const unsigned cto = f->cto << 24;
-    unsigned lastcall = 0;
-
+    const unsigned cto = (unsigned)f->cto << 24;
+//    unsigned lastcall = 0;    // lastcall is not used in COND macro
    unsigned ic, jc;

    for (ic = 0; ic < size5; ic++)
@@ -178,7 +155,7 @@ static int U(Filter *f)
                set_le32(b+ic+1,jc-ic-1-addvalue-cto);
                f->calls++;
                ic += 4;
-                f->lastcall = lastcall = ic+1;
+                f->lastcall = ic+1;
            }
            else
                f->noncalls++;
@@ -188,7 +165,7 @@ static int U(Filter *f)
 #endif


-/*
-vi:ts=4:et
-*/
+#undef F
+#undef U

+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,347 @@
+/* ctojr.h -- filter CTO implementation; renumber destinations MRU
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   Copyright (C) 2000-2017 John F. Reiser
+   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>
+
+   John F. Reiser
+   <jreiser@users.sourceforge.net>
+ */
+
+
+#if (ACC_CC_MSC && (_MSC_VER >= 1000 && _MSC_VER < 1300))
+#  pragma warning(disable: 4702)        // W4: unreachable code
+#endif
+
+
+/*************************************************************************
+// filter / scan
+**************************************************************************/
+
+#ifdef U  //{
+#define NOFILT 0  // no filter
+#define FNOMRU 1  // filter, but not using mru
+#define MRUFLT 2  // mru filter
+
+static unsigned
+f80_call(Filter const *f)
+{
+    return (1+ (0x0f & f->id)) % 3;
+}
+
+static unsigned
+f80_jmp1(Filter const *f)
+{
+    return ((1+ (0x0f & f->id)) / 3) % 3;
+}
+
+static unsigned
+f80_jcc2(Filter const *f)
+{
+    return f80_jmp1(f);
+}
+
+#define N_MRU 32    // does not have to be a power of 2
+
+// Adaptively remember recent destinations.
+static void
+update_mru(
+    unsigned const jc,  // destination address
+    int const kh,  // mru[kh] is slot where found
+    unsigned mru[N_MRU],  // circular buffer of most recent destinations
+    int &hand,  // mru[hand] is most recent destination
+    int &tail   // mru[tail] is beyond oldest destination ("cold cache" startup)
+)
+{
+    if (0 > --hand) {
+        hand = N_MRU -1;
+    }
+    unsigned const t = mru[hand];  // entry which will be overwritten by jc
+    if (0!=t) { // have seen at least N_MRU destinations
+        mru[kh] = t;
+    }
+    else { // "cold cache": keep active region contiguous
+        if (0 > --tail) {
+            tail = N_MRU -1;
+        }
+        unsigned const t2 = mru[tail];
+        mru[tail] = 0;
+        mru[kh] = t2;
+    }
+    mru[hand] = jc;
+}
+#endif  //}
+
+
+static int F(Filter *f)
+{
+#ifdef U
+    // filter
+    upx_byte *const b = f->buf;
+#else
+    // scan
+    const upx_byte *b = f->buf;
+#endif
+    const unsigned size = f->buf_len;
+
+    unsigned ic, jc, kc;
+    unsigned calls = 0, noncalls = 0, noncalls2 = 0;
+    unsigned lastnoncall = size, lastcall = 0;
+    unsigned wtally[3]; memset(wtally, 0, sizeof(wtally));
+
+#ifdef U  //{
+    unsigned const f_call = f80_call(f);
+    unsigned const f_jmp1 = f80_jmp1(f);
+    unsigned const f_jcc2 = f80_jcc2(f);
+
+    int hand = 0, tail = 0;
+    unsigned mru[N_MRU];
+    memset(&mru[0], 0, sizeof(mru));
+    assert(N_MRU<=256);
+    f->n_mru = (MRUFLT==f_call || MRUFLT==f_jmp1 || MRUFLT==f_jcc2) ?
+        N_MRU : 0;
+#endif  //}
+
+    // FIXME: We must fit into 8 MiB because we steal one bit.
+    // find a 16 MiB large empty address space
+    {
+        int which;
+        unsigned char buf[256];
+        memset(buf,0,256);
+
+        for (ic = 0; ic < size - 5; ic++)
+            if (CONDF(which,b,ic,lastcall) && get_le32(b+ic+1)+ic+1 >= size)
+            {
+                buf[b[ic+1]] |= 1;
+            }
+        UNUSED(which);
+
+        if (getcto(f, buf) < 0)
+            return -1;
+    }
+    const unsigned char cto8 = f->cto;
+#ifdef U
+    const unsigned cto = (unsigned)f->cto << 24;
+#endif
+
+    for (ic = 0; ic < size - 5; ic++)
+    {
+        int which;
+        int f_on = 0;
+        if (!CONDF(which,b,ic,lastcall))
+            continue;
+        ++wtally[which];
+        jc = get_le32(b+ic+1)+ic+1;
+        // try to detect 'real' calls only
+        if (jc < size)
+        {
+#ifdef U
+            if (2==which && NOFILT!=f_jcc2) { // 6-byte Jcc <disp32>
+                // Prefix 0x0f is constant, but opcode condition 0x80..0x8f
+                // varies.  Because we store the destination (or its mru index)
+                // in be32 big endian format, the low-addressed bytes
+                // will tend to be constant.  Swap prefix and opcode
+                // so that constants are together for better compression.
+                unsigned char const t =
+                b[ic-1];
+                b[ic-1] = b[ic];
+                          b[ic] = t;
+            }
+    // FIXME [?]: Extend to 8 bytes if "ADD ESP, byte 4*n" follows CALL.
+    //   This will require two related cto's (consecutive, or otherwise).
+            if ((0==which && MRUFLT==f_call)
+            ||  (1==which && MRUFLT==f_jmp1)
+            ||  (2==which && MRUFLT==f_jcc2) ) {
+                f_on = 1;
+                // Recode the destination: narrower mru indices
+                // should compress better than wider addresses.
+                // (But not when offset of match is unlimited?)
+                int k;
+                for (k = 0; k < N_MRU; ++k) {
+                    int kh = hand + k;
+                    if (N_MRU <= kh) {
+                        kh -= N_MRU;
+                    }
+                    if (mru[kh] == jc) { // destination was seen recently
+                        set_be32(b+ic+1,((k<<1)|0)+cto);
+                        update_mru(jc, kh, mru, hand, tail);
+                        break;
+                    }
+                }
+                if (k == N_MRU) { // loop failed; jc is not in mru[]
+                    set_be32(b+ic+1,((jc<<1)|1)+cto);
+                    // Adaptively remember recent destinations.
+                    if (0 > --hand) {
+                        hand = N_MRU -1;
+                    }
+                    mru[hand] = jc;
+                }
+            } else
+            if ((0==which && NOFILT!=f_call)
+            ||  (1==which && NOFILT!=f_jmp1)
+            ||  (2==which && NOFILT!=f_jcc2) ) {
+                f_on = 1;
+                set_be32(b+ic+1, jc+cto);
+            }
+#endif
+            if (f_on) {
+                    if (ic - lastnoncall < 5)
+                    {
+                        // check the last 4 bytes before this call
+                        for (kc = 4; kc; kc--)
+                            if (CONDF(which,b,ic-kc,lastcall) && b[ic-kc+1] == cto8)
+                                break;
+                        if (kc)
+                        {
+        #ifdef U
+                            // restore original
+                            if (2==which) {
+                                // Unswap prefix and opcode for 6-byte Jcc <disp32>
+                                unsigned char const t =
+                                b[ic-1];
+                                b[ic-1] = b[ic];
+                                          b[ic] = t;
+                            }
+                            set_le32(b+ic+1,jc-ic-1);
+        #endif
+                            if (b[ic+1] == cto8)
+                                return 1;           // fail - buffer not restored
+                            lastnoncall = ic;
+                            noncalls2++;
+                            continue;
+                        }
+                    }
+                    calls++;
+                    ic += 4;
+                    lastcall = ic+1;
+            }
+        }
+        else
+        {
+            assert(b[ic+1] != cto8);        // this should not happen
+            lastnoncall = ic;
+            noncalls++;
+        }
+    }
+
+    f->calls = calls;
+    f->noncalls = noncalls;
+    f->lastcall = lastcall;
+
+#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
+    return 0;
+}
+
+
+/*************************************************************************
+// unfilter
+**************************************************************************/
+
+#ifdef U
+static int U(Filter *f)
+{
+    unsigned ic, jc;
+
+    upx_byte *const b = f->buf;
+    const unsigned size5 = f->buf_len - 5;
+    const unsigned cto = (unsigned)f->cto << 24;
+    unsigned lastcall = 0;
+    int hand = 0, tail = 0;
+    unsigned const f_call = f80_call(f);
+    unsigned const f_jmp1 = f80_jmp1(f);
+    unsigned const f_jcc2 = f80_jcc2(f);
+
+    unsigned mru[N_MRU];
+    memset(&mru[0], 0, sizeof(mru));
+
+    for (ic = 0; ic < size5; ic++) {
+        int which;
+        if (CONDU(which,b,ic,lastcall))
+        {
+            unsigned f_on = 0;
+            jc = get_be32(b+ic+1) - cto;
+            if (b[ic+1] == f->cto)
+            {
+                if ((0==which && MRUFLT==f_call)
+                ||  (1==which && MRUFLT==f_jmp1)
+                ||  (2==which && MRUFLT==f_jcc2) ) {
+                    f_on = 1;
+                        if (1&jc) { // 1st time at this destination
+                            jc >>= 1;
+                            if (0 > --hand) {
+                                hand = N_MRU -1;
+                            }
+                            mru[hand] = jc;
+                        }
+                        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;
+                            }
+                            jc = mru[kh];
+                            update_mru(jc, kh, mru, hand, tail);
+                        }
+                    set_le32(b+ic+1,jc-ic-1);
+                } else
+                if ((0==which && NOFILT!=f_call)
+                ||  (1==which && NOFILT!=f_jmp1)
+                ||  (2==which && NOFILT!=f_jcc2) ) {
+                    f_on = 1;
+                    set_le32(b+ic+1,jc-ic-1);
+                }
+                if (2==which && NOFILT!=f_jcc2) {
+                    // Unswap prefix and opcode for 6-byte Jcc <disp32>
+                    unsigned char const t =
+                    b[ic-1];
+                    b[ic-1] = b[ic];
+                            b[ic] = t;
+                }
+
+                if (f_on) {
+                    f->calls++;
+                    ic += 4;
+                    f->lastcall = lastcall = ic+1;
+                }
+            }
+            else
+                f->noncalls++;
+        }
+    }
+    return 0;
+}
+#endif
+
+#undef N_MRU
+#undef F
+#undef U
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,174 @@
+/* ctok.h -- filter CTO implementation
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   Copyright (C) 2000-2017 John F. Reiser
+   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>
+
+   John F. Reiser
+   <jreiser@users.sourceforge.net>
+ */
+
+
+
+/*************************************************************************
+// filter / scan
+**************************************************************************/
+
+static int F(Filter *f)
+{
+#ifdef U
+    // filter
+    upx_byte *b = f->buf;
+#else
+    // scan
+    const upx_byte *b = f->buf;
+#endif
+    const unsigned addvalue = f->addvalue;
+    const unsigned size = f->buf_len;
+    unsigned const id = f->id;
+
+    unsigned ic, jc, kc;
+    unsigned calls = 0, noncalls = 0, noncalls2 = 0;
+    unsigned lastnoncall = size, lastcall = 0;
+
+    // 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))
+                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;
+        }
+
+        if (getcto(f, buf) < 0)
+            return -1;
+    }
+    const unsigned char cto8 = f->cto;
+#ifdef U
+    const unsigned cto = (unsigned)f->cto << 24;
+#endif
+
+    for (ic = 0; ic < size - 5; ic++)
+    {
+        if (!COND(b,ic,lastcall,id))
+            continue;
+        jc = get_le32(b+ic+1)+ic+1;
+        // try to detect 'real' calls only
+        if (jc < size)
+        {
+            assert(jc + addvalue < (1u << 24)); // hi 8 bits won't be cto8
+#ifdef U
+            set_be32(b+ic+1,jc+addvalue+cto);
+#endif
+            if (ic - lastnoncall < 5)
+            {
+                // check the last 4 bytes before this call
+                for (kc = 4; kc; kc--)
+                    if (COND(b,ic-kc,lastcall,id) && b[ic-kc+1] == cto8)
+                        break;
+                if (kc)
+                {
+#ifdef U
+                    // restore original
+                    set_le32(b+ic+1,jc-ic-1);
+#endif
+                    if (b[ic+1] == cto8)
+                        return 1;           // fail - buffer not restored
+                    lastnoncall = ic;
+                    noncalls2++;
+                    continue;
+                }
+            }
+            calls++;
+            ic += 4;
+            lastcall = ic+1;
+        }
+        else
+        {
+            assert(b[ic+1] != cto8);        // this should not happen
+            lastnoncall = ic;
+            noncalls++;
+        }
+    }
+
+    f->calls = calls;
+    f->noncalls = noncalls;
+    f->lastcall = lastcall;
+
+#if 0 || defined(TESTING)
+    printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",calls,noncalls,noncalls2,size,cto);
+#endif
+    return 0;
+}
+
+
+/*************************************************************************
+// unfilter
+**************************************************************************/
+
+#ifdef U
+static int U(Filter *f)
+{
+    upx_byte *b = f->buf;
+    const unsigned size5 = f->buf_len - 5;
+    const unsigned addvalue = f->addvalue;
+    const unsigned cto = (unsigned)f->cto << 24;
+    unsigned const id = f->id;
+    unsigned lastcall = 0;
+
+    unsigned ic, jc;
+
+    for (ic = 0; ic < size5; ic++)
+        if (COND(b,ic,lastcall,id))
+        {
+            jc = get_be32(b+ic+1);
+            if (b[ic+1] == f->cto)
+            {
+                set_le32(b+ic+1,jc-ic-1-addvalue-cto);
+                f->calls++;
+                ic += 4;
+                f->lastcall = lastcall = ic+1;
+            }
+            else
+                f->noncalls++;
+        }
+    return 0;
+}
+#endif
+
+
+#undef F
+#undef U
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,169 @@
+/* ctsw.h -- call-/swaptrick filter
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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>
+ */
+
+
+
+/*************************************************************************
+// 16-bit call-/swaptrick ("naive")
+**************************************************************************/
+
+#define CTSW16(f, cond1, cond2, addvalue, get, set) \
+    upx_byte *b = f->buf; \
+    upx_byte *b_end = b + f->buf_len - 3; \
+    do { \
+        if (cond1) \
+        { \
+            b += 1; \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b) + (addvalue)); \
+            f->calls++; \
+            b += 2 - 1; \
+        } \
+        else if (cond2) \
+        { \
+            b += 1; \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b)); \
+            f->calls++; \
+            b += 2 - 1; \
+        } \
+    } while (++b < b_end); \
+    if (f->lastcall) f->lastcall += 2; \
+    return 0;
+
+
+// filter
+static int f_ctsw16_e8_e9(Filter *f)
+{
+    CTSW16(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le16, set_be16)
+}
+
+static int f_ctsw16_e9_e8(Filter *f)
+{
+    CTSW16(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le16, set_be16)
+}
+
+
+// unfilter
+static int u_ctsw16_e8_e9(Filter *f)
+{
+    CTSW16(f, (*b == 0xe8), (*b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16)
+}
+
+static int u_ctsw16_e9_e8(Filter *f)
+{
+    CTSW16(f, (*b == 0xe9), (*b == 0xe8), 0 - a - f->addvalue, get_be16, set_le16)
+}
+
+
+// scan
+static int s_ctsw16_e8_e9(Filter *f)
+{
+    CTSW16(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le16, set_dummy)
+}
+
+static int s_ctsw16_e9_e8(Filter *f)
+{
+    CTSW16(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le16, set_dummy)
+}
+
+
+#undef CTSW16
+
+
+/*************************************************************************
+// 32-bit call-/swaptrick ("naive")
+**************************************************************************/
+
+#define CTSW32(f, cond1, cond2, addvalue, get, set) \
+    upx_byte *b = f->buf; \
+    upx_byte *b_end = b + f->buf_len - 5; \
+    do { \
+        if (cond1) \
+        { \
+            b += 1; \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b) + (addvalue)); \
+            f->calls++; \
+            b += 4 - 1; \
+        } \
+        else if (cond2) \
+        { \
+            b += 1; \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b)); \
+            f->calls++; \
+            b += 4 - 1; \
+        } \
+    } while (++b < b_end); \
+    if (f->lastcall) f->lastcall += 4; \
+    return 0;
+
+
+// filter
+static int f_ctsw32_e8_e9(Filter *f)
+{
+    CTSW32(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le32, set_be32)
+}
+
+static int f_ctsw32_e9_e8(Filter *f)
+{
+    CTSW32(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le32, set_be32)
+}
+
+
+// unfilter
+static int u_ctsw32_e8_e9(Filter *f)
+{
+    CTSW32(f, (*b == 0xe8), (*b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32)
+}
+
+static int u_ctsw32_e9_e8(Filter *f)
+{
+    CTSW32(f, (*b == 0xe9), (*b == 0xe8), 0 - a - f->addvalue, get_be32, set_le32)
+}
+
+
+// scan
+static int s_ctsw32_e8_e9(Filter *f)
+{
+    CTSW32(f, (*b == 0xe8), (*b == 0xe9), a + f->addvalue, get_le32, set_dummy)
+}
+
+static int s_ctsw32_e9_e8(Filter *f)
+{
+    CTSW32(f, (*b == 0xe9), (*b == 0xe8), a + f->addvalue, get_le32, set_dummy)
+}
+
+
+#undef CTSW32
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,70 @@
+/* getcto.h -- calltrick util
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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>
+ */
+
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+static int getcto(Filter *f, const unsigned char *buf, const int n=256)
+{
+    int ic = n;
+
+    if (f->preferred_ctos)
+    {
+        for (const int *pc = f->preferred_ctos; *pc >= 0; pc++)
+        {
+            if (*pc < n && buf[*pc] == 0)
+            {
+                ic = *pc;
+                break;
+            }
+        }
+    }
+
+#if 0
+    // just a test to see if certain ctos would improve compression
+    if (ic >= n)
+        for (ic = 0; ic < n; ic += 16)
+            if (buf[ic] == 0)
+                break;
+#endif
+    if (ic >= n)
+        for (ic = 0; ic < n; ic++)
+            if (buf[ic] == 0)
+                break;
+
+    if (ic >= n)
+        //throwCantPack("call trick problem");
+        return -1;
+
+    f->cto = (unsigned char) ic;
+    return ic;
+}
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,156 @@
+/* ppcbxx.h -- PowerPC Branch trick
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   Copyright (C) 2004-2017 John F. Reiser
+   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>
+
+   John F. Reiser
+   <jreiser@users.sourceforge.net>
+ */
+
+
+
+/*************************************************************************
+// filter / scan
+**************************************************************************/
+
+#define W_CTO 4  /* width of cto; must match stub/ppc_bxx.S */
+
+static int F(Filter *f)
+{
+#ifdef U
+    // filter
+    upx_byte *b = f->buf;
+    const unsigned addvalue = f->addvalue;
+#else
+    // scan
+    const upx_byte *b = f->buf;
+#endif
+    const unsigned size  = umin(f->buf_len, 0u - (~0u<<(32 - (6+ W_CTO))));
+    const unsigned size4 = size -4;
+
+    unsigned ic;
+    unsigned calls = 0, noncalls = 0;
+    unsigned lastnoncall = size, lastcall = 0;
+
+    // find 26-2-W_CTO bits of displacements that contain no targets
+    {
+        unsigned char buf[256];
+        unsigned short wbuf[256];
+        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);
+
+        for (ic = 0; ic<=size4; ic+=4) if (COND(b,ic)) {
+            unsigned const off = (int)(get_be32(b+ic)<<6) >>6;
+            if (size <= (off & (~0u<<2))+ic) {
+                buf[(~(~0u<<W_CTO)) & (off>>(26 - W_CTO))] |= 1;
+                ++wbuf[0xff&(off>>18)];
+            }
+        }
+
+        if (getcto(f, buf) < 0) {
+#if (W_CTO != 0)
+            return -1;
+#else
+            f->cto = 0;
+#endif
+        }
+    }
+    const unsigned char cto8 = f->cto;
+#ifdef U
+    const unsigned cto = (unsigned)f->cto << (24+2 - W_CTO);
+#endif
+
+    for (ic = 0; ic<=size4; ic+=4) if (COND(b,ic)) {
+        unsigned const word = get_be32(b+ic);
+        unsigned const off = (int)(word<<6) >>6;
+        unsigned const jc = (off & (~0u<<2))+ic;
+        // try to detect 'real' calls only
+        if (jc < size) {
+#ifdef U
+            set_be32(b+ic,(0xfc000003&word) | (jc+addvalue+cto));
+#endif
+            calls++;
+            lastcall = ic;
+        }
+        else {
+#if (W_CTO != 0)
+            assert((~(~0u<<W_CTO) & (word>>(24+2 - W_CTO))) != (unsigned) cto8);  // this should not happen
+#endif
+            lastnoncall = ic;
+            noncalls++;
+        }
+    }
+
+    f->calls = calls;
+    f->noncalls = noncalls;
+    f->lastcall = lastcall;
+    ACC_UNUSED(lastnoncall);
+
+#if 0 || defined(TESTING)
+    printf("\ncalls=%d noncalls=%d text_size=%x calltrickoffset=%x\n",
+        calls,noncalls,size,cto8);
+#endif
+    return 0;
+}
+
+
+/*************************************************************************
+// unfilter
+**************************************************************************/
+
+#ifdef U
+static int U(Filter *f)
+{
+    upx_byte *b = f->buf;
+    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))) == (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++;
+            f->lastcall = ic;
+        }
+        else {
+            f->noncalls++;
+        }
+    }
+    return 0;
+}
+#endif
+
+
+#undef F
+#undef U
+
+#undef W_CTO
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,82 @@
+/* sub.hh -- simple delta filter
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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>
+ */
+
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+#define SUB(f, N, T, get, set) \
+    upx_byte *b = f->buf; \
+    unsigned l = f->buf_len / sizeof(T); \
+    int i; \
+    T d[N]; \
+    \
+    i = N - 1; do d[i] = 0; while (--i >= 0); \
+    \
+    i = N - 1; \
+    do { \
+        T delta = (T) (get(b) - d[i]); \
+        set(b, delta); \
+        d[i] = (T) (d[i] + delta); \
+        b += sizeof(T); \
+        if (--i < 0) \
+            i = N - 1; \
+    } while (--l > 0); \
+    f->calls = (f->buf_len / sizeof(T)) - N; \
+    assert((int)f->calls > 0); \
+    return 0;
+
+
+#define ADD(f, N, T, get, set) \
+    upx_byte *b = f->buf; \
+    unsigned l = f->buf_len / sizeof(T); \
+    int i; \
+    T d[N]; \
+    \
+    i = N - 1; do d[i] = 0; while (--i >= 0); \
+    \
+    i = N - 1; \
+    do { \
+        d[i] = (T) (d[i] + get(b)); \
+        set(b, d[i]); \
+        b += sizeof(T); \
+        if (--i < 0) \
+            i = N - 1; \
+    } while (--l > 0); \
+    f->calls = (f->buf_len / sizeof(T)) - N; \
+    assert((int)f->calls > 0); \
+    return 0;
+
+
+#define SCAN(f, N, T, get, set) \
+    f->calls = (f->buf_len / sizeof(T)) - N; \
+    assert((int)f->calls > 0); \
+    return 0;
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,118 @@
+/* sub16.h -- simple delta filter
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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 "sub.hh"
+
+#define SUB16(f, N)     SUB(f, N, unsigned short, get_le16, set_le16)
+#define ADD16(f, N)     ADD(f, N, unsigned short, get_le16, set_le16)
+#define SCAN16(f, N)    SCAN(f, N, unsigned short, get_le16, set_le16)
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+// filter
+static int f_sub16_1(Filter *f)
+{
+    SUB16(f, 1)
+}
+
+static int f_sub16_2(Filter *f)
+{
+    SUB16(f, 2)
+}
+
+static int f_sub16_3(Filter *f)
+{
+    SUB16(f, 3)
+}
+
+static int f_sub16_4(Filter *f)
+{
+    SUB16(f, 4)
+}
+
+
+// unfilter
+static int u_sub16_1(Filter *f)
+{
+    ADD16(f, 1)
+}
+
+static int u_sub16_2(Filter *f)
+{
+    ADD16(f, 2)
+}
+
+static int u_sub16_3(Filter *f)
+{
+    ADD16(f, 3)
+}
+
+static int u_sub16_4(Filter *f)
+{
+    ADD16(f, 4)
+}
+
+
+// scan
+static int s_sub16_1(Filter *f)
+{
+    SCAN16(f, 1)
+}
+
+static int s_sub16_2(Filter *f)
+{
+    SCAN16(f, 2)
+}
+
+static int s_sub16_3(Filter *f)
+{
+    SCAN16(f, 3)
+}
+
+static int s_sub16_4(Filter *f)
+{
+    SCAN16(f, 4)
+}
+
+
+#undef SUB
+#undef ADD
+#undef SCAN
+#undef SUB16
+#undef ADD16
+#undef SCAN16
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,118 @@
+/* sub32.h -- simple delta filter
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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 "sub.hh"
+
+#define SUB32(f, N)     SUB(f, N, unsigned int, get_le32, set_le32)
+#define ADD32(f, N)     ADD(f, N, unsigned int, get_le32, set_le32)
+#define SCAN32(f, N)    SCAN(f, N, unsigned int, get_le32, set_le32)
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+// filter
+static int f_sub32_1(Filter *f)
+{
+    SUB32(f, 1)
+}
+
+static int f_sub32_2(Filter *f)
+{
+    SUB32(f, 2)
+}
+
+static int f_sub32_3(Filter *f)
+{
+    SUB32(f, 3)
+}
+
+static int f_sub32_4(Filter *f)
+{
+    SUB32(f, 4)
+}
+
+
+// unfilter
+static int u_sub32_1(Filter *f)
+{
+    ADD32(f, 1)
+}
+
+static int u_sub32_2(Filter *f)
+{
+    ADD32(f, 2)
+}
+
+static int u_sub32_3(Filter *f)
+{
+    ADD32(f, 3)
+}
+
+static int u_sub32_4(Filter *f)
+{
+    ADD32(f, 4)
+}
+
+
+// scan
+static int s_sub32_1(Filter *f)
+{
+    SCAN32(f, 1)
+}
+
+static int s_sub32_2(Filter *f)
+{
+    SCAN32(f, 2)
+}
+
+static int s_sub32_3(Filter *f)
+{
+    SCAN32(f, 3)
+}
+
+static int s_sub32_4(Filter *f)
+{
+    SCAN32(f, 4)
+}
+
+
+#undef SUB
+#undef ADD
+#undef SCAN
+#undef SUB32
+#undef ADD32
+#undef SCAN32
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,118 @@
+/* sub8.h -- simple delta filter
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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 "sub.hh"
+
+#define SUB8(f, N)      SUB(f, N, unsigned char, get_8, set_8)
+#define ADD8(f, N)      ADD(f, N, unsigned char, get_8, set_8)
+#define SCAN8(f, N)     SCAN(f, N, unsigned char, get_8, set_8)
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+// filter
+static int f_sub8_1(Filter *f)
+{
+    SUB8(f, 1)
+}
+
+static int f_sub8_2(Filter *f)
+{
+    SUB8(f, 2)
+}
+
+static int f_sub8_3(Filter *f)
+{
+    SUB8(f, 3)
+}
+
+static int f_sub8_4(Filter *f)
+{
+    SUB8(f, 4)
+}
+
+
+// unfilter
+static int u_sub8_1(Filter *f)
+{
+    ADD8(f, 1)
+}
+
+static int u_sub8_2(Filter *f)
+{
+    ADD8(f, 2)
+}
+
+static int u_sub8_3(Filter *f)
+{
+    ADD8(f, 3)
+}
+
+static int u_sub8_4(Filter *f)
+{
+    ADD8(f, 4)
+}
+
+
+// scan
+static int s_sub8_1(Filter *f)
+{
+    SCAN8(f, 1)
+}
+
+static int s_sub8_2(Filter *f)
+{
+    SCAN8(f, 2)
+}
+
+static int s_sub8_3(Filter *f)
+{
+    SCAN8(f, 3)
+}
+
+static int s_sub8_4(Filter *f)
+{
+    SCAN8(f, 4)
+}
+
+
+#undef SUB
+#undef ADD
+#undef SCAN
+#undef SUB8
+#undef ADD8
+#undef SCAN8
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,183 @@
+/* sw.h -- swaptrick filter
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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>
+ */
+
+
+
+/*************************************************************************
+// 16-bit swaptrick ("naive")
+**************************************************************************/
+
+#define SW16(f, cond, get, set) \
+    upx_byte *b = f->buf; \
+    upx_byte *b_end = b + f->buf_len - 3; \
+    do { \
+        if (cond) \
+        { \
+            b += 1; \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b)); \
+            f->calls++; \
+            b += 2 - 1; \
+        } \
+    } while (++b < b_end); \
+    if (f->lastcall) f->lastcall += 2; \
+    return 0;
+
+
+// filter
+static int f_sw16_e8(Filter *f)
+{
+    SW16(f, (*b == 0xe8), get_le16, set_be16)
+}
+
+static int f_sw16_e9(Filter *f)
+{
+    SW16(f, (*b == 0xe9), get_le16, set_be16)
+}
+
+static int f_sw16_e8e9(Filter *f)
+{
+    SW16(f, (*b == 0xe8 || *b == 0xe9), get_le16, set_be16)
+}
+
+
+// unfilter
+static int u_sw16_e8(Filter *f)
+{
+    SW16(f, (*b == 0xe8), get_be16, set_le16)
+}
+
+static int u_sw16_e9(Filter *f)
+{
+    SW16(f, (*b == 0xe9), get_be16, set_le16)
+}
+
+static int u_sw16_e8e9(Filter *f)
+{
+    SW16(f, (*b == 0xe8 || *b == 0xe9), get_be16, set_le16)
+}
+
+
+// scan
+static int s_sw16_e8(Filter *f)
+{
+    SW16(f, (*b == 0xe8), get_le16, set_dummy)
+}
+
+static int s_sw16_e9(Filter *f)
+{
+    SW16(f, (*b == 0xe9), get_le16, set_dummy)
+}
+
+static int s_sw16_e8e9(Filter *f)
+{
+    SW16(f, (*b == 0xe8 || *b == 0xe9), get_le16, set_dummy)
+}
+
+
+#undef SW16
+
+
+
+
+/*************************************************************************
+// 32-bit swaptrick ("naive")
+**************************************************************************/
+
+#define SW32(f, cond, get, set) \
+    upx_byte *b = f->buf; \
+    upx_byte *b_end = b + f->buf_len - 5; \
+    do { \
+        if (cond) \
+        { \
+            b += 1; \
+            unsigned a = (unsigned) (b - f->buf); \
+            f->lastcall = a; \
+            set(b, get(b)); \
+            f->calls++; \
+            b += 4 - 1; \
+        } \
+    } while (++b < b_end); \
+    if (f->lastcall) f->lastcall += 4; \
+    return 0;
+
+
+// filter
+static int f_sw32_e8(Filter *f)
+{
+    SW32(f, (*b == 0xe8), get_le32, set_be32)
+}
+
+static int f_sw32_e9(Filter *f)
+{
+    SW32(f, (*b == 0xe9), get_le32, set_be32)
+}
+
+static int f_sw32_e8e9(Filter *f)
+{
+    SW32(f, (*b == 0xe8 || *b == 0xe9), get_le32, set_be32)
+}
+
+
+// unfilter
+static int u_sw32_e8(Filter *f)
+{
+    SW32(f, (*b == 0xe8), get_be32, set_le32)
+}
+
+static int u_sw32_e9(Filter *f)
+{
+    SW32(f, (*b == 0xe9), get_be32, set_le32)
+}
+
+static int u_sw32_e8e9(Filter *f)
+{
+    SW32(f, (*b == 0xe8 || *b == 0xe9), get_be32, set_le32)
+}
+
+
+// scan
+static int s_sw32_e8(Filter *f)
+{
+    SW32(f, (*b == 0xe8), get_le32, set_dummy)
+}
+
+static int s_sw32_e9(Filter *f)
+{
+    SW32(f, (*b == 0xe9), get_le32, set_dummy)
+}
+
+static int s_sw32_e8e9(Filter *f)
+{
+    SW32(f, (*b == 0xe8 || *b == 0xe9), get_le32, set_dummy)
+}
+
+
+#undef SW32
+
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,385 +21,147 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #include "conf.h"
 #include "filter.h"

+static unsigned
+umin(unsigned const a, unsigned const b)
+{
+    return (a<=b) ? a : b;
+}
+

 #define set_dummy(p, v)     ((void)0)
+#define get_8(p)            (*(p))
+#define set_8(p, v)         (*(p) = (v))


 /*************************************************************************
-// 16-bit calltrick ("naive")
+// util
 **************************************************************************/

-#define CT16(f, cond, addvalue, get, set) \
-    upx_byte *b = f->buf; \
-    upx_byte *b_end = b + f->buf_len - 3; \
-    do { \
-        if (cond) \
-        { \
-            b += 1; \
-            unsigned a = (unsigned) (b - f->buf); \
-            f->lastcall = a; \
-            set(b, get(b) + (addvalue)); \
-            f->calls++; \
-            b += 2 - 1; \
-        } \
-    } while (++b < b_end); \
-    if (f->lastcall) f->lastcall += 2; \
-    return 0;
-
-
-
-// filter: e8, e9, e8e9
-static int f_ct16_e8(Filter *f)
-{
-    CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_le16)
-}
-
-static int f_ct16_e9(Filter *f)
-{
-    CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_le16)
-}
-
-static int f_ct16_e8e9(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_le16)
-}
-
-
-// unfilter: e8, e9, e8e9
-static int u_ct16_e8(Filter *f)
-{
-    CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_le16, set_le16)
-}
-
-static int u_ct16_e9(Filter *f)
-{
-    CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_le16, set_le16)
-}
-
-static int u_ct16_e8e9(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le16, set_le16)
-}
-
-
-// scan: e8, e9, e8e9
-static int s_ct16_e8(Filter *f)
-{
-    CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_dummy)
-}
-
-static int s_ct16_e9(Filter *f)
-{
-    CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_dummy)
-}
-
-static int s_ct16_e8e9(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_dummy)
-}
-
-
-// filter: e8, e9, e8e9 with bswap le->be
-static int f_ct16_e8_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_be16)
-}
-
-static int f_ct16_e9_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_be16)
-}
-
-static int f_ct16_e8e9_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_be16)
-}
-
-
-// unfilter: e8, e9, e8e9 with bswap le->be
-static int u_ct16_e8_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_be16, set_le16)
-}
-
-static int u_ct16_e9_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16)
-}
-
-static int u_ct16_e8e9_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_be16, set_le16)
-}
-
-
-// scan: e8, e9, e8e9 with bswap le->be
-static int s_ct16_e8_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe8), a + f->addvalue, get_be16, set_dummy)
-}
-
-static int s_ct16_e9_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe9), a + f->addvalue, get_be16, set_dummy)
-}
-
-static int s_ct16_e8e9_bswap_le(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be16, set_dummy)
-}
-
-
-// filter: e8, e9, e8e9 with bswap be->le
-static int f_ct16_e8_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe8), a + f->addvalue, get_be16, set_le16)
-}
-
-static int f_ct16_e9_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe9), a + f->addvalue, get_be16, set_le16)
-}
-
-static int f_ct16_e8e9_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be16, set_le16)
-}
-
-
-// unfilter: e8, e9, e8e9 with bswap be->le
-static int u_ct16_e8_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe8), 0 - a - f->addvalue, get_le16, set_be16)
-}
-
-static int u_ct16_e9_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe9), 0 - a - f->addvalue, get_le16, set_be16)
-}
-
-static int u_ct16_e8e9_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le16, set_be16)
-}
-
-
-// scan: e8, e9, e8e9 with bswap be->le
-static int s_ct16_e8_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe8), a + f->addvalue, get_le16, set_dummy)
-}
-
-static int s_ct16_e9_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe9), a + f->addvalue, get_le16, set_dummy)
-}
-
-static int s_ct16_e8e9_bswap_be(Filter *f)
-{
-    CT16(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le16, set_dummy)
-}
-
-
-#undef CT16
+#include "filter/getcto.h"


 /*************************************************************************
-// 32-bit calltrick ("naive")
+// simple filters: calltrick / swaptrick / delta / ...
 **************************************************************************/

-#define CT32(f, cond, addvalue, get, set) \
-    upx_byte *b = f->buf; \
-    upx_byte *b_end = b + f->buf_len - 5; \
-    do { \
-        if (cond) \
-        { \
-            b += 1; \
-            unsigned a = (unsigned) (b - f->buf); \
-            f->lastcall = a; \
-            set(b, get(b) + (addvalue)); \
-            f->calls++; \
-            b += 4 - 1; \
-        } \
-    } while (++b < b_end); \
-    if (f->lastcall) f->lastcall += 4; \
-    return 0;
+#include "filter/ct.h"
+#include "filter/sw.h"
+#include "filter/ctsw.h"

-
-// filter: e8, e9, e8e9
-static int f_ct32_e8(Filter *f)
-{
-    CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_le32)
-}
-
-static int f_ct32_e9(Filter *f)
-{
-    CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_le32)
-}
-
-static int f_ct32_e8e9(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_le32)
-}
-
-
-// unfilter: e8, e9, e8e9
-static int u_ct32_e8(Filter *f)
-{
-    CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_le32, set_le32)
-}
-
-static int u_ct32_e9(Filter *f)
-{
-    CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_le32, set_le32)
-}
-
-static int u_ct32_e8e9(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le32, set_le32)
-}
-
-
-// scan: e8, e9, e8e9
-static int s_ct32_e8(Filter *f)
-{
-    CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_dummy)
-}
-
-static int s_ct32_e9(Filter *f)
-{
-    CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_dummy)
-}
-
-static int s_ct32_e8e9(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_dummy)
-}
-
-
-// filter: e8, e9, e8e9 with bswap le->be
-static int f_ct32_e8_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_be32)
-}
-
-static int f_ct32_e9_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_be32)
-}
-
-static int f_ct32_e8e9_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_be32)
-}
-
-
-// unfilter: e8, e9, e8e9 with bswap le->be
-static int u_ct32_e8_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_be32, set_le32)
-}
-
-static int u_ct32_e9_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32)
-}
-
-static int u_ct32_e8e9_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_be32, set_le32)
-}
-
-
-// scan: e8, e9, e8e9 with bswap le->be
-static int s_ct32_e8_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe8), a + f->addvalue, get_be32, set_dummy)
-}
-
-static int s_ct32_e9_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe9), a + f->addvalue, get_be32, set_dummy)
-}
-
-static int s_ct32_e8e9_bswap_le(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be32, set_dummy)
-}
-
-
-// filter: e8, e9, e8e9 with bswap be->le
-static int f_ct32_e8_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe8), a + f->addvalue, get_be32, set_le32)
-}
-
-static int f_ct32_e9_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe9), a + f->addvalue, get_be32, set_le32)
-}
-
-static int f_ct32_e8e9_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_be32, set_le32)
-}
-
-
-// unfilter: e8, e9, e8e9 with bswap be->le
-static int u_ct32_e8_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe8), 0 - a - f->addvalue, get_le32, set_be32)
-}
-
-static int u_ct32_e9_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe9), 0 - a - f->addvalue, get_le32, set_be32)
-}
-
-static int u_ct32_e8e9_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), 0 - a - f->addvalue, get_le32, set_be32)
-}
-
-
-// scan: e8, e9, e8e9 with bswap be->le
-static int s_ct32_e8_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe8), a + f->addvalue, get_le32, set_dummy)
-}
-
-static int s_ct32_e9_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe9), a + f->addvalue, get_le32, set_dummy)
-}
-
-static int s_ct32_e8e9_bswap_be(Filter *f)
-{
-    CT32(f, (*b == 0xe8 || *b == 0xe9), a + f->addvalue, get_le32, set_dummy)
-}
-
-
-#undef CT32
-
-#undef set_dummy
+#include "filter/sub8.h"
+#include "filter/sub16.h"
+#include "filter/sub32.h"


 /*************************************************************************
-// 32-bit calltrick with cto ("clever")
-//
-// This version is more sophisticated because it only
-// tries to change actual calls and/or jumps.
+// cto calltrick
 **************************************************************************/

-#include "fcto_ml.ch"
+#define COND(b,x)               (b[x] == 0xe8)
+#define F                       f_cto32_e8_bswap_le
+#define U                       u_cto32_e8_bswap_le
+#include "filter/cto.h"
+#define F                       s_cto32_e8_bswap_le
+#include "filter/cto.h"
+#undef COND
+
+#define COND(b,x)               (b[x] == 0xe9)
+#define F                       f_cto32_e9_bswap_le
+#define U                       u_cto32_e9_bswap_le
+#include "filter/cto.h"
+#define F                       s_cto32_e9_bswap_le
+#include "filter/cto.h"
+#undef COND
+
+#define COND(b,x)               (b[x] == 0xe8 || b[x] == 0xe9)
+#define F                       f_cto32_e8e9_bswap_le
+#define U                       u_cto32_e8e9_bswap_le
+#include "filter/cto.h"
+#define F                       s_cto32_e8e9_bswap_le
+#include "filter/cto.h"
+#undef COND
+
+
+/*************************************************************************
+// cto calltrick with jmp
+**************************************************************************/
+
+#define COND(b,x,lastcall) (b[x] == 0xe8 || b[x] == 0xe9)
+#define F                       f_ctoj32_e8e9_bswap_le
+#define U                       u_ctoj32_e8e9_bswap_le
+#include "filter/ctoj.h"
+#define F                       s_ctoj32_e8e9_bswap_le
+#include "filter/ctoj.h"
+#undef COND
+
+
+/*************************************************************************
+// cto calltrick with jmp, optional jcc
+**************************************************************************/
+
+#define COND1(b,x)     (b[x] == 0xe8 || b[x] == 0xe9)
+#define COND2(b,x,lc)  (lc!=(x) && 0xf==b[(x)-1] && 0x80<=b[x] && b[x]<=0x8f)
+#define COND(b,x,lc,id) (COND1(b,x) || ((9<=(0xf&(id))) && COND2(b,x,lc)))
+#define F                       f_ctok32_e8e9_bswap_le
+#define U                       u_ctok32_e8e9_bswap_le
+#include "filter/ctok.h"
+#define F                       s_ctok32_e8e9_bswap_le
+#include "filter/ctok.h"
+#undef COND
+#undef COND2
+#undef COND1
+
+
+/*************************************************************************
+// cto calltrick with jmp and jcc and relative renumbering
+**************************************************************************/
+
+#define COND_CALL(which,b,x) ((which = 0), b[x] == 0xe8)
+#define COND_JMP( which,b,x) ((which = 1), b[x] == 0xe9)
+#define COND_JCC( which,b,lastcall,x,y,z) ((which = 2), \
+         (lastcall!=(x) && 0xf==b[y] && 0x80<=b[z] && b[z]<=0x8f))
+#define COND1(which,b,x) (COND_CALL(which,b,x) || COND_JMP(which,b,x))
+#define COND2(which,b,lastcall,x,y,z) COND_JCC(which,b,lastcall,x,y,z)
+
+#define CONDF(which,b,x,lastcall) \
+    (COND1(which,b,x) || COND2(which,b,lastcall,x,(x)-1, x   ))
+#define CONDU(which,b,x,lastcall) \
+    (COND1(which,b,x) || COND2(which,b,lastcall,x, x   ,(x)-1))
+
+#define F                       f_ctojr32_e8e9_bswap_le
+#define U                       u_ctojr32_e8e9_bswap_le
+#include "filter/ctojr.h"
+#define F                       s_ctojr32_e8e9_bswap_le
+#include "filter/ctojr.h"
+
+#undef CONDU
+#undef CONDF
+#undef COND2
+#undef COND1
+#undef COND_JCC
+#undef COND_JMP
+#undef COND_CALL
+
+
+/*************************************************************************
+// PowerPC branch [incl. call] trick
+**************************************************************************/
+
+#define COND(b,x) (18==(get_be32(b+x)>>26))
+#define F                       f_ppcbxx
+#define U                       u_ppcbxx
+#include "filter/ppcbxx.h"
+#define F                       s_ppcbxx
+#include "filter/ppcbxx.h"
+#undef COND


 /*************************************************************************
@@ -409,8 +171,9 @@ static int s_ct32_e8e9_bswap_be(Filter *f)
 const FilterImp::FilterEntry FilterImp::filters[] = {
    // no filter
    { 0x00, 0,          0, NULL, NULL, NULL },
+
    // 16-bit calltrick
-    { 0x01, 4,          0, f_ct16_e8, u_ct16_e8, s_ct16_e8,},
+    { 0x01, 4,          0, f_ct16_e8, u_ct16_e8, s_ct16_e8 },
    { 0x02, 4,          0, f_ct16_e9, u_ct16_e9, s_ct16_e9 },
    { 0x03, 4,          0, f_ct16_e8e9, u_ct16_e8e9, s_ct16_e8e9 },
    { 0x04, 4,          0, f_ct16_e8_bswap_le, u_ct16_e8_bswap_le, s_ct16_e8_bswap_le },
@@ -419,6 +182,16 @@ const FilterImp::FilterEntry FilterImp::filters[] = {
    { 0x07, 4,          0, f_ct16_e8_bswap_be, u_ct16_e8_bswap_be, s_ct16_e8_bswap_be },
    { 0x08, 4,          0, f_ct16_e9_bswap_be, u_ct16_e9_bswap_be, s_ct16_e9_bswap_be },
    { 0x09, 4,          0, f_ct16_e8e9_bswap_be, u_ct16_e8e9_bswap_be, s_ct16_e8e9_bswap_be },
+
+    // 16-bit swaptrick
+    { 0x0a, 4,          0, f_sw16_e8, u_sw16_e8, s_sw16_e8 },
+    { 0x0b, 4,          0, f_sw16_e9, u_sw16_e9, s_sw16_e9 },
+    { 0x0c, 4,          0, f_sw16_e8e9, u_sw16_e8e9, s_sw16_e8e9 },
+
+    // 16-bit call-/swaptrick
+    { 0x0d, 4,          0, f_ctsw16_e8_e9, u_ctsw16_e8_e9, s_ctsw16_e8_e9 },
+    { 0x0e, 4,          0, f_ctsw16_e9_e8, u_ctsw16_e9_e8, s_ctsw16_e9_e8 },
+
    // 32-bit calltrick
    { 0x11, 6,          0, f_ct32_e8, u_ct32_e8, s_ct32_e8 },
    { 0x12, 6,          0, f_ct32_e9, u_ct32_e9, s_ct32_e9 },
@@ -429,24 +202,65 @@ const FilterImp::FilterEntry FilterImp::filters[] = {
    { 0x17, 6,          0, f_ct32_e8_bswap_be, u_ct32_e8_bswap_be, s_ct32_e8_bswap_be },
    { 0x18, 6,          0, f_ct32_e9_bswap_be, u_ct32_e9_bswap_be, s_ct32_e9_bswap_be },
    { 0x19, 6,          0, f_ct32_e8e9_bswap_be, u_ct32_e8e9_bswap_be, s_ct32_e8e9_bswap_be },
+
+    // 32-bit swaptrick
+    { 0x1a, 6,          0, f_sw32_e8, u_sw32_e8, s_sw32_e8 },
+    { 0x1b, 6,          0, f_sw32_e9, u_sw32_e9, s_sw32_e9 },
+    { 0x1c, 6,          0, f_sw32_e8e9, u_sw32_e8e9, s_sw32_e8e9 },
+
+    // 32-bit call-/swaptrick
+    { 0x1d, 6,          0, f_ctsw32_e8_e9, u_ctsw32_e8_e9, s_ctsw32_e8_e9 },
+    { 0x1e, 6,          0, f_ctsw32_e9_e8, u_ctsw32_e9_e8, s_ctsw32_e9_e8 },
+
    // 32-bit cto calltrick
-    { 0x21, 6, 0x00ffffff, f_cto32_e8, u_cto32_e8, s_cto32_e8 },
-    { 0x22, 6, 0x00ffffff, f_cto32_e9, u_cto32_e9, s_cto32_e9 },
-    { 0x23, 6, 0x00ffffff, f_cto32_e8e9, u_cto32_e8e9, s_cto32_e8e9 },
    { 0x24, 6, 0x00ffffff, f_cto32_e8_bswap_le, u_cto32_e8_bswap_le, s_cto32_e8_bswap_le },
    { 0x25, 6, 0x00ffffff, f_cto32_e9_bswap_le, u_cto32_e9_bswap_le, s_cto32_e9_bswap_le },
    { 0x26, 6, 0x00ffffff, f_cto32_e8e9_bswap_le, u_cto32_e8e9_bswap_le, s_cto32_e8e9_bswap_le },
-    { 0x27, 6, 0x00ffffff, f_cto32_e8_bswap_be, u_cto32_e8_bswap_be, s_cto32_e8_bswap_be },
-    { 0x28, 6, 0x00ffffff, f_cto32_e9_bswap_be, u_cto32_e9_bswap_be, s_cto32_e9_bswap_be },
-    { 0x29, 6, 0x00ffffff, f_cto32_e8e9_bswap_be, u_cto32_e8e9_bswap_be, s_cto32_e8e9_bswap_be },
-    // 32-bit cto calltrick + jmp
-    { 0x36, 6, 0x00ffffff, f_ctjo32_e8e9_bswap_le, u_ctjo32_e8e9_bswap_le, s_ctjo32_e8e9_bswap_le },
+
+    // 32-bit cto calltrick with jmp
+    { 0x36, 6, 0x00ffffff, f_ctoj32_e8e9_bswap_le, u_ctoj32_e8e9_bswap_le, s_ctoj32_e8e9_bswap_le },
+
+    // 32-bit calltrick with jmp, optional jcc; runtime can unfilter more than one block
+    { 0x46, 6, 0x00ffffff, f_ctok32_e8e9_bswap_le, u_ctok32_e8e9_bswap_le, s_ctok32_e8e9_bswap_le },
+    { 0x49, 6, 0x00ffffff, f_ctok32_e8e9_bswap_le, u_ctok32_e8e9_bswap_le, s_ctok32_e8e9_bswap_le },
+
+    // 24-bit calltrick for arm
+    { 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 },
+    { 0x82, 8, 0x00ffffff, f_ctojr32_e8e9_bswap_le, u_ctojr32_e8e9_bswap_le, s_ctojr32_e8e9_bswap_le },
+    { 0x83, 8, 0x00ffffff, f_ctojr32_e8e9_bswap_le, u_ctojr32_e8e9_bswap_le, s_ctojr32_e8e9_bswap_le },
+    { 0x84, 8, 0x00ffffff, f_ctojr32_e8e9_bswap_le, u_ctojr32_e8e9_bswap_le, s_ctojr32_e8e9_bswap_le },
+    { 0x85, 8, 0x00ffffff, f_ctojr32_e8e9_bswap_le, u_ctojr32_e8e9_bswap_le, s_ctojr32_e8e9_bswap_le },
+    { 0x86, 8, 0x00ffffff, f_ctojr32_e8e9_bswap_le, u_ctojr32_e8e9_bswap_le, s_ctojr32_e8e9_bswap_le },
+    { 0x87, 8, 0x00ffffff, f_ctojr32_e8e9_bswap_le, u_ctojr32_e8e9_bswap_le, s_ctojr32_e8e9_bswap_le },
+
+    // simple delta filter
+    { 0x90, 2,          0, f_sub8_1, u_sub8_1, s_sub8_1 },
+    { 0x91, 3,          0, f_sub8_2, u_sub8_2, s_sub8_2 },
+    { 0x92, 4,          0, f_sub8_3, u_sub8_3, s_sub8_3 },
+    { 0x93, 5,          0, f_sub8_4, u_sub8_4, s_sub8_4 },
+
+    { 0xa0,99,          0, f_sub16_1, u_sub16_1, s_sub16_1 },
+    { 0xa1,99,          0, f_sub16_2, u_sub16_2, s_sub16_2 },
+    { 0xa2,99,          0, f_sub16_3, u_sub16_3, s_sub16_3 },
+    { 0xa3,99,          0, f_sub16_4, u_sub16_4, s_sub16_4 },
+
+    { 0xb0,99,          0, f_sub32_1, u_sub32_1, s_sub32_1 },
+    { 0xb1,99,          0, f_sub32_2, u_sub32_2, s_sub32_2 },
+    { 0xb2,99,          0, f_sub32_3, u_sub32_3, s_sub32_3 },
+    { 0xb3,99,          0, f_sub32_4, u_sub32_4, s_sub32_4 },
+
+    // PowerPC branch+call trick
+    { 0xd0, 8,          0, f_ppcbxx, u_ppcbxx, s_ppcbxx },
 };

-const int FilterImp::n_filters = HIGH(filters);
-
-
-/*
-vi:ts=4:et:nowrap
-*/
+const int FilterImp::n_filters = TABLESIZE(filters);

+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,12 +21,15 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <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,13 +53,32 @@ 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\n"
-                "UPX v%-12sMarkus F.X.J. Oberhumer & Laszlo Molnar%21s\n\n",
-                UPX_VERSION_STRING, UPX_VERSION_DATE);
+                "                       Ultimate Packer for eXecutables\n"
+                "                          Copyright (C) 1996 - " UPX_VERSION_YEAR "\n"
+#if defined(UPX_VERSION_GITREV)
+                "UPX git-%6.6s%c"
+#else
+                "UPX %-11s"
+#endif
+                " Markus Oberhumer, Laszlo Molnar & John Reiser  %14s\n\n",
+#if defined(UPX_VERSION_GITREV)
+                gitrev,
+                (sizeof(gitrev)-1 > 6 && gitrev[sizeof(gitrev)-2] == '+') ? '+' : ' ',
+#elif (ACC_OS_DOS16 || ACC_OS_DOS32)
+                V("d"),
+#elif (ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
+                V("w"),
+#else
+                UPX_VERSION_STRING,
+#endif
+                UPX_VERSION_DATE);
    fg = con_fg(f,fg);
+#undef V
+
+    UNUSED(fg);
 }


@@ -62,8 +90,8 @@ void show_usage(void)
 {
    FILE *f = con_term;

-    con_fprintf(f,"Usage: %s [-123456788dlthVL] [-qvfk] [-o file] %sfile..\n", progname,
-#if defined(__DJGPP__) || defined(__EMX__)
+    con_fprintf(f,"Usage: %s [-123456789dlthVL] [-qvfk] [-o file] %sfile..\n", progname,
+#if (ACC_OS_DOS32) && defined(__DJGPP__)
                "[@]");
 #else
                "");
@@ -75,7 +103,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(NULL) { }
+    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 = NULL;
+        return NULL;
+    }
+    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, NULL, &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;
@@ -92,8 +192,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 very slow for big files)\n",
-                x == 0 ? "more" : "this", x == 0 ? "" : "\n");
+                verbose == 0 ? "" : "  --best compress best (can be slow for big files)\n",
+                verbose == 0 ? "more" : "this", verbose == 0 ? "" : "\n");

    fg = con_fg(f,FG_YELLOW);
    con_fprintf(f,"Options:\n");
@@ -101,23 +201,29 @@ void show_help(int x)

    con_fprintf(f,
                "  -q     be quiet                          -v    be verbose\n"
-                //"  -oFILE write output to `FILE'            -c    write output to stdout\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,
+                    "  --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"
@@ -128,7 +234,7 @@ void show_help(int x)
        fg = con_fg(f,fg);
        con_fprintf(f,
                    "  --overlay=copy      copy any extra data attached to the file [default]\n"
-                    "  --overlay=strip     strip any extra data attached to the file [dangerous]\n"
+                    "  --overlay=strip     strip any extra data attached to the file [DANGEROUS]\n"
                    "  --overlay=skip      don't compress a file with an overlay\n"
                    "\n");
        fg = con_fg(f,FG_YELLOW);
@@ -156,25 +262,6 @@ void show_help(int x)
        con_fprintf(f,
                    "  --8086              make compressed sys work on any 8086\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");
-        fg = con_fg(f,fg);
-        con_fprintf(f,
-                    "  --compress-exports=0    do not compress the export section\n"
-                    "  --compress-exports=1    compress the export section [default]\n"
-                    "  --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-resources=0  do not compress any resources at all\n"
-                    "  --strip-relocs=0        do not strip relocations\n"
-                    "  --strip-relocs=1        strip relocations [default]\n"
-                    "\n");
 #if 0
        fg = con_fg(f,FG_YELLOW);
        con_fprintf(f,"Options for linux/386\n");
@@ -184,43 +271,76 @@ void show_help(int x)
                    "  --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,
+                    "  --8-bit             uses 8 bit size compression [default: 32 bit]\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 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, 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"
+                    "  --compress-exports=1    compress the export section [default]\n"
+                    "  --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"
+                    "\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,
-                "  file.. executables to (de)compress\n"
-                "\n"
-                "This version supports:\n    "
-                "atari/tos, "
-                "bvmlinuz/386, "
-                "djgpp2/coff, "
-                "dos/com, "
-                "dos/exe, "
-                "dos/sys,\n    "
-                "linux/386, "
-                "linux/elf386, "
-                "linux/sh386, "
-                "rtm32/pe, "
-                "tmt/adam, "
-                "vmlinuz/386,\n    "
-                "watcom/le, "
-                "win32/pe"
-                "\n\nUPX comes with ABSOLUTELY NO WARRANTY; for details visit http://upx.tsx.org\n"
-                //"\n\nUPX comes with ABSOLUTELY NO WARRANTY; for details type `upx -L'.\n"
+    con_fprintf(f, "file..   executables to (de)compress\n");
+
+    if (verbose > 0)
+    {
+        fg = con_fg(f,FG_YELLOW);
+        con_fprintf(f,"\nThis version supports:\n");
+        fg = con_fg(f,fg);
+        show_all_packers(f, verbose);
+    }
+    else
+    {
+        con_fprintf(f,"\nType '%s --help' for more detailed help.\n", progname);
+    }
+
+    con_fprintf(f,"\nUPX comes with ABSOLUTELY NO WARRANTY; for details visit https://upx.github.io\n"
+//                "\nUPX comes with ABSOLUTELY NO WARRANTY; for details type 'upx -L'.\n"
                "");

-
-#if defined(DEBUG) || defined(TESTING)
+#if (DEBUG) || (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");
    fg = con_fg(f,fg);
 #endif
+
+    UNUSED(fg);
 }


@@ -234,7 +354,7 @@ void show_license(void)

    show_head();

-con_fprintf(f,
+    con_fprintf(f,
        "   This program may be used freely, and you are welcome to\n"
        "   redistribute it under certain conditions.\n"
        "\n"
@@ -249,17 +369,19 @@ con_fprintf(f,
        "\n"
    );
    int fg = con_fg(f,FG_CYAN);
-con_fprintf(f,
-        "        http://upx.tsx.org\n"
-        "        http://wildsau.idv.uni-linz.ac.at/mfx/upx.html\n"
+    con_fprintf(f,
+        "        http://upx.sourceforge.net\n"
+        "        http://www.oberhumer.com/opensource/upx/\n"
    );
    (void)con_fg(f,FG_ORANGE);
-con_fprintf(f,
+    con_fprintf(f,
        "\n"
-        "   Markus F.X.J. Oberhumer                   Laszlo Molnar\n"
-        "   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu\n"
+        "   Markus F.X.J. Oberhumer              Laszlo Molnar\n"
+        "   <markus@oberhumer.com>               <ezerotven+github@gmail.com>\n"
    );
    fg = con_fg(f,fg);
+
+    UNUSED(fg);
 }


@@ -269,24 +391,47 @@ con_fprintf(f,

 void show_version(int x)
 {
-    FILE *f = stdout;
+    FILE *fp = stdout;
+    const char *v;
    UNUSED(x);
+    UNUSED(v);

-    fprintf(f,"upx %s\n",UPX_VERSION_STRING);
-#if defined(WITH_NRV)
-    fprintf(f,"NRV data compression library %s\n", nrv_version_string());
+    fprintf(fp, "upx %s\n", UPX_VERSION_STRING
+#if defined(UPX_VERSION_GITREV)
+            "-git-" UPX_VERSION_GITREV
 #endif
-#if defined(WITH_UCL)
-    fprintf(f,"UCL data compression library %s\n", ucl_version_string());
+           );
+#if (WITH_NRV)
+    v = upx_nrv_version_string();
+    if (v != NULL && v[0])
+        fprintf(fp, "NRV data compression library %s\n", v);
 #endif
-    fprintf(f,"Copyright (C) 1996,1997,1998,1999,2000 Markus Franz Xaver Johannes Oberhumer\n");
-    fprintf(f,"Copyright (C) 1996,1997,1998,1999,2000 Laszlo Molnar\n");
-    fprintf(f,"Copyright (C) 2000 John F. Reiser\n");
-    fprintf(f,"UPX comes with ABSOLUTELY NO WARRANTY; for details type `%s -L'.\n", progname);
+#if (WITH_UCL)
+    v = upx_ucl_version_string();
+    if (v != NULL && v[0])
+        fprintf(fp, "UCL data compression library %s\n", v);
+#endif
+#if (WITH_ZLIB)
+    v = upx_zlib_version_string();
+    if (v != NULL && v[0])
+        fprintf(fp, "zlib data compression library %s\n", v);
+#endif
+#if (WITH_LZMA)
+    v = upx_lzma_version_string();
+    if (v != NULL && v[0])
+        fprintf(fp, "LZMA SDK version %s\n", v);
+#endif
+    fprintf(fp, "Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer\n");
+    fprintf(fp, "Copyright (C) 1996-2017 Laszlo Molnar\n");
+    fprintf(fp, "Copyright (C) 2000-2017 John F. Reiser\n");
+    fprintf(fp, "Copyright (C) 2002-2017 Jens Medoch\n");
+#if (WITH_ZLIB)
+    fprintf(fp, "Copyright (C) 1995" "-2005 Jean-loup Gailly and Mark Adler\n");
+#endif
+#if (WITH_LZMA)
+    fprintf(fp, "Copyright (C) 1999" "-2006 Igor Pavlov\n");
+#endif
+    fprintf(fp, "UPX comes with ABSOLUTELY NO WARRANTY; for details type '%s -L'.\n", progname);
 }

-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,8 +21,8 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


@@ -32,8 +32,13 @@
 #include "lefile.h"


-LeFile::LeFile(InputFile *f) : fif(f)
+LeFile::LeFile(InputFile *f) :
+    fif(f), fof(NULL),
+    le_offset(0), exe_offset(0)
 {
+    COMPILE_TIME_ASSERT(sizeof(le_header_t) == 196);
+    COMPILE_TIME_ASSERT(sizeof(le_object_table_entry_t) == 24);
+    COMPILE_TIME_ASSERT(sizeof(le_pagemap_entry_t) == 4);
    memset(&ih,0,sizeof ih);
    memset(&oh,0,sizeof oh);
    iobject_table = oobject_table = NULL;
@@ -43,7 +48,6 @@ LeFile::LeFile(InputFile *f) : fif(f)
    ifixups = ofixups = NULL;
    inonres_names = ononres_names = NULL;
    ientries = oentries = NULL;
-    le_offset = exe_offset = 0;
 }


@@ -168,6 +172,18 @@ void LeFile::writeFixups()
 }


+unsigned LeFile::getImageSize() const
+{
+    unsigned n = 0;
+    if (ih.memory_pages > 0)
+    {
+        n = (ih.memory_pages - 1) * ih.memory_page_size;
+        n += ih.bytes_on_last_page;
+    }
+    return n;
+}
+
+
 void LeFile::readImage()
 {
    soimage = pages*mps;
@@ -295,7 +311,8 @@ void LeFile::writeFile(OutputFile *f, bool le)

 void LeFile::countFixups(unsigned *counts) const
 {
-    memset(counts,0,sizeof(unsigned)*(objects+2));
+    const unsigned o = objects;
+    memset(counts,0,sizeof(unsigned)*(o+2));
    // counts[0..objects-1] - # of 32-bit offset relocations in for that objects
    // counts[objects]      - # of selector fixups
    // counts[objects+1]    - # of self-relative fixups
@@ -311,7 +328,7 @@ void LeFile::countFixups(unsigned *counts) const
        switch (*fix)
        {
            case 2:       // selector fixup
-                counts[objects] += 9;
+                counts[o] += 9;
                fix += 5;
                break;
            case 0x12:    // alias selector
@@ -320,7 +337,8 @@ void LeFile::countFixups(unsigned *counts) const
                fix += (fix[1] & 0x10) ? 9 : 7;
                break;
            case 6:       // 16:32 pointer
-                counts[objects] += 9;
+                counts[o] += 9;
+                // fall through
            case 7:       // 32-bit offset
                counts[fix[4]-1] += 4;
                fix += (fix[1] & 0x10) ? 9 : 7;
@@ -332,19 +350,15 @@ void LeFile::countFixups(unsigned *counts) const
                fix += ll*2;
                break;
            case 8:       // 32-bit self relative fixup
-                counts[objects+1] += 4;
+                counts[o+1] += 4;
                fix += (fix[1] & 0x10) ? 9 : 7;
                break;
            default:
                throwCantPack("unsupported fixup record");
        }
    }
-    counts[objects]++; // extra space for 'ret'
-    counts[objects+1] += 4; // extra space for 0xFFFFFFFF
+    counts[o]++; // extra space for 'ret'
+    counts[o+1] += 4; // extra space for 0xFFFFFFFF
 }

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,13 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_LEFILE_H
-#define __UPX_LEFILE_H
+#define __UPX_LEFILE_H 1

 class InputFile;
 class OutputFile;
@@ -49,8 +49,8 @@ public:
 protected:
    enum { FIXUP_EXTRA = 3 };

-    struct le_header_t
-    {   // 0x00
+    __packed_struct(le_header_t)
+        // 0x00
        char  _[2];             // signature: 'LE' || 'LX'
        char  byte_order;       // 0 little endian
        char  word_order;       // 0 little endian
@@ -117,25 +117,23 @@ protected:
        LE16  device_id;
        LE16  ddk_version;
 #endif
-    };
+    __packed_struct_end()

-    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()

-    struct le_pagemap_entry_t
-    {
-        upx_byte  h;
-        upx_byte  m;
-        upx_byte  l;
-        upx_byte  type;              // 0x00-legal;0x40-iterated;0x80-invalid;0xC0-zeroed
-    };
+    __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()

    virtual void readObjectTable();
    virtual void writeObjectTable();
@@ -178,11 +176,12 @@ protected:
    //virtual void decodeImage(){encodeImage();}

    void countFixups(unsigned *) const;
+    unsigned getImageSize() const;

    InputFile *fif;
    OutputFile *fof;
-    long le_offset;
-    long exe_offset;
+    unsigned le_offset;
+    unsigned exe_offset;

    le_header_t ih;
    le_header_t oh;
@@ -215,15 +214,11 @@ protected:

 private:
    // disable copy and assignment
-    LeFile(LeFile const &); // {}
-    LeFile& operator= (LeFile const &); // { return *this; }
+    LeFile(const LeFile &); // {}
+    LeFile& operator= (const LeFile &); // { return *this; }
 };


 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,188 +21,840 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */

-
 #include "conf.h"
 #include "linker.h"

+static unsigned hex(unsigned char c) { return (c & 0xf) + (c > '9' ? 9 : 0); }

-struct Linker::section
-{
-    int  istart;
-    int  ostart;
-    int  len;
-    char name[8];
-};
+static bool update_capacity(unsigned size, unsigned *capacity) {
+    if (size < *capacity)
+        return false;
+    if (*capacity == 0)
+        *capacity = 16;
+    while (size >= *capacity)
+        *capacity *= 2;
+    return true;
+}

-struct Linker::jump
-{
-    int  pos;
-    int  len;
-    char tsect[8];
-    int  toffs;
-};
+static void __acc_cdecl_va internal_error(const char *format, ...) {
+    static char buf[1024];
+    va_list ap;

+    va_start(ap, format);
+    vsnprintf(buf, sizeof(buf), format, ap);
+    va_end(ap);

-Linker::Linker(const void *pdata, int plen, int pinfo)
-{
-    iloader = new char[(ilen = plen) + 4096];
-    memcpy(iloader,pdata,plen);
-    oloader = new char[plen];
-    olen = 0;
-    align_hack = 0;
-    info = pinfo;
-    njumps = nsections = frozen = 0;
-    jumps = new jump[200];
-    sections = new section[200];
+    throwInternalError(buf);
+}

-    char *p = iloader + info;
-    while (get_le32(p) != (unsigned)(-1))
-    {
-        if (get_le32(p))
-        {
-            memcpy(sections[nsections].name,p,8);
-            sections[nsections].istart = get_le32(p+8);
-            sections[nsections++].ostart = -1;
-            p += 12;
-            assert(nsections < 200);
+/*************************************************************************
+// Section
+**************************************************************************/
+
+ElfLinker::Section::Section(const char *n, const void *i, unsigned s, unsigned a)
+    : name(NULL), output(NULL), size(s), offset(0), p2align(a), next(NULL) {
+    name = strdup(n);
+    assert(name != NULL);
+    input = malloc(s + 1);
+    assert(input != NULL);
+    if (s != 0)
+        memcpy(input, i, s);
+    ((char *) input)[s] = 0;
+}
+
+ElfLinker::Section::~Section() {
+    free(name);
+    free(input);
+}
+
+/*************************************************************************
+// Symbol
+**************************************************************************/
+
+ElfLinker::Symbol::Symbol(const char *n, Section *s, upx_uint64_t o)
+    : name(NULL), section(s), offset(o) {
+    name = strdup(n);
+    assert(name != NULL);
+    assert(section != NULL);
+}
+
+ElfLinker::Symbol::~Symbol() { free(name); }
+
+/*************************************************************************
+// Relocation
+**************************************************************************/
+
+ElfLinker::Relocation::Relocation(const Section *s, unsigned o, const char *t, const Symbol *v,
+                                  upx_uint64_t a)
+    : section(s), offset(o), type(t), value(v), add(a) {
+    assert(section != NULL);
+}
+
+/*************************************************************************
+// ElfLinker
+**************************************************************************/
+
+ElfLinker::ElfLinker()
+    : bele(&N_BELE_RTP::le_policy), input(NULL), output(NULL), head(NULL), tail(NULL),
+      sections(NULL), symbols(NULL), relocations(NULL), nsections(0), nsections_capacity(0),
+      nsymbols(0), nsymbols_capacity(0), nrelocations(0), nrelocations_capacity(0),
+      reloc_done(false) {}
+
+ElfLinker::~ElfLinker() {
+    delete[] input;
+    delete[] output;
+
+    unsigned ic;
+    for (ic = 0; ic < nsections; ic++)
+        delete sections[ic];
+    free(sections);
+    for (ic = 0; ic < nsymbols; ic++)
+        delete symbols[ic];
+    free(symbols);
+    for (ic = 0; ic < nrelocations; ic++)
+        delete relocations[ic];
+    free(relocations);
+}
+
+void ElfLinker::init(const void *pdata_v, int plen) {
+    const upx_byte *pdata = (const upx_byte *) pdata_v;
+    if (plen >= 16 && memcmp(pdata, "UPX#", 4) == 0) {
+        // decompress pre-compressed stub-loader
+        int method;
+        unsigned u_len, c_len;
+        if (pdata[4]) {
+            method = pdata[4];
+            u_len = get_le16(pdata + 5);
+            c_len = get_le16(pdata + 7);
+            pdata += 9;
+            assert(9 + c_len == (unsigned) plen);
+        } else {
+            method = pdata[5];
+            u_len = get_le32(pdata + 6);
+            c_len = get_le32(pdata + 10);
+            pdata += 14;
+            assert(14 + c_len == (unsigned) plen);
        }
-        else
-        {
-            int l;
-            for (l = get_le32(p+4) - 1; iloader[l] == 0; l--)
-                ;
+        assert((unsigned) plen < u_len);
+        inputlen = u_len;
+        input = new upx_byte[inputlen + 1];
+        unsigned new_len = u_len;
+        int r = upx_decompress(pdata, c_len, input, &new_len, method, NULL);
+        if (r == UPX_E_OUT_OF_MEMORY)
+            throwOutOfMemoryException();
+        if (r != UPX_E_OK || new_len != u_len)
+            throwBadLoader();
+    } else {
+        inputlen = plen;
+        input = new upx_byte[inputlen + 1];
+        if (inputlen)
+            memcpy(input, pdata, inputlen);
+    }
+    input[inputlen] = 0; // NUL terminate

-            jumps[njumps].pos = l+1;
-            jumps[njumps].len = get_le32(p+4)-jumps[njumps].pos;
-            memcpy(jumps[njumps].tsect,p+8,8);
-            jumps[njumps++].toffs = get_le32(p+16);
-            p += 20;
-            assert(njumps < 200);
+    output = new upx_byte[inputlen ? inputlen : 0x4000];
+    outputlen = 0;
+
+    if ((int) strlen("Sections:\n"
+                     "SYMBOL TABLE:\n"
+                     "RELOCATION RECORDS FOR ") < inputlen) {
+        int pos = find(input, inputlen, "Sections:\n", 10);
+        assert(pos != -1);
+        char *psections = (char *) input + pos;
+
+        char *psymbols = strstr(psections, "SYMBOL TABLE:\n");
+        assert(psymbols != NULL);
+
+        char *prelocs = strstr(psymbols, "RELOCATION RECORDS FOR ");
+        assert(prelocs != NULL);
+
+        preprocessSections(psections, psymbols);
+        preprocessSymbols(psymbols, prelocs);
+        preprocessRelocations(prelocs, (char *) input + inputlen);
+        addLoader("*UND*");
+    }
+}
+
+void ElfLinker::preprocessSections(char *start, char *end) {
+    char *nextl;
+    for (nsections = 0; start < end; start = 1 + nextl) {
+        nextl = strchr(start, '\n');
+        assert(nextl != NULL);
+        *nextl = '\0'; // a record is a line
+
+        unsigned offset, size, align;
+        char name[1024];
+
+        if (sscanf(start, "%*d %1023s %x %*d %*d %x 2**%d", name, &size, &offset, &align) == 4) {
+            char *n = strstr(start, name);
+            n[strlen(name)] = 0;
+            addSection(n, input + offset, size, align);
+
+            // printf("section %s preprocessed\n", n);
        }
    }
-
-    int ic;
-    for (ic = 0; ic < nsections - 1; ic++)
-        sections[ic].len = sections[ic+1].istart - sections[ic].istart;
-    sections[ic].len = 0;
+    addSection("*ABS*", NULL, 0, 0);
+    addSection("*UND*", NULL, 0, 0);
 }

+void ElfLinker::preprocessSymbols(char *start, char *end) {
+    char *nextl;
+    for (nsymbols = 0; start < end; start = 1 + nextl) {
+        nextl = strchr(start, '\n');
+        assert(nextl != NULL);
+        *nextl = '\0'; // a record is a line

-Linker::~Linker()
-{
-    delete [] iloader;
-    delete [] oloader;
-    delete [] jumps;
-    delete [] sections;
-}
+        unsigned value, offset;
+        char section[1024];
+        char symbol[1024];

-
-void Linker::addSection(const char *sect)
-{
-    int ic;
-    while (*sect)
-    {
-        if (*sect == '+') // alignment
+        if (sscanf(start, "%x g *ABS* %x %1023s", &value, &offset, symbol) == 3) {
+            char *s = strstr(start, symbol);
+            s[strlen(symbol)] = 0;
+            addSymbol(s, "*ABS*", value);
+            assert(offset == 0);
+        }
+#if 0
+        else if (sscanf(start, "%x%*8c %1023s %*x %1023s",
+#else
+        // work around broken scanf() implementations
+        // http://bugs.winehq.org/show_bug.cgi?id=10401 (fixed in Wine 0.9.58)
+        else if (sscanf(start, "%x%*c%*c%*c%*c%*c%*c%*c%*c %1023s %*x %1023s",
+#endif
+                        &offset, section, symbol) == 3)
        {
-            if (sect[1] == '0')
-                align_hack = olen;
-            else
-            {
-                ic = (sect[1] & 0xf) + (sect[1] > '9' ? 9 : 0);
-                ic = (ic + (sect[2] & 0xf) + (sect[2] > '9' ? 9 : 0)
-                      - (olen - align_hack) % ic) % ic;
-                memset(oloader+olen,sect[3] == 'C' ? 0x90 : 0,ic);
-                olen += ic;
+                            char *s = strstr(start, symbol);
+                            s[strlen(symbol)] = 0;
+                            if (strcmp(section, "*UND*") == 0)
+                                offset = 0xdeaddead;
+                            assert(strcmp(section, "*ABS*") != 0);
+                            addSymbol(s, section, offset);
+                        }
+    }
+}
+
+void ElfLinker::preprocessRelocations(char *start, char *end) {
+    Section *section = NULL;
+    char *nextl;
+    for (nrelocations = 0; start < end; start = 1 + nextl) {
+        nextl = strchr(start, '\n');
+        assert(nextl != NULL);
+        *nextl = '\0'; // a record is a line
+
+        {
+            char sect[1024];
+            if (sscanf(start, "RELOCATION RECORDS FOR [%[^]]", sect) == 1)
+                section = findSection(sect);
+        }
+
+        unsigned offset;
+        char type[100];
+        char symbol[1024];
+
+        if (sscanf(start, "%x %99s %1023s", &offset, type, symbol) == 3) {
+            char *t = strstr(start, type);
+            t[strlen(type)] = 0;
+
+            upx_uint64_t add = 0;
+            char *p = strstr(symbol, "+0x");
+            if (p == NULL)
+                p = strstr(symbol, "-0x");
+            if (p) {
+                char sign = *p;
+                *p = 0; // terminate the symbol name
+                p += 3;
+                assert(strlen(p) == 8 || strlen(p) == 16);
+#if (ACC_CC_MSC && (_MSC_VER < 1800))
+                unsigned a = 0, b = 0;
+                if (sscanf(p, "%08x%08x", &a, &b) == 2)
+                    add = ((upx_uint64_t) a << 32) | b;
+                else
+                    add = a;
+#else
+                char *endptr = NULL;
+                add = strtoull(p, &endptr, 16);
+                assert(endptr && *endptr == '\0');
+#endif
+                if (sign == '-')
+                    add = 0 - add;
+            }
+
+            if (section) {
+                addRelocation(section->name, offset, t, symbol, add);
+                // printf("relocation %s %s %x %llu preprocessed\n", section->name, symbol, offset,
+                // (unsigned long long) add);
            }
        }
-        else
+    }
+}
+
+ElfLinker::Section *ElfLinker::findSection(const char *name, bool fatal) const {
+    for (unsigned ic = 0; ic < nsections; ic++)
+        if (strcmp(sections[ic]->name, name) == 0)
+            return sections[ic];
+    if (fatal)
+        internal_error("unknown section %s\n", name);
+    return NULL;
+}
+
+ElfLinker::Symbol *ElfLinker::findSymbol(const char *name, bool fatal) const {
+    for (unsigned ic = 0; ic < nsymbols; ic++)
+        if (strcmp(symbols[ic]->name, name) == 0)
+            return symbols[ic];
+    if (fatal)
+        internal_error("unknown symbol %s\n", name);
+    return NULL;
+}
+
+ElfLinker::Section *ElfLinker::addSection(const char *sname, const void *sdata, int slen,
+                                          unsigned p2align) {
+    // printf("addSection: %s len=%d align=%d\n", sname, slen, p2align);
+    if (update_capacity(nsections, &nsections_capacity))
+        sections =
+            static_cast<Section **>(realloc(sections, nsections_capacity * sizeof(Section *)));
+    assert(sections);
+    assert(sname);
+    assert(sname[0]);
+    assert(sname[strlen(sname) - 1] != ':');
+    assert(findSection(sname, false) == NULL);
+    Section *sec = new Section(sname, sdata, slen, p2align);
+    sections[nsections++] = sec;
+    return sec;
+}
+
+ElfLinker::Symbol *ElfLinker::addSymbol(const char *name, const char *section,
+                                        upx_uint64_t offset) {
+    // printf("addSymbol: %s %s 0x%x\n", name, section, offset);
+    if (update_capacity(nsymbols, &nsymbols_capacity))
+        symbols = static_cast<Symbol **>(realloc(symbols, nsymbols_capacity * sizeof(Symbol *)));
+    assert(symbols != NULL);
+    assert(name);
+    assert(name[0]);
+    assert(name[strlen(name) - 1] != ':');
+    assert(findSymbol(name, false) == NULL);
+    Symbol *sym = new Symbol(name, findSection(section), offset);
+    symbols[nsymbols++] = sym;
+    return sym;
+}
+
+ElfLinker::Relocation *ElfLinker::addRelocation(const char *section, unsigned off, const char *type,
+                                                const char *symbol, upx_uint64_t add) {
+    if (update_capacity(nrelocations, &nrelocations_capacity))
+        relocations = static_cast<Relocation **>(
+            realloc(relocations, (nrelocations_capacity) * sizeof(Relocation *)));
+    assert(relocations != NULL);
+    Relocation *rel = new Relocation(findSection(section), off, type, findSymbol(symbol), add);
+    relocations[nrelocations++] = rel;
+    return rel;
+}
+
+#if 0
+void ElfLinker::setLoaderAlignOffset(int phase)
+{
+    //assert(phase & 0);
+    printf("\nFIXME: ElfLinker::setLoaderAlignOffset %d\n", phase);
+}
+#endif
+
+int ElfLinker::addLoader(const char *sname) {
+    assert(sname != NULL);
+    if (!sname[0])
+        return outputlen;
+
+    char *begin = strdup(sname);
+    char *end = begin + strlen(begin);
+    for (char *sect = begin; sect < end;) {
+        for (char *tokend = sect; *tokend; tokend++)
+            if (*tokend == ' ' || *tokend == ',') {
+                *tokend = 0;
+                break;
+            }
+
+        if (sect[0] == '+') // alignment
        {
-            for (ic = 0; ic < nsections; ic++)
-                if (memcmp(sect,sections[ic].name,8) == 0)
-                {
-                    memcpy(oloader+olen,iloader+sections[ic].istart,sections[ic].len);
-                    sections[ic].ostart = olen;
-                    olen += sections[ic].len;
-                    break;
+            assert(tail);
+            unsigned l = hex(sect[2]) - tail->offset - tail->size;
+            unsigned m = hex(sect[1]);
+            if (m) {
+                l %= hex(sect[1]);
+            }
+            if (l) {
+                if (sect[3] == 'D')
+                    alignData(l);
+                else
+                    alignCode(l);
+                tail->size += l;
+            }
+        } else {
+            Section *section = findSection(sect);
+            if (section->p2align) {
+                assert(tail);
+                assert(tail != section);
+                // .p2align must be < 32
+                unsigned const v = ~0u << section->p2align;
+                if (unsigned const l = ~v & (0u - (unsigned) (tail->offset + tail->size))) {
+                    alignCode(l);
+                    tail->size += l;
                }
-            //printf("%8.8s",section);
-            assert(ic!=nsections);
+            }
+            memcpy(output + outputlen, section->input, section->size);
+            section->output = output + outputlen;
+            // printf("section added: 0x%04x %3d %s\n", outputlen, section->size, section->name);
+            outputlen += section->size;
+
+            if (head) {
+                tail->next = section;
+                section->offset = tail->offset + tail->size;
+            } else
+                head = section;
+            tail = section;
        }
-        sect += 8;
+        sect += strlen(sect) + 1;
+    }
+    free(begin);
+    return outputlen;
+}
+
+void ElfLinker::addLoader(const char *s, va_list ap) {
+    while (s != NULL) {
+        addLoader(s);
+        s = va_arg(ap, const char *);
    }
 }

-
-void Linker::addSection(const char *sname, const void *sdata, unsigned len)
-{
-    // add a new section - can be used for adding stuff like ident or header
-    memcpy(sections[nsections].name,sname,8);
-    sections[nsections].istart = ilen;
-    sections[nsections].len = len;
-    sections[nsections++].ostart = olen;
-    assert(nsections < 200);
-    memcpy(iloader+ilen,sdata,len);
-    ilen += len;
+void __acc_cdecl_va ElfLinker::addLoaderVA(const char *s, ...) {
+    va_list ap;
+    va_start(ap, s);
+    addLoader(s, ap);
+    va_end(ap);
 }

+int ElfLinker::getSection(const char *sname, int *slen) const {
+    const Section *section = findSection(sname);
+    if (slen)
+        *slen = section->size;
+    return (int) (section->output - output);
+}

-const char *Linker::getLoader(int *llen)
-{
-    if (!frozen)
+int ElfLinker::getSectionSize(const char *sname) const {
+    const Section *section = findSection(sname);
+    return section->size;
+}
+
+upx_byte *ElfLinker::getLoader(int *llen) const {
+    if (llen)
+        *llen = outputlen;
+    return output;
+}
+
+void ElfLinker::relocate() {
+    assert(!reloc_done);
+    reloc_done = true;
+    for (unsigned ic = 0; ic < nrelocations; ic++) {
+        const Relocation *rel = relocations[ic];
+        upx_uint64_t value = 0;
+
+        if (rel->section->output == NULL)
+            continue;
+        if (strcmp(rel->value->section->name, "*ABS*") == 0) {
+            value = rel->value->offset;
+        } else if (strcmp(rel->value->section->name, "*UND*") == 0 &&
+                   rel->value->offset == 0xdeaddead)
+            internal_error("undefined symbol '%s' referenced\n", rel->value->name);
+        else if (rel->value->section->output == NULL)
+            internal_error("can not apply reloc '%s:%x' without section '%s'\n", rel->section->name,
+                           rel->offset, rel->value->section->name);
+        else {
+            value = rel->value->section->offset + rel->value->offset + rel->add;
+        }
+        upx_byte *location = rel->section->output + rel->offset;
+        // printf("%-28s %-28s %-10s %#16llx %#16llx\n", rel->section->name, rel->value->name,
+        // rel->type, (long long) value, (long long) value - rel->section->offset - rel->offset);
+        // printf("  %llx %d %llx %d %llx : %d\n", (long long) value,
+        // (int)rel->value->section->offset,
+        // rel->value->offset, rel->offset, (long long) rel->add, *location);
+        relocate1(rel, location, value, rel->type);
+    }
+}
+
+void ElfLinker::defineSymbol(const char *name, upx_uint64_t value) {
+    Symbol *symbol = findSymbol(name);
+    if (strcmp(symbol->section->name, "*ABS*") == 0)
+        internal_error("defineSymbol: symbol '%s' is *ABS*\n", name);
+    else if (strcmp(symbol->section->name, "*UND*") == 0) // for undefined symbols
+        symbol->offset = value;
+    else if (strcmp(symbol->section->name, name) == 0) // for sections
    {
-        int ic,jc,kc;
-        for (ic = 0; ic < njumps; ic++)
-        {
-            for (jc = 0; jc < nsections-1; jc++)
-                if (jumps[ic].pos >= sections[jc].istart
-                    && jumps[ic].pos < sections[jc+1].istart)
-                    break;
-            assert(jc!=nsections-1);
-            if (sections[jc].ostart < 0)
-                continue;
-
-            for (kc = 0; kc < nsections-1; kc++)
-                if (memcmp(jumps[ic].tsect,sections[kc].name,8) == 0)
-                    break;
-            assert(kc!=nsections-1);
-
-            int offs = sections[kc].ostart+jumps[ic].toffs -
-                (jumps[ic].pos+jumps[ic].len -
-                 sections[jc].istart+sections[jc].ostart);
-
-            if (jumps[ic].len == 1)
-                assert(-128 <= offs && offs <= 127);
-
-            set_le32(&offs,offs);
-            memcpy(oloader+sections[jc].ostart+jumps[ic].pos-sections[jc].istart,&offs,jumps[ic].len);
+        for (Section *section = symbol->section; section; section = section->next) {
+            assert(section->offset < value);
+            section->offset = value;
+            value += section->size;
        }
-        frozen=1;
+    } else
+        internal_error("defineSymbol: symbol '%s' already defined\n", name);
+}
+
+// debugging support
+void ElfLinker::dumpSymbol(const Symbol *symbol, unsigned flags, FILE *fp) const {
+    if ((flags & 1) && symbol->section->output == NULL)
+        return;
+    char d0[16 + 1], d1[16 + 1];
+    upx_snprintf(d0, sizeof(d0), "%016llx", (upx_uint64_t) symbol->offset);
+    upx_snprintf(d1, sizeof(d1), "%016llx", (upx_uint64_t) symbol->section->offset);
+    fprintf(fp, "%-28s 0x%-16s | %-28s 0x%-16s\n", symbol->name, d0, symbol->section->name, d1);
+}
+void ElfLinker::dumpSymbols(unsigned flags, FILE *fp) const {
+    if (fp == NULL)
+        fp = stdout;
+    if ((flags & 2) == 0) {
+        // default: dump symbols in used section order
+        for (const Section *section = head; section; section = section->next) {
+            char d1[16 + 1];
+            upx_snprintf(d1, sizeof(d1), "%016llx", (upx_uint64_t) section->offset);
+            fprintf(fp, "%-42s%-28s 0x%-16s\n", "", section->name, d1);
+            for (unsigned ic = 0; ic < nsymbols; ic++) {
+                const Symbol *symbol = symbols[ic];
+                if (symbol->section == section && strcmp(symbol->name, section->name) != 0)
+                    dumpSymbol(symbol, flags, fp);
+            }
+        }
+    } else {
+        // dump all symbols
+        for (unsigned ic = 0; ic < nsymbols; ic++)
+            dumpSymbol(symbols[ic], flags, fp);
    }
-    if (llen) *llen = olen;
-    return oloader;
 }

+upx_uint64_t ElfLinker::getSymbolOffset(const char *name) const {
+    const Symbol *symbol = findSymbol(name);
+    if (symbol->section->output == NULL)
+        return 0xdeaddead;
+    return symbol->section->offset + symbol->offset;
+}

-int Linker::getSection(const char *name, int *slen) const
+void ElfLinker::alignWithByte(unsigned len, unsigned char b) {
+    memset(output + outputlen, b, len);
+    outputlen += len;
+}
+
+void ElfLinker::relocate1(const Relocation *rel, upx_byte *, upx_uint64_t, const char *) {
+    internal_error("unknown relocation type '%s\n'", rel->type);
+}
+
+/*************************************************************************
+// ElfLinker arch subclasses
+// FIXME: add more displacment overflow checks
+// FIXME: add support for our special "ignore_reloc_overflow" section
+**************************************************************************/
+
+#if 0 // FIXME
+static void check8(const Relocation *rel, const upx_byte *location, int v, int d)
 {
-    if (!frozen)
-        return -1;
-    for (int ic = 0; ic < nsections; ic++)
-        if (memcmp(name,sections[ic].name,8) == 0)
-        {
-            if (slen)
-                *slen = sections[ic].len;
-            return sections[ic].ostart;
-        }
-    return -1;
+    if (v < -128 || v > 127)
+        internal_error("value out of range (%d) in reloc %s:%x\n",
+                       v, rel->section->name, rel->offset);
+    if (d < -128 || d > 127)
+        internal_error("displacement target out of range (%d) in reloc %s:%x\n",
+                       v, rel->section->name, rel->offset);
+}
+#endif
+
+void ElfLinkerAMD64::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                               const char *type) {
+    if (strncmp(type, "R_X86_64_", 9))
+        return super::relocate1(rel, location, value, type);
+    type += 9;
+
+    bool range_check = false;
+    if (strncmp(type, "PC", 2) == 0) {
+        value -= rel->section->offset + rel->offset;
+        type += 2;
+        range_check = true;
+    }
+
+    if (strcmp(type, "8") == 0) {
+        int displ = (signed char) *location + (int) value;
+        if (range_check && (displ < -128 || displ > 127))
+            internal_error("target out of range (%d) in reloc %s:%x\n", displ, rel->section->name,
+                           rel->offset);
+        *location += value;
+    } else if (strcmp(type, "16") == 0)
+        set_le16(location, get_le16(location) + value);
+    else if (strncmp(type, "32", 2) == 0) // for "32" and "32S"
+        set_le32(location, get_le32(location) + value);
+    else if (strcmp(type, "64") == 0)
+        set_le64(location, get_le64(location) + value);
+    else
+        super::relocate1(rel, location, value, type);
 }

+void ElfLinkerARM64::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                               const char *type) {
+    if (strncmp(type, "R_AARCH64_", 10))
+        return super::relocate1(rel, location, value, type);
+    type += 10;

-/*
-vi:ts=4:et
-*/
+    if (!strncmp(type, "PREL", 4)) {
+        value -= rel->section->offset + rel->offset;
+        type += 4;

+        if (!strcmp(type, "16"))
+            set_le16(location, get_le16(location) + value);
+        else if (!strncmp(type, "32", 2)) // for "32" and "32S"
+            set_le32(location, get_le32(location) + value);
+        else if (!strcmp(type, "64"))
+            set_le64(location, get_le64(location) + value);
+    } else if (!strcmp(type, "ABS32")) {
+        set_le32(location, get_le32(location) + value);
+    } else if (!strcmp(type, "ABS64")) {
+        set_le64(location, get_le64(location) + value);
+    } else if (!strcmp(type, "CONDBR19")) {
+        value -= rel->section->offset + rel->offset;
+        upx_uint32_t const m19 = ~(~0u << 19);
+        upx_uint32_t w = get_le32(location);
+        set_le32(location, (w & ~(m19 << 5)) | ((((w >> 5) + (value >> 2)) & m19) << 5));
+    } else
+        super::relocate1(rel, location, value, type);
+}
+
+void ElfLinkerArmBE::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                               const char *type) {
+    if (strcmp(type, "R_ARM_PC24") == 0) {
+        value -= rel->section->offset + rel->offset;
+        set_be24(1 + location, get_be24(1 + location) + value / 4);
+    } else if (strcmp(type, "R_ARM_ABS32") == 0) {
+        set_be32(location, get_be32(location) + value);
+    } else if (strcmp(type, "R_ARM_THM_CALL") == 0 || strcmp(type, "R_ARM_THM_XPC22") == 0 ||
+               strcmp(type, "R_ARM_THM_PC22") == 0) {
+        value -= rel->section->offset + rel->offset;
+        value += ((get_be16(location) & 0x7ff) << 12);
+        value += (get_be16(location + 2) & 0x7ff) << 1;
+
+        set_be16(location, 0xf000 + ((value >> 12) & 0x7ff));
+        set_be16(location + 2, 0xf800 + ((value >> 1) & 0x7ff));
+
+        //(b, 0xF000 + ((v - 1) / 2) * 0x10000);
+        // set_be32(location, get_be32(location) + value / 4);
+    } else if (0 == strcmp("R_ARM_ABS8", type)) {
+        *location += value;
+    } else
+        super::relocate1(rel, location, value, type);
+}
+
+void ElfLinkerArmLE::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                               const char *type) {
+    if (strcmp(type, "R_ARM_PC24") == 0) {
+        value -= rel->section->offset + rel->offset;
+        set_le24(location, get_le24(location) + value / 4);
+    } else if (strcmp(type, "R_ARM_ABS32") == 0) {
+        set_le32(location, get_le32(location) + value);
+    } else if (strcmp(type, "R_ARM_THM_CALL") == 0 || strcmp(type, "R_ARM_THM_XPC22") == 0 ||
+               strcmp(type, "R_ARM_THM_PC22") == 0) {
+        value -= rel->section->offset + rel->offset;
+        value += ((get_le16(location) & 0x7ff) << 12);
+        value += (get_le16(location + 2) & 0x7ff) << 1;
+
+        set_le16(location, 0xf000 + ((value >> 12) & 0x7ff));
+        set_le16(location + 2, 0xf800 + ((value >> 1) & 0x7ff));
+
+        //(b, 0xF000 + ((v - 1) / 2) * 0x10000);
+        // set_le32(location, get_le32(location) + value / 4);
+    } else if (0 == strcmp("R_ARM_ABS8", type)) {
+        *location += value;
+    } else
+        super::relocate1(rel, location, value, type);
+}
+
+void ElfLinkerArm64LE::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                                 const char *type) {
+    if (strcmp(type, "R_AARCH64_CALL26") == 0) {
+        value -= rel->section->offset + rel->offset;
+        set_le24(location, get_le24(location) + value / 4); // FIXME set_le26
+    } else if (strcmp(type, "R_AARCH64_ABS32") == 0) {
+        set_le32(location, get_le32(location) + value);
+    } else
+        super::relocate1(rel, location, value, type);
+}
+
+void ElfLinkerM68k::alignCode(unsigned len) {
+    assert((len & 1) == 0);
+    assert((outputlen & 1) == 0);
+    for (unsigned i = 0; i < len; i += 2)
+        set_be16(output + outputlen + i, 0x4e71); // "nop"
+    outputlen += len;
+}
+
+void ElfLinkerM68k::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                              const char *type) {
+    if (strncmp(type, "R_68K_", 6))
+        return super::relocate1(rel, location, value, type);
+    type += 6;
+
+    if (strncmp(type, "PC", 2) == 0) {
+        value -= rel->section->offset + rel->offset;
+        type += 2;
+    }
+    if (strcmp(type, "8") == 0) {
+        *location += value;
+    } else if (strcmp(type, "16") == 0) {
+        set_be16(location, get_be16(location) + value);
+    } else if (strcmp(type, "32") == 0) {
+        set_be32(location, get_be32(location) + value);
+    } else
+        super::relocate1(rel, location, value, type);
+}
+
+void ElfLinkerMipsBE::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                                const char *type) {
+#define MIPS_HI(a) (((a) >> 16) + (((a) &0x8000) >> 15))
+#define MIPS_LO(a) ((a) &0xffff)
+#define MIPS_PC16(a) ((a) >> 2)
+#define MIPS_PC26(a) (((a) &0x0fffffff) >> 2)
+
+    if (strcmp(type, "R_MIPS_HI16") == 0)
+        set_be16(2 + location, get_be16(2 + location) + MIPS_HI(value));
+    else if (strcmp(type, "R_MIPS_LO16") == 0)
+        set_be16(2 + location, get_be16(2 + location) + MIPS_LO(value));
+    else if (strcmp(type, "R_MIPS_PC16") == 0) {
+        value -= rel->section->offset + rel->offset;
+        set_be16(2 + location, get_be16(2 + location) + MIPS_PC16(value));
+    } else if (strcmp(type, "R_MIPS_26") == 0)
+        set_be32(location, get_be32(location) + MIPS_PC26(value));
+    else if (strcmp(type, "R_MIPS_32") == 0)
+        set_be32(location, get_be32(location) + value);
+    else
+        super::relocate1(rel, location, value, type);
+
+#undef MIPS_HI
+#undef MIPS_LO
+#undef MIPS_PC16
+#undef MIPS_PC26
+}
+
+void ElfLinkerMipsLE::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                                const char *type) {
+#define MIPS_HI(a) (((a) >> 16) + (((a) &0x8000) >> 15))
+#define MIPS_LO(a) ((a) &0xffff)
+#define MIPS_PC16(a) ((a) >> 2)
+#define MIPS_PC26(a) (((a) &0x0fffffff) >> 2)
+
+    if (strcmp(type, "R_MIPS_HI16") == 0)
+        set_le16(location, get_le16(location) + MIPS_HI(value));
+    else if (strcmp(type, "R_MIPS_LO16") == 0)
+        set_le16(location, get_le16(location) + MIPS_LO(value));
+    else if (strcmp(type, "R_MIPS_PC16") == 0) {
+        value -= rel->section->offset + rel->offset;
+        set_le16(location, get_le16(location) + MIPS_PC16(value));
+    } else if (strcmp(type, "R_MIPS_26") == 0)
+        set_le32(location, get_le32(location) + MIPS_PC26(value));
+    else if (strcmp(type, "R_MIPS_32") == 0)
+        set_le32(location, get_le32(location) + value);
+    else
+        super::relocate1(rel, location, value, type);
+
+#undef MIPS_HI
+#undef MIPS_LO
+#undef MIPS_PC16
+#undef MIPS_PC26
+}
+
+void ElfLinkerPpc32::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                               const char *type) {
+    if (strncmp(type, "R_PPC_", 6))
+        return super::relocate1(rel, location, value, type);
+    type += 6;
+
+    if (strcmp(type, "ADDR32") == 0) {
+        set_be32(location, get_be32(location) + value);
+        return;
+    }
+
+    if (strncmp(type, "REL", 3) == 0) {
+        value -= rel->section->offset + rel->offset;
+        type += 3;
+    }
+
+    // FIXME: more relocs
+
+    // Note that original (*location).displ is ignored.
+    if (strcmp(type, "24") == 0) {
+        if (3 & value)
+            internal_error("unaligned word diplacement");
+        // FIXME: displacment overflow?
+        set_be32(location, (0xfc000003 & get_be32(location)) + (0x03fffffc & value));
+    } else if (strcmp(type, "14") == 0) {
+        if (3 & value)
+            internal_error("unaligned word diplacement");
+        // FIXME: displacment overflow?
+        set_be32(location, (0xffff0003 & get_be32(location)) + (0x0000fffc & value));
+    } else
+        super::relocate1(rel, location, value, type);
+}
+
+void ElfLinkerPpc64le::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                                 const char *type) {
+    if (strncmp(type, "R_PPC64_REL", 11))
+        return super::relocate1(rel, location, value, type);
+    type += 11;
+
+    bool range_check = false;
+    if (strncmp(type, "PC", 2) == 0) {
+        type += 2;
+        range_check = true;
+    }
+
+    /* value will hold relative displacement */
+    value -= rel->section->offset + rel->offset;
+
+    if (strcmp(type, "8") == 0) {
+        int displ = (signed char) *location + (int) value;
+        if (range_check && (displ < -128 || displ > 127))
+            internal_error("target out of range (%d) in reloc %s:%x\n", displ, rel->section->name,
+                           rel->offset);
+        *location += value;
+    } else if (strncmp(type, "14", 2) == 0) // for "32" and "32S"
+        set_le16(location, get_le16(location) + value);
+    else if (strcmp(type, "16") == 0)
+        set_le16(location, get_le16(location) + value);
+    else if (strncmp(type, "24", 2) == 0) // for "32" and "32S"
+        set_le24(location, get_le24(location) + value);
+    else if (strncmp(type, "32", 2) == 0) // for "32" and "32S"
+        set_le32(location, get_le32(location) + value);
+    else if (strcmp(type, "64") == 0)
+        set_le64(location, get_le64(location) + value);
+    else
+        super::relocate1(rel, location, value, type);
+}
+
+void ElfLinkerX86::relocate1(const Relocation *rel, upx_byte *location, upx_uint64_t value,
+                             const char *type) {
+    if (strncmp(type, "R_386_", 6))
+        return super::relocate1(rel, location, value, type);
+    type += 6;
+
+    bool range_check = false;
+    if (strncmp(type, "PC", 2) == 0) {
+        value -= rel->section->offset + rel->offset;
+        type += 2;
+        range_check = true;
+    }
+
+    if (strcmp(type, "8") == 0) {
+        int displ = (signed char) *location + (int) value;
+        if (range_check && (displ < -128 || displ > 127))
+            internal_error("target out of range (%d,%d,%d) in reloc %s:%x\n", displ, *location,
+                           value, rel->section->name, rel->offset);
+        *location += value;
+    } else if (strcmp(type, "16") == 0)
+        set_le16(location, get_le16(location) + value);
+    else if (strcmp(type, "32") == 0)
+        set_le32(location, get_le32(location) + value);
+    else
+        super::relocate1(rel, location, value, type);
+}
+
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,51 +21,240 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */

-
 #ifndef __UPX_LINKER_H
-#define __UPX_LINKER_H
+#define __UPX_LINKER_H 1

+/*************************************************************************
+// ElfLinker
+**************************************************************************/
+
+class ElfLinker : private noncopyable {
+    friend class Packer;

-class Linker
-{
 public:
-    Linker(const void *pdata, int plen, int pinfo);
-    ~Linker();
-    void addSection(const char *sect);
-    void addSection(const char *sname, const void *sdata, unsigned len);
-    const char *getLoader(int *llen);
-    int getSection(const char *name, int *slen) const;
+    const N_BELE_RTP::AbstractPolicy *bele; // target endianness
+protected:
+    struct Section;
+    struct Symbol;
+    struct Relocation;

-private:
-    struct section;
-    struct jump;
+    upx_byte *input;
+    int inputlen;
+    upx_byte *output;
+    int outputlen;

-    char     *iloader, *oloader;
-    int      ilen, olen;
-    int      info;
-    jump     *jumps;
-    int      njumps;
-    section  *sections;
-    int      nsections;
-    int      frozen;
-    int      align_hack;
+    Section *head;
+    Section *tail;

-private:
-    // disable copy and assignment
-    Linker(Linker const &); // {}
-    Linker& operator= (Linker const &); // { return *this; }
+    Section **sections;
+    Symbol **symbols;
+    Relocation **relocations;
+
+    unsigned nsections;
+    unsigned nsections_capacity;
+    unsigned nsymbols;
+    unsigned nsymbols_capacity;
+    unsigned nrelocations;
+    unsigned nrelocations_capacity;
+
+    bool reloc_done;
+
+protected:
+    void preprocessSections(char *start, char *end);
+    void preprocessSymbols(char *start, char *end);
+    void preprocessRelocations(char *start, char *end);
+    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, upx_uint64_t offset);
+    Relocation *addRelocation(const char *section, unsigned off, const char *type,
+                              const char *symbol, upx_uint64_t add);
+
+public:
+    ElfLinker();
+    virtual ~ElfLinker();
+
+    virtual void init(const void *pdata, int plen);
+    // virtual void setLoaderAlignOffset(int phase);
+    virtual int addLoader(const char *sname);
+    void addLoader(const char *s, va_list ap);
+#if 1 && (ACC_CC_CLANG || (ACC_CC_GNUC >= 0x040100))
+    void __acc_cdecl_va addLoaderVA(const char *s, ...) __attribute__((__sentinel__));
+#else
+    void __acc_cdecl_va addLoaderVA(const char *s, ...);
+#endif
+    virtual Section *addSection(const char *sname, const void *sdata, int slen, unsigned p2align);
+    virtual int getSection(const char *sname, int *slen = NULL) const;
+    virtual int getSectionSize(const char *sname) const;
+    virtual upx_byte *getLoader(int *llen = NULL) const;
+    virtual void defineSymbol(const char *name, upx_uint64_t value);
+    virtual upx_uint64_t getSymbolOffset(const char *) const;
+
+    virtual void dumpSymbol(const Symbol *, unsigned flags, FILE *fp) const;
+    virtual void dumpSymbols(unsigned flags = 0, FILE *fp = NULL) const;
+
+    void alignWithByte(unsigned len, unsigned char b);
+    virtual void alignCode(unsigned len) { alignWithByte(len, 0); }
+    virtual void alignData(unsigned len) { alignWithByte(len, 0); }
+
+protected:
+    virtual 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;
+    void *input;
+    upx_byte *output;
+    unsigned size;
+    upx_uint64_t offset;
+    unsigned p2align; // log2
+    Section *next;

+    Section(const char *n, const void *i, unsigned s, unsigned a = 0);
+    ~Section();
+};
+
+struct ElfLinker::Symbol : private noncopyable {
+    char *name;
+    Section *section;
+    upx_uint64_t offset;
+
+    Symbol(const char *n, Section *s, upx_uint64_t o);
+    ~Symbol();
+};
+
+struct ElfLinker::Relocation : private noncopyable {
+    const Section *section;
+    unsigned offset;
+    const char *type;
+    const Symbol *value;
+    upx_uint64_t add; // used in .rela relocations
+
+    Relocation(const Section *s, unsigned o, const char *t, const Symbol *v, upx_uint64_t a);
+};
+
+/*************************************************************************
+// ElfLinker arch subclasses
+**************************************************************************/
+
+class ElfLinkerAMD64 : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void alignCode(unsigned len) { alignWithByte(len, 0x90); }
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};
+
+class ElfLinkerARM64 : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void alignCode(unsigned len) { alignWithByte(len, 0x90); }
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};
+
+class ElfLinkerArmBE : public ElfLinker {
+    typedef ElfLinker super;
+
+public:
+    ElfLinkerArmBE() { bele = &N_BELE_RTP::be_policy; }
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};
+
+class ElfLinkerArmLE : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};
+
+class ElfLinkerArm64LE : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};
+
+class ElfLinkerM68k : public ElfLinker {
+    typedef ElfLinker super;
+
+public:
+    ElfLinkerM68k() { bele = &N_BELE_RTP::be_policy; }
+
+protected:
+    virtual void alignCode(unsigned len);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};
+
+class ElfLinkerMipsBE : 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);
+};
+
+class ElfLinkerMipsLE : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};
+
+class ElfLinkerPpc32 : 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);
+};
+
+class ElfLinkerPpc64le : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};
+
+class ElfLinkerX86 : public ElfLinker {
+    typedef ElfLinker super;
+
+protected:
+    virtual void alignCode(unsigned len) { alignWithByte(len, 0x90); }
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
+};

 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,8 +21,8 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


@@ -30,92 +30,172 @@
 #include "mem.h"


+/*************************************************************************
+// bool use_simple_mcheck()
+**************************************************************************/
+
+#if defined(__SANITIZE_ADDRESS__)
+__acc_static_forceinline bool use_simple_mcheck() { return false; }
+#elif (WITH_VALGRIND) && defined(RUNNING_ON_VALGRIND)
+static int use_simple_mcheck_flag = -1;
+__acc_static_noinline void use_simple_mcheck_init()
+{
+    use_simple_mcheck_flag = 1;
+    if (RUNNING_ON_VALGRIND) {
+        use_simple_mcheck_flag = 0;
+        //fprintf(stderr, "upx: detected RUNNING_ON_VALGRIND\n");
+    }
+}
+__acc_static_forceinline bool use_simple_mcheck()
+{
+    if __acc_unlikely(use_simple_mcheck_flag < 0)
+        use_simple_mcheck_init();
+    return (bool) use_simple_mcheck_flag;
+}
+#else
+__acc_static_forceinline bool use_simple_mcheck() { return true; }
+#endif
+
+
 /*************************************************************************
 //
 **************************************************************************/

-MemBuffer::MemBuffer(unsigned size) :
-    ptr(NULL), alloc_ptr(NULL), alloc_size(0)
+MemBuffer::MemBuffer(upx_uint64_t size) :
+    b(NULL), b_size(0)
 {
-    if (size > 0)
-        alloc(size, 0);
+    alloc(size);
 }


 MemBuffer::~MemBuffer()
 {
-    this->free();
+    this->dealloc();
 }

-
-void MemBuffer::free()
+void MemBuffer::dealloc()
 {
-    if (alloc_ptr)
-        ::free(alloc_ptr);
-    alloc_ptr = ptr = NULL;
-    alloc_size = 0;
-}
-
-
-unsigned MemBuffer::getSize() const
-{
-    if (!alloc_ptr)
-        return 0;
-    unsigned size = alloc_size - (ptr - alloc_ptr);
-    assert((int)size > 0);
-    return size;
-}
-
-
-void MemBuffer::alloc(unsigned size, unsigned base_offset)
-{
-#if 0
-    this->free();
-#else
-    // don't automaticlly free a used buffer
-#endif
-    assert(alloc_ptr == NULL);
-    assert((int)size > 0);
-    size = base_offset + size;
-    alloc_ptr = (unsigned char *) malloc(size);
-    if (!alloc_ptr)
+    if (b != NULL)
    {
-        throwCantPack("out of memory");
-        //exit(1);
+        checkState();
+        if (use_simple_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;
    }
-    alloc_size = size;
-    ptr = alloc_ptr + base_offset;
+    else
+        assert(b_size == 0);
 }


-void MemBuffer::alloc(unsigned size)
+unsigned MemBuffer::getSizeForCompression(unsigned uncompressed_size, unsigned extra)
 {
-    alloc(size, 0);
+    size_t bytes = mem_size(1, uncompressed_size, extra);
+    bytes += uncompressed_size/8 + 256;
+    return ACC_ICONV(unsigned, bytes);
+}
+
+unsigned MemBuffer::getSizeForUncompression(unsigned uncompressed_size, unsigned extra)
+{
+    size_t bytes = mem_size(1, uncompressed_size, extra);
+    // INFO: 3 bytes are the allowed overrun for the i386 asm_fast decompressors
+#if (ACC_ARCH_I386)
+    bytes += 3;
+#endif
+    return ACC_ICONV(unsigned, bytes);
 }


-void MemBuffer::allocForCompression(unsigned uncompressed_size)
+void MemBuffer::allocForCompression(unsigned uncompressed_size, unsigned extra)
 {
-    // Idea:
-    //   We allocate the buffer at an offset of 4096 so
-    //   that we could do an in-place decompression for
-    //   verifying our overlap_overhead at the end
-    //   of packing.
+    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) ((upx_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_simple_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(upx_uint64_t size)
+{
+    // NOTE: we don't automatically free a used buffer
+    assert(b == NULL);
+    assert(b_size == 0);
    //
-    // See Packer::verifyOverlappingDecompression().
+    assert(size > 0);
+    size_t bytes = mem_size(1, size, use_simple_mcheck() ? 32 : 0);
+    unsigned char *p = (unsigned char *) malloc(bytes);
+    if (!p)
+        throwOutOfMemoryException();
+    b_size = ACC_ICONV(unsigned, size);
+    if (use_simple_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 ;

-    alloc(uncompressed_size + uncompressed_size/8 + 256, MAX_OVERLAP_OVERHEAD);
+    //fill(0, b_size, (rand() & 0xff) | 1); // debug
 }

-
-void MemBuffer::allocForUncompression(unsigned uncompressed_size)
-{
-    //alloc(uncompressed_size + 3 + 512, 0);  // 512 safety bytes
-    alloc(uncompressed_size + 3, 0);  // 3 bytes for asm_fast decompresion
-}
-
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,13 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_MEM_H
-#define __UPX_MEM_H
+#define __UPX_MEM_H 1


 /*************************************************************************
@@ -37,47 +37,47 @@
 class MemBuffer
 {
 public:
-    MemBuffer(unsigned size=0);
+    MemBuffer() : b(NULL), b_size(0) { }
+    explicit MemBuffer(upx_uint64_t size);
    ~MemBuffer();

-    void alloc(unsigned size);
-    void allocForCompression(unsigned uncompressed_size);
-    void allocForUncompression(unsigned uncompressed_size);
+    static unsigned getSizeForCompression(unsigned uncompressed_size, unsigned extra=0);
+    static unsigned getSizeForUncompression(unsigned uncompressed_size, unsigned extra=0);

-    void free();
+    void alloc(upx_uint64_t size);
+    void allocForCompression(unsigned uncompressed_size, unsigned extra=0);
+    void allocForUncompression(unsigned uncompressed_size, unsigned extra=0);

-    const unsigned char *getBuf()     const { return ptr; }
-    unsigned getSize() const ;
+    void dealloc();

-    operator       unsigned char * ()       { return ptr; }
-    //operator const unsigned char * () const { return ptr; }
+    void checkState() const;

-    enum { MAX_OVERLAP_OVERHEAD = 4096 };
+    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:
-    void alloc(unsigned size, unsigned base_offset);
+    unsigned char *b;
+    unsigned b_size;

-    unsigned char *ptr;
-    unsigned char *alloc_ptr;
-    unsigned alloc_size;
+    static unsigned global_alloc_counter;

-private:
    // disable copy and assignment
-    MemBuffer(MemBuffer const &); // {}
-    MemBuffer& operator= (MemBuffer const &); // { return *this; }
+    MemBuffer(const MemBuffer &); // {}
+    MemBuffer& operator= (const MemBuffer &); // { return *this; }

    // disable dynamic allocation
-    static void *operator new (size_t); // {}
-    static void *operator new[] (size_t); // {}
-    //static void operator delete (void *) {}
-    //static void operator delete[] (void *) {}
+    DISABLE_NEW_DELETE
 };

-
 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,8 +21,8 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


@@ -57,7 +57,7 @@ void printClearLine(FILE *f)
    fflush(stdout); fflush(stderr);
    if (f == NULL)
        f = stdout;
-    con_fprintf(f,clear_line_msg);
+    con_fprintf(f, "%s", clear_line_msg);
    fflush(f);
    printSetNl(0);
 }
@@ -66,14 +66,13 @@ void printClearLine(FILE *f)
 static void pr_print(bool c, const char *msg)
 {
    if (c && !opt->to_stdout)
-        con_fprintf(stderr,msg);
+        con_fprintf(stderr, "%s", msg);
    else
-        fprintf(stderr,msg);
+        fprintf(stderr, "%s", msg);
 }

 static void pr_error(const char *iname, const char *msg, bool is_warning)
 {
-    set_ec(EXIT_ERROR);
    fflush(stdout); fflush(stderr);
    char buf[1024];
    buf[0] = 0;
@@ -89,7 +88,7 @@ static void pr_error(const char *iname, const char *msg, bool is_warning)
    // This hack is needed, otherwise error messages may get lost
    // when the cursor is not yet at the bottom of the screen.
    // At least I can use some colors then...
-    bool c = isatty(STDERR_FILENO) ? 1 : 0;
+    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);
@@ -104,23 +103,35 @@ static void pr_error(const char *iname, const char *msg, bool is_warning)
    fg = con_fg(stderr,fg);

    UNUSED(is_warning);
+    UNUSED(fg);
 }


 void printErr(const char *iname, const Throwable *e)
 {
    char buf[1024];
+    size_t l;

-    upx_snprintf(buf, sizeof(buf), "%s", prettyName(typeid(*e)));
-    if (e->getMsg())
-        upx_snprintf(buf+strlen(buf),sizeof(buf)-strlen(buf),": %s", e->getMsg());
-    if (e->getErrno())
-        upx_snprintf(buf+strlen(buf),sizeof(buf)-strlen(buf),": %s", strerror(e->getErrno()));
+    upx_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());
+    l = strlen(buf);
+    if (l < sizeof(buf) && e->getErrno()) {
+        upx_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
+        l = strlen(buf);
+        while (l-- > 0 && (buf[l] == '\n' || buf[l] == ' '))
+            buf[l] = 0;
+#endif
+    }
    pr_error(iname,buf,e->isWarning());
 }


-void printErr(const char *iname, const char *format, ...)
+void __acc_cdecl_va printErr(const char *iname, const char *format, ...)
 {
    va_list args;
    char buf[1024];
@@ -133,7 +144,7 @@ void printErr(const char *iname, const char *format, ...)
 }


-void printWarn(const char *iname, const char *format, ...)
+void __acc_cdecl_va printWarn(const char *iname, const char *format, ...)
 {
    va_list args;
    char buf[1024];
@@ -146,7 +157,7 @@ void printWarn(const char *iname, const char *format, ...)
 }


-void printUnhandledException(const char *iname, const exception *e)
+void printUnhandledException(const char *iname, const std::exception *e)
 {
    if (e)
        printErr(iname,"unhandled exception: %s\n", prettyName(e->what()));
@@ -190,7 +201,7 @@ void infoHeader()
    info_header = 0;
 }

-void infoHeader(const char *format, ...)
+void __acc_cdecl_va infoHeader(const char *format, ...)
 {
    if (opt->info_mode <= 0)
        return;
@@ -204,7 +215,7 @@ void infoHeader(const char *format, ...)
 }


-void info(const char *format, ...)
+void __acc_cdecl_va info(const char *format, ...)
 {
    if (opt->info_mode <= 0)
        return;
@@ -219,7 +230,7 @@ void info(const char *format, ...)
 }


-void infoWarning(const char *format, ...)
+void __acc_cdecl_va infoWarning(const char *format, ...)
 {
    if (opt->info_mode <= 0)
    {
@@ -242,8 +253,4 @@ void infoWriting(const char *what, long size)
    info("Writing %s: %ld bytes", what, size);
 }

-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -1,696 +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.  */
-
-
-#include "tailor.h"
-#ifndef EOF
-#include <stdio.h>
-#include <string.h>
-#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
-#define my_index                strchr
-#define my_strlen               strlen
-#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, **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;
-
-#if defined(DOSISH)
-      /* allow `--option#value' because you cannout assign a '='
-         to an environment variable under DOS command.com */
-      while (*s && *s != '=' && * s != '#')
-        s++;
-#else
-      while (*s && *s != '=')
-        s++;
-#endif
-
-      /* 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) == my_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",
-                     argv[0], argv[optind]);
-          nextchar += my_strlen (nextchar);
-          optind++;
-          return BAD_OPTION;
-        }
-      if (ambig && !exact)
-        {
-          if (opterr)
-            fprintf (stderr, "%s: option `%s' is ambiguous\n",
-                     argv[0], argv[optind]);
-          nextchar += my_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",
-                                 argv[0], pfound->name);
-                      else
-                        /* +option or -option */
-                        fprintf (stderr,
-                             "%s: option `%c%s' doesn't allow an argument\n",
-                             argv[0], argv[optind - 1][0], pfound->name);
-                    }
-                  nextchar += my_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",
-                             argv[0], pfound->name,
-                             (pfound->has_arg & 0x20) ? "=" : "");
-                  nextchar += my_strlen (nextchar);
-                  return optstring[0] == ':' ? ':' : BAD_OPTION;
-                }
-            }
-          nextchar += my_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 */
-          || my_index (optstring, *nextchar) == NULL)
-        {
-          if (opterr)
-            {
-              if (argv[optind][1] == '-')
-                /* --option */
-                fprintf (stderr, "%s: unrecognized option `--%s'\n",
-                         argv[0], nextchar);
-              else
-                /* +option or -option */
-                fprintf (stderr, "%s: unrecognized option `%c%s'\n",
-                         argv[0], argv[optind][0], nextchar);
-            }
-          nextchar = empty_string;
-          optind++;
-          return BAD_OPTION;
-        }
-        ambig = ambig;
-    }
-
-  /* Look at and handle the next option-character.  */
-
-  {
-    char c = *nextchar++;
-    const char *temp = my_index (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",
-                       argv[0], c);
-            else
-              fprintf (stderr, "%s: unrecognized option `-%c'\n", argv[0], c);
-#else
-            /* 1003.2 specifies the format of this message.  */
-            fprintf (stderr, "%s: illegal option -- %c\n", 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",
-                             argv[0], c);
-#else
-                    /* 1003.2 specifies the format of this message.  */
-                    fprintf (stderr, "%s: option requires an argument -- %c\n",
-                             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 */
@@ -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 /* _GETOPT_H */
@@ -0,0 +1,171 @@
+/* options.h --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   All Rights Reserved.
+
+   UPX and the UCL library are free software; you can redistribute them
+   and/or modify them under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
+ */
+
+
+#ifndef __UPX_OPTIONS_H
+#define __UPX_OPTIONS_H 1
+
+
+/*************************************************************************
+// globals
+**************************************************************************/
+
+// options - command
+enum {
+    CMD_NONE,
+    CMD_COMPRESS, CMD_DECOMPRESS, CMD_TEST, CMD_LIST, CMD_FILEINFO,
+    CMD_HELP, CMD_LICENSE, CMD_VERSION
+};
+
+
+struct options_t {
+    int cmd;
+
+    // mp (meta) options
+    int mp_compress_task;
+    bool mp_query_format;
+    bool mp_query_num_tasks;
+
+    // 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;
+    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;
+    int console;
+    int force;
+    int info_mode;
+    bool ignorewarn;
+    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;
+
+    // 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_year[4+1];       // for internal debugging
+    } debug;
+
+    // overlay handling
+    enum {
+        SKIP_OVERLAY      = 0,
+        COPY_OVERLAY      = 1,
+        STRIP_OVERLAY     = 2
+    };
+    int overlay;
+
+    // compression runtime parameters - see struct XXX_compress_config_t
+    struct crp_t {
+        lzma_compress_config_t  crp_lzma;
+        ucl_compress_config_t   crp_ucl;
+        zlib_compress_config_t  crp_zlib;
+        void reset() { crp_lzma.reset(); crp_ucl.reset(); crp_zlib.reset(); }
+    };
+    crp_t crp;
+
+    // CPU
+    enum {
+        CPU_DEFAULT = 0,
+        CPU_8086    = 1,
+        CPU_286     = 2,
+        CPU_386     = 3,
+        CPU_486     = 4,
+        CPU_586     = 5,
+        CPU_686     = 6
+    };
+    int cpu;
+
+    // options for various executable formats
+    struct {
+        bool split_segments;
+    } atari_tos;
+    struct {
+        bool coff;
+    } djgpp2_coff;
+    struct {
+        bool force_stub;
+        bool no_reloc;
+    } dos_exe;
+    struct {
+        bool boot_only;
+        bool no_align;
+        bool do_8bit;
+        bool do_8mib;
+    } ps1_exe;
+    struct {
+        unsigned blocksize;
+        bool force_execve;          // force the linux/386 execve format
+        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]
+        bool preserve_build_id;     // copy the build-id to the compressed binary
+        bool android_shlib;         // keep some ElfXX_Shdr for dlopen()
+    } o_unix;
+    struct {
+        bool le;
+    } watcom_le;
+    struct {
+        int compress_exports;
+        int compress_icons;
+        int compress_resources;
+        signed char compress_rt[25];    // 25 == RT_LAST
+        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: */
@@ -0,0 +1,262 @@
+/* p_armpe.cpp --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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 "file.h"
+#include "filter.h"
+#include "packer.h"
+#include "pefile.h"
+#include "p_armpe.h"
+#include "linker.h"
+
+static const
+#include "stub/arm.v4a-wince.pe.h"
+static const
+#include "stub/arm.v4t-wince.pe.h"
+
+/*************************************************************************
+//
+**************************************************************************/
+
+PackArmPe::PackArmPe(InputFile *f) : super(f)
+{
+    use_thumb_stub = false;
+}
+
+
+PackArmPe::~PackArmPe()
+{}
+
+
+const int *PackArmPe::getCompressionMethods(int method, int level) const
+{
+    static const int m_all[]   = { M_NRV2B_8, M_NRV2E_8, M_LZMA, M_END };
+    static const int m_lzma[]  = { M_LZMA, M_END };
+    static const int m_nrv2b[] = { M_NRV2B_8, M_END };
+    static const int m_nrv2e[] = { M_NRV2E_8, M_END };
+
+    if (!use_thumb_stub)
+        return getDefaultCompressionMethods_8(method, level);
+
+    if (method == M_ALL)    return m_all;
+    if (M_IS_LZMA(method))  return m_lzma;
+    if (M_IS_NRV2B(method)) return m_nrv2b;
+    if (M_IS_NRV2E(method)) return m_nrv2e;
+    return m_nrv2e;
+}
+
+
+const int *PackArmPe::getFilters() const
+{
+    static const int filters[] = { 0x50, FT_END };
+    return filters;
+}
+
+
+Linker* PackArmPe::newLinker() const
+{
+    return new ElfLinkerArmLE;
+}
+
+
+/*************************************************************************
+// import handling
+**************************************************************************/
+
+void PackArmPe::processImports2(unsigned myimport, unsigned iat_off) // pass 2
+{
+    PeFile::processImports2(myimport, iat_off);
+
+__packed_struct(import_desc)
+    LE32  oft;      // orig first thunk
+    char  _[8];
+    LE32  dllname;
+    LE32  iat;      // import address table
+__packed_struct_end()
+
+    COMPILE_TIME_ASSERT(sizeof(import_desc) == 20);
+
+    // adjust import data
+    for (import_desc *im = (import_desc*) oimpdlls; im->dllname; im++)
+    {
+        im->oft = im->iat;
+        bool is_coredll = strcasecmp(kernelDll(), (char*) oimpdlls +
+                                     im->dllname - myimport) == 0;
+        im->iat = is_coredll ? iat_off : iat_off + 12;
+    }
+}
+
+void PackArmPe::addStubImports()
+{
+    // the order of procedure names below should match the
+    // assumptions of the assembly stubs
+    // WARNING! these names are sorted alphanumerically by the ImportLinker
+    addKernelImport("CacheSync");
+    addKernelImport("GetProcAddressA");
+    addKernelImport("LoadLibraryW");
+}
+
+void PackArmPe::processTls(Interval *) // pass 1
+{
+    if ((sotls = ALIGN_UP(IDSIZE(PEDIR_TLS),4u)) == 0)
+        return;
+
+    // never should happen on wince
+    throwCantPack("Static TLS entries found. Send a report please.");
+}
+
+
+/*************************************************************************
+// pack
+**************************************************************************/
+
+bool PackArmPe::canPack()
+{
+    if (!readFileHeader() || (ih.cpu != 0x1c0 && ih.cpu != 0x1c2))
+        return false;
+    use_thumb_stub |= ih.cpu == 0x1c2 || (ih.entry & 1) == 1;
+    use_thumb_stub |= (opt->cpu == opt->CPU_8086); // FIXME
+    return true;
+}
+
+
+void PackArmPe::buildLoader(const Filter *ft)
+{
+    const unsigned char *loader = use_thumb_stub ? stub_arm_v4t_wince_pe : stub_arm_v4a_wince_pe;
+    unsigned size = use_thumb_stub ? sizeof(stub_arm_v4t_wince_pe) : sizeof(stub_arm_v4a_wince_pe);
+
+    // prepare loader
+    initLoader(loader, size);
+
+    if (isdll)
+        addLoader("DllStart", NULL);
+    addLoader("ExeStart", NULL);
+
+    if (ph.method == M_NRV2E_8)
+        addLoader("Call2E", NULL);
+    else if (ph.method == M_NRV2B_8)
+        addLoader("Call2B", NULL);
+    else if (ph.method == M_NRV2D_8)
+        addLoader("Call2D", NULL);
+    else if (M_IS_LZMA(ph.method))
+        addLoader("+40C,CallLZMA", NULL);
+
+
+    if (ft->id == 0x50)
+        addLoader("+40C,Unfilter_0x50", NULL);
+
+    if (sorelocs)
+        addLoader("+40C,Relocs", NULL);
+
+    addLoader("+40C,Imports", NULL);
+    addLoader("ProcessEnd", NULL);
+
+    if (ph.method == M_NRV2E_8)
+        addLoader(".ucl_nrv2e_decompress_8", NULL);
+    else if (ph.method == M_NRV2B_8)
+        addLoader(".ucl_nrv2b_decompress_8", NULL);
+    else if (ph.method == M_NRV2D_8)
+        addLoader(".ucl_nrv2d_decompress_8", NULL);
+    else if (M_IS_LZMA(ph.method))
+        addLoader("+40C,LZMA_DECODE,LZMA_DEC10", NULL);
+
+    addLoader("IDENTSTR,UPX1HEAD", NULL);
+}
+
+bool PackArmPe::handleForceOption()
+{
+    return (ih.cpu != 0x1c0 && ih.cpu != 0x1c2)
+        || (ih.opthdrsize != 0xe0)
+        || ((ih.flags & EXECUTABLE) == 0)
+        || (ih.entry == 0 /*&& !isdll*/)
+        || (ih.ddirsentries != 16)
+//        || IDSIZE(PEDIR_EXCEPTION) // is this used on arm?
+//        || IDSIZE(PEDIR_COPYRIGHT)
+        ;
+}
+
+void PackArmPe::callCompressWithFilters(Filter &ft, int filter_strategy, unsigned ih_codebase)
+{
+    // limit stack size needed for runtime decompression
+    upx_compress_config_t cconf; cconf.reset();
+    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
+    compressWithFilters(&ft, 2048, &cconf, filter_strategy,
+                        ih_codebase, rvamin, 0, NULL, 0);
+}
+
+void PackArmPe::addNewRelocations(Reloc &rel, unsigned upxsection)
+{
+    static const char* symbols_to_relocate[] = {
+        "ONAM", "BIMP", "BREL", "FIBE", "FIBS", "ENTR", "DST0", "SRC0"
+    };
+    for (unsigned s2r = 0; s2r < TABLESIZE(symbols_to_relocate); s2r++)
+    {
+        unsigned off = linker->getSymbolOffset(symbols_to_relocate[s2r]);
+        if (off != 0xdeaddead)
+            rel.add(off + upxsection, 3);
+    }
+}
+
+unsigned PackArmPe::getProcessImportParam(unsigned upxsection)
+{
+    return linker->getSymbolOffset("IATT") + upxsection;
+}
+
+void PackArmPe::defineSymbols(unsigned ncsection, unsigned, unsigned,
+                              unsigned ic, unsigned s1addr)
+{
+    const unsigned onam = ncsection + soxrelocs + ih.imagebase;
+    linker->defineSymbol("start_of_dll_names", onam);
+    linker->defineSymbol("start_of_imports", ih.imagebase + rvamin + cimports);
+    linker->defineSymbol("start_of_relocs", crelocs + rvamin + ih.imagebase);
+    linker->defineSymbol("filter_buffer_end", ih.imagebase + ih.codebase + ih.codesize);
+    linker->defineSymbol("filter_buffer_start", ih.imagebase + ih.codebase);
+    linker->defineSymbol("original_entry", ih.entry + ih.imagebase);
+    linker->defineSymbol("uncompressed_length", ph.u_len);
+    linker->defineSymbol("start_of_uncompressed", ih.imagebase + rvamin);
+    linker->defineSymbol("compressed_length", ph.c_len);
+    linker->defineSymbol("start_of_compressed", ih.imagebase + s1addr + ic);
+    defineDecompressorSymbols();
+}
+
+void PackArmPe::setOhDataBase(const pe_section_t *osection)
+{
+    oh.database = osection[2].vaddr;
+}
+
+void PackArmPe::setOhHeaderSize(const pe_section_t *osection)
+{
+    oh.headersize = osection[1].rawdataptr;
+}
+
+void PackArmPe::pack(OutputFile *fo)
+{
+    super::pack0(fo, 1U << 9, 0x10000, true);
+}
+
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,81 @@
+/* p_armpe.h --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   All Rights Reserved.
+
+   UPX and the UCL library are free software; you can redistribute them
+   and/or modify them under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of
+   the License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.
+   If not, write to the Free Software Foundation, Inc.,
+   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
+ */
+
+
+#ifndef __UPX_P_ARMPE_H
+#define __UPX_P_ARMPE_H 1
+
+
+/*************************************************************************
+// arm/pe
+**************************************************************************/
+
+class PackArmPe : public PeFile32
+{
+    typedef PeFile32 super;
+
+public:
+    PackArmPe(InputFile *f);
+    virtual ~PackArmPe();
+    virtual int getFormat() const { return UPX_F_WINCE_ARM_PE; }
+    virtual const char *getName() const { return "arm/pe"; }
+    virtual const char *getFullName(const options_t *) const { return "arm-wince.pe"; }
+    virtual const int *getCompressionMethods(int method, int level) const;
+    virtual const int *getFilters() const;
+    virtual void defineFilterSymbols(const Filter *) {}
+
+    virtual bool handleForceOption();
+    virtual void callCompressWithFilters(Filter &, int filter_strategy,
+                                         unsigned ih_codebase);
+    virtual void defineSymbols(unsigned ncsection, unsigned upxsection,
+                               unsigned sizeof_oh, unsigned isize_isplit,
+                               unsigned s1addr);
+    virtual void addNewRelocations(Reloc &, unsigned upxsection);
+    virtual unsigned getProcessImportParam(unsigned upxsection);
+    virtual void setOhDataBase(const pe_section_t *osection);
+    virtual void setOhHeaderSize(const pe_section_t *osection);
+    virtual void pack(OutputFile *fo);
+
+    virtual bool canPack();
+
+protected:
+    virtual void buildLoader(const Filter *ft);
+    virtual Linker* newLinker() const;
+
+    virtual const char *kernelDll() const { return "COREDLL.dll"; }
+    virtual void processImports2(unsigned, unsigned);
+    virtual void addStubImports();
+
+    virtual void processTls(Interval *);
+
+    bool use_thumb_stub;
+};
+
+
+#endif /* already included */
+
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,8 +21,8 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


@@ -31,35 +31,34 @@
 #include "filter.h"
 #include "packer.h"
 #include "p_com.h"
+#include "linker.h"

 static const
-#include "stub/l_com.h"
+#include "stub/i086-dos16.com.h"

-#define STACKSIZE 0x60
-
-//#define TESTING
+//#define TESTING 1


 /*************************************************************************
 //
 **************************************************************************/

-int PackCom::getCompressionMethod() const
+const int *PackCom::getCompressionMethods(int method, int level) const
 {
-    if (M_IS_NRV2B(opt->method))
-        return M_NRV2B_LE16;
+    static const int m_nrv2b[] = { M_NRV2B_LE16, M_END };
 #if 0
-    // NOT IMPLEMENTED
-    if (M_IS_NRV2D(opt->method))
-        return M_NRV2D_LE16;
+    static const int m_nrv2d[] = { M_NRV2D_LE16, M_END };
 #endif
-    return M_NRV2B_LE16;
+    UNUSED(method); UNUSED(level);
+    return m_nrv2b;
 }


 const int *PackCom::getFilters() const
 {
-    static const int filters[] = { 0x06, 0x03, 0x04, 0x01, 0x05, 0x02, -1 };
+    static const int filters[] = {
+        0x06, 0x03, 0x04, 0x01, 0x05, 0x02,
+    FT_END };
    return filters;
 }

@@ -72,14 +71,13 @@ bool PackCom::canPack()
 {
    unsigned char buf[128];

-    fi->readx(buf,128);
+    fi->readx(buf, sizeof(buf));
    if (memcmp(buf,"MZ",2) == 0 || memcmp(buf,"ZM",2) == 0 // .exe
        || memcmp (buf,"\xff\xff\xff\xff",4) == 0) // .sys
        return false;
    if (!fn_has_ext(fi->getName(),"com"))
        return false;
-    if (find_le32(buf,128,UPX_MAGIC_LE32) >= 0)
-        throwAlreadyPacked();
+    checkAlreadyPacked(buf, sizeof(buf));
    if (file_size < 1024)
        throwCantPack("file is too small");
    if (file_size > 0xFF00)
@@ -94,34 +92,33 @@ bool PackCom::canPack()

 void PackCom::patchLoader(OutputFile *fo,
                          upx_byte *loader, int lsize,
-                          unsigned calls, unsigned overlapoh)
+                          unsigned calls)
 {
-    const int filter_id = ph.filter;
    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 + overlapoh + d_len + 0x100;
-    if (upper_end + STACKSIZE > 0xfffe)
-        throwNotCompressible();
+    const unsigned upper_end = ph.u_len + ph.overlap_overhead + d_len + 0x100;
+    unsigned stacksize = 0x60;
+    if (upper_end + stacksize > 0xfffe)
+        stacksize = 0x56;
+    if (upper_end + stacksize > 0xfffe)
+        throwCantPack("file is too big for dos/com");

-    if (filter_id)
-    {
-        assert(calls > 0);
-        patch_le16(loader,lsize,"CT",calls);
-    }
+    linker->defineSymbol("calltrick_calls", calls);
+    linker->defineSymbol("sp_limit", upper_end + stacksize);
+    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("neg_e_len", 0 - e_len);
+    linker->defineSymbol("NRV2B160", ph.u_len + ph.overlap_overhead);

+    relocateLoader();
+    loader = getLoader();
+
+    // some day we could use the relocation stuff for patchPackHeader too
    patchPackHeader(loader,e_len);
-
-    // NOTE: Depends on: decompr_start == cutpoint+1 !!!
-    patch_le16(loader,e_len,"JM",upper_end - 0xff - d_len - getLoaderSection("UPX1HEAD"));
-    loader[getLoaderSection("COMSUBSI") - 1] = (upx_byte) -e_len;
-    patch_le16(loader,e_len,"DI",upper_end);
-    patch_le16(loader,e_len,"SI",ph.c_len + lsize + 0x100);
-    patch_le16(loader,e_len,"CX",ph.c_len + lsize);
-    patch_le16(loader,e_len,"SP",upper_end + STACKSIZE);
-
    // write loader + compressed file
    fo->write(loader,e_len);            // entry
    fo->write(obuf,ph.c_len);
@@ -134,22 +131,25 @@ void PackCom::patchLoader(OutputFile *fo,
 }


-int PackCom::buildLoader(const Filter *ft)
+void PackCom::buildLoader(const Filter *ft)
 {
-    const int filter_id = ft->id;
-    initLoader(nrv2b_loader,sizeof(nrv2b_loader));
-    addLoader("COMMAIN1""COMSUBSI",
-              filter_id ? "COMCALLT" : "",
-              "COMMAIN2""UPX1HEAD""COMCUTPO""NRV2B160",
-              filter_id ? "NRVDDONE" : "NRVDRETU",
+    initLoader(stub_i086_dos16_com, sizeof(stub_i086_dos16_com));
+    addLoader("COMMAIN1",
+              ph.first_offset_found == 1 ? "COMSBBBP" : "",
+              "COMPSHDI",
+              ft->id ? "COMCALLT" : "",
+              "COMMAIN2,UPX1HEAD,COMCUTPO,NRV2B160",
+              ft->id ? "NRVDDONE" : "NRVDRETU",
              "NRVDECO1",
              ph.max_offset_found <= 0xd00 ? "NRVLED00" : "NRVGTD00",
-              "NRVDECO2""NRV2B169",
+              "NRVDECO2",
              NULL
             );
-    if (filter_id)
-        addFilter16(filter_id);
-    return getLoaderSize();
+    if (ft->id)
+    {
+        assert(ft->calls > 0);
+        addFilter16(ft->id);
+    }
 }


@@ -161,7 +161,7 @@ void PackCom::addFilter16(int filter_id)
    if (filter_id % 3 == 0)
        addLoader("CALLTR16",
                  filter_id < 4 ? "CT16SUB0" : "",
-                  filter_id < 4 ? "" : (opt->cpu == opt->CPU_8086 ? "CT16I086" : "CT16I286""CT16SUB0"),
+                  filter_id < 4 ? "" : (opt->cpu == opt->CPU_8086 ? "CT16I086" : "CT16I286,CT16SUB0"),
                  "CALLTRI2",
                  getFormat() == UPX_F_DOS_COM ? "CORETURN" : "",
                  NULL
@@ -171,7 +171,7 @@ void PackCom::addFilter16(int filter_id)
                  "CALLTRI5",
                  getFormat() == UPX_F_DOS_COM ? "CT16JEND" : "CT16JUL2",
                  filter_id < 4 ? "CT16SUB1" : "",
-                  filter_id < 4 ? "" : (opt->cpu == opt->CPU_8086 ? "CT16I087" : "CT16I287""CT16SUB1"),
+                  filter_id < 4 ? "" : (opt->cpu == opt->CPU_8086 ? "CT16I087" : "CT16I287,CT16SUB1"),
                  "CALLTRI6",
                  NULL
                 );
@@ -192,35 +192,22 @@ void PackCom::pack(OutputFile *fo)

    // prepare packheader
    ph.u_len = file_size;
-    ph.filter = 0;
    // prepare filter
-    Filter ft(opt->level);
+    Filter ft(ph.level);
    ft.addvalue = getCallTrickOffset();
-    // prepare other settings
+    // compress
    const unsigned overlap_range = ph.u_len < 0xFE00 - ft.addvalue ? 32 : 0;
-    unsigned overlapoh;
-
-    int strategy = -1;      // try the first working filter
-    if (opt->filter >= 0 && isValidFilter(opt->filter))
-        // try opt->filter or 0 if that fails
-        strategy = -2;
-    else if (opt->all_filters || opt->level > 9)
-        // choose best from all available filters
-        strategy = 0;
-    else if (opt->level == 9)
-        // choose best from the first 4 filters
-        strategy = 4;
-    compressWithFilters(&ft, &overlapoh, overlap_range, strategy);
+    compressWithFilters(&ft, overlap_range, NULL_cconf);

    const int lsize = getLoaderSize();
    MemBuffer loader(lsize);
    memcpy(loader,getLoader(),lsize);

    const unsigned calls = ft.id % 3 ? ft.lastcall - 2 * ft.calls : ft.calls;
-    patchLoader(fo, loader, lsize, calls, overlapoh);
+    patchLoader(fo, loader, lsize, calls);

    // verify
-    verifyOverlappingDecompression(&obuf, overlapoh);
+    verifyOverlappingDecompression();

    // finally check the compression ratio
    if (!checkFinalCompressionRatio(fo))
@@ -274,7 +261,9 @@ void PackCom::unpack(OutputFile *fo)
 }


-/*
-vi:ts=4:et
-*/
+Linker* PackCom::newLinker() const
+{
+    return new ElfLinkerX86();
+}

+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,13 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_P_COM_H
-#define __UPX_P_COM_H
+#define __UPX_P_COM_H 1


 /*************************************************************************
@@ -38,11 +38,13 @@ class PackCom : public Packer
 {
    typedef Packer super;
 public:
-    PackCom(InputFile *f) : super(f) { }
-    virtual int getVersion() const { return 11; }
+    PackCom(InputFile *f) : super(f) { bele = &N_BELE_RTP::le_policy; }
+    virtual int getVersion() const { return 13; }
    virtual int getFormat() const { return UPX_F_DOS_COM; }
    virtual const char *getName() const { return "dos/com"; }
-    virtual int getCompressionMethod() const;
+    //virtual const char *getFullName(const options_t *o) const { return o && o->cpu == o->CPU_8086 ? "i086-dos16.com" : "i286-dos16.com"; }
+    virtual const char *getFullName(const options_t *) const { return "i086-dos16.com"; }
+    virtual const int *getCompressionMethods(int method, int level) const;
    virtual const int *getFilters() const;

    virtual void pack(OutputFile *fo);
@@ -52,19 +54,16 @@ public:
    virtual int canUnpack();

 protected:
-    virtual const unsigned getCallTrickOffset() const { return 0x100; }
+    virtual unsigned getCallTrickOffset() const { return 0x100; }
+    virtual Linker* newLinker() const;

 protected:
-    virtual int buildLoader(const Filter *ft);
-    virtual void patchLoader(OutputFile *fo, upx_byte *, int, unsigned, unsigned);
+    virtual void buildLoader(const Filter *ft);
+    virtual void patchLoader(OutputFile *fo, upx_byte *, int, unsigned);
    virtual void addFilter16(int filter_id);
 };


 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,21 +21,22 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */

+
 #include "conf.h"
 #include "file.h"
 #include "filter.h"
 #include "packer.h"
 #include "p_djgpp2.h"
+#include "linker.h"

 static const
-#include "stub/stubify.h"
-
+#include "stub/i386-dos32.djgpp2.h"
 static const
-#include "stub/l_djgpp2.h"
+#include "stub/i386-dos32.djgpp2-stubify.h"


 /*************************************************************************
@@ -45,47 +46,72 @@ static const
 PackDjgpp2::PackDjgpp2(InputFile *f) :
    super(f), coff_offset(0)
 {
-    assert(sizeof(coff_hdr) == 0xa8);
-    assert(sizeof(stubify_stub) == 2048);
+    bele = &N_BELE_RTP::le_policy;
+    COMPILE_TIME_ASSERT(sizeof(external_scnhdr_t) == 40)
+    COMPILE_TIME_ASSERT(sizeof(coff_header_t) == 0xa8)
+    COMPILE_TIME_ASSERT_ALIGNED1(external_scnhdr_t)
+    COMPILE_TIME_ASSERT_ALIGNED1(coff_header_t)
+    COMPILE_TIME_ASSERT(sizeof(stub_i386_dos32_djgpp2_stubify) == 2048)
+    COMPILE_TIME_ASSERT(STUB_I386_DOS32_DJGPP2_STUBIFY_ADLER32 == 0xbf689ba8)
+    COMPILE_TIME_ASSERT(STUB_I386_DOS32_DJGPP2_STUBIFY_CRC32   == 0x2ae982b2)
+    //printf("0x%08x\n", upx_adler32(stubify_stub, sizeof(stubify_stub)));
+    //assert(upx_adler32(stubify_stub, sizeof(stubify_stub)) == STUBIFY_STUB_ADLER32);
 }


-int PackDjgpp2::getCompressionMethod() const
+const int *PackDjgpp2::getCompressionMethods(int method, int level) const
 {
-    if (M_IS_NRV2B(opt->method))
-        return M_NRV2B_LE32;
-    if (M_IS_NRV2D(opt->method))
-        return M_NRV2D_LE32;
-    return opt->level > 1 && file_size >= 512*1024 ? M_NRV2D_LE32 : M_NRV2B_LE32;
+    return Packer::getDefaultCompressionMethods_le32(method, level);
 }

+
 const int *PackDjgpp2::getFilters() const
 {
-    static const int filters[] = { 0x26, 0x24, 0x11, 0x14, 0x13, 0x16,
-                                   0x25, 0x15, 0x12, -1 };
+    static const int filters[] = {
+        0x26, 0x24, 0x49, 0x46, 0x16, 0x13, 0x14, 0x11,
+        FT_ULTRA_BRUTE, 0x25, 0x15, 0x12,
+    FT_END };
    return filters;
 }


-int PackDjgpp2::buildLoader(const Filter *ft)
+unsigned PackDjgpp2::findOverlapOverhead(const upx_bytep buf,
+                                         const upx_bytep tbuf,
+                                         unsigned range,
+                                         unsigned upper_limit) const
+{
+    unsigned o = super::findOverlapOverhead(buf, tbuf, range, upper_limit);
+    o = (o + 0x3ff) &~ 0x1ff;
+    return o;
+}
+
+
+Linker* PackDjgpp2::newLinker() const
+{
+    return new ElfLinkerX86;
+}
+
+
+void PackDjgpp2::buildLoader(const Filter *ft)
 {
    // prepare loader
-    initLoader(nrv_loader,sizeof(nrv_loader));
-    addLoader("IDENTSTR""DJ2MAIN1",
+    initLoader(stub_i386_dos32_djgpp2, sizeof(stub_i386_dos32_djgpp2));
+    addLoader("IDENTSTR,DJ2MAIN1",
              ft->id ? "DJCALLT1" : "",
-              "DJ2MAIN2",
-              getDecompressor(),
+              ph.first_offset_found == 1 ? "DJ2MAIN2" : "",
+              M_IS_LZMA(ph.method) ? "LZMA_INIT_STACK" : "",
+              getDecompressorSections(),
+              M_IS_LZMA(ph.method) ? "LZMA_DONE_STACK" : "",
              "DJ2BSS00",
              NULL
             );
    if (ft->id)
    {
        assert(ft->calls > 0);
-        addLoader("DJCALLT2",NULL);
+        addLoader("DJCALLT2", NULL);
        addFilter32(ft->id);
    }
-    addLoader("DJRETURN+40DXXXXUPX1HEAD",NULL);
-    return getLoaderSize();
+    addLoader("DJRETURN,+40C,UPX1HEAD", NULL);
 }


@@ -95,39 +121,39 @@ int PackDjgpp2::buildLoader(const Filter *ft)

 void PackDjgpp2::handleStub(OutputFile *fo)
 {
-    if (fo && !opt->djgpp2.coff)
+    if (fo && !opt->djgpp2_coff.coff)
    {
        if (coff_offset > 0)
        {
            // copy stub from exe
-            Packer::handleStub(fi,fo,coff_offset);
+            Packer::handleStub(fi, fo, coff_offset);
        }
        else
        {
            // "stubify" stub
-            info("Adding stub: %ld bytes", (long)sizeof(stubify_stub));
-            fo->write(stubify_stub,sizeof(stubify_stub));
+            info("Adding stub: %ld bytes", (long)sizeof(stub_i386_dos32_djgpp2_stubify));
+            fo->write(stub_i386_dos32_djgpp2_stubify, sizeof(stub_i386_dos32_djgpp2_stubify));
        }
    }
 }


-static bool is_dlm(InputFile *fi, long coff_offset)
+static bool is_dlm(InputFile *fi, unsigned coff_offset)
 {
    unsigned char buf[4];
-    long off;
+    unsigned off;

    try {
-        fi->seek(coff_offset,SEEK_SET);
-        fi->readx(buf,4);
+        fi->seek(coff_offset, SEEK_SET);
+        fi->readx(buf, 4);
        off = get_le32(buf);
-        if (off < 0 || off > coff_offset + 4)
+        if (off > coff_offset + 4)
            return false;
-        fi->seek(off,SEEK_SET);
-        fi->readx(buf,4);
-        if (memcmp(buf,"DLMF",4) == 0)
+        fi->seek(off, SEEK_SET);
+        fi->readx(buf, 4);
+        if (memcmp(buf, "DLMF", 4) == 0)
            return true;
-    } catch (IOException&) {
+    } catch (const IOException&) {
    }
    return false;
 }
@@ -136,65 +162,67 @@ static bool is_dlm(InputFile *fi, long coff_offset)
 static void handle_allegropak(InputFile *fi, OutputFile *fo)
 {
    unsigned char buf[0x4000];
-    unsigned pfsize=0, ic;
+    int pfsize = 0;

    try {
-        fi->seek(-8,SEEK_END);
-        fi->readx(buf,8);
-        if (memcmp(buf,"slh+",4) != 0)
+        fi->seek(-8, SEEK_END);
+        fi->readx(buf, 8);
+        if (memcmp(buf, "slh+", 4) != 0)
            return;
-        pfsize = get_be32(buf+4);
-        fi->seek(-(off_t)pfsize,SEEK_END);
-    } catch (IOException&) {
+        pfsize = get_be32_signed(buf+4);
+        if (pfsize <= 8 || pfsize >= (off_t) fi->st.st_size)
+            return;
+        fi->seek(-(off_t)pfsize, SEEK_END);
+    } catch (const IOException&) {
        return;
    }
-    while (pfsize)
+    while (pfsize > 0)
    {
-        ic = pfsize < sizeof(buf) ? pfsize : sizeof(buf);
-        fi->readx(buf,ic);
-        fo->write(buf,ic);
-        pfsize -= ic;
+        const int len = UPX_MIN(pfsize, (int)sizeof(buf));
+        fi->readx(buf, len);
+        fo->write(buf, len);
+        pfsize -= len;
    }
 }


-bool PackDjgpp2::readFileHeader()
+int PackDjgpp2::readFileHeader()
 {
    unsigned char hdr[0x1c];
    unsigned char magic[8];

-    fi->seek(0,SEEK_SET);
-    fi->readx(hdr,sizeof(hdr));
+    fi->seek(0, SEEK_SET);
+    fi->readx(hdr, sizeof(hdr));
    if (get_le16(hdr) == 0x5a4d)        // MZ exe signature, stubbed?
    {
        coff_offset = 512 * get_le16(hdr+4);
        if (get_le16(hdr+2) != 0)
            coff_offset += get_le16(hdr+2) - 512;
-        fi->seek(512,SEEK_SET);
-        fi->readx(magic,8);
-        if (memcmp("go32stub",magic,8) != 0)
-            return false;               // not V2 image
-        fi->seek(coff_offset,SEEK_SET);
-        if (fi->read(&coff_hdr,sizeof(coff_hdr)) != sizeof(coff_hdr))
+        fi->seek(512, SEEK_SET);
+        fi->readx(magic, 8);
+        if (memcmp("go32stub", magic, 8) != 0)
+            return 0;                   // not V2 image
+        fi->seek(coff_offset, SEEK_SET);
+        if (fi->read(&coff_hdr, sizeof(coff_hdr)) != sizeof(coff_hdr))
            throwCantPack("skipping djgpp symlink");
    }
    else
    {
-        fi->seek(coff_offset,SEEK_SET);
-        fi->readx(&coff_hdr,0xa8);
+        fi->seek(coff_offset, SEEK_SET);
+        fi->readx(&coff_hdr, 0xa8);
    }
    if (coff_hdr.f_magic != 0x014c)    // I386MAGIC
-        return false;
+        return 0;
    if ((coff_hdr.f_flags & 2) == 0)   // F_EXEC - COFF executable
-        return false;
+        return 0;
    if (coff_hdr.a_magic != 0413)      // ZMAGIC - demand load format
-        return false;
+        return 0;
    // FIXME: check for Linux etc.

    text = coff_hdr.sh;
    data = text + 1;
    bss  = data + 1;
-    return true;
+    return UPX_F_DJGPP2_COFF;
 }


@@ -204,7 +232,7 @@ void PackDjgpp2::stripDebug()
    coff_hdr.f_symptr = 0;
    coff_hdr.f_nsyms = 0;
    coff_hdr.f_flags = 0x10f;   // 0x100: "32 bit machine: LSB first"
-    memset(text->misc,0,12);
+    memset(text->misc, 0, 12);
 }


@@ -216,7 +244,7 @@ bool PackDjgpp2::canPack()
 {
    if (!readFileHeader())
        return false;
-    if (is_dlm(fi,coff_offset))
+    if (is_dlm(fi, coff_offset))
        throwCantPack("can't handle DLM");

    if (opt->force == 0)
@@ -253,102 +281,85 @@ void PackDjgpp2::pack(OutputFile *fo)
    // read file
    const unsigned size = text->size + data->size;
    const unsigned tpos = text->scnptr;
-    const unsigned usize = size + (tpos & 0x1ff);
-    const unsigned hdrsize = 20 + 28 + (40 * coff_hdr.f_nscns);
+    const unsigned hdrsize = 20 + 28 + sizeof(external_scnhdr_t) * coff_hdr.f_nscns;
+    const unsigned usize = size + hdrsize;
    if (hdrsize < sizeof(coff_hdr) || hdrsize > tpos)
        throwCantPack("coff header error");

    ibuf.alloc(usize);
    obuf.allocForCompression(usize);

-    fi->seek(coff_offset,SEEK_SET);
-    fi->readx(ibuf,hdrsize);             // orig. coff header
-    memset(ibuf + hdrsize, 0, tpos - hdrsize);
-    fi->seek(coff_offset+tpos,SEEK_SET);
-    fi->readx(ibuf + (tpos & 0x1ff),size);
-
-#if 0
-    // filter
-    Filter ft(opt->level);
-    tryFilters(&ft, ibuf, usize - data->size, text->vaddr & ~0x1ff);
-
-    // compress
-    ph.filter = ft.id;
-    ph.filter_cto = ft.cto;
-    ph.u_len = usize;
-    if (!compress(ibuf,obuf))
-        throwNotCompressible();
-
-    unsigned overlapoh = findOverlapOverhead(obuf,ibuf,512);
-    overlapoh = (overlapoh + 0x3ff) & ~0x1ff;
-
-    // verify filter
-    ft.verifyUnfilter();
-#else
-    // new version using compressWithFilters()
+    fi->seek(coff_offset, SEEK_SET);
+    fi->readx(ibuf, hdrsize);             // orig. coff header
+    fi->seek(coff_offset + tpos, SEEK_SET);
+    fi->readx(ibuf + hdrsize, size);

    // prepare packheader
    ph.u_len = usize;
-    ph.filter = 0;
    // prepare filter
-    Filter ft(opt->level);
+    Filter ft(ph.level);
    ft.buf_len = usize - data->size;
-    ft.addvalue = text->vaddr & ~0x1ff;
-    // prepare other settings
-    const unsigned overlap_range = 512;
-    unsigned overlapoh;
-
-    int strategy = -1;      // try the first working filter
-    if (opt->filter >= 0 && isValidFilter(opt->filter))
-        // try opt->filter or 0 if that fails
-        strategy = -2;
-    else if (opt->all_filters)
-        // choose best from all available filters
-        strategy = 0;
-    compressWithFilters(&ft, &overlapoh, overlap_range, strategy);
-    overlapoh = (overlapoh + 0x3ff) & ~0x1ff;
-#endif
+    ft.addvalue = text->vaddr - hdrsize;
+    // compress
+    upx_compress_config_t cconf; cconf.reset();
+    // limit stack size needed for runtime decompression
+    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
+    compressWithFilters(&ft, 512, &cconf);

    // patch coff header #2
    const unsigned lsize = getLoaderSize();
+    assert(lsize % 4 == 0);
    text->size = lsize;                   // new size of .text
    data->size = ph.c_len;                // new size of .data

-    if (bss->size < overlapoh)            // give it a .bss
-        bss->size = overlapoh;
+    unsigned stack = 1024 + ph.overlap_overhead + getDecompressorWrkmemSize();
+    stack = ALIGN_UP(stack, 16u);
+    if (bss->size < stack)  // give it a .bss
+        bss->size = stack;

    text->scnptr = sizeof(coff_hdr);
    data->scnptr = text->scnptr + text->size;
-    data->vaddr = bss->vaddr + ((data->scnptr + data->size) & 0x1ff) - data->size + overlapoh - 0x200;
+    data->vaddr = bss->vaddr + ((data->scnptr + data->size) & 0x1ff) - data->size + ph.overlap_overhead - 0x200;
    coff_hdr.f_nscns = 3;

-    // prepare loader
-    MemBuffer loader(lsize);
-    memcpy(loader,getLoader(),lsize);
-
-    // patch loader
-    patchPackHeader(loader,lsize);
-    patch_le32(loader,lsize,"ENTR",coff_hdr.a_entry);
-    patchFilter32(loader, lsize, &ft);
-    patch_le32(loader,lsize,"BSSL",overlapoh/4);
+    linker->defineSymbol("original_entry", coff_hdr.a_entry);
+    linker->defineSymbol("length_of_bss", ph.overlap_overhead / 4);
+    defineDecompressorSymbols();
    assert(bss->vaddr == ((size + 0x1ff) &~ 0x1ff) + (text->vaddr &~ 0x1ff));
-    patch_le32(loader,lsize,"OUTP",text->vaddr &~ 0x1ff);
-    patch_le32(loader,lsize,"INPP",data->vaddr);
+    linker->defineSymbol("stack_for_lzma", bss->vaddr + bss->size);
+    linker->defineSymbol("start_of_uncompressed", text->vaddr - hdrsize);
+    linker->defineSymbol("start_of_compressed", data->vaddr);
+    defineFilterSymbols(&ft);
+
+    // we should not overwrite our decompressor during unpacking
+    // the original coff header (which is put just before the
+    // beginning of the original .text section)
+    assert(text->vaddr > hdrsize + lsize + sizeof(coff_hdr));

    // patch coff header #3
    text->vaddr = sizeof(coff_hdr);
    coff_hdr.a_entry = sizeof(coff_hdr) + getLoaderSection("DJ2MAIN1");
-    bss->vaddr += overlapoh;
-    bss->size -= overlapoh;
+    bss->vaddr += ph.overlap_overhead;
+    bss->size -= ph.overlap_overhead;

    // because of a feature (bug?) in stub.asm we need some padding
-    memcpy(obuf+data->size,"UPX",3);
-    data->size = ALIGN_UP(data->size,4);
+    memcpy(obuf+data->size, "UPX", 3);
+    data->size = ALIGN_UP(data->size, 4u);
+
+    linker->defineSymbol("DJ2MAIN1", coff_hdr.a_entry);
+    relocateLoader();
+
+    // prepare loader
+    MemBuffer loader(lsize);
+    memcpy(loader, getLoader(), lsize);
+    patchPackHeader(loader, lsize);

    // write coff header, loader and compressed file
-    fo->write(&coff_hdr,sizeof(coff_hdr));
-    fo->write(loader,lsize);
-    fo->write(obuf,data->size);
+    fo->write(&coff_hdr, sizeof(coff_hdr));
+    fo->write(loader, lsize);
+    if (opt->debug.dump_stub_loader)
+        OutputFile::dump(opt->debug.dump_stub_loader, loader, lsize);
+    fo->write(obuf, data->size);
 #if 0
    printf("%-13s: coff hdr   : %8ld bytes\n", getName(), (long) sizeof(coff_hdr));
    printf("%-13s: loader     : %8ld bytes\n", getName(), (long) lsize);
@@ -356,11 +367,11 @@ void PackDjgpp2::pack(OutputFile *fo)
 #endif

    // verify
-    verifyOverlappingDecompression(&obuf, overlapoh);
+    verifyOverlappingDecompression();

    // handle overlay
    // FIXME: only Allegro pakfiles are supported
-    handle_allegropak(fi,fo);
+    handle_allegropak(fi, fo);

    // finally check the compression ratio
    if (!checkFinalCompressionRatio(fo))
@@ -376,10 +387,10 @@ int PackDjgpp2::canUnpack()
 {
    if (!readFileHeader())
        return false;
-    if (is_dlm(fi,coff_offset))
+    if (is_dlm(fi, coff_offset))
        throwCantUnpack("can't handle DLM");
    fi->seek(coff_offset, SEEK_SET);
-    return readPackHeader(1024) ? 1 : -1;
+    return readPackHeader(4096) ? 1 : -1;
 }


@@ -394,19 +405,30 @@ void PackDjgpp2::unpack(OutputFile *fo)
    ibuf.alloc(ph.c_len);
    obuf.allocForUncompression(ph.u_len);

-    fi->seek(coff_offset + ph.buf_offset + ph.getPackHeaderSize(),SEEK_SET);
-    fi->readx(ibuf,ph.c_len);
+    fi->seek(coff_offset + ph.buf_offset + ph.getPackHeaderSize(), SEEK_SET);
+    fi->readx(ibuf, ph.c_len);

    // decompress
-    decompress(ibuf,obuf);
+    decompress(ibuf, obuf);
+
+    coff_header_t *chdr = (coff_header_t*) obuf.getVoidPtr();
+    text = chdr->sh;
+    data = text + 1;
+
+    const unsigned hdrsize = 20 + 28
+        + sizeof(external_scnhdr_t) * chdr->f_nscns;
+
+    unsigned addvalue;
+    if (ph.version >= 14)
+        addvalue = text->vaddr - hdrsize;
+    else
+        addvalue = text->vaddr &~ 0x1ff; // for old versions

    // unfilter
    if (ph.filter)
    {
-        memcpy(&coff_hdr,obuf,sizeof(coff_hdr));
-
        Filter ft(ph.level);
-        ft.init(ph.filter, text->vaddr &~ 0x1ff);
+        ft.init(ph.filter, addvalue);
        ft.cto = (unsigned char) ph.filter_cto;
        if (ph.version < 11)
        {
@@ -417,22 +439,34 @@ void PackDjgpp2::unpack(OutputFile *fo)
        ft.unfilter(obuf, ph.u_len - data->size);
    }

-    // fixup for the aligning bug in strip 2.8+
-    text = ((coff_header_t*) (unsigned char *) obuf)->sh;
-    data = text + 1;
-    text->scnptr &= 0x1ff;
-    data->scnptr = text->scnptr + text->size;
-
-    // write decompressed file
-    if (fo)
+    if (ph.version < 14)
    {
-        fo->write(obuf,ph.u_len);
-        handle_allegropak(fi,fo);
+        // fixup for the aligning bug in strip 2.8+
+        text->scnptr &= 0x1ff;
+        data->scnptr = text->scnptr + text->size;
+        // write decompressed file
+        if (fo)
+            fo->write(obuf, ph.u_len);
    }
+    else
+    {
+        // write the header
+        // some padding might be required between the end
+        // of the header and the start of the .text section
+
+        const unsigned padding = text->scnptr - hdrsize;
+        ibuf.clear(0, padding);
+
+        if (fo)
+        {
+            fo->write(obuf, hdrsize);
+            fo->write(ibuf, padding);
+            fo->write(obuf + hdrsize, ph.u_len - hdrsize);
+        }
+    }
+
+    if (fo)
+        handle_allegropak(fi, fo);
 }

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,13 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_P_DJGPP2_H
-#define __UPX_P_DJGPP2_H
+#define __UPX_P_DJGPP2_H 1


 /*************************************************************************
@@ -40,10 +40,11 @@ class PackDjgpp2 : public Packer

 public:
    PackDjgpp2(InputFile *f);
-    virtual int getVersion() const { return 11; }
+    virtual int getVersion() const { return 14; }
    virtual int getFormat() const { return UPX_F_DJGPP2_COFF; }
    virtual const char *getName() const { return "djgpp2/coff"; }
-    virtual int getCompressionMethod() const;
+    virtual const char *getFullName(const options_t *) const { return "i386-dos32.djgpp2.coff"; }
+    virtual const int *getCompressionMethods(int method, int level) const;
    virtual const int *getFilters() const;

    virtual void pack(OutputFile *fo);
@@ -53,23 +54,28 @@ public:
    virtual int canUnpack();

 protected:
-    virtual int buildLoader(const Filter *ft);
    virtual void handleStub(OutputFile *fo);
+    virtual int readFileHeader();

-    long coff_offset;
+    virtual unsigned findOverlapOverhead(const upx_bytep buf,
+                                         const upx_bytep tbuf,
+                                         unsigned range = 0,
+                                         unsigned upper_limit = ~0u) const;
+    virtual void buildLoader(const Filter *ft);
+    virtual Linker* newLinker() const;

-    struct external_scnhdr_t
-    {
+    unsigned coff_offset;
+
+    __packed_struct(external_scnhdr_t)
        char    _[12];    // name, paddr
        LE32    vaddr;
        LE32    size;
        LE32    scnptr;
        char    misc[12]; // relptr, lnnoptr, nreloc, nlnno
        char    __[4];    // flags
-    };
+    __packed_struct_end()

-    struct coff_header_t
-    {
+    __packed_struct(coff_header_t)
        // ext_file_hdr
        LE16    f_magic;
        LE16    f_nscns;
@@ -90,19 +96,15 @@ protected:

        // section headers
        external_scnhdr_t sh[3];
-    } coff_hdr;
+    __packed_struct_end()

+    coff_header_t coff_hdr;
    external_scnhdr_t *text,*data,*bss;

-    bool readFileHeader();
    void stripDebug();
 };


 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,64 +21,421 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_P_ELF_H
-#define __UPX_P_ELF_H
+#define __UPX_P_ELF_H 1


 /*************************************************************************
-// Some ELF type definitinons
+// N_Elf
 **************************************************************************/

+namespace N_Elf {
+
+// integral types
+template <class THalf, class TWord, class TXword, class TAddr, class TOff>
+struct ElfITypes
+{
+    typedef THalf   Half;
+    typedef TWord   Word;
+    typedef TXword  Xword;
+    typedef TAddr   Addr;
+    typedef TOff    Off;
+    typedef THalf   Section;
+    typedef THalf   Versym;
+};
+
+
 // The ELF file header. This appears at the start of every ELF file.
-struct Elf_LE32_Ehdr
-{
+template <class TElfITypes>
+__packed_struct(Ehdr)
+    typedef typename TElfITypes::Half    Half;
+    typedef typename TElfITypes::Word    Word;
+    typedef typename TElfITypes::Addr    Addr;
+    typedef typename TElfITypes::Off     Off;
+
    unsigned char e_ident[16];  /* Magic number and other info */
-    LE16 e_type;                /* Object file type */
-    LE16 e_machine;             /* Architecture */
-    LE32 e_version;             /* Object file version */
-    LE32 e_entry;               /* Entry point virtual address */
-    LE32 e_phoff;               /* Program header table file offset */
-    LE32 e_shoff;               /* Section header table file offset */
-    LE32 e_flags;               /* Processor-specific flags */
-    LE16 e_ehsize;              /* ELF header size in bytes */
-    LE16 e_phentsize;           /* Program header table entry size */
-    LE16 e_phnum;               /* Program header table entry count */
-    LE16 e_shentsize;           /* Section header table entry size */
-    LE16 e_shnum;               /* Section header table entry count */
-    LE16 e_shstrndx;            /* Section header string table index */
-};
+    Half e_type;                /* Object file type */
+    Half e_machine;             /* Architecture */
+    Word e_version;             /* Object file version */
+    Addr e_entry;               /* Entry point virtual address */
+    Off  e_phoff;               /* Program header table file offset */
+    Off  e_shoff;               /* Section header table file offset */
+    Word e_flags;               /* Processor-specific flags */
+    Half e_ehsize;              /* ELF header size in bytes */
+    Half e_phentsize;           /* Program header table entry size */
+    Half e_phnum;               /* Program header table entry count */
+    Half e_shentsize;           /* Section header table entry size */
+    Half e_shnum;               /* Section header table entry count */
+    Half e_shstrndx;            /* Section header string table index */
+
+#   define WANT_EHDR_ENUM 1
+#   include "p_elf_enum.h"
+__packed_struct_end()


-// Program segment header.
-struct Elf_LE32_Phdr
+template <class TElfITypes>
+__packed_struct(Dyn)
+    typedef typename TElfITypes::Xword   Xword;
+    typedef typename TElfITypes::Addr    Addr;
+
+    Xword d_tag;
+    Addr d_val;
+
+#   define WANT_DYN_ENUM 1
+#   include "p_elf_enum.h"
+__packed_struct_end()
+
+
+template <class TElfITypes>
+__packed_struct(Rel)
+    typedef typename TElfITypes::Xword   Xword;
+    typedef typename TElfITypes::Addr    Addr;
+
+    Addr r_offset;
+    Xword r_info;
+__packed_struct_end()
+
+
+template <class TElfITypes>
+__packed_struct(Rela)
+    typedef typename TElfITypes::Xword   Xword;
+    typedef typename TElfITypes::Addr    Addr;
+
+    Addr r_offset;
+    Xword r_info;
+    Xword r_addend;
+__packed_struct_end()
+
+
+template <class TElfITypes>
+__packed_struct(External_Note)
+    typedef typename TElfITypes::Word   Word;
+
+    Word xn_namesz;  // includes terminating '\0'
+    Word xn_datasz;
+    Word xn_type;
+    //char xn_name[N];  // terminate with '\0'
+    //char xn_data[M];  // aligned to 0 mod 4
+__packed_struct_end()
+
+
+} // namespace N_Elf
+
+
+/*************************************************************************
+// N_Elf32
+**************************************************************************/
+
+namespace N_Elf32 {
+
+template <class TElfITypes>
+__packed_struct(Phdr)
+    typedef typename TElfITypes::Word    Word;
+    typedef typename TElfITypes::Addr    Addr;
+    typedef typename TElfITypes::Off     Off;
+
+    Word p_type;                /* Segment type */
+    Off  p_offset;              /* Segment file offset */
+    Addr p_vaddr;               /* Segment virtual address */
+    Addr p_paddr;               /* Segment physical address */
+    Word p_filesz;              /* Segment size in file */
+    Word p_memsz;               /* Segment size in memory */
+    Word p_flags;               /* Segment flags */
+    Word p_align;               /* Segment alignment */
+
+#   define WANT_PHDR_ENUM 1
+#   include "p_elf_enum.h"
+__packed_struct_end()
+
+
+template <class TElfITypes>
+__packed_struct(Shdr)
+    typedef typename TElfITypes::Word    Word;
+    typedef typename TElfITypes::Addr    Addr;
+    typedef typename TElfITypes::Off     Off;
+
+    Word sh_name;               /* Section name (string tbl index) */
+    Word sh_type;               /* Section type */
+    Word sh_flags;              /* Section flags */
+    Addr sh_addr;               /* Section virtual addr at execution */
+    Off  sh_offset;             /* Section file offset */
+    Word sh_size;               /* Section size in bytes */
+    Word sh_link;               /* Link to another section */
+    Word sh_info;               /* Additional section information */
+    Word sh_addralign;          /* Section alignment */
+    Word sh_entsize;            /* Entry size if section holds table */
+
+#   define WANT_SHDR_ENUM 1
+#   include "p_elf_enum.h"
+__packed_struct_end()
+
+
+template <class TElfITypes>
+__packed_struct(Sym)
+    typedef typename TElfITypes::Word    Word;
+    typedef typename TElfITypes::Addr    Addr;
+    typedef typename TElfITypes::Section Section;
+
+    Word st_name;               /* symbol name (index into string table) */
+    Addr st_value;              /* symbol value */
+    Word st_size;               /* symbol size */
+    unsigned char st_info;      /* symbol type and binding */
+    unsigned char st_other;     /* symbol visibility */
+    Section st_shndx;           /* section index */
+
+#   define WANT_SYM_ENUM 1
+#   include "p_elf_enum.h"
+
+    static unsigned int  get_st_bind(unsigned x) { return 0xf & (x>>4); }
+    static unsigned int  get_st_type(unsigned x) { return 0xf &  x    ; }
+    static unsigned char make_st_info(unsigned bind, unsigned type)
+        { return (unsigned char) (((bind<<4) + (0xf & type)) & 0xff); }
+__packed_struct_end()
+
+
+} // namespace N_Elf32
+
+
+/*************************************************************************
+// N_Elf64
+**************************************************************************/
+
+namespace N_Elf64 {
+
+template <class TElfITypes>
+__packed_struct(Phdr)
+    typedef typename TElfITypes::Word    Word;
+    typedef typename TElfITypes::Xword   Xword;
+    typedef typename TElfITypes::Addr    Addr;
+    typedef typename TElfITypes::Off     Off;
+
+    Word  p_type;               /* Segment type */
+    Word  p_flags;              /* Segment flags */
+    Off   p_offset;             /* Segment file offset */
+    Addr  p_vaddr;              /* Segment virtual address */
+    Addr  p_paddr;              /* Segment physical address */
+    Xword p_filesz;             /* Segment size in file */
+    Xword p_memsz;              /* Segment size in memory */
+    Xword p_align;              /* Segment alignment */
+
+#   define WANT_PHDR_ENUM 1
+#   include "p_elf_enum.h"
+__packed_struct_end()
+
+
+template <class TElfITypes>
+__packed_struct(Shdr)
+    typedef typename TElfITypes::Word    Word;
+    typedef typename TElfITypes::Xword   Xword;
+    typedef typename TElfITypes::Addr    Addr;
+    typedef typename TElfITypes::Off     Off;
+
+    Word  sh_name;              /* Section name (string tbl index) */
+    Word  sh_type;              /* Section type */
+    Xword sh_flags;             /* Section flags */
+    Addr  sh_addr;              /* Section virtual addr at execution */
+    Off   sh_offset;            /* Section file offset */
+    Xword sh_size;              /* Section size in bytes */
+    Word  sh_link;              /* Link to another section */
+    Word  sh_info;              /* Additional section information */
+    Xword sh_addralign;         /* Section alignment */
+    Xword sh_entsize;           /* Entry size if section holds table */
+
+#   define WANT_SHDR_ENUM 1
+#   include "p_elf_enum.h"
+__packed_struct_end()
+
+
+template <class TElfITypes>
+__packed_struct(Sym)
+    typedef typename TElfITypes::Word    Word;
+    typedef typename TElfITypes::Xword   Xword;
+    typedef typename TElfITypes::Addr    Addr;
+    typedef typename TElfITypes::Section Section;
+
+    Word st_name;               /* symbol name (index into string table) */
+    unsigned char st_info;      /* symbol type and binding */
+    unsigned char st_other;     /* symbol visibility */
+    Section st_shndx;           /* section index */
+    Addr st_value;              /* symbol value */
+    Xword st_size;              /* symbol size */
+
+#   define WANT_SYM_ENUM 1
+#   include "p_elf_enum.h"
+
+    static unsigned int  get_st_bind(unsigned x) { return 0xf & (x>>4); }
+    static unsigned int  get_st_type(unsigned x) { return 0xf &  x    ; }
+    static unsigned char make_st_info(unsigned bind, unsigned type)
+        { return (unsigned char) (((bind<<4) + (0xf & type)) & 0xff); }
+__packed_struct_end()
+
+
+} // namespace N_Elf64
+
+
+/*************************************************************************
+// aggregate types into an ElfClass
+**************************************************************************/
+
+namespace N_Elf {
+
+template <class TP>
+struct ElfClass_32
 {
-    LE32 p_type;                /* Segment type */
-    LE32 p_offset;              /* Segment file offset */
-    LE32 p_vaddr;               /* Segment virtual address */
-    LE32 p_paddr;               /* Segment physical address */
-    LE32 p_filesz;              /* Segment size in file */
-    LE32 p_memsz;               /* Segment size in memory */
-    LE32 p_flags;               /* Segment flags */
-    LE32 p_align;               /* Segment alignment */
+    typedef TP BeLePolicy;
+
+    // integral types (target endianness)
+    typedef typename TP::U16 TE16;
+    typedef typename TP::U32 TE32;
+    typedef typename TP::U64 TE64;
+    typedef N_Elf::ElfITypes<TE16, TE32, TE32, TE32, TE32> ElfITypes;
+
+    // ELF types
+    typedef N_Elf  ::Ehdr<ElfITypes> Ehdr;
+    typedef N_Elf32::Phdr<ElfITypes> Phdr;
+    typedef N_Elf32::Shdr<ElfITypes> Shdr;
+    typedef N_Elf  ::Dyn <ElfITypes> Dyn;
+    typedef N_Elf  ::Rel <ElfITypes> Rel;
+    typedef N_Elf  ::Rela<ElfITypes> Rela;
+    typedef N_Elf32::Sym <ElfITypes> Sym;
+    typedef N_Elf  ::External_Note<ElfITypes> External_Note;
+
+    static void compileTimeAssertions() {
+        BeLePolicy::compileTimeAssertions();
+        COMPILE_TIME_ASSERT(sizeof(Ehdr) == 52)
+        COMPILE_TIME_ASSERT(sizeof(Phdr) == 32)
+        COMPILE_TIME_ASSERT(sizeof(Shdr) == 40)
+        COMPILE_TIME_ASSERT(sizeof(Dyn)  ==  8)
+        COMPILE_TIME_ASSERT(sizeof(Rel)  ==  8)
+        COMPILE_TIME_ASSERT(sizeof(Rela) == 12)
+        COMPILE_TIME_ASSERT(sizeof(Sym)  == 16)
+        COMPILE_TIME_ASSERT_ALIGNED1(Ehdr)
+        COMPILE_TIME_ASSERT_ALIGNED1(Phdr)
+        COMPILE_TIME_ASSERT_ALIGNED1(Shdr)
+        COMPILE_TIME_ASSERT_ALIGNED1(Dyn)
+        COMPILE_TIME_ASSERT_ALIGNED1(Rel)
+        COMPILE_TIME_ASSERT_ALIGNED1(Rela)
+        COMPILE_TIME_ASSERT_ALIGNED1(Sym)
+    }
 };


-// Values for p_type
-#define PT_LOAD     1           /* Loadable program segment */
+template <class TP>
+struct ElfClass_64
+{
+    typedef TP BeLePolicy;
+
+    // integral types (target endianness)
+    typedef typename TP::U16 TE16;
+    typedef typename TP::U32 TE32;
+    typedef typename TP::U64 TE64;
+    typedef N_Elf::ElfITypes<TE16, TE32, TE64, TE64, TE64> ElfITypes;
+
+    // ELF types
+    typedef N_Elf  ::Ehdr<ElfITypes> Ehdr;
+    typedef N_Elf64::Phdr<ElfITypes> Phdr;
+    typedef N_Elf64::Shdr<ElfITypes> Shdr;
+    typedef N_Elf  ::Dyn <ElfITypes> Dyn;
+    typedef N_Elf  ::Rel <ElfITypes> Rel;
+    typedef N_Elf  ::Rela<ElfITypes> Rela;
+    typedef N_Elf64::Sym <ElfITypes> Sym;
+    typedef N_Elf  ::External_Note<ElfITypes> External_Note;
+
+    static void compileTimeAssertions() {
+        BeLePolicy::compileTimeAssertions();
+        COMPILE_TIME_ASSERT(sizeof(Ehdr) == 64)
+        COMPILE_TIME_ASSERT(sizeof(Phdr) == 56)
+        COMPILE_TIME_ASSERT(sizeof(Shdr) == 64)
+        COMPILE_TIME_ASSERT(sizeof(Dyn)  == 16)
+        COMPILE_TIME_ASSERT(sizeof(Rel)  == 16)
+        COMPILE_TIME_ASSERT(sizeof(Rela) == 24)
+        COMPILE_TIME_ASSERT(sizeof(Sym)  == 24)
+        COMPILE_TIME_ASSERT_ALIGNED1(Ehdr)
+        COMPILE_TIME_ASSERT_ALIGNED1(Phdr)
+        COMPILE_TIME_ASSERT_ALIGNED1(Shdr)
+        COMPILE_TIME_ASSERT_ALIGNED1(Dyn)
+        COMPILE_TIME_ASSERT_ALIGNED1(Rel)
+        COMPILE_TIME_ASSERT_ALIGNED1(Rela)
+        COMPILE_TIME_ASSERT_ALIGNED1(Sym)
+    }
+};
+
+
+} // namespace N_Elf
+
+
+typedef N_Elf::ElfClass_32<N_BELE_CTP::HostPolicy> ElfClass_Host32;
+typedef N_Elf::ElfClass_64<N_BELE_CTP::HostPolicy> ElfClass_Host64;
+typedef N_Elf::ElfClass_32<N_BELE_CTP::BEPolicy>   ElfClass_BE32;
+typedef N_Elf::ElfClass_64<N_BELE_CTP::BEPolicy>   ElfClass_BE64;
+typedef N_Elf::ElfClass_32<N_BELE_CTP::LEPolicy>   ElfClass_LE32;
+typedef N_Elf::ElfClass_64<N_BELE_CTP::LEPolicy>   ElfClass_LE64;
+
+
+/*************************************************************************
+// shortcuts
+**************************************************************************/
+
+typedef ElfClass_Host32::Ehdr Elf32_Ehdr;
+typedef ElfClass_Host32::Phdr Elf32_Phdr;
+typedef ElfClass_Host32::Shdr Elf32_Shdr;
+typedef ElfClass_Host32::Dyn  Elf32_Dyn;
+typedef ElfClass_Host32::Rel  Elf32_Rel;
+typedef ElfClass_Host32::Rela Elf32_Rela;
+typedef ElfClass_Host32::Sym  Elf32_Sym;
+typedef ElfClass_Host32::External_Note  Elf32_External_Note;
+
+typedef ElfClass_Host64::Ehdr Elf64_Ehdr;
+typedef ElfClass_Host64::Phdr Elf64_Phdr;
+typedef ElfClass_Host64::Shdr Elf64_Shdr;
+typedef ElfClass_Host64::Dyn  Elf64_Dyn;
+typedef ElfClass_Host64::Rel  Elf64_Rel;
+typedef ElfClass_Host64::Rela Elf64_Rela;
+typedef ElfClass_Host64::Sym  Elf64_Sym;
+typedef ElfClass_Host64::External_Note  Elf64_External_Note;
+
+typedef ElfClass_BE32::Ehdr   Elf_BE32_Ehdr;
+typedef ElfClass_BE32::Phdr   Elf_BE32_Phdr;
+typedef ElfClass_BE32::Shdr   Elf_BE32_Shdr;
+typedef ElfClass_BE32::Dyn    Elf_BE32_Dyn;
+typedef ElfClass_BE32::Rel    Elf_BE32_Rel;
+typedef ElfClass_BE32::Rela   Elf_BE32_Rela;
+typedef ElfClass_BE32::Sym    Elf_BE32_Sym;
+typedef ElfClass_BE32::External_Note    Elf_BE32_External_Note;
+
+typedef ElfClass_BE64::Ehdr   Elf_BE64_Ehdr;
+typedef ElfClass_BE64::Phdr   Elf_BE64_Phdr;
+typedef ElfClass_BE64::Shdr   Elf_BE64_Shdr;
+typedef ElfClass_BE64::Dyn    Elf_BE64_Dyn;
+typedef ElfClass_BE64::Rel    Elf_BE64_Rel;
+typedef ElfClass_BE64::Rela   Elf_BE64_Rela;
+typedef ElfClass_BE64::Sym    Elf_BE64_Sym;
+typedef ElfClass_BE64::External_Note    Elf_BE64_External_Note;
+
+typedef ElfClass_LE32::Ehdr   Elf_LE32_Ehdr;
+typedef ElfClass_LE32::Phdr   Elf_LE32_Phdr;
+typedef ElfClass_LE32::Shdr   Elf_LE32_Shdr;
+typedef ElfClass_LE32::Dyn    Elf_LE32_Dyn;
+typedef ElfClass_LE32::Rel    Elf_LE32_Rel;
+typedef ElfClass_LE32::Rela   Elf_LE32_Rela;
+typedef ElfClass_LE32::Sym    Elf_LE32_Sym;
+typedef ElfClass_LE32::External_Note    Elf_LE32_External_Note;
+
+typedef ElfClass_LE64::Ehdr   Elf_LE64_Ehdr;
+typedef ElfClass_LE64::Phdr   Elf_LE64_Phdr;
+typedef ElfClass_LE64::Shdr   Elf_LE64_Shdr;
+typedef ElfClass_LE64::Dyn    Elf_LE64_Dyn;
+typedef ElfClass_LE64::Rel    Elf_LE64_Rel;
+typedef ElfClass_LE64::Rela   Elf_LE64_Rela;
+typedef ElfClass_LE64::Sym    Elf_LE64_Sym;
+typedef ElfClass_LE64::External_Note    Elf_LE64_External_Note;

-// Values for p_flags
-#define PF_X        (1 << 0)    /* Segment is executable */
-#define PF_W        (1 << 1)    /* Segment is writable */
-#define PF_R        (1 << 2)    /* Segment is readable */

 #endif /* already included */

-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,253 @@
+/* p_elf_enum.h --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 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>
+ */
+
+
+/*************************************************************************
+// Use the preprocessor to work around
+//   - that the types embedding these enums have to be PODs, and
+//     deriving from an empty base class (which is the usual C++ way
+//     of "importing" enums) does not yield a POD any more
+//   - that older compilers do not correctly perform EBCO
+**************************************************************************/
+
+#ifdef WANT_EHDR_ENUM
+#undef WANT_EHDR_ENUM
+    enum { // e_ident[]
+        EI_CLASS      = 4,
+        EI_DATA       = 5,      /* Data encoding */
+        EI_VERSION    = 6,
+        EI_OSABI      = 7,
+        EI_ABIVERSION = 8
+    };
+    enum { // e_ident[EI_CLASS]
+        ELFCLASS32 = 1,         /* 32-bit objects */
+        ELFCLASS64 = 2          /* 64-bit objects */
+    };
+    enum { // e_ident[EI_DATA]
+        ELFDATA2LSB = 1,        /* 2's complement, little endian */
+        ELFDATA2MSB = 2         /* 2's complement, big endian */
+    };
+    enum { // e_ident[EI_OSABI]
+        ELFOSABI_NONE    = 0,      // == ELFOSABI_SYSV
+        ELFOSABI_NETBSD  = 2,
+        ELFOSABI_LINUX   = 3,
+        ELFOSABI_FREEBSD = 9,
+        ELFOSABI_OPENBSD = 12,
+        ELFOSABI_ARM     = 97
+    };
+    enum { // e_type
+        ET_NONE = 0,            /* No file type */
+        ET_REL  = 1,            /* Relocatable file */
+        ET_EXEC = 2,            /* Executable file */
+        ET_DYN  = 3,            /* Shared object file */
+        ET_CORE = 4             /* Core file */
+    };
+    enum { // e_machine
+        EM_386    = 3,
+        EM_MIPS   = 8,
+        EM_MIPS_RS3_LE =  10,   /* MIPS R3000 little-endian */
+        EM_PPC    = 20,
+        EM_PPC64  = 21,
+        EM_ARM    = 40,
+        EM_X86_64 = 62,
+        EM_AARCH64 = 183
+
+    };
+    enum { // e_version
+        EV_CURRENT = 1
+    };
+#endif
+
+
+#ifdef WANT_PHDR_ENUM
+#undef WANT_PHDR_ENUM
+    enum { // p_type
+        PT_LOAD    = 1,         /* Loadable program segment */
+        PT_DYNAMIC = 2,         /* Dynamic linking information */
+        PT_INTERP  = 3,         /* Name of program interpreter */
+        PT_NOTE    = 4,         /* Auxiliary information (esp. OpenBSD) */
+        PT_PHDR    = 6          /* Entry for header table itself */
+        , PT_GNU_STACK = 0x6474e551      /* Indicates stack executability */
+    };
+
+    enum { // p_flags
+        PF_X = 1,               /* Segment is executable */
+        PF_W = 2,               /* Segment is writable */
+        PF_R = 4                /* Segment is readable */
+    };
+#endif
+
+
+#ifdef WANT_SHDR_ENUM
+#undef WANT_SHDR_ENUM
+    enum { // sh_type
+        SHT_NULL = 0,           /* Section header table entry unused */
+        SHT_PROGBITS = 1,       /* Program data */
+        SHT_SYMTAB = 2,         /* Symbol table */
+        SHT_STRTAB = 3,         /* String table */
+        SHT_RELA = 4,           /* Relocation entries with addends */
+        SHT_HASH = 5,           /* Symbol hash table */
+        SHT_DYNAMIC = 6,        /* Dynamic linking information */
+        SHT_NOTE = 7,           /* Notes */
+        SHT_NOBITS = 8,         /* Program space with no data (bss) */
+        SHT_REL = 9,            /* Relocation entries, no addends */
+        SHT_SHLIB = 10,         /* Reserved */
+        SHT_DYNSYM = 11,        /* Dynamic linker symbol table */
+            /* 12, 13  hole */
+        SHT_INIT_ARRAY = 14,    /* Array of constructors */
+        SHT_FINI_ARRAY = 15,    /* Array of destructors */
+        SHT_PREINIT_ARRAY = 16, /* Array of pre-constructors */
+        SHT_GROUP = 17,         /* Section group */
+        SHT_SYMTAB_SHNDX = 18,  /* Extended section indeces */
+        SHT_GNU_LIBLIST = 0x6ffffff7    /* Prelink library list */
+
+        , SHT_LOOS = 0x60000000  /* LOcal OS; SHT_ANDROID_REL{,A} is +1, +2 */
+    };
+
+    enum { // sh_flags
+        SHF_WRITE      = (1 << 0),  /* Writable */
+        SHF_ALLOC      = (1 << 1),  /* Occupies memory during execution */
+        SHF_EXECINSTR  = (1 << 2),  /* Executable */
+        SHF_MERGE      = (1 << 4),  /* Might be merged */
+        SHF_STRINGS    = (1 << 5),  /* Contains nul-terminated strings */
+        SHF_INFO_LINK  = (1 << 6),  /* 'sh_info' contains SHT index */
+        SHF_LINK_ORDER = (1 << 7)   /* Preserve order after combining */
+    };
+#endif
+
+
+#ifdef WANT_DYN_ENUM
+#undef WANT_DYN_ENUM
+    enum { // d_tag
+        DT_NULL     =  0,       /* End flag */
+        DT_NEEDED   =  1,       /* Name of needed library */
+        DT_PLTRELSZ =  2,       /* Size in bytes of PLT relocs */
+        DT_HASH     =  4,       /* Hash table of symbol names */
+        DT_STRTAB   =  5,       /* String table */
+        DT_SYMTAB   =  6,       /* Symbol table */
+        DT_RELA     =  7,       /* Relocations which do contain an addend */
+        DT_RELASZ   =  8,       /* Total size of Rela relocs */
+        DT_RELAENT  =  9,       /* Size of one RELA relocation */
+        DT_INIT     = 12,       /* Address of init function */
+        DT_REL      = 17,       /* Relocations which contain no addend */
+        DT_RELENT   = 19,       /* Size of one Rel relocation */
+        DT_STRSZ    = 10,       /* Sizeof string table */
+        DT_PLTREL   = 20,       /* Type of reloc in PLT */
+        DT_TEXTREL  = 22,       /* Reloc might modify .text */
+        DT_JMPREL   = 23,       /* Address of PLT relocs */
+        DT_CHECKSUM = 0x6ffffdf8,       /* Only for prelink? */
+        DT_GNU_HASH = 0x6ffffef5,       /* GNU-style hash table */
+        DT_VERSYM   = 0x6ffffff0,       /* version[] for each symbol */
+        DT_VERDEF   = 0x6ffffffc,       /* version definitions[] */
+        DT_VERNEEDED= 0x6ffffffe        /* version[] needed */
+    };
+#endif
+
+
+#ifdef WANT_SYM_ENUM
+#undef WANT_SYM_ENUM
+    enum { // st_bind (high 4 bits of st_info)
+        STB_LOCAL   =   0,      /* Local symbol */
+        STB_GLOBAL  =   1,      /* Global symbol */
+        STB_WEAK    =   2       /* Weak symbol */
+    };
+
+    enum { // st_type (low 4 bits of st_info)
+        STT_NOTYPE  =   0,      /* Symbol type is unspecified */
+        STT_OBJECT  =   1,      /* Symbol is a data object */
+        STT_FUNC    =   2,      /* Symbol is a code object */
+        STT_SECTION =   3,      /* Symbol associated with a section */
+        STT_FILE    =   4,      /* Symbol's name is file name */
+        STT_COMMON  =   5,      /* Symbol is a common data object */
+        STT_TLS     =   6       /* Symbol is thread-local data object*/
+    };
+
+    enum { // st_other (visibility)
+        STV_DEFAULT  =  0,      /* Default symbol visibility rules */
+        STV_INTERNAL =  1,      /* Processor specific hidden class */
+        STV_HIDDEN   =  2,      /* Sym unavailable in other modules */
+        STV_PROTECTED=  3       /* Not preemptible, not exported */
+    };
+
+    enum { // st_shndx
+        SHN_UNDEF   =   0,      /* Undefined section */
+        SHN_ABS     =   0xfff1, /* Associated symbol is absolute */
+        SHN_COMMON  =   0xfff2  /* Associated symbol is common */
+    };
+#endif
+
+
+#ifdef WANT_NHDR_ENUM
+#undef WANT_NHDR_ENUM
+    enum { // ELF PT_NOTE types
+#define ELF_NOTE_GNU_NAME "GNU\0"
+        NT_GNU_ABI_TAG = 1,
+        NT_GNU_HWCAP = 2,
+        NT_GNU_BUILD_ID = 3,
+
+#define ELF_NOTE_OPENBSD_NAME "OpenBSD\0"
+        NHDR_OPENBSD_TAG = 1,
+
+#define ELF_NOTE_NETBSD_NAME "NetBSD\0"
+        NHDR_NETBSD_TAG = 1,
+        NHDR_CHECKSUM_TAG = 2,
+        NHDR_PAX_TAG = 3
+    };
+
+    enum { // descsz  descriptor sizes
+        GNU_ABI_DESCSZ = 16, // int GNU_OS, major, minor, subminor;
+        NETBSD_DESCSZ = 4,   // major_ver * (10**8) + minor
+        OPENBSD_DESCSZ = 4,  // 32-bit zero
+            // CHECKSUM_DESCSZ is 2*sizeof(short) + sizeof(checksum)
+        PAX_DESCSZ = 4  // 32-bit mask
+    };
+
+    enum { // GNU OS/version
+        GNU_OS_LINUX = 0,
+        GNU_OS_HURD = 1,
+        GNU_OS_SOLARIS = 2
+    };
+
+    enum { // NetBSD checksum methods
+        CHECKSUM_CRC32 = 1,
+        CHECKSUM_MD5 = 2,
+        CHECKSUM_SHA1 = 3,
+        CHECKSUM_SHA256 = 4
+    };
+
+#define ELF_NOTE_PAX_NAME "PaX\0"
+    enum { // NetBSD PaX bit values
+        PAX_MPROTECT   = (1<<0),  /* force  enable Mprotect */
+        PAX_NOMPROTECT = (1<<1),  /* force disable Mprotect */
+        PAX_GUARD      = (1<<2),  /* force  enable SEGVguard */
+        PAX_NOGUARD    = (1<<3),  /* force disable SEGVguard */
+        PAX_ASLR       = (1<<4),  /* force  enable ASLR */
+        PAX_NOASLR     = (1<<5)   /* force disable ASLR */
+    };
+#endif
+
+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,8 +21,8 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


@@ -31,14 +31,17 @@
 #include "filter.h"
 #include "packer.h"
 #include "p_exe.h"
+#include "linker.h"

 static const
-#include "stub/l_exe.h"
+#include "stub/i086-dos16.exe.h"

 #define RSFCRI          4096    // Reserved Space For Compressed Relocation Info
 #define MAXMATCH        0x2000
 #define MAXRELOCS       (0x8000-MAXMATCH)

+#define DI_LIMIT        0xff00  // see the assembly why
+

 /*************************************************************************
 //
@@ -47,18 +50,23 @@ static const
 PackExe::PackExe(InputFile *f) :
    super(f)
 {
-    assert(sizeof(exe_header_t) == 32);
+    bele = &N_BELE_RTP::le_policy;
+    COMPILE_TIME_ASSERT(sizeof(exe_header_t) == 32)
+    COMPILE_TIME_ASSERT_ALIGNED1(exe_header_t)
    ih_exesize = ih_imagesize = ih_overlay = 0;
+    stack_for_lzma = 0;
+    use_clear_dirty_stack = false;
 }


-int PackExe::getCompressionMethod() const
+const int *PackExe::getCompressionMethods(int method, int level) const
 {
-    if (M_IS_NRV2B(opt->method))
-        return M_NRV2B_8;
-    if (M_IS_NRV2D(opt->method))
-        return M_NRV2D_8;
-    return opt->level > 1 && ih_imagesize >= 300000 ? M_NRV2D_8 : M_NRV2B_8;
+    bool small = ih_imagesize <= 256*1024;
+    // disable lzma for "--brute" unless explicitly given "--lzma"
+    // WARNING: this side effect persists for later files!
+    if (opt->all_methods_use_lzma && !opt->method_lzma_seen)
+        opt->all_methods_use_lzma = false;
+    return Packer::getDefaultCompressionMethods_8(method, level, small);
 }


@@ -68,16 +76,210 @@ const int *PackExe::getFilters() const
 }


+int PackExe::fillExeHeader(struct exe_header_t *eh) const
+{
+#define oh  (*eh)
+    // fill new exe header
+    int flag = 0;
+    if (!opt->dos_exe.no_reloc && !M_IS_LZMA(ph.method))
+        flag |= USEJUMP;
+    if (ih.relocs == 0)
+        flag |= NORELOC;
+
+    memset(&oh,0,sizeof(oh));
+    oh.ident = 'M' + 'Z' * 256;
+    oh.headsize16 = 2;
+
+    unsigned minsp = 0x200;
+    if (M_IS_LZMA(ph.method))
+        minsp = stack_for_lzma;
+    minsp = ALIGN_UP(minsp, 16u);
+    assert(minsp < 0xff00);
+    if (oh.sp > minsp)
+        minsp = oh.sp;
+    if (minsp < 0xff00 - 2)
+        minsp = ALIGN_UP(minsp, 2u);
+    oh.sp = minsp;
+
+    unsigned destpara = (ph.u_len + ph.overlap_overhead - ph.c_len + 31) / 16;
+    oh.ss = ph.c_len/16 + destpara;
+    if (ih.ss*16 + ih.sp < 0x100000 && ih.ss > oh.ss && ih.sp > 0x200)
+        oh.ss = ih.ss;
+    if (oh.ss*16 + 0x50 < ih.ss*16 + ih.sp
+        && oh.ss*16 + 0x200 > ih.ss*16 + ih.sp)
+        oh.ss += 0x20;
+
+    if (oh.ss != ih.ss)
+        flag |= SS;
+    if (oh.sp != ih.sp || M_IS_LZMA(ph.method))
+        flag |= SP;
+    return flag;
+#undef oh
+}
+
+void PackExe::addLoaderEpilogue(int flag)
+{
+    addLoader("EXEMAIN5", NULL);
+    if (relocsize)
+        addLoader(ph.u_len <= DI_LIMIT || (ph.u_len & 0x7fff) >= relocsize ? "EXENOADJ" : "EXEADJUS",
+                  "EXERELO1",
+                  has_9a ? "EXEREL9A" : "",
+                  "EXERELO2",
+                  ih_exesize > 0xFE00 ? "EXEREBIG" : "",
+                  "EXERELO3",
+                  NULL
+                 );
+    addLoader("EXEMAIN8",
+              device_driver ? "DEVICEEND" : "",
+              (flag & SS) ? "EXESTACK" : "",
+              (flag & SP) ? "EXESTASP" : "",
+              (flag & USEJUMP) ? "EXEJUMPF" : "",
+              NULL
+             );
+    if (!(flag & USEJUMP))
+        addLoader(ih.cs ? "EXERCSPO" : "",
+                  "EXERETIP",
+                  NULL
+                 );
+
+    linker->defineSymbol("original_cs", ih.cs);
+    linker->defineSymbol("original_ip", ih.ip);
+    linker->defineSymbol("original_sp", ih.sp);
+    linker->defineSymbol("original_ss", ih.ss);
+    linker->defineSymbol("reloc_size",
+                         (ph.u_len <= DI_LIMIT || (ph.u_len & 0x7fff)
+                          >= relocsize ? 0 : MAXRELOCS) - relocsize);
+}
+
+void PackExe::buildLoader(const Filter *)
+{
+    // get flag
+    exe_header_t dummy_oh;
+    int flag = fillExeHeader(&dummy_oh);
+
+    initLoader(stub_i086_dos16_exe, sizeof(stub_i086_dos16_exe));
+
+    if (M_IS_LZMA(ph.method))
+    {
+        addLoader("LZMA_DEC00",
+                  opt->small ? "LZMA_DEC10" : "LZMA_DEC20",
+                  "LZMA_DEC30",
+                  use_clear_dirty_stack ? "LZMA_DEC31" : "",
+                  "LZMA_DEC32",
+                  ph.u_len > 0xffff ? "LZMA_DEC33" : "",
+                  NULL
+                 );
+
+        addLoaderEpilogue(flag);
+        defineDecompressorSymbols();
+        const unsigned lsize0 = getLoaderSize();
+
+        // Lzma decompression code starts at ss:0x10, and its size is
+        // lsize bytes. It also needs getDecompressorWrkmemSize() bytes
+        // during uncompression. It also uses some stack, so 0x100
+        // more bytes are allocated
+        stack_for_lzma = 0x10 + lsize0 + getDecompressorWrkmemSize() + 0x100;
+        stack_for_lzma = ALIGN_UP(stack_for_lzma, 16u);
+
+        unsigned clear_dirty_stack_low = 0x10 + lsize0;
+        clear_dirty_stack_low = ALIGN_UP(clear_dirty_stack_low, 2u);
+        if (use_clear_dirty_stack)
+            linker->defineSymbol("clear_dirty_stack_low", clear_dirty_stack_low);
+
+        relocateLoader();
+        const unsigned lsize = getLoaderSize();
+        assert(lsize0 == lsize);
+        MemBuffer loader(lsize);
+        memcpy(loader, getLoader(), lsize);
+
+        MemBuffer compressed_lzma;
+        compressed_lzma.allocForCompression(lsize);
+        unsigned c_len_lzma = MemBuffer::getSizeForCompression(lsize);
+        int r = upx_compress(loader, lsize, compressed_lzma, &c_len_lzma,
+                             NULL, M_NRV2B_LE16, 9, NULL, NULL);
+        assert(r == UPX_E_OK); assert(c_len_lzma < lsize);
+
+        info("lzma+relocator code compressed: %u -> %u", lsize, c_len_lzma);
+        // reinit the loader
+        initLoader(stub_i086_dos16_exe, sizeof(stub_i086_dos16_exe));
+        // prepare loader
+        if (device_driver)
+            addLoader("DEVICEENTRY,LZMADEVICE,DEVICEENTRY2", NULL);
+
+        linker->addSection("COMPRESSED_LZMA", compressed_lzma, c_len_lzma, 0);
+        addLoader("LZMAENTRY,NRV2B160,NRVDDONE,NRVDECO1,NRVGTD00,NRVDECO2",
+                  NULL);
+
+    }
+    else if (device_driver)
+        addLoader("DEVICEENTRY,DEVICEENTRY2", NULL);
+
+    addLoader("EXEENTRY",
+              M_IS_LZMA(ph.method) && device_driver ? "LONGSUB" : "SHORTSUB",
+              "JNCDOCOPY",
+              relocsize ? "EXERELPU" : "",
+              "EXEMAIN4",
+              M_IS_LZMA(ph.method) ? "" : "EXEMAIN4B",
+              "EXEMAIN4C",
+              M_IS_LZMA(ph.method) ? "COMPRESSED_LZMA_START,COMPRESSED_LZMA" : "",
+              "+G5DXXXX,UPX1HEAD,EXECUTPO",
+              NULL
+             );
+    if (ph.method == M_NRV2B_8)
+        addLoader("NRV2B16S",               // decompressor
+                  ph.u_len > DI_LIMIT ? "N2B64K01" : "",
+                  "NRV2BEX1",
+                  opt->cpu == opt->CPU_8086 ? "N2BX8601" : "N2B28601",
+                  "NRV2BEX2",
+                  opt->cpu == opt->CPU_8086 ? "N2BX8602" : "N2B28602",
+                  "NRV2BEX3",
+                  ph.c_len > 0xffff ? "N2B64K02" : "",
+                  "NRV2BEX9",
+                  NULL
+                 );
+    else if (ph.method == M_NRV2D_8)
+        addLoader("NRV2D16S",
+                  ph.u_len > DI_LIMIT ? "N2D64K01" : "",
+                  "NRV2DEX1",
+                  opt->cpu == opt->CPU_8086 ? "N2DX8601" : "N2D28601",
+                  "NRV2DEX2",
+                  opt->cpu == opt->CPU_8086 ? "N2DX8602" : "N2D28602",
+                  "NRV2DEX3",
+                  ph.c_len > 0xffff ? "N2D64K02" : "",
+                  "NRV2DEX9",
+                  NULL
+                 );
+    else if (ph.method == M_NRV2E_8)
+        addLoader("NRV2E16S",
+                  ph.u_len > DI_LIMIT ? "N2E64K01" : "",
+                  "NRV2EEX1",
+                  opt->cpu == opt->CPU_8086 ? "N2EX8601" : "N2E28601",
+                  "NRV2EEX2",
+                  opt->cpu == opt->CPU_8086 ? "N2EX8602" : "N2E28602",
+                  "NRV2EEX3",
+                  ph.c_len > 0xffff ? "N2E64K02" : "",
+                  "NRV2EEX9",
+                  NULL
+                 );
+    else if M_IS_LZMA(ph.method)
+        return;
+    else
+        throwInternalError("unknown compression method");
+
+    addLoaderEpilogue(flag);
+}
+
+
 /*************************************************************************
 //
 **************************************************************************/

-bool PackExe::readFileHeader()
+int PackExe::readFileHeader()
 {
    ih_exesize = ih_imagesize = ih_overlay = 0;
    fi->readx(&ih,sizeof(ih));
    if (ih.ident != 'M' + 'Z'*256 && ih.ident != 'Z' + 'M'*256)
-        return false;
+        return 0;
    ih_exesize = ih.m512 + ih.p512*512 - (ih.m512 ? 512 : 0);
    ih_imagesize = ih_exesize - ih.headsize16*16;
    ih_overlay = file_size - ih_exesize;
@@ -88,7 +290,7 @@ bool PackExe::readFileHeader()
 #if 0
    printf("dos/exe header: %d %d %d\n", ih_exesize, ih_imagesize, ih_overlay);
 #endif
-    return true;
+    return UPX_F_DOS_EXE;
 }


@@ -105,7 +307,7 @@ bool PackExe::canPack()
    fi->readx(&offs,sizeof (offs));
    if (ih.relocoffs >= 0x40 && offs)
    {
-        if (opt->dos.force_stub)
+        if (opt->dos_exe.force_stub)
            opt->overlay = opt->COPY_OVERLAY;
        else
            throwCantPack("can't pack new-exe");
@@ -123,7 +325,10 @@ unsigned optimize_relocs(upx_byte *b, const unsigned size,
                         const upx_byte *relocs, const unsigned nrelocs,
                         upx_byte *crel, bool *has_9a)
 {
-    upx_byte *crel_save = crel;
+    if (opt->exact)
+        throwCantPackExact();
+
+    upx_byte * const crel_save = crel;
    unsigned i;
    unsigned seg_high = 0;
 #if 0
@@ -185,7 +390,9 @@ unsigned optimize_relocs(upx_byte *b, const unsigned size,
        {
            addr = get_le32(relocs+4*i);
            //printf ("%x\n",es*16+di);
-            if (addr - es*16 > 0xfffe)
+            if ((addr - es*16 > 0xfffe)
+                || (i == nrelocs - 1 && addr - es * 16 > 0xff00)
+               )
            {
                // segment change
                t = 1+(0xffff-di)/254;
@@ -195,7 +402,7 @@ unsigned optimize_relocs(upx_byte *b, const unsigned size,
                break;
            }
            unsigned offs = addr - es*16;
-            if (offs >= 3 && b[es*16 + offs-3] == 0x9a)
+            if (offs >= 3 && b[es*16 + offs-3] == 0x9a && offs > di + 3)
            {
                for (t = di; t < offs-3; t++)
                    if (b[es*16+t] == 0x9a && get_le16(b+es*16+t+3) <= seg_high)
@@ -230,7 +437,7 @@ unsigned optimize_relocs(upx_byte *b, const unsigned size,
    set_le16 (crel_save+2,seg_high);

    //OutputFile::dump("x.rel", crel_save, crel - crel_save);
-    return crel - crel_save;
+    return (unsigned) (crel - crel_save);
 }


@@ -241,35 +448,27 @@ unsigned optimize_relocs(upx_byte *b, const unsigned size,
 void PackExe::pack(OutputFile *fo)
 {
    unsigned ic;
-    unsigned char flag = 0;

-    unsigned char extra_info[32];
-    unsigned eisize = 0;
-
-    //
-    const unsigned exesize = ih_exesize;
-    const unsigned imagesize = ih_imagesize;
-    const unsigned overlay = ih_overlay;
    if (ih.relocs > MAXRELOCS)
        throwCantPack("too many relocations");
-    checkOverlay(overlay);
+    checkOverlay(ih_overlay);

    // alloc buffers
-    unsigned relocsize = RSFCRI + 4*ih.relocs;
-
-    ibuf.alloc(imagesize+16+relocsize+2);
-    obuf.allocForCompression(imagesize+16+relocsize+2);
+    relocsize = RSFCRI + 4*ih.relocs;
+    ibuf.alloc(ih_imagesize+16+relocsize+2);
+    obuf.allocForCompression(ih_imagesize+16+relocsize+2);

    // read image
    fi->seek(ih.headsize16*16,SEEK_SET);
-    fi->readx(ibuf,imagesize);
+    fi->readx(ibuf,ih_imagesize);

-    if (find_le32(ibuf, UPX_MIN(imagesize, 127u), UPX_MAGIC_LE32) >= 0)
-        throwAlreadyPacked();
+    checkAlreadyPacked(ibuf, UPX_MIN(ih_imagesize, 127u));
+
+    device_driver = get_le32(ibuf) == 0xffffffffu;

    // relocations
    has_9a = false;
-    upx_byte *w = ibuf + imagesize;
+    upx_byte *w = ibuf + ih_imagesize;
    if (ih.relocs)
    {
        upx_byte *wr = w + RSFCRI;
@@ -280,10 +479,10 @@ void PackExe::pack(OutputFile *fo)
        for (ic = 0; ic < ih.relocs; ic++)
        {
            unsigned jc = get_le32(wr+4*ic);
-            set_le32(wr+4*ic, (jc>>16)*16+(jc&0xffff));
+            set_le32(wr+4*ic, ((jc>>16)*16+(jc&0xffff)) & 0xfffff);
        }
        qsort(wr,ih.relocs,4,le32_compare);
-        relocsize = optimize_relocs(ibuf, imagesize, wr, ih.relocs, w, &has_9a);
+        relocsize = optimize_relocs(ibuf, ih_imagesize, wr, ih.relocs, w, &has_9a);
        set_le16(w+relocsize, relocsize+2);
        relocsize += 2;
        if (relocsize > MAXRELOCS)
@@ -298,121 +497,43 @@ void PackExe::pack(OutputFile *fo)
    }
    else
    {
-        flag |= NORELOC;
        relocsize = 0;
    }

-    ph.u_len = imagesize + relocsize;
-    if (!compress(ibuf,obuf,0,MAXMATCH))
-        throwNotCompressible();
-    const unsigned overlapoh = findOverlapOverhead(obuf,32);
+    // prepare packheader
+    ph.u_len = ih_imagesize + relocsize;
+    // prepare filter
+    Filter ft(ph.level);
+    // compress (max_match = 8192)
+    upx_compress_config_t cconf; cconf.reset();
+    cconf.conf_ucl.max_match = MAXMATCH;
+    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
+    compressWithFilters(&ft, 32, &cconf);

-    if (ph.max_run_found + ph.max_match_found > 0x8000)
-        throwCantPack("decompressor limit exceeded, send a bugreport");
-#ifdef TESTING
-    if (opt->debug)
+    if (M_IS_NRV2B(ph.method) || M_IS_NRV2D(ph.method) || M_IS_NRV2E(ph.method))
+        if (ph.max_run_found + ph.max_match_found > 0x8000)
+            throwCantPack("decompressor limit exceeded, send a bugreport");
+
+#if TESTING
+    if (opt->debug.debug_level)
    {
-        printf("image+relocs %d -> %d\n",imagesize+relocsize,ph.c_len);
+        printf("image+relocs %d -> %d\n",ih_imagesize+relocsize,ph.c_len);
        printf("offsets: %d - %d\nmatches: %d - %d\nruns: %d - %d\n",
               0/*ph.min_offset_found*/,ph.max_offset_found,
               0/*ph.min_match_found*/,ph.max_match_found,
               0/*ph.min_run_found*/,ph.max_run_found);
    }
 #endif
-    const unsigned packedsize = ph.c_len;

-    if (!opt->dos.no_reloc)
-        flag |= USEJUMP;
+    int flag = fillExeHeader(&oh);

-    // fill new exe header
-    memset(&oh,0,sizeof(oh));
-    oh.ident = 'M' + 'Z' * 256;
-
-    unsigned destpara = (ph.u_len+overlapoh-packedsize+31)/16;
-
-    oh.ss = packedsize/16 + destpara;
-    if (ih.ss*16 + ih.sp < 0x100000 && ih.ss > oh.ss && ih.sp > 0x200)
-        oh.ss = ih.ss;
-    oh.sp = ih.sp > 0x200 ? ih.sp : 0x200;
-    if (oh.ss*16u + 0x50 < ih.ss*16u + ih.sp
-        && oh.ss*16u + 0x200 > ih.ss*16u + ih.sp)
-        oh.ss += 0x20;
-
-    destpara = oh.ss - packedsize/16;
-    if (oh.ss != ih.ss)
-    {
-        set_le16(extra_info+eisize,ih.ss);
-        eisize += 2;
-        flag |= SS;
-    }
-    if (oh.sp != ih.sp)
-    {
-        set_le16(extra_info+eisize,ih.sp);
-        eisize += 2;
-        flag |= SP;
-    }
-
-#define DI_LIMIT 0xff00  // see the assembly why
-    // prepare loader
-    initLoader(nrv_loader,sizeof(nrv_loader));
-    addLoader("EXEENTRY",
-              relocsize ? "EXERELPU" : "",
-              "EXEMAIN4""+G5DXXXX""UPX1HEAD""EXECUTPO",
-              NULL
-             );
-    if (ph.method == M_NRV2B_8)
-        addLoader("NRV2B16S",               // decompressor
-                  ph.u_len > DI_LIMIT ? "NDIGT64K" : "",
-                  "NRV2BEX1",
-                  opt->cpu == opt->CPU_8086 ? "N2BX8601" : "N2B28601",
-                  "NRV2BEX2",
-                  opt->cpu == opt->CPU_8086 ? "N2BX8602" : "N2B28602",
-                  "NRV2BEX3",
-                  packedsize > 0xffff ? "NSIGT64K" : "",
-                  "NRV2BEX9""NRV2B16E",
-                  NULL
-                 );
-    else if (ph.method == M_NRV2D_8)
-        addLoader("NRV2D16S",
-                  ph.u_len > DI_LIMIT ? "NDIGT64D" : "",
-                  "NRV2DEX1",
-                  opt->cpu == opt->CPU_8086 ? "N2DX8601" : "N2D28601",
-                  "NRV2DEX2",
-                  opt->cpu == opt->CPU_8086 ? "N2DX8602" : "N2D28602",
-                  "NRV2DEX3",
-                  packedsize > 0xffff ? "NSIGT64D" : "",
-                  "NRV2DEX9""NRV2D16E",
-                  NULL
-                 );
-    else
-        throwInternalError("unknown compression method");
-    addLoader("EXEMAIN5", NULL);
-    if (relocsize)
-        addLoader(ph.u_len <= DI_LIMIT || (ph.u_len & 0x7fff) >= relocsize ? "EXENOADJ" : "EXEADJUS",
-                  "EXERELO1",
-                  has_9a ? "EXEREL9A" : "",
-                  "EXERELO2",
-                  exesize > 0xFE00 ? "EXEREBIG" : "",
-                  "EXERELO3",
-                  NULL
-                 );
-    addLoader("EXEMAIN8",
-              (flag & SS) ? "EXESTACK" : "",
-              (flag & SP) ? "EXESTASP" : "",
-              (flag & USEJUMP) ? "EXEJUMPF" : "",
-              NULL
-             );
-    if (!(flag & USEJUMP))
-        addLoader(ih.cs ? "EXERCSPO" : "",
-                  "EXERETIP",
-                  NULL
-                 );
    const unsigned lsize = getLoaderSize();
    MemBuffer loader(lsize);
    memcpy(loader,getLoader(),lsize);
    //OutputFile::dump("xxloader.dat", loader, lsize);

    // patch loader
+    const unsigned packedsize = ph.c_len;
    const unsigned e_len = getLoaderSectionStart("EXECUTPO");
    const unsigned d_len = lsize - e_len;
    assert((e_len&15) == 0);
@@ -420,17 +541,29 @@ void PackExe::pack(OutputFile *fo)
    const unsigned copysize = (1+packedsize+d_len) & ~1;
    const unsigned firstcopy = copysize%0x10000 ? copysize%0x10000 : 0x10000;

-    oh.headsize16 = 2;
-    oh.ip = 0;
-
-    ic = ih.min*16+imagesize;
+    // set oh.min & oh.max
+    ic = ih.min*16 + ih_imagesize;
    if (ic < oh.ss*16u + oh.sp)
        ic = oh.ss*16u + oh.sp;
-
    oh.min = (ic - (packedsize + lsize)) / 16;
-    ic = ((unsigned) oh.min) + (ih.max - ih.min);
+    ic = oh.min + (ih.max - ih.min);
    oh.max = ic < 0xffff && ih.max != 0xffff ? ic : 0xffff;

+    // set extra info
+    unsigned char extra_info[9];
+    unsigned eisize = 0;
+    if (oh.ss != ih.ss)
+    {
+        set_le16(extra_info+eisize,ih.ss);
+        eisize += 2;
+        assert((flag & SS) != 0);   // set in fillExeHeader()
+    }
+    if (oh.sp != ih.sp)
+    {
+        set_le16(extra_info+eisize,ih.sp);
+        eisize += 2;
+        assert((flag & SP) != 0);   // set in fillExeHeader()
+    }
    if (ih.min != oh.min)
    {
        set_le16(extra_info+eisize,ih.min);
@@ -443,57 +576,63 @@ void PackExe::pack(OutputFile *fo)
        eisize += 2;
        flag |= MAXMEM;
    }
+    extra_info[eisize++] = (unsigned char) flag;

+    if (M_IS_NRV2B(ph.method) || M_IS_NRV2D(ph.method) || M_IS_NRV2E(ph.method))
+        linker->defineSymbol("bx_magic", 0x7FFF + 0x10 * ((packedsize & 15) + 1));
+
+    unsigned decompressor_entry = 1 + (packedsize & 15);
+    if (M_IS_LZMA(ph.method))
+        decompressor_entry = 0x10;
+    linker->defineSymbol("decompressor_entry", decompressor_entry);
+
+    // patch loader
    if (flag & USEJUMP)
    {
        // I use a relocation entry to set the original cs
-        unsigned n = find_le32(loader,lsize,get_le32("IPCS"));
-        patch_le32(loader,lsize,get_le32("IPCS"), ih.cs*0x10000 + ih.ip);
+        unsigned n = getLoaderSectionStart("EXEJUMPF") + 1;
        n += packedsize + 2;
        oh.relocs = 1;
-        oh.firstreloc = (n&0xf) + ((n>>4)<<16);
+        oh.firstreloc = (n & 0xf) + ((n >> 4) << 16);
    }
    else
    {
-        patch_le16(loader,lsize,"IP",ih.ip);
-        if (ih.cs)
-            patch_le16(loader,lsize,"CS",ih.cs);
        oh.relocs = 0;
-        oh.firstreloc = ih.cs*0x10000 + ih.ip;
+        oh.firstreloc = ih.cs * 0x10000 + ih.ip;
    }
-    oh.relocoffs = offsetof(exe_header_t, firstreloc);

-    if (flag & SP)
-        patch_le16(loader,lsize,"SP",ih.sp);
-    if (flag & SS)
-        patch_le16(loader,lsize,"SS",ih.ss);
-    if (relocsize)
-        patch_le16(loader,lsize,"RS",(ph.u_len <= DI_LIMIT || (ph.u_len & 0x7fff) >= relocsize ? 0 : MAXRELOCS) - relocsize);
+    // g++ 3.1 does not like the following line...
+//    oh.relocoffs = offsetof(exe_header_t, firstreloc);
+    oh.relocoffs = ptr_diff(&oh.firstreloc, &oh);

-    patchPackHeader(loader,e_len);
+    linker->defineSymbol("destination_segment", oh.ss - ph.c_len / 16 - e_len / 16);
+    linker->defineSymbol("source_segment", e_len / 16 + (copysize - firstcopy) / 16);
+    linker->defineSymbol("copy_offset", firstcopy - 2);
+    linker->defineSymbol("words_to_copy",firstcopy / 2);

-    patch_le16(loader,e_len,"BX",0x800F + 0x10*((packedsize&15)+1) - 0x10);
-    patch_le16(loader,e_len,"BP",(packedsize&15)+1);
+    linker->defineSymbol("exe_stack_sp", oh.sp);
+    linker->defineSymbol("exe_stack_ss", oh.ss);
+    linker->defineSymbol("interrupt", get_le16(ibuf + 8));
+    linker->defineSymbol("attribute", get_le16(ibuf + 4));
+    linker->defineSymbol("orig_strategy", get_le16(ibuf + 6));

-    patch_le16(loader,e_len,"ES",destpara-e_len/16);
-    patch_le16(loader,e_len,"DS",e_len/16+(copysize-firstcopy)/16);
-    patch_le16(loader,e_len,"SI",firstcopy-2);
-    patch_le16(loader,e_len,"CX",firstcopy/2);
-
-    // finish --stub support
-    //if (ih.relocoffs >= 0x40 && memcmp(&ih.relocoffs,">TIPPACH",8))
-    //    throwCantPack("FIXME");
-
-    extra_info[eisize++] = flag;
    const unsigned outputlen = sizeof(oh)+lsize+packedsize+eisize;
    oh.m512 = outputlen & 511;
    oh.p512 = (outputlen + 511) >> 9;

-//fprintf(stderr,"\ne_len=%x d_len=%x clen=%x oo=%x ulen=%x destp=%x copys=%x images=%x",e_len,d_len,packedsize,overlapoh,ph.u_len,destpara,copysize,imagesize);
+    const char *exeentry = M_IS_LZMA(ph.method) ? "LZMAENTRY" : "EXEENTRY";
+    oh.ip = device_driver ? getLoaderSection(exeentry) - 2 : 0;
+
+    defineDecompressorSymbols();
+    relocateLoader();
+    memcpy(loader, getLoader(), lsize);
+    patchPackHeader(loader,e_len);
+
+//fprintf(stderr,"\ne_len=%x d_len=%x c_len=%x oo=%x ulen=%x destp=%x copys=%x images=%x",e_len,d_len,packedsize,ph.overlap_overhead,ph.u_len,destpara,copysize,ih_imagesize);

    // write header + write loader + compressed file
-#ifdef TESTING
-    if (opt->debug)
+#if TESTING
+    if (opt->debug.debug_level)
        printf("\n%d %d %d %d\n",(int)sizeof(oh),e_len,packedsize,d_len);
 #endif
    fo->write(&oh,sizeof(oh));
@@ -511,10 +650,10 @@ void PackExe::pack(OutputFile *fo)
 #endif

    // verify
-    verifyOverlappingDecompression(&obuf, overlapoh);
+    verifyOverlappingDecompression();

    // copy the overlay
-    copyOverlay(fo, overlay, &obuf);
+    copyOverlay(fo, ih_overlay, &obuf);
 //fprintf (stderr,"%x %x\n",relocsize,ph.u_len);

    // finally check the compression ratio
@@ -533,7 +672,7 @@ int PackExe::canUnpack()
        return false;
    const off_t off = ih.headsize16 * 16;
    fi->seek(off, SEEK_SET);
-    bool b = readPackHeader(128);
+    bool b = readPackHeader(4096);
    return b && (off + (off_t) ph.c_len <= file_size);
 }

@@ -548,23 +687,22 @@ void PackExe::unpack(OutputFile *fo)
    obuf.allocForUncompression(ph.u_len);

    // read the file
-    unsigned imagesize = ih_imagesize;
-    const unsigned overlay = ih_overlay;
-
    fi->seek(ih.headsize16*16,SEEK_SET);
-    fi->readx(ibuf,imagesize);
+    fi->readx(ibuf,ih_imagesize);

    // get compressed data offset
    unsigned e_len = ph.buf_offset + ph.getPackHeaderSize();
-    if (imagesize <= e_len + ph.c_len)
+    if (ih_imagesize <= e_len + ph.c_len)
        throwCantUnpack("file damaged");

-    checkOverlay(overlay);
+    checkOverlay(ih_overlay);

    // decompress
    decompress(ibuf+e_len,obuf);

-    const unsigned char flag = ibuf[imagesize-1];
+    unsigned imagesize = ih_imagesize;
+    imagesize--;
+    const unsigned char flag = ibuf[imagesize];

    unsigned relocn = 0;
    upx_byte *relocs = obuf + ph.u_len;
@@ -574,12 +712,11 @@ void PackExe::unpack(OutputFile *fo)
    {
        relocs -= get_le16(obuf+ph.u_len-2);
        ph.u_len -= 2;
-        upx_byte *p;

        wrkmem.alloc(4*MAXRELOCS);
-        unsigned es = 0,ones = get_le16(relocs);
-        unsigned seghi = get_le16(relocs+2);
-        p = relocs + 4;
+        unsigned es = 0, ones = get_le16(relocs);
+        const unsigned seghi = get_le16(relocs+2);
+        const upx_byte *p = relocs + 4;

        while (ones)
        {
@@ -597,10 +734,10 @@ void PackExe::unpack(OutputFile *fo)
                dorel = true;
                if (*p == 0)
                {
-                    upx_byte *q;
+                    const upx_byte *q;
                    for (q = obuf+es*16+di; !(*q == 0x9a && get_le16(q+3) <= seghi); q++)
                        ;
-                    di = q - (obuf+es*16) + 3;
+                    di = ptr_diff(q, obuf+es*16) + 3;
                }
                else if (*p == 1)
                {
@@ -614,35 +751,38 @@ void PackExe::unpack(OutputFile *fo)
            }
        }
    }
+
    // fill new exe header
    memset(&oh,0,sizeof(oh));
    oh.ident = 'M' + 'Z'*256;

-    oh.relocs = relocn;
-    while (relocn&3)
-        set_le32(wrkmem+4*relocn++,0);
+    if (relocn)
+    {
+        oh.relocs = relocn;
+        while (relocn & 3)
+            set_le32(wrkmem+4*relocn++,0);
+    }

-    unsigned outputlen = sizeof(oh)+relocn*4+relocs-obuf;
+    unsigned outputlen = ptr_diff(relocs, obuf) + sizeof(oh) + relocn*4;
    oh.m512 = outputlen & 511;
    oh.p512 = (outputlen + 511) >> 9;
    oh.headsize16 = 2+relocn/4;

-    imagesize--;
    oh.max = ih.max;
    oh.min = ih.min;
    oh.sp = ih.sp;
    oh.ss = ih.ss;

    if (flag & MAXMEM)
-        imagesize -= 2, oh.max = get_le16(ibuf+imagesize);
+        { imagesize -= 2; oh.max = get_le16(ibuf+imagesize); }
    if (flag & MINMEM)
-        imagesize -= 2, oh.min = get_le16(ibuf+imagesize);
+        { imagesize -= 2; oh.min = get_le16(ibuf+imagesize); }
    if (flag & SP)
-        imagesize -= 2, oh.sp = get_le16(ibuf+imagesize);
+        { imagesize -= 2; oh.sp = get_le16(ibuf+imagesize); }
    if (flag & SS)
-        imagesize -= 2, oh.ss = get_le16(ibuf+imagesize);
+        { imagesize -= 2; oh.ss = get_le16(ibuf+imagesize); }

-    unsigned ip = (flag & USEJUMP) ? get_le32(ibuf+imagesize-4) : ih.firstreloc;
+    unsigned ip = (flag & USEJUMP) ? get_le32(ibuf+imagesize-4) : (unsigned) ih.firstreloc;
    oh.ip = ip & 0xffff;
    oh.cs = ip >> 16;

@@ -653,15 +793,81 @@ void PackExe::unpack(OutputFile *fo)

    // write header + relocations + uncompressed file
    fo->write(&oh,sizeof(oh));
-    fo->write(wrkmem,relocn*4);
-    fo->write(obuf,relocs-obuf);
+    if (relocn)
+        fo->write(wrkmem,relocn*4);
+    fo->write(obuf, ptr_diff(relocs, obuf));

    // copy the overlay
-    copyOverlay(fo, overlay, &obuf);
+    copyOverlay(fo, ih_overlay, &obuf);
 }


+Linker* PackExe::newLinker() const
+{
+    return new ElfLinkerX86();
+}
+
 /*
-vi:ts=4:et
+
+memory layout at decompression time
+===================================
+
+normal exe
+----------
+
+a, at load time
+
+(e - copying code, C - compressed data, d - decompressor+relocator,
+ x - not specified, U - uncompressed code+data, R uncompressed relocation)
+
+eeCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCdddd
+^ CS:0                                       ^ SS:0
+
+b, after copying
+
+xxxxxxxxxxxxxxxCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCdddd
+^ES:DI=0       ^ DS:SI=0                     ^ CS=SS, IP in range 0..0xf
+
+c, after uncompression
+
+UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUURRdddd
+                                           ^ ES:DI
+
+device driver
+-------------
+
+the file has 2 entry points, CS:0 in device driver mode, and
+CS:exe_as_device_entry in normal mode. the code in section DEVICEENTRY
+sets up the same environment for section EXEENTRY, as it would see in normal
+execution mode.
+
+lzma uncompression for normal exes
+----------------------------------
+
+(n - nrv2b uncompressor, l - nrv2b compressed lzma + relocator code)
+
+a, at load time
+
+nneelllCCCCCCCCCCCCCCCCCCCCCCCCC
+
+^ CS:0                                       ^ SS:0
+
+b, after nrv2b
+
+nneelllCCCCCCCCCCCCCCCCCCCCCCCCC             dddd
+^ CS:0                                       ^ SS:0x10
+
+after this, normal ee code runs
+
+lzma + device driver
+--------------------
+
+(D - device driver adapter)
+
+a, at load time
+
+DDnneelllCCCCCCCCCCCCCCCCCCCCCCCCC
+
 */

+/* vim:set ts=4 sw=4 et: */
@@ -2,8 +2,8 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -21,13 +21,13 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 */


 #ifndef __UPX_P_EXE_H
-#define __UPX_P_EXE_H
+#define __UPX_P_EXE_H 1


 /*************************************************************************
@@ -39,10 +39,12 @@ class PackExe : public Packer
    typedef Packer super;
 public:
    PackExe(InputFile *f);
-    virtual int getVersion() const { return 11; }
+    virtual int getVersion() const { return 13; }
    virtual int getFormat() const { return UPX_F_DOS_EXE; }
    virtual const char *getName() const { return "dos/exe"; }
-    virtual int getCompressionMethod() const;
+    //virtual const char *getFullName(const options_t *o) const { return o && o->cpu == o->CPU_8086 ? "i086-dos16.exe" : "i286-dos16.exe"; }
+    virtual const char *getFullName(const options_t *) const { return "i086-dos16.exe"; }
+    virtual const int *getCompressionMethods(int method, int level) const;
    virtual const int *getFilters() const;

    virtual void pack(OutputFile *fo);
@@ -63,10 +65,16 @@ public:
    }

 protected:
-    virtual bool readFileHeader(void);
+    struct exe_header_t;

-    struct exe_header_t
-    {
+    virtual int readFileHeader(void);
+
+    virtual int fillExeHeader(struct exe_header_t *) const;
+    virtual void buildLoader(const Filter *ft);
+    virtual Linker* newLinker() const;
+    void addLoaderEpilogue(int flag);
+
+    __packed_struct(exe_header_t)
        LE16 ident;
        LE16 m512;
        LE16 p512;
@@ -82,13 +90,17 @@ protected:
        LE16 relocoffs;
        char __[2];             // overlnum
        LE32 firstreloc;
-    } ih, oh;
+    __packed_struct_end()
+
+    exe_header_t ih, oh;

    unsigned ih_exesize;
    unsigned ih_imagesize;
    unsigned ih_overlay;
+    unsigned relocsize;

    bool has_9a;
+    bool device_driver;

    enum {
        NORELOC = 1,
@@ -98,13 +110,12 @@ protected:
        MINMEM = 16,
        MAXMEM = 32
    };
+
+    unsigned stack_for_lzma;    // stack size required for lzma
+    bool use_clear_dirty_stack;
 };


 #endif /* already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -2,9 +2,9 @@

   This file is part of the UPX executable compressor.

-   Copyright (C) 1996-2000 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2000 Laszlo Molnar
-   Copyright (C) 2000 John F. Reiser
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   Copyright (C) 2000-2017 John F. Reiser
   All Rights Reserved.

   UPX and the UCL library are free software; you can redistribute them
@@ -22,67 +22,612 @@
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

-   Markus F.X.J. Oberhumer                   Laszlo Molnar
-   markus.oberhumer@jk.uni-linz.ac.at        ml1050@cdata.tvnet.hu
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>

   John F. Reiser
-   jreiser@BitWagon.com
+   <jreiser@users.sourceforge.net>
 */


 #ifndef __UPX_P_LX_ELF_H  //{
-#define __UPX_P_LX_ELF_H
+#define __UPX_P_LX_ELF_H 1
+
+
+class PackLinuxElf : public PackUnix
+{
+    typedef PackUnix super;
+public:
+    PackLinuxElf(InputFile *f);
+    virtual ~PackLinuxElf();
+    /*virtual void buildLoader(const Filter *);*/
+    virtual bool canUnpackVersion(int version) const { return (version >= 11); }
+
+protected:
+    virtual const int *getCompressionMethods(int method, int level) const;
+
+    // All other virtual functions in this class must be pure virtual
+    // because they depend on Elf32 or Elf64 data structures, which differ.
+
+    virtual void pack1(OutputFile *, Filter &) = 0;  // generate executable header
+    virtual int  pack2(OutputFile *, Filter &) = 0;  // append compressed data
+    virtual void pack3(OutputFile *, Filter &) = 0;  // append loader
+    //virtual void pack4(OutputFile *, Filter &) = 0;  // append pack header
+
+    virtual void generateElfHdr(
+        OutputFile *,
+        void const *proto,
+        unsigned const brka
+    ) = 0;
+    virtual void defineSymbols(Filter const *);
+    virtual void addStubEntrySections(Filter const *);
+    virtual void unpack(OutputFile *fo);
+
+    virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const = 0;
+    static unsigned elf_hash(char const *) /*const*/;
+    static unsigned gnu_hash(char const *) /*const*/;
+
+protected:
+    unsigned e_type;
+    unsigned e_phnum;       /* Program header table entry count */
+    unsigned e_shnum;
+    MemBuffer file_image;   // if ET_DYN investigation
+    char const *dynstr;   // from DT_STRTAB
+
+    unsigned sz_phdrs;  // sizeof Phdr[]
+    unsigned sz_elf_hdrs;  // all Elf headers
+    unsigned sz_pack2;  // after pack2(), before loader
+    unsigned sz_pack2a;  // after pack2() of all PT_LOAD
+    unsigned lg2_page;  // log2(PAGE_SIZE)
+    unsigned page_size;  // 1u<<lg2_page
+    bool is_big;  // stub style: must use area above the brk
+    unsigned xct_off;  // shared library: file offset of SHT_EXECINSTR
+    unsigned hatch_off;  // file offset of escape hatch
+    upx_uint64_t load_va;  // PT_LOAD[0].p_vaddr
+    upx_uint64_t xct_va;  // minimum SHT_EXECINSTR virtual address
+    upx_uint64_t jni_onload_va;  // runtime &JNI_OnLoad
+
+    upx_uint16_t  e_machine;
+    unsigned char ei_class;
+    unsigned char ei_data;
+    unsigned char ei_osabi;
+    char const *osabi_note;
+
+    unsigned char const *buildid_data;
+    int o_elf_shnum; // num output Shdrs
+    static unsigned char o_shstrtab[];
+};
+
+class PackLinuxElf32 : public PackLinuxElf
+{
+    typedef PackLinuxElf super;
+public:
+    PackLinuxElf32(InputFile *f);
+    virtual ~PackLinuxElf32();
+protected:
+    virtual void PackLinuxElf32help1(InputFile *f);
+    virtual int checkEhdr(Elf32_Ehdr const *ehdr) const;
+    virtual bool canPack();
+
+    // These ARM routines are essentially common to big/little endian,
+    // but the class hierarchy splits after this class.
+    virtual void ARM_defineSymbols(Filter const *ft);
+    virtual void ARM_updateLoader(OutputFile *);
+    virtual int  ARM_is_QNX(void);
+
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    virtual int  pack2(OutputFile *, Filter &);  // append compressed data
+    virtual void pack3(OutputFile *, Filter &);  // append loader
+    virtual void pack4(OutputFile *, Filter &);  // append pack header
+    virtual void unpack(OutputFile *fo);
+
+    virtual void generateElfHdr(
+        OutputFile *,
+        void const *proto,
+        unsigned const brka
+    );
+    virtual void buildLinuxLoader(
+        upx_byte const *const proto,  // assembly-only sections
+        unsigned const szproto,
+        upx_byte const *const fold,  // linked assembly + C section
+        unsigned const szfold,
+        Filter const *ft
+    );
+    virtual off_t getbrk(const Elf32_Phdr *phdr, int e_phnum) const;
+    virtual void patchLoader();
+    virtual void updateLoader(OutputFile *fo);
+    virtual unsigned find_LOAD_gap(Elf32_Phdr const *const phdri, unsigned const k,
+        unsigned const e_phnum);
+    virtual off_t getbase(const Elf32_Phdr *phdr, int e_phnum) const;
+
+    virtual Elf32_Sym const *elf_lookup(char const *) const;
+    virtual unsigned elf_get_offset_from_address(unsigned) const;
+    Elf32_Phdr const *elf_find_ptype(unsigned type, Elf32_Phdr const *phdr0, unsigned phnum);
+    Elf32_Shdr const *elf_find_section_name(char const *) const;
+    Elf32_Shdr const *elf_find_section_type(unsigned) const;
+    void const *elf_find_dynamic(unsigned) const;
+    Elf32_Dyn const *elf_has_dynamic(unsigned) const;
+    virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const;
+
+protected:
+    Elf32_Ehdr  ehdri; // from input file
+    Elf32_Phdr *phdri; // for  input file
+    Elf32_Shdr const *shdri; // from input file
+    Elf32_Phdr const *gnu_stack;  // propagate NX
+    unsigned e_phoff;
+    unsigned e_shoff;
+    unsigned so_slide;
+    unsigned char *note_body;  // concatenated contents of PT_NOTEs, if any
+    unsigned note_size;  // total size of PT_NOTEs
+    unsigned page_mask;  // AND clears the offset-within-page
+
+    Elf32_Dyn    const *dynseg;   // from PT_DYNAMIC
+    unsigned int const *hashtab;  // from DT_HASH
+    unsigned int const *gashtab;  // from DT_GNU_HASH
+    Elf32_Sym    const *dynsym;   // from DT_SYMTAB
+    Elf32_Sym    const *jni_onload_sym;
+    char const *shstrtab;   // via Elf32_Shdr
+
+    Elf32_Shdr const *sec_strndx;
+    Elf32_Shdr const *sec_dynsym;
+    Elf32_Shdr const *sec_dynstr;
+
+    __packed_struct(cprElfHdr1)
+        Elf32_Ehdr ehdr;
+        Elf32_Phdr phdr[1];
+        l_info linfo;
+    __packed_struct_end()
+
+    __packed_struct(cprElfHdr2)
+        Elf32_Ehdr ehdr;
+        Elf32_Phdr phdr[2];
+        l_info linfo;
+    __packed_struct_end()
+
+    __packed_struct(cprElfHdr3)
+        Elf32_Ehdr ehdr;
+        Elf32_Phdr phdr[3];
+        l_info linfo;
+    __packed_struct_end()
+
+    __packed_struct(cprElfHdrNetBSD)
+        Elf32_Ehdr ehdr;
+        Elf32_Phdr phdr[4];
+        unsigned char notes[512];
+    __packed_struct_end()
+
+    cprElfHdrNetBSD elfout;
+
+    __packed_struct(cprElfShdr3)
+        Elf32_Shdr shdr[3];
+    __packed_struct_end()
+
+    cprElfShdr3 shdrout;
+
+    struct Elf32_Nhdr {
+        unsigned namesz;
+        unsigned descsz;
+        unsigned type;
+        //unsigned char body[0];
+    };
+
+    static void compileTimeAssertions() {
+        COMPILE_TIME_ASSERT(sizeof(cprElfHdr1) == 52 + 1*32 + 12)
+        COMPILE_TIME_ASSERT(sizeof(cprElfHdr2) == 52 + 2*32 + 12)
+        COMPILE_TIME_ASSERT(sizeof(cprElfHdr3) == 52 + 3*32 + 12)
+        COMPILE_TIME_ASSERT(sizeof(cprElfHdrNetBSD) == 52 + 4*32 + 512)
+        COMPILE_TIME_ASSERT_ALIGNED1(cprElfHdr1)
+        COMPILE_TIME_ASSERT_ALIGNED1(cprElfHdr2)
+        COMPILE_TIME_ASSERT_ALIGNED1(cprElfHdr3)
+        COMPILE_TIME_ASSERT_ALIGNED1(cprElfHdrNetBSD)
+    }
+};
+
+
+class PackLinuxElf64 : public PackLinuxElf
+{
+    typedef PackLinuxElf super;
+public:
+    PackLinuxElf64(InputFile *f);
+    virtual ~PackLinuxElf64();
+    /*virtual void buildLoader(const Filter *);*/
+
+protected:
+    virtual void PackLinuxElf64help1(InputFile *f);
+    virtual int checkEhdr(Elf64_Ehdr const *ehdr) const;
+
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    virtual int  pack2(OutputFile *, Filter &);  // append compressed data
+    virtual void pack3(OutputFile *, Filter &);  // append loader
+    virtual void pack4(OutputFile *, Filter &);  // append pack header
+    virtual void unpack(OutputFile *fo);
+
+    virtual void generateElfHdr(
+        OutputFile *,
+        void const *proto,
+        unsigned const brka
+    );
+    virtual void buildLinuxLoader(
+        upx_byte const *const proto,  // assembly-only sections
+        unsigned const szproto,
+        upx_byte const *const fold,  // linked assembly + C section
+        unsigned const szfold,
+        Filter const *ft
+    );
+    virtual off_t getbrk(const Elf64_Phdr *phdr, int e_phnum) const;
+    virtual void patchLoader();
+    virtual void updateLoader(OutputFile *fo);
+    virtual unsigned find_LOAD_gap(Elf64_Phdr const *const phdri, unsigned const k,
+        unsigned const e_phnum);
+
+    virtual Elf64_Sym const *elf_lookup(char const *) const;
+    virtual upx_uint64_t elf_get_offset_from_address(upx_uint64_t) const;
+    Elf64_Phdr const *elf_find_ptype(unsigned type, Elf64_Phdr const *phdr0, unsigned phnum);
+    Elf64_Shdr const *elf_find_section_name(char const *) const;
+    Elf64_Shdr const *elf_find_section_type(unsigned) const;
+    void const *elf_find_dynamic(unsigned) const;
+    Elf64_Dyn const *elf_has_dynamic(unsigned) const;
+    virtual upx_uint64_t elf_unsigned_dynamic(unsigned) const;
+
+protected:
+    Elf64_Ehdr  ehdri; // from input file
+    Elf64_Phdr *phdri; // for  input file
+    Elf64_Shdr const *shdri; // from input file
+    Elf64_Phdr const *gnu_stack;  // propagate NX
+    upx_uint64_t e_phoff;
+    upx_uint64_t e_shoff;
+    unsigned so_slide;
+    unsigned char *note_body;  // concatenated contents of PT_NOTEs, if any
+    unsigned note_size;  // total size of PT_NOTEs
+    upx_uint64_t page_mask;  // AND clears the offset-within-page
+
+    Elf64_Dyn    const *dynseg;   // from PT_DYNAMIC
+    unsigned int const *hashtab;  // from DT_HASH
+    unsigned int const *gashtab;  // from DT_GNU_HASH
+    Elf64_Sym    const *dynsym;   // from DT_SYMTAB
+    Elf64_Sym    const *jni_onload_sym;
+    char const *shstrtab;   // via Elf64_Shdr
+
+    Elf64_Shdr const *sec_strndx;
+    Elf64_Shdr const *sec_dynsym;
+    Elf64_Shdr const *sec_dynstr;
+
+    __packed_struct(cprElfHdr1)
+        Elf64_Ehdr ehdr;
+        Elf64_Phdr phdr[1];
+        l_info linfo;
+    __packed_struct_end()
+
+    __packed_struct(cprElfHdr2)
+        Elf64_Ehdr ehdr;
+        Elf64_Phdr phdr[2];
+        l_info linfo;
+    __packed_struct_end()
+
+    __packed_struct(cprElfHdr3)
+        Elf64_Ehdr ehdr;
+        Elf64_Phdr phdr[3];
+        l_info linfo;
+    __packed_struct_end()
+
+    __packed_struct(cprElfHdr4)
+        Elf64_Ehdr ehdr;
+        Elf64_Phdr phdr[4];
+        l_info linfo;
+    __packed_struct_end()
+
+    cprElfHdr4 elfout;
+
+    __packed_struct(cprElfShdr3)
+        Elf64_Shdr shdr[3];
+    __packed_struct_end()
+
+    cprElfShdr3 shdrout;
+
+    static void compileTimeAssertions() {
+        COMPILE_TIME_ASSERT(sizeof(cprElfHdr1) == 64 + 1*56 + 12)
+        COMPILE_TIME_ASSERT(sizeof(cprElfHdr2) == 64 + 2*56 + 12)
+        COMPILE_TIME_ASSERT(sizeof(cprElfHdr3) == 64 + 3*56 + 12)
+        COMPILE_TIME_ASSERT(sizeof(cprElfHdr4) == 64 + 4*56 + 12)
+        COMPILE_TIME_ASSERT_ALIGNED1(cprElfHdr1)
+        COMPILE_TIME_ASSERT_ALIGNED1(cprElfHdr2)
+        COMPILE_TIME_ASSERT_ALIGNED1(cprElfHdr3)
+        COMPILE_TIME_ASSERT_ALIGNED1(cprElfHdr4)
+    }
+};
+
+class PackLinuxElf32Be : public PackLinuxElf32
+{
+    typedef PackLinuxElf32 super;
+protected:
+    PackLinuxElf32Be(InputFile *f) : super(f) {
+        bele = &N_BELE_RTP::be_policy;
+        PackLinuxElf32help1(f);
+    }
+};
+
+class PackLinuxElf32Le : public PackLinuxElf32
+{
+    typedef PackLinuxElf32 super;
+protected:
+    PackLinuxElf32Le(InputFile *f) : super(f) {
+        bele = &N_BELE_RTP::le_policy;
+        PackLinuxElf32help1(f);
+    }
+};
+
+class PackLinuxElf64Le : public PackLinuxElf64
+{
+    typedef PackLinuxElf64 super;
+protected:
+    PackLinuxElf64Le(InputFile *f) : super(f) {
+        lg2_page=16;
+        page_size=1u<<lg2_page;
+        bele = &N_BELE_RTP::le_policy;
+        PackLinuxElf64help1(f);
+    }
+};
+
+
+/*************************************************************************
+// linux/elf64amd
+**************************************************************************/
+
+class PackLinuxElf64amd : public PackLinuxElf64Le
+{
+    typedef PackLinuxElf64Le super;
+public:
+    PackLinuxElf64amd(InputFile *f);
+    virtual ~PackLinuxElf64amd();
+    virtual int getFormat() const { return UPX_F_LINUX_ELF64_AMD; }
+    virtual const char *getName() const { return "linux/amd64"; }
+    virtual const char *getFullName(const options_t *) const { return "amd64-linux.elf"; }
+    virtual const int *getFilters() const;
+    virtual bool canPack();
+protected:
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    //virtual void pack3(OutputFile *, Filter &);  // append loader
+    virtual void buildLoader(const Filter *);
+    virtual Linker* newLinker() const;
+    virtual void defineSymbols(Filter const *);
+};
+
+class PackLinuxElf64arm : public PackLinuxElf64Le
+{
+    typedef PackLinuxElf64Le super;
+public:
+    PackLinuxElf64arm(InputFile *f);
+    virtual ~PackLinuxElf64arm();
+    virtual int getFormat() const { return UPX_F_LINUX_ELF64_ARM; }
+    virtual const char *getName() const { return "linux/arm64"; }
+    virtual const char *getFullName(const options_t *) const { return "arm64-linux.elf"; }
+    virtual const int *getFilters() const;
+    virtual bool canPack();
+protected:
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    //virtual void pack3(OutputFile *, Filter &);  // append loader
+    virtual void buildLoader(const Filter *);
+    virtual Linker* newLinker() const;
+    virtual void defineSymbols(Filter const *);
+};
+
+
+/*************************************************************************
+// linux/elf32ppc
+**************************************************************************/
+
+class PackLinuxElf32ppc : public PackLinuxElf32Be
+{
+    typedef PackLinuxElf32Be super;
+public:
+    PackLinuxElf32ppc(InputFile *f);
+    virtual ~PackLinuxElf32ppc();
+    virtual int getFormat() const { return UPX_F_LINUX_ELFPPC32; }
+    virtual const char *getName() const { return "linux/ppc32"; }
+    virtual const char *getFullName(const options_t *) const { return "powerpc-linux.elf"; }
+    virtual const int *getFilters() const;
+protected:
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    virtual void buildLoader(const Filter *);
+    virtual Linker* newLinker() const;
+};
+
+/*************************************************************************
+// linux/elf64ppcle
+**************************************************************************/
+
+class PackLinuxElf64ppcle : public PackLinuxElf64Le
+{
+    typedef PackLinuxElf64Le super;
+public:
+    PackLinuxElf64ppcle(InputFile *f);
+    virtual ~PackLinuxElf64ppcle();
+    virtual int getFormat() const { return UPX_F_LINUX_ELFPPC64LE; }
+    virtual const char *getName() const { return "linux/ppc64le"; }
+    virtual const char *getFullName(const options_t *) const { return "powerpc64le-linux.elf"; }
+    virtual const int *getFilters() const;
+protected:
+    unsigned lg2_page;  // log2(PAGE_SIZE)
+    unsigned page_size;  // 1u<<lg2_page
+    virtual bool canPack();
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    virtual void buildLoader(const Filter *);
+    virtual Linker* newLinker() const;
+};


 /*************************************************************************
 // linux/elf386
 **************************************************************************/

-class PackLinuxI386elf : public PackLinuxI386
+class PackLinuxElf32x86 : public PackLinuxElf32Le
 {
-    typedef PackLinuxI386 super;
+    typedef PackLinuxElf32Le super;
 public:
-    PackLinuxI386elf(InputFile *f);
-    virtual ~PackLinuxI386elf();
-    virtual int getVersion() const { return 11; }
+    PackLinuxElf32x86(InputFile *f);
+    virtual ~PackLinuxElf32x86();
    virtual int getFormat() const { return UPX_F_LINUX_ELF_i386; }
-    virtual const char *getName() const { return "linux/elf386"; }
-    virtual const int *getFilters() const { return NULL; }
-
-    virtual void pack(OutputFile *fo);
-    virtual void unpack(OutputFile *fo);
-
-    virtual bool canPack();
-    virtual bool canUnpackVersion(int version) const
-        { return (version >= 11); }
+    virtual const char *getName() const { return "linux/i386"; }
+    virtual const char *getFullName(const options_t *) const { return "i386-linux.elf"; }
+    virtual const int *getFilters() const;

 protected:
-    struct Extent {
-        off_t offset;
-        off_t size;
-    };
-    virtual void packExtent(Extent const &x, OutputFile *fo,
-        unsigned &total_in, unsigned &total_out);
-    virtual void unpackExtent(unsigned wanted, OutputFile *fo,
-        unsigned &total_in, unsigned &total_out,
-        unsigned &c_adler, unsigned &u_adler);
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+
+    virtual void buildLoader(const Filter *);
+    virtual void addStubEntrySections(Filter const *);
+    virtual Linker* newLinker() const;
+    virtual void defineSymbols(Filter const *);
+};
+
+class PackBSDElf32x86 : public PackLinuxElf32x86
+{
+    typedef PackLinuxElf32x86 super;
+public:
+    PackBSDElf32x86(InputFile *f);
+    virtual ~PackBSDElf32x86();
+    virtual int getFormat() const = 0;
+    virtual const char *getName() const = 0;
+    virtual const char *getFullName(const options_t *) const = 0;

 protected:
-    virtual const upx_byte *getLoader() const;
-    virtual int getLoaderSize() const;
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header

-    virtual void patchLoader();
+    virtual void buildLoader(const Filter *);
+};
+
+class PackFreeBSDElf32x86 : public PackBSDElf32x86
+{
+    typedef PackBSDElf32x86 super;
+public:
+    PackFreeBSDElf32x86(InputFile *f);
+    virtual ~PackFreeBSDElf32x86();
+    virtual int getFormat() const { return UPX_F_BSD_ELF_i386; }
+    virtual const char *getName() const { return "freebsd/i386"; }
+    virtual const char *getFullName(const options_t *) const { return "i386-freebsd.elf"; }
+};
+
+class PackNetBSDElf32x86 : public PackLinuxElf32x86
+{
+    typedef PackLinuxElf32x86 super;
+public:
+    PackNetBSDElf32x86(InputFile *f);
+    virtual ~PackNetBSDElf32x86();
+    virtual int getFormat() const { return UPX_F_BSD_ELF_i386; }
+    virtual const char *getName() const { return "netbsd/i386"; }
+    virtual const char *getFullName(const options_t *) const { return "i386-netbsd.elf"; }
+protected:
+    virtual void buildLoader(const Filter *ft);
+    virtual void generateElfHdr(
+        OutputFile *,
+        void const *proto,
+        unsigned const brka
+    );
+};
+
+class PackOpenBSDElf32x86 : public PackBSDElf32x86
+{
+    typedef PackBSDElf32x86 super;
+public:
+    PackOpenBSDElf32x86(InputFile *f);
+    virtual ~PackOpenBSDElf32x86();
+    virtual int getFormat() const { return UPX_F_BSD_ELF_i386; }
+    virtual const char *getName() const { return "openbsd/i386"; }
+    virtual const char *getFullName(const options_t *) const { return "i386-openbsd.elf"; }
+
+protected:
+    virtual void buildLoader(const Filter *ft);
+    virtual void generateElfHdr(
+        OutputFile *,
+        void const *proto,
+        unsigned const brka
+    );
+};
+
+
+/*************************************************************************
+// linux/elfarm
+**************************************************************************/
+
+class PackLinuxElf32armLe : public PackLinuxElf32Le
+{
+    typedef PackLinuxElf32Le super;
+public:
+    PackLinuxElf32armLe(InputFile *f);
+    virtual ~PackLinuxElf32armLe();
+    virtual int getFormat() const { return UPX_F_LINUX_ELF32_ARMEL; }
+    virtual const char *getName() const { return "linux/arm"; }
+    virtual const char *getFullName(const options_t *) const { return "arm-linux.elf"; }
+    virtual const int *getFilters() const;
+
+protected:
+    virtual const int *getCompressionMethods(int method, int level) const;
+    virtual Linker* newLinker() const;
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    virtual void buildLoader(const Filter *);
    virtual void updateLoader(OutputFile *);
+    virtual void defineSymbols(Filter const *);
+};

-    Elf_LE32_Ehdr  ehdri; // from input file
-    Elf_LE32_Phdr *phdri; // for  input file
+class PackLinuxElf32armBe : public PackLinuxElf32Be
+{
+    typedef PackLinuxElf32Be super;
+public:
+    PackLinuxElf32armBe(InputFile *f);
+    virtual ~PackLinuxElf32armBe();
+    virtual int getFormat() const { return UPX_F_LINUX_ELF32_ARMEB; }
+    virtual const char *getName() const { return "linux/armeb"; }
+    virtual const char *getFullName(const options_t *) const { return "armeb-linux.elf"; }
+    virtual const int *getFilters() const;
+
+protected:
+    virtual const int *getCompressionMethods(int method, int level) const;
+    virtual Linker* newLinker() const;
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    virtual void buildLoader(const Filter *);
+    virtual void updateLoader(OutputFile *);
+    virtual void defineSymbols(Filter const *);
+};
+
+class PackLinuxElf32mipseb : public PackLinuxElf32Be
+{
+    typedef PackLinuxElf32Be super;
+public:
+    PackLinuxElf32mipseb(InputFile *f);
+    virtual ~PackLinuxElf32mipseb();
+    virtual int getFormat() const { return UPX_F_LINUX_ELF32_MIPSEB; }
+    virtual const char *getName() const { return "linux/mips"; }
+    virtual const char *getFullName(const options_t *) const { return "mips-linux.elf"; }
+    virtual const int *getFilters() const;
+
+protected:
+    virtual Linker* newLinker() const;
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    virtual void buildLoader(const Filter *);
+    virtual void updateLoader(OutputFile *);
+    virtual void defineSymbols(Filter const *);
+};
+
+class PackLinuxElf32mipsel : public PackLinuxElf32Le
+{
+    typedef PackLinuxElf32Le super;
+public:
+    PackLinuxElf32mipsel(InputFile *f);
+    virtual ~PackLinuxElf32mipsel();
+    virtual int getFormat() const { return UPX_F_LINUX_ELF32_MIPSEL; }
+    virtual const char *getName() const { return "linux/mipsel"; }
+    virtual const char *getFullName(const options_t *) const { return "mipsel-linux.elf"; }
+    virtual const int *getFilters() const;
+
+protected:
+    virtual Linker* newLinker() const;
+    virtual void pack1(OutputFile *, Filter &);  // generate executable header
+    virtual void buildLoader(const Filter *);
+    virtual void updateLoader(OutputFile *);
+    virtual void defineSymbols(Filter const *);
 };


 #endif /*} already included */

-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */
@@ -0,0 +1,617 @@
+/* p_lx_exc.cpp --
+
+   This file is part of the UPX executable compressor.
+
+   Copyright (C) 1996-2017 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2017 Laszlo Molnar
+   Copyright (C) 2001-2017 John F. Reiser
+   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>
+
+   John F. Reiser
+   <jreiser@users.sourceforge.net>
+ */
+
+
+#include "conf.h"
+
+#include "file.h"
+#include "filter.h"
+#include "linker.h"
+#include "packer.h"
+#include "p_elf.h"
+#include "p_unix.h"
+#include "p_lx_exc.h"
+
+#define PT_LOAD     Elf32_Phdr::PT_LOAD
+#define PT_DYNAMIC  Elf32_Phdr::PT_DYNAMIC
+#if 0 // UNUSED
+#define DT_NULL     Elf32_Dyn::DT_NULL
+#define DT_NEEDED   Elf32_Dyn::DT_NEEDED
+#define DT_STRTAB   Elf32_Dyn::DT_STRTAB
+#define DT_STRSZ    Elf32_Dyn::DT_STRSZ
+#endif
+
+
+/*************************************************************************
+// linux/386 (generic "execve" format)
+**************************************************************************/
+
+PackLinuxI386::PackLinuxI386(InputFile *f) : super(f),
+    ei_osabi(Elf32_Ehdr::ELFOSABI_LINUX), osabi_note(NULL)
+{
+    bele = &N_BELE_RTP::le_policy;
+}
+
+PackBSDI386::PackBSDI386(InputFile *f) : super(f)
+{
+    // Shell scripts need help specifying the target operating system.
+    // Elf input will override this with .e_ident[EI_OSABI] or PT_NOTE.
+    // [2006-09-27: Today's only runtime stub for shell is for linux.]
+    if (Elf32_Ehdr::ELFOSABI_LINUX==opt->o_unix.osabi0) {
+        // Disallow an incompatibility.
+        ei_osabi = Elf32_Ehdr::ELFOSABI_NONE;
+    }
+    else {
+        ei_osabi = opt->o_unix.osabi0;  // might be ELFOSABI_NONE
+    }
+}
+
+static const
+#include "stub/i386-linux.elf.execve-entry.h"
+static const
+#include "stub/i386-linux.elf.execve-fold.h"
+
+static const
+#include "stub/i386-bsd.elf.execve-entry.h"
+static const
+#include "stub/i386-bsd.elf.execve-fold.h"
+
+
+const int *PackLinuxI386::getCompressionMethods(int method, int level) const
+{
+    return Packer::getDefaultCompressionMethods_le32(method, level);
+}
+
+const int *PackLinuxI386::getFilters() const
+{
+    static const int filters[] = {
+        0x49, 0x46,
+        0x26, 0x24, 0x11, 0x14, 0x13, 0x16, 0x25, 0x15, 0x12,
+#if 0
+// 0x80..0x87 are regarded as "untested".
+        0x83, 0x86, 0x80, 0x84, 0x87, 0x81, 0x82, 0x85,
+        0x24, 0x16, 0x13, 0x14, 0x11, 0x25, 0x15, 0x12,
+#endif
+    FT_END };
+    return filters;
+}
+
+static void
+set_stub_brk(Elf_LE32_Phdr *const phdr1, unsigned brka)
+{
+#define PAGE_MASK (~0ul<<12)
+        // linux-2.6.14 binfmt_elf.c: SIGKILL if (0==.p_memsz) on a page boundary
+        unsigned const brkb = brka | ((0==(~PAGE_MASK & brka)) ? 0x20 : 0);
+        phdr1->p_type = PT_LOAD;  // be sure
+        phdr1->p_offset = ~PAGE_MASK & brkb;
+        phdr1->p_vaddr = brkb;
+        phdr1->p_paddr = brkb;
+        phdr1->p_filesz = 0;
+        phdr1->p_memsz =  0;
+        if (0==phdr1->p_flags) {
+            phdr1->p_flags = Elf32_Phdr::PF_R|Elf32_Phdr::PF_W;
+        }
+        if (0==phdr1->p_align) {
+            phdr1->p_align = 0x1000;
+        }
+#undef PAGE_MASK
+}
+
+void
+PackLinuxI386::generateElfHdr(
+    OutputFile *fo,
+    void const *proto,
+    unsigned const brka
+)
+{
+    cprElfHdr2 *const h2 = (cprElfHdr2 *)(void *)&elfout;
+    cprElfHdr3 *const h3 = (cprElfHdr3 *)(void *)&elfout;
+    memcpy(h3, proto, sizeof(*h3));  // reads beyond, but OK
+
+    assert(h2->ehdr.e_phoff     == sizeof(Elf32_Ehdr));
+    assert(h2->ehdr.e_shoff     == 0);
+    assert(h2->ehdr.e_ehsize    == sizeof(Elf32_Ehdr));
+    assert(h2->ehdr.e_phentsize == sizeof(Elf32_Phdr));
+    assert(h2->ehdr.e_shnum     == 0);
+
+#if 0  //{
+    unsigned identsize;
+    char const *const ident = getIdentstr(&identsize);
+#endif  //}
+    h2->phdr[0].p_filesz = sizeof(*h2);  // + identsize;
+    h2->phdr[0].p_memsz  = h2->phdr[0].p_filesz;
+
+    // Info for OS kernel to set the brk()
+    if (brka) {
+        set_stub_brk(&h2->phdr[1], brka);
+    }
+
+    if (ph.format==UPX_F_LINUX_i386
+    ||  ph.format==UPX_F_LINUX_SH_i386
+    ||  ph.format==UPX_F_BSD_i386
+    ) {
+        // SELinux, PAx, grSecurity demand no PF_W if PF_X.
+        // kernel-2.6.12-2.3.legacy_FC3 has a bug which demands
+        // a PT_LOAD with PF_W, else SIGSEGV when clearing page fragment
+        // on low page of ".bss", which is the high page of .text.
+        // So the minimum number of PT_LOAD is 2.
+        assert(h2->ehdr.e_phnum==2);
+        memset(&h2->linfo, 0, sizeof(h2->linfo));
+        fo->write(h2, sizeof(*h2));
+    }
+    else if (ph.format==UPX_F_LINUX_ELFI_i386) {
+        assert(h3->ehdr.e_phnum==3);
+        memset(&h3->linfo, 0, sizeof(h3->linfo));
+        fo->write(h3, sizeof(*h3));
+    }
+    else {
+        assert(false);  // unknown ph.format, PackUnix::generateElfHdr
+    }
+}
+
+void
+PackLinuxI386::pack1(OutputFile *fo, Filter &)
+{
+    // create a pseudo-unique program id for our paranoid stub
+    progid = getRandomId();
+
+    generateElfHdr(fo, stub_i386_linux_elf_execve_fold, 0);
+}
+
+void
+PackBSDI386::pack1(OutputFile *fo, Filter &)
+{
+    // create a pseudo-unique program id for our paranoid stub
+    progid = getRandomId();
+
+    generateElfHdr(fo, stub_i386_bsd_elf_execve_fold, 0);
+}
+
+void
+PackLinuxI386::pack4(OutputFile *fo, Filter &ft)
+{
+    overlay_offset = sizeof(elfout.ehdr) +
+        (elfout.ehdr.e_phentsize * elfout.ehdr.e_phnum) +
+        sizeof(l_info) +
+        ((elfout.ehdr.e_phnum==3) ? (unsigned) elfout.phdr[2].p_memsz : 0) ;
+    unsigned nw = fo->getBytesWritten();
+    elfout.phdr[0].p_filesz = nw;
+    nw = 0u-((0u-elfout.phdr[0].p_align) & (0u-nw));  // ALIGN_UP
+    super::pack4(fo, ft);  // write PackHeader and overlay_offset
+    set_stub_brk(&elfout.phdr[1], nw + elfout.phdr[0].p_vaddr);
+
+#if 0  // {
+    // /usr/bin/strip from RedHat 8.0 (binutils-2.13.90.0.2-2)
+    // generates a 92-byte [only] output, because the "linking view"
+    // is empty.  This code supplies a "linking view".
+    // However, 'strip' then generates _plausible_ junk that gets
+    // "Illegal instruction"  because 'strip' changes p_hdr[1].p_align,
+    // .p_offset, and .p_vaddr incorrectly.  So the "cure" is worse than
+    // the disease.  It is obvious that a 92-byte file is bad,
+    // but it is not obvious that the changed .p_align is bad.
+    // Also, having a totally empty "linking view" is easier for 'strip'
+    // to fix: just detect that, and do nothing.
+    // So, we don't use this code for now [2003-01-11].
+
+    // Supply a "linking view" that covers everything,
+    // so that 'strip' does not omit everything.
+    Elf_LE32_Shdr shdr;
+    // The section header string table.
+    char const shstrtab[] = "\0.\0.shstrtab";
+
+    unsigned eod = elfout.phdr[0].p_filesz;
+    elfout.ehdr.e_shoff = eod;
+    elfout.ehdr.e_shentsize = sizeof(shdr);
+    elfout.ehdr.e_shnum = 3;
+    elfout.ehdr.e_shstrndx = 2;
+
+    // An empty Elf32_Shdr for space as a null index.
+    memset(&shdr, 0, sizeof(shdr));
+    shdr.sh_type = Elf32_Shdr::SHT_NULL;
+    fo->write(&shdr, sizeof(shdr));
+
+    // Cover all the bits we need at runtime.
+    memset(&shdr, 0, sizeof(shdr));
+    shdr.sh_name = 1;
+    shdr.sh_type = Elf32_Shdr::SHT_PROGBITS;
+    shdr.sh_flags = Elf32_Shdr::SHF_ALLOC;
+    shdr.sh_addr = elfout.phdr[0].p_vaddr;
+    shdr.sh_offset = overlay_offset;
+    shdr.sh_size = eod - overlay_offset;
+    shdr.sh_addralign = 4096;
+    fo->write(&shdr, sizeof(shdr));
+
+    // A section header for the section header string table.
+    memset(&shdr, 0, sizeof(shdr));
+    shdr.sh_name = 3;
+    shdr.sh_type = Elf32_Shdr::SHT_STRTAB;
+    shdr.sh_offset = 3*sizeof(shdr) + eod;
+    shdr.sh_size = sizeof(shstrtab);
+    fo->write(&shdr, sizeof(shdr));
+
+    fo->write(shstrtab, sizeof(shstrtab));
+#endif  // }
+
+
+    // Cannot pre-round .p_memsz.  If .p_filesz < .p_memsz, then kernel
+    // tries to make .bss, which requires PF_W.
+    // But strict SELinux (or PaX, grSecurity) disallows PF_W with PF_X.
+#if 0  /*{*/
+#undef PAGE_MASK
+#define PAGE_MASK (~0u<<12)
+    // pre-calculate for benefit of runtime disappearing act via munmap()
+    elfout.phdr[0].p_memsz =  PAGE_MASK & (~PAGE_MASK + elfout.phdr[0].p_filesz);
+#undef PAGE_MASK
+#else  /*}{*/
+    elfout.phdr[0].p_memsz =  elfout.phdr[0].p_filesz;
+#endif  /*}*/
+
+    // rewrite Elf header
+    fo->seek(0, SEEK_SET);
+    fo->rewrite(&elfout, overlay_offset);
+}
+
+static unsigned
+umax(unsigned a, unsigned b)
+{
+    if (a <= b) {
+        return b;
+    }
+    return a;
+}
+
+Linker *PackLinuxI386::newLinker() const
+{
+    return new ElfLinkerX86;
+}
+
+void
+PackLinuxI386::buildLinuxLoader(
+    upx_byte const *const proto,
+    unsigned        const szproto,
+    upx_byte const *const fold,
+    unsigned        const szfold,
+    Filter const *ft
+)
+{
+    initLoader(proto, szproto);
+
+    unsigned fold_hdrlen = 0;
+  if (0 < szfold) {
+    cprElfHdr1 const *const hf = (cprElfHdr1 const *)fold;
+    fold_hdrlen = sizeof(hf->ehdr) + hf->ehdr.e_phentsize * hf->ehdr.e_phnum +
+         sizeof(l_info);
+    if (0 == get_le32(fold_hdrlen + fold)) {
+        // inconsistent SIZEOF_HEADERS in *.lds (ld, binutils)
+        fold_hdrlen = umax(0x80, fold_hdrlen);
+    }
+  }
+    // This adds the definition to the "library", to be used later.
+    // NOTE: the stub is NOT compressed!  The savings is not worth it.
+    linker->addSection("FOLDEXEC", fold + fold_hdrlen, szfold - fold_hdrlen, 0);
+
+    n_mru = ft->n_mru;
+
+// Rely on "+80CXXXX" [etc] in getDecompressorSections() packer_c.cpp */
+//    // Here is a quick summary of the format of the output file:
+//    linker->setLoaderAlignOffset(
+//            // Elf32_Edhr
+//        sizeof(elfout.ehdr) +
+//            // Elf32_Phdr: 1 for exec86, 2 for sh86, 3 for elf86
+//        (elfout.ehdr.e_phentsize * elfout.ehdr.e_phnum) +
+//            // checksum UPX! lsize version format
+//        sizeof(l_info) +
+//            // PT_DYNAMIC with DT_NEEDED "forwarded" from original file
+//        ((elfout.ehdr.e_phnum==3) ? (unsigned) elfout.phdr[2].p_memsz : 0) +
+//            // p_progid, p_filesize, p_blocksize
+//        sizeof(p_info) +
+//            // compressed data
+//        b_len + ph.c_len );
+//            // entry to stub
+    addLoader("LEXEC000", NULL);
+
+    if (ft->id) {
+        if (n_mru) {
+            addLoader("LEXEC009", NULL);
+        }
+    }
+    addLoader("LEXEC010", NULL);
+    linker->defineSymbol("filter_cto", ft->cto);
+    linker->defineSymbol("filter_length",
+                         (ft->id & 0xf) % 3 == 0 ? ft->calls :
+                         ft->lastcall - ft->calls * 4);
+    addLoader(getDecompressorSections(), NULL);
+    addLoader("LEXEC015", NULL);
+    if (ft->id) {
+        {  // decompr, unfilter not separate
+            if (0x80==(ft->id & 0xF0)) {
+                addLoader("LEXEC110", NULL);
+                if (n_mru) {
+                    addLoader("LEXEC100", NULL);
+                }
+                // bug in APP: jmp and label must be in same .asx/.asy
+                addLoader("LEXEC016", NULL);
+            }
+        }
+        addFilter32(ft->id);
+        {  // decompr always unfilters
+            addLoader("LEXEC017", NULL);
+        }
+    }
+    else {
+        addLoader("LEXEC017", NULL);
+    }
+
+    addLoader("IDENTSTR", NULL);
+    addLoader("LEXEC020", NULL);
+    addLoader("FOLDEXEC", NULL);
+    if (M_IS_LZMA(ph.method)) {
+        const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
+        upx_uint32_t properties = // lc, lp, pb, dummy
+            (res->lit_context_bits << 0) |
+            (res->lit_pos_bits << 8) |
+            (res->pos_bits << 16);
+        if (linker->bele->isBE()) // big endian - bswap32
+            acc_swab32s(&properties);
+        linker->defineSymbol("lzma_properties", properties);
+        // -2 for properties
+        linker->defineSymbol("lzma_c_len", ph.c_len - 2);
+        linker->defineSymbol("lzma_u_len", ph.u_len);
+        unsigned const stack = getDecompressorWrkmemSize();
+        linker->defineSymbol("lzma_stack_adjust", 0u - stack);
+    }
+    if (0x80==(ft->id & 0xF0)) {
+        int const mru = ft->n_mru ? 1+ ft->n_mru : 0;
+        if (mru && mru!=256) {
+            unsigned const is_pwr2 = (0==((mru -1) & mru));
+            linker->defineSymbol("NMRU", mru - is_pwr2);
+        }
+    }
+    relocateLoader();
+}
+
+void
+PackLinuxI386::buildLoader(Filter const *ft)
+{
+    unsigned const sz_fold = sizeof(stub_i386_linux_elf_execve_fold);
+    MemBuffer buf(sz_fold);
+    memcpy(buf, stub_i386_linux_elf_execve_fold, sz_fold);
+
+    // patch loader
+    // note: we only can use /proc/<pid>/fd when exetype > 0.
+    //   also, we sleep much longer when compressing a script.
+    checkPatch(NULL, 0, 0, 0);  // reset
+    patch_le32(buf,sz_fold,"UPX4",exetype > 0 ? 3 : 15);   // sleep time
+    patch_le32(buf,sz_fold,"UPX3",progid);
+    patch_le32(buf,sz_fold,"UPX2",exetype > 0 ? 0 : 0x7fffffff);
+
+    buildLinuxLoader(
+        stub_i386_linux_elf_execve_entry, sizeof(stub_i386_linux_elf_execve_entry),
+        buf, sz_fold, ft );
+}
+
+void
+PackBSDI386::buildLoader(Filter const *ft)
+{
+    unsigned const sz_fold = sizeof(stub_i386_bsd_elf_execve_fold);
+    MemBuffer buf(sz_fold);
+    memcpy(buf, stub_i386_bsd_elf_execve_fold, sz_fold);
+
+    // patch loader
+    // note: we only can use /proc/<pid>/fd when exetype > 0.
+    //   also, we sleep much longer when compressing a script.
+    checkPatch(NULL, 0, 0, 0);  // reset
+    patch_le32(buf,sz_fold,"UPX4",exetype > 0 ? 3 : 15);   // sleep time
+    patch_le32(buf,sz_fold,"UPX3",progid);
+    patch_le32(buf,sz_fold,"UPX2",exetype > 0 ? 0 : 0x7fffffff);
+
+    buildLinuxLoader(
+        stub_i386_bsd_elf_execve_entry, sizeof(stub_i386_bsd_elf_execve_entry),
+        buf, sz_fold, ft );
+}
+
+// FIXME: getLoaderPrefixSize is unused?
+int PackLinuxI386::getLoaderPrefixSize() const
+{
+    return 116;
+}
+
+
+/*************************************************************************
+// some ELF utitlity functions
+**************************************************************************/
+
+// basic check of a Linux ELF Ehdr
+int PackLinuxI386::checkEhdr(const Elf_LE32_Ehdr *ehdr) const
+{
+    const unsigned char * const buf = ehdr->e_ident;
+
+    if (memcmp(buf, "\x7f\x45\x4c\x46\x01\x01\x01", 7)) // ELF 32-bit LSB
+        return -1;
+
+    // now check the ELF header
+    if (!memcmp(buf+8, "FreeBSD", 7))                  // branded
+        return 1;
+    if (ehdr->e_type != Elf32_Ehdr::ET_EXEC
+    &&  ehdr->e_type != Elf32_Ehdr::ET_DYN )           // executable
+        return 2;
+    if (ehdr->e_machine != Elf32_Ehdr::EM_386)         // Intel 80386
+        return 3;
+    if (ehdr->e_version != Elf32_Ehdr::EV_CURRENT)     // version
+        return 4;
+    if (ehdr->e_phnum < 1)
+        return 5;
+    if (ehdr->e_phentsize != sizeof(Elf32_Phdr))
+        return 6;
+
+    // check for Linux kernels
+    if (ehdr->e_entry == 0xC0100000)                    // uncompressed vmlinux
+        return 1000;
+    if (ehdr->e_entry == 0x00001000)                    // compressed vmlinux
+        return 1001;
+    if (ehdr->e_entry == 0x00100000)                    // compressed bvmlinux
+        return 1002;
+
+    // FIXME: add more checks for kernels
+
+    // FIXME: add special checks for other ELF i386 formats, like
+    //        NetBSD, OpenBSD, Solaris, ....
+
+    // success
+    return 0;
+}
+
+
+
+/*************************************************************************
+//
+**************************************************************************/
+
+bool PackLinuxI386::canPack()
+{
+    if (exetype != 0)
+        return super::canPack();
+
+    Elf_LE32_Ehdr ehdr;
+    unsigned char *buf = ehdr.e_ident;
+
+    fi->seek(0, SEEK_SET);
+    fi->readx(&ehdr, sizeof(ehdr));
+    fi->seek(0, SEEK_SET);
+
+    exetype = 0;
+    const unsigned l = get_le32(buf);
+
+    int elf = checkEhdr(&ehdr);
+    if (elf >= 0) {
+        // NOTE: ELF executables are now handled by p_lx_elf.cpp,
+        //   so we only handle them here if force_execve
+        if (elf == 0 && opt->o_unix.force_execve) {
+            exetype = 1;
+
+            unsigned osabi0 = ehdr.e_ident[Elf32_Ehdr::EI_OSABI];
+            switch (osabi0) {
+            case Elf32_Ehdr::ELFOSABI_LINUX:
+            case Elf32_Ehdr::ELFOSABI_FREEBSD:
+            case Elf32_Ehdr::ELFOSABI_NETBSD:
+            case Elf32_Ehdr::ELFOSABI_OPENBSD:
+                ei_osabi = osabi0;  // Proudly declares its osabi in Ehdr.
+                break;
+            default:
+            unsigned const e_phnum = get_te16(&ehdr.e_phnum);
+            if (e_phnum<=(512/sizeof(Elf32_Phdr))) {
+                union {
+                    unsigned char buf2[512];
+                    //Elf32_Phdr phdr;
+                } u;
+                fi->seek(get_te32(&ehdr.e_phoff), SEEK_SET);
+                fi->readx(u.buf2, sizeof(u.buf2));
+                fi->seek(0, SEEK_SET);
+                Elf32_Phdr const *phdr = (Elf32_Phdr *) u.buf2;
+                for (unsigned j=0; j < e_phnum; ++phdr, ++j) {
+                    if (phdr->PT_NOTE == get_te32(&phdr->p_type)) {
+                        unsigned const offset = get_te32(&phdr->p_offset);
+                        struct Elf32_Note note; memset(&note, 0, sizeof(note));
+                        fi->seek(offset, SEEK_SET);
+                        fi->readx(&note, sizeof(note));
+                        fi->seek(0, SEEK_SET);
+                        if (4==get_te32(&note.descsz)
+                        &&  1==get_te32(&note.type)
+                        &&  0==note.end ) {
+                            if (0==strcmp("NetBSD", (char const *)note.text)) {
+                                ei_osabi = Elf32_Ehdr::ELFOSABI_NETBSD;
+                                break;
+                            }
+                            if (0==strcmp("OpenBSD", (char const *)note.text)) {
+                                ei_osabi = Elf32_Ehdr::ELFOSABI_OPENBSD;
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+            }
+        }
+        if (UPX_F_BSD_i386==getFormat()
+        && !(Elf32_Ehdr::ELFOSABI_FREEBSD==ei_osabi
+          || Elf32_Ehdr::ELFOSABI_NETBSD ==ei_osabi
+          || Elf32_Ehdr::ELFOSABI_OPENBSD==ei_osabi )) {
+            return false;
+        }
+    }
+    else if (l == 0x00640107 || l == 0x00640108 || l == 0x0064010b || l == 0x006400cc)
+    {
+        // OMAGIC / NMAGIC / ZMAGIC / QMAGIC
+        exetype = 2;
+        // FIXME: N_TRSIZE, N_DRSIZE
+        // FIXME: check for aout shared libraries
+    }
+    else { // shell scripts and other interpreters
+        if (Elf32_Ehdr::ELFOSABI_LINUX!=ei_osabi) {
+            return false;  // so far, only Linux has runtime stub for shell
+        }
+        else if (!memcmp(buf, "#!/", 3))                    // #!/bin/sh
+            exetype = -1;
+        else if (!memcmp(buf, "#! /", 4))                   // #! /bin/sh
+            exetype = -1;
+        else if (!memcmp(buf, "\xca\xfe\xba\xbe", 4))       // Java bytecode
+            exetype = -2;
+    }
+
+    return super::canPack();
+}
+
+
+void PackLinuxI386::patchLoader() { }
+
+
+void PackLinuxI386::patchLoaderChecksum()
+{
+    unsigned char *const ptr = getLoader();
+    l_info *const lp = (l_info *)(sizeof(elfout.ehdr) +
+        (elfout.ehdr.e_phnum * elfout.ehdr.e_phentsize) + (char *)&elfout );
+    // checksum for loader + p_info
+    lp->l_checksum = 0;
+    lp->l_magic = UPX_ELF_MAGIC;
+    set_te16(&lp->l_lsize, (upx_uint16_t) lsize);
+    lp->l_version = (unsigned char) ph.version;
+    lp->l_format  = (unsigned char) ph.format;
+    // INFO: lp->l_checksum is currently unused
+    set_te32(&lp->l_checksum, upx_adler32(ptr, lsize));
+}
+
+
+void PackLinuxI386::updateLoader(OutputFile *fo)
+{
+    elfout.ehdr.e_entry = fo->getBytesWritten() + elfout.phdr[0].p_vaddr;
+}
+
+/* vim:set ts=4 sw=4 et: */
--- a/Show More
+++ b/Show More