Bump release date.

modified:   README
	modified:   README.1ST

.appveyor.yml

@@ -0,0 +1,100 @@
+# 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: gcc-4.9-m32, T: SKIP }
+#   - { C: gcc-4.9-m64, T: SKIP }
+
+init:
+  - git config --global core.autocrlf input
+  - where bash & where cat & where curl & where file & where git & where gzip & where readlink & where sed & where sha256sum & 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 )
+
+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 -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
+
+# vim:set ts=2 sw=2 et:

.circle.yml

@@ -0,0 +1,31 @@
+# Support for Circle CI -- https://circleci.com/gh/upx/upx
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+machine:
+  environment:
+    TRAVIS_OS_NAME: linux
+    CROSS:
+    C: gcc-4.8-m64
+    B: release
+    T:
+    X:
+
+checkout:
+  post:
+    - git submodule update --init --recursive
+
+dependencies:
+  pre:
+    - mkdir -p ../deps
+    - cd ../deps && wget -q -O - https://github.com/upx/upx/releases/download/v3.00/ucl-1.03.tar.xz | tar -xJ
+    - cd ../deps && wget -q -O - https://github.com/upx/upx/releases/download/v3.00/zlib-1.2.8.tar.xz | tar -xJ
+    - cd ../deps && git clone https://github.com/upx/upx-testsuite
+  override:
+    - mkdir -p ../build/travis
+    - bash ./.github/travis_build.sh
+
+test:
+  override:
+    - bash ./.github/travis_testsuite_1.sh
+
+# vim:set ts=2 sw=2 et:

.editorconfig

@@ -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

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,31 @@
+<!---
+
+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`):
+* Operating System and version:
+* CPU architecture:

.github/travis_build.sh

@@ -0,0 +1,138 @@
+#! /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
+    bin_upx=$(readlink -en -- "$upx_SRCDIR/../deps/bin-upx-20160918")
+    cd / && cd $upx_SRCDIR || exit 1
+    make -C src/stub maintainer-clean
+    failed=0
+    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
+    if [[ $BM_X == rebuild-stubs ]]; then
+        echo "X=rebuild-stubs done. Exiting."
+        exit 0
+    fi
+    unset bin_upx failed
+fi
+
+#
+# build UCL
+#
+
+cd / && cd $ucl_BUILDDIR || exit 1
+if [[ -n $BM_CROSS || $TRAVIS_OS_NAME == windows ]]; 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
+
+ls -l upx${upx_exeext}
+$SIZE upx${upx_exeext} || true
+file upx${upx_exeext}
+
+exit 0

.github/travis_init.sh

@@ -0,0 +1,191 @@
+## 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=
+
+# compatibility wrappers
+if [[ $TRAVIS_OS_NAME == osx ]]; then
+# use GNU coreutils ("brew install coreutils")
+readlink() {
+    greadlink "$@"
+}
+sha256sum() {
+    gsha256sum "$@"
+}
+fi
+if [[ -n $APPVEYOR_JOB_ID ]]; then
+# for some reason this is needed for bash on AppVeyor
+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_ZLIB=1
+    upx_exeext=.exe
+    # dir c:\cygwin
+    case $BM_C in
+        gcc-m32 | gcc-4.9-m32)
+            export upx_EXTRA_LDFLAGS="-static-libgcc -static-libstdc++"
+            x=i686-w64-mingw32; AR="$x-ar"; CC="$x-gcc -m32"; CXX="$x-g++ -m32" ;;
+        gcc-m64 | gcc-4.9-m64)
+            export upx_EXTRA_LDFLAGS="-static-libgcc -static-libstdc++"
+            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 $TRAVIS_JOB_ID ]]; then # TODO: should check for Ubuntu and not for Travis
+if [[ -n $BM_CROSS ]]; then
+    BUILD_LOCAL_ZLIB=1
+    case $BM_CROSS-$BM_C in
+        arm-linux-gnueabi-gcc | arm-linux-gnueabi-gcc-4.6)
+            export upx_EXTRA_LDFLAGS="-static-libgcc -static-libstdc++"
+            [[ -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)
+            export upx_EXTRA_LDFLAGS="-static-libgcc -static-libstdc++"
+            [[ -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)
+            export upx_EXTRA_LDFLAGS="-static-libgcc -static-libstdc++"
+            [[ -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)
+            export upx_EXTRA_LDFLAGS="-static-libgcc -static-libstdc++"
+            [[ -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 # TRAVIS_JOB_ID
+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-[34].[0-9]-m??)
+            v=${BM_C:6:3}; CC="clang-$v"; CXX="clang++-$v"; SCAN_BUILD="scan-build-$v" ;;
+        gcc | gcc-m??)
+            CC="gcc"; CXX="g++" ;; # standard system compiler
+        gcc-[34].[0-9]-m??)
+            v=${BM_C:4:3}; CC="gcc-$v"; CXX="g++-$v" ;;
+        gcc-[56]-m?? | gcc-[56].[0-9]-m??)
+            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" ;;
+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_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_settings() {
+    local v var_prefix var_suffix
+    # Build Matrix
+    for v in TRAVIS_OS_NAME BM_CROSS BM_C BM_B BM_T; do
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+    done
+    # BM_C related
+    for v in AR CC CXX CPPFLAGS CFLAGS CXXFLAGS LDFLAGS LIBS SCAN_BUILD; do
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+        v=EXTRA_${v}
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+    done
+    # directories and other info
+    for v in TRAVIS_XCODE_SDK UPX_UCLDIR lcov_OUTPUTDIR; do
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+    done
+    for var_prefix in ucl upx upx_testsuite zlib; do
+    for var_suffix in _BUILDDIR _SRCDIR; do
+        v=${var_prefix}${var_suffix}
+        [[ -n ${!v} ]] && echo "${v}='${!v}'"
+    done
+    done
+    ##env | LC_ALL=C sort
+}
+
+true

.github/travis_testsuite_1.sh

@@ -0,0 +1,385 @@
+#! /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() {
+    local x="==========="; x="$x$x$x$x$x$x$x"
+    echo -e "\n${x}\n${1}\n${x}\n"
+}
+
+testsuite_split_f() {
+    fd=$(dirname "$1")
+    fb=$(basename "$1")
+    fsubdir=$(basename "$fd")
+    # sanity checks
+    if [[ ! -f $f || -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="\
+a1f0fd57e4323eb25abf1d000569d3c7b62ceb12fb59e645d4807742baf0cd1f *amd64-linux.elf/upx-3.91
+6be5bd999387712f90fde45556c9487d02306593146c8d3cd4ced89568732729 *arm-wince.pe/upx-3.91.exe
+9d0ccc7e39ef23845b858869bf9718c43de5fd0eee7c61edbd63565a55110032 *armeb-linux.elf/upx-3.91
+03988f039a5372125bf90b6658516656a8582dd1c46423cb12faeb82870348bb *i386-dos32.djgpp2.coff/upx-3.91.exe
+91a9d980788c2974448c83a84af245cf22dbbe01d33850849c8b0ebcec79aab4 *i386-linux.elf/upx-3.91
+b9145c02bac9ce7f10bd65587ce35001d3e15a7a102d8f7cc51930b92f477ebf *i386-win32.pe/upx-3.91.exe
+08baacfa5d7e9339cd67263f41983e7c6f773fe9fce862f5daad58a2ac57ce28 *m68k-atari.tos/upx-3.91.ttp
+6b33a055b2c85dddd5fa6d846939d114ee24a342205f5a23aad31b8873041592 *mipsel-linux.elf/upx-3.91
+3e97639d9b13132edd3cf5e17f18a5d3f158124b920cabe8c415b8df3e4a8d1d *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t120_compress_ucl_nrv2d_3_no_filter="\
+1e870e9e12336eaa18289efa86275822025e15feeb9168b21f8c438f2560b84e *amd64-linux.elf/upx-3.91
+23ef6083a6e678975305ceb96f78ce186973b4400d357ca643573b6dd6487512 *arm-wince.pe/upx-3.91.exe
+5f1584a75584ef3421ba4aec8167422e78d33e2451ef9a925560d1112eacf88e *armeb-linux.elf/upx-3.91
+8d2938aa4c2b6ee3c50a2fce1041592a766d48c26605b50129b8a14697cc9694 *i386-dos32.djgpp2.coff/upx-3.91.exe
+40ecb345f3094446b5035e058b3d2351c42cc9f108333e3e4d51a64142d8950c *i386-linux.elf/upx-3.91
+7f4931501baa222ce54b241417f143162865de790be48ecc75846115baa2ce2f *i386-win32.pe/upx-3.91.exe
+5abbe27c76c6f12fb560e68dbf56dd0f39bb089428374c42be7585d09f7df1fd *m68k-atari.tos/upx-3.91.ttp
+ac552f23195dfebd82558e0523eaa6ece695c711f298ed9a3cdbb571f1df4f1d *mipsel-linux.elf/upx-3.91
+d30f7e75bcfab63aa620e0c677f738395ab7c8b26ba0871e94e052849660dccb *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t130_compress_ucl_nrv2e_3_no_filter="\
+bc67396d280c28532b2687fe694fb5dfaef60b1d1b05881027a2a97322545f7e *amd64-linux.elf/upx-3.91
+8844ace5189f90a9bf696e5fa2323be9e715d90df4ba60805a2079cb94c218f1 *arm-wince.pe/upx-3.91.exe
+ea42d52676d2698f29587e98a9e1536b96ebf523a7d8bc926f6c241a159b4116 *armeb-linux.elf/upx-3.91
+27f1afd1e1fec37d4dcd43163b9ec60a6af3abeab21a4adf539b7faea848eb20 *i386-dos32.djgpp2.coff/upx-3.91.exe
+5edf3dcfd0458b0f23c19e6c44b4c54a5457bc34c3bf045b37678d4f96301e00 *i386-linux.elf/upx-3.91
+e440de3826a193a81700dd6238eab5f903826e08af120a25bc963ffb6d365087 *i386-win32.pe/upx-3.91.exe
+510e2cd126bb8129b9076eb61e1ad3308d9af109cd42dff7252bf43e1e3552ea *m68k-atari.tos/upx-3.91.ttp
+b61aa58e493b3961646e5c0bcb7f19f74b439fe8f5c934db25b00f97f51a05d0 *mipsel-linux.elf/upx-3.91
+18c6b0ec20590dfbe4851ad837e2bb9bc99c6e4e1ac97b49dff2fb632e0e9d4c *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t140_compress_lzma_2_no_filter="\
+07e31b504273082dc475f217d8418f76ca409f018d42073a387f8a886dbaa83e *amd64-linux.elf/upx-3.91
+0eceefcc32ed25b2f1296cfa853935124aa1b7785b8a177d6e8c5804c24ca319 *arm-wince.pe/upx-3.91.exe
+3e7446d8ac6d9b442d6c8e6a3c45aec97f54aa8e90bdc554dd39976495bfa36a *armeb-linux.elf/upx-3.91
+1ecd559c89d3995fa0e7ecfa8e60b7746f804fc74ddce87d2c6cbeac8e372a39 *i386-dos32.djgpp2.coff/upx-3.91.exe
+8a9bde7a9b4a8f6c4efc4a28afe2b3cabe6c0b820dbc38c74c6abae73093b784 *i386-linux.elf/upx-3.91
+02d3b09168728cace52f29c5ee5a455c71d2777ccf12f6767cf92a709ceb6640 *i386-win32.pe/upx-3.91.exe
+35333e53bc2f8a4a8e346f4fba0d366f024bd63d0b8bb083967193ae6466b6ff *m68k-atari.tos/upx-3.91.ttp
+20526efe085aee06bfde1952f90e9d0e1524e0cb56d582caa720934f55562b78 *mipsel-linux.elf/upx-3.91
+65990ec2ab6bceb2d5444918af797be0bdb0931abce8e7db0d2e774614faa64b *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t150_compress_ucl_2_all_filters="\
+e773ed4ac55d5b967e4c1654f2b540899a63f7722a44d7056d424a6292274aa4 *amd64-linux.elf/upx-3.91
+0bf874c45ebb90b062cd986fe10cfbd01cdc6a50e3e0b5dda035eb55ded492ff *arm-wince.pe/upx-3.91.exe
+db894f24777334abb9bf8e34661d057e25c2889b46290cf83db7310c4cdd86fa *armeb-linux.elf/upx-3.91
+33bde57c3f7ed8809bec0658fe6c48d047bdec97476643f2e8e2970ab0c4eb5f *i386-dos32.djgpp2.coff/upx-3.91.exe
+7f4ad752cab7db426356eb5068e37d06bade2422b6012069814dcfadae7e2cca *i386-linux.elf/upx-3.91
+b00756ba6b73b937ac3b2c1222267dc44953ac69337a7ac582ba2e7a471e83a6 *i386-win32.pe/upx-3.91.exe
+7b09fa5b2f8d85673f3a52c3b478a8dd129ed23681de4028625b33f5f6890942 *m68k-atari.tos/upx-3.91.ttp
+707b7f32b8b0c1a4e5c26e370b93ae6eb60ab78f7d6163b4e853eb94e69f5d14 *mipsel-linux.elf/upx-3.91
+4403a20c1951c9d42b51a175b55a4a9ee6901d626b8e3ed1e7e55a51ae098272 *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t160_compress_all_methods_1_no_filter="\
+db82bffefd5ec10cea93b7cc47860db0dc122fac441980b3ae320e3b9c48c7e2 *amd64-linux.elf/upx-3.91
+df81b2376af28989faa0e48f9cb5d5f339d94166b7e11232c8d1ff952113a669 *arm-wince.pe/upx-3.91.exe
+07ca9736f1cd478bde2c8da95a6ecb95bd865dcf8ea48a396b13050ac40d196e *armeb-linux.elf/upx-3.91
+9e852e95b38ca57319d1e911bf97226a82b60dd336e201496c30bf62943aecce *i386-dos32.djgpp2.coff/upx-3.91.exe
+e408fbcbbe422c06fce0cfed5d28ea0f0ef7c1b9225bf1f5a7d789cc84fb93b8 *i386-linux.elf/upx-3.91
+30dbd980e85c88df62f4c13d6d0e44708f4ebfac63a4c12fa6a91b75563aead6 *i386-win32.pe/upx-3.91.exe
+dd561ff9c530711be0934db352cf40f606066c280e27b26e7f8fd6dd1a087e6a *m68k-atari.tos/upx-3.91.ttp
+813536a8f1b8b8852ed52c560afce8b51612876ac5a3a9e51434d8677932ef7b *mipsel-linux.elf/upx-3.91
+c6d010b0cdee8adc381efc424a44c14a1d110c52d7b12925265fddc4ba781a6c *powerpc-linux.elf/upx-3.91
+"
+expected_sha256sums__t170_compress_all_methods_no_lzma_5_no_filter="\
+689160a438a5650a40db1193b115566b55b3caa1fbbce88b5c608dda0ebc7c43 *amd64-linux.elf/upx-3.91
+debd7f6b30bfcb1fef0fac558d8ae721c6a9d193c9b41126b3491c66870435ab *arm-wince.pe/upx-3.91.exe
+7ee87918e7473d44c3a5af014cad48298f0a99c4028880d0a87a5a1776b977c7 *armeb-linux.elf/upx-3.91
+dcdcad70f1b79290022041938957dccd4daa2f2fad166864cfb55f3400d5b03b *i386-dos32.djgpp2.coff/upx-3.91.exe
+fece6171853a531cffdf264ae0ca9a47ee3b9b9a1416adc1ba2632e5da8a5d93 *i386-linux.elf/upx-3.91
+0a32f50fe00e6f24ab5ab0bbfdfd037819f01071e849fb486a07ccc0794105f9 *i386-win32.pe/upx-3.91.exe
+73dc44603f0fbf3a2a9e470c1291671b2670fa7f2f0cb54a8a7cdb883d1783c9 *m68k-atari.tos/upx-3.91.ttp
+48877f2e614d4697e0ebc6d3f69e59328e0942e48bb5e54b4d9b9fe3cb917d9f *mipsel-linux.elf/upx-3.91
+9df3e5bb2a641d03da582f6e5dc01e2497e616d585c8e2c07c78910ca7ac6db3 *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"
+$upx_run --version || echo "UPX-ERROR: upx --version FAILED"
+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

.gitignore

@@ -0,0 +1,58 @@
+/.bzr*
+/.hg*
+/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*/*.map
+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

.gitlab-ci.yml

@@ -0,0 +1,102 @@
+# Support for GibLab CI -- https://gitlab.com/
+# Copyright (C) Markus Franz Xaver Johannes Oberhumer
+
+before_script:
+  - export TRAVIS_OS_NAME=linux
+  - unset CROSS C B T X
+  - uname -a; pwd; id; umask; env
+  - cat /etc/os-release || true
+  -
+    if egrep -q '^PRETTY_NAME="?Fedora' /etc/os-release; then
+      time rpm -qa | LC_ALL=C sort;
+      time dnf install -y --best --allowerasing
+        coreutils curl diffutils grep gzip sed
+        bzip2 file findutils git perl tar wget which xz
+        clang gcc gcc-c++ lcov make valgrind
+        glibc-devel      libasan      libstdc++-devel      libubsan      zlib-devel
+        glibc-devel.i686 libasan.i686 libstdc++-devel.i686 libubsan.i686 zlib-devel.i686;
+    fi
+  -
+    if egrep -q '^PRETTY_NAME="?Ubuntu' /etc/os-release; then
+      export DEBIAN_FRONTEND=noninteractive;
+      time dpkg -l;
+      time apt-get -yq update;
+      time apt-get -yq --no-install-suggests --no-install-recommends --force-yes upgrade;
+      time apt-get -yq --no-install-suggests --no-install-recommends --force-yes install
+        build-essential ca-certificates curl file git wget xz-utils zlib1g-dev;
+    fi
+  -
+    if egrep -q '^PRETTY_NAME="?Ubuntu 16\.04' /etc/os-release; then
+      dpkg --add-architecture i386;
+      time apt-get -yq update;
+      time apt-get -yq --no-install-suggests --no-install-recommends --force-yes install
+        crossbuild-essential-arm64 crossbuild-essential-armel crossbuild-essential-armhf
+        crossbuild-essential-powerpc crossbuild-essential-ppc64el crossbuild-essential-s390x
+        qemu wine;
+    fi
+  - umask 022; mkdir -p ../deps ../build/gitlab
+  - time git submodule update --init --recursive
+  - cd ../deps && time wget -q -O - https://github.com/upx/upx/releases/download/v3.00/ucl-1.03.tar.xz | tar -xJ
+  - cd ../deps && time wget -q -O - https://github.com/upx/upx/releases/download/v3.00/zlib-1.2.8.tar.xz | tar -xJ
+  - cd ../deps && time git clone https://github.com/upx/upx-testsuite
+  - cd $CI_PROJECT_DIR; pwd
+
+Fedora23-clang+gcc-m32+m64:
+  image: fedora:23
+  script:
+  - time C=clang-m32            bash ./.github/travis_build.sh
+  - time C=gcc-m32              bash ./.github/travis_build.sh
+  - time C=clang-m64            bash ./.github/travis_build.sh
+  - time C=gcc-m64              bash ./.github/travis_build.sh
+  - time C=gcc-m64   B=sanitize bash ./.github/travis_build.sh
+  - time C=clang-m32            bash ./.github/travis_testsuite_1.sh
+  - time C=gcc-m32              bash ./.github/travis_testsuite_1.sh
+  - time C=clang-m64            bash ./.github/travis_testsuite_1.sh
+  - time C=gcc-m64              bash ./.github/travis_testsuite_1.sh
+  - time C=gcc-m64   B=sanitize bash ./.github/travis_testsuite_1.sh
+  - time C=gcc-m64   T=valgrind bash ./.github/travis_testsuite_1.sh
+  tags: [ shared ]
+  except: [ tags ]
+
+Fedora24-clang+gcc-m32+m64:
+  image: fedora:24
+  script:
+  - time C=clang-m32            bash ./.github/travis_build.sh
+  - time C=gcc-m32              bash ./.github/travis_build.sh
+  - time C=clang-m64            bash ./.github/travis_build.sh
+  - time C=gcc-m64              bash ./.github/travis_build.sh
+  - time C=gcc-m64   B=sanitize bash ./.github/travis_build.sh
+  - time C=clang-m32            bash ./.github/travis_testsuite_1.sh
+  - time C=gcc-m32              bash ./.github/travis_testsuite_1.sh
+  - time C=clang-m64            bash ./.github/travis_testsuite_1.sh
+  - time C=gcc-m64              bash ./.github/travis_testsuite_1.sh
+  - time C=gcc-m64   B=sanitize bash ./.github/travis_testsuite_1.sh
+  - time C=gcc-m64   T=valgrind bash ./.github/travis_testsuite_1.sh
+  tags: [ shared ]
+  except: [ tags ]
+
+Ubuntu1204-gcc-m64:
+  image: ubuntu:12.04
+  script:
+  - time C=gcc-m64              bash ./.github/travis_build.sh
+  - time C=gcc-m64              bash ./.github/travis_testsuite_1.sh
+  tags: [ shared ]
+  except: [ tags ]
+
+Ubuntu1404-gcc-m64:
+  image: ubuntu:14.04
+  script:
+  - time C=gcc-m64              bash ./.github/travis_build.sh
+  - time C=gcc-m64              bash ./.github/travis_testsuite_1.sh
+  tags: [ shared ]
+  except: [ tags ]
+
+Ubuntu1604-gcc-m64:
+  image: ubuntu:16.04
+  script:
+  - time C=gcc-m64              bash ./.github/travis_build.sh
+  - time C=gcc-m64              bash ./.github/travis_testsuite_1.sh
+  tags: [ shared ]
+  except: [ tags ]
+
+# vim:set ts=2 sw=2 et:

.gitmodules

@@ -0,0 +1,4 @@
+[submodule "src/lzma-sdk"]
+	path = src/lzma-sdk
+	url = https://github.com/upx/upx-lzma-sdk.git
+	branch = master

.hgignore

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

.hgtags

@@ -1,16 +0,0 @@
-140415ffbcef86a42b4d672249927364430d3d38 RELEASE_111
-223ac5b23f9731ceac9ff8d65167df4900776e36 RELEASE_190
-2c753c5bf38e7322715e2a5c6c5381111bd7a61a RELEASE_194
-2ee65b77f9117651e2e5517b2edede23698d73ca RELEASE_196
-396983c065fc743cb5b9703e266ca87eeff8a6ee RELEASE_291
-70402aeee6e0e4fc2889658ed8cee44461c0b0a8 RELEASE_200
-a1c61174f54aac714f59ac20fcba839d71e64c5c RELEASE_292
-a916a2fe22de45167d25abcb40008315f415221c RELEASE_201
-a935d577fc7dd9c2c87761c9c702805da6ce1e51 RELEASE_193
-b0353253b0b3d062eb5adb50d4b665a96620da45 RELEASE_195
-b82ef51896199484afe5b0553af7d1e59b7ce428 BRANCHPOINT_FOR_upx2.hg
-c2e0cd4d621b047f254f2def42132a03683ff52c RELEASE_192
-d276aa09033c24d0981bc3f4fee5628aecc988ad RELEASE_290
-eb1ce56dce7dd1835964362470610925963b9043 RELEASE_110
-ed96891ef795bceec6b7ff3ca1ca7764431bfb39 RELEASE_191
-efa52753e366300c0e0ebe20631adcb24ed3c15b RELEASE_293

.travis.yml

@@ -0,0 +1,211 @@
+# 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
+
+env:
+  global:
+    - CROSS= C= B= T= X=
+  matrix:
+    - TRAVIS_EMPTY_JOB_WORKAROUND=true
+
+matrix:
+  fast_finish: true
+  exclude:
+    - env: TRAVIS_EMPTY_JOB_WORKAROUND=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.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-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.8-m64 B=debug+sanitize
+      addons: { apt: { sources: *S, packages: [ "clang-3.8" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.8-m64 B=sanitize
+      addons: { apt: { sources: *S, packages: [ "clang-3.8" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.8-m64 B=debug+scan-build
+      addons: { apt: { sources: *S, packages: [ "clang-3.8" ] } }
+    - os: linux
+      compiler: clang
+      env: C=clang-3.8-m64 B=scan-build
+      addons: { apt: { sources: *S, packages: [ "clang-3.8" ] } }
+    - 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.1
+      compiler: clang
+      env: C=clang-800-m32
+    - os: osx
+      osx_image: xcode8.1
+      compiler: clang
+      env: C=clang-800-m64
+
+install:
+  - umask 022; cd $TRAVIS_BUILD_DIR && mkdir -p ../deps
+  - 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
+  - |
+    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
+
+script:
+  - cd $TRAVIS_BUILD_DIR && mkdir -p ../build/travis
+  - cd $TRAVIS_BUILD_DIR && bash ./.github/travis_build.sh
+  - cd $TRAVIS_BUILD_DIR && bash ./.github/travis_testsuite_1.sh
+
+# vim:set ts=2 sw=2 et:

BUGS

@@ -8,8 +8,8 @@
 
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2007 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
+   Copyright (c) 1996-2016 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io
 
 
 Limitations and other things which are not (yet) supported:
@@ -28,7 +28,7 @@ dos/exe
 watcom/le
 ---------
  * 16-bit selector alias fixups
- * 16-bit offset relocation for objects larger than 4 kB
+ * 16-bit offset relocation for objects larger than 4 KiB
  * 16:16 fixups
 
 If you need any of the above (they're very rare), send us an URL of a
@@ -44,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

Makefile

@@ -1,30 +1,26 @@
 #
 # UPX toplevel Makefile - needs GNU make 3.81 or better
 #
+# Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+#
 
 MAKEFLAGS += -rR
 .SUFFIXES:
 export SHELL = /bin/sh
 
-ifneq ($(findstring $(firstword $(MAKE_VERSION)),3.77 3.78 3.78.1 3.79 3.79.1 3.80),)
-$(error GNU make 3.81 or better is required)
-endif
-
 srcdir = .
 top_srcdir = .
 include $(wildcard $(top_srcdir)/Makevars.global ./Makevars.local)
 
-
-# info: src/stub needs special build tools
+# info: src/stub needs special build tools from https://github.com/upx/upx-stubtools
 BUILD_STUB = 0
-ifneq ($(wildcard $(HOME)/local/bin/bin-upx/.),)
+ifneq ($(wildcard $(HOME)/local/bin/bin-upx/upx-stubtools-check-version),)
 BUILD_STUB = 1
 endif
-ifneq ($(wildcard $(HOME)/bin/bin-upx/.),)
+ifneq ($(wildcard $(HOME)/bin/bin-upx/upx-stubtools-check-version),)
 BUILD_STUB = 1
 endif
 
-
 default:
 	@echo "UPX info: please choose a target for 'make'"
 
@@ -35,14 +31,6 @@ endif
 	$(MAKE) -C src $@
 	$(MAKE) -C doc $@
 
-
-ifneq ($(wildcard .hg/data/.),)
-# automatically generate ChangeLog from local Mercurial repo
-ChangeLog:
-	hg log --style=changelog > $@
-.PHONY: ChangeLog
-endif
-
-
 .PHONY: default all mostlyclean clean distclean maintainer-clean
 
+# vim:set ts=8 sw=8 noet:

NEWS

@@ -2,6 +2,93 @@
 User visible changes for UPX
 ==================================================================
 
+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
+
+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
 

PROJECTS

@@ -8,8 +8,8 @@
 
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2007 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
+   Copyright (c) 1996-2016 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

README

@@ -8,8 +8,8 @@
 
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2007 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
+   Copyright (c) 1996-2016 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io
 
 
 
@@ -81,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
@@ -108,9 +103,9 @@ THE FUTURE
 COPYRIGHT
 =========
 
-Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-Copyright (C) 1996-2007 Laszlo Molnar
-Copyright (C) 2000-2007 John F. Reiser
+Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+Copyright (C) 1996-2016 Laszlo Molnar
+Copyright (C) 2000-2016 John F. Reiser
 
 This program may be used freely, and you are welcome to
 redistribute it under certain conditions.
@@ -125,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.com                      ml1050@users.sourceforge.net
+   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

README.1ST

@@ -8,16 +8,8 @@
 
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2007 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
-
-
-
-WARNING - UNSTABLE BETA VERSION
-===============================
-
-The current stable release is 2.02, and the next stable release
-will be called version 3.00.
+   Copyright (c) 1996-2016 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io
 
 
 MAJOR NEWS IN UPX 3
@@ -29,3 +21,4 @@ The main news since UPX 2 are:
 
   * better compression using the LZMA algorithm (option '--lzma')
 
+  * better support for MacOS

README.SRC

@@ -66,10 +66,15 @@ Prerequisites
 Tools needed to build/modify the UPX sources
 --------------------------------------------
 
-  - A C++ compiler supporting inner classes, templates, exceptions
-    and RTTI.
+  - A C++ compiler: gcc >= 3.3 or clang.
 
-  - GNU make 3.80 or better (GNU make 3.81 recommened).
+  - GNU make 3.81 or better
+
+  - 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
@@ -81,11 +86,6 @@ To compile the packer sources
      set UPX_UCLDIR=c:\src\ucl-1.03                   (DOS / Windows)
      export UPX_UCLDIR=$HOME/local/src/ucl-1.03       (Unix)
 
-  Set the environment variable UPX_LZMADIR to point to your
-  to your unpacked lzma443.tar.bz2 source directory, e.g.
-
-     export UPX_LZMADIR=$HOME/local/src/lzma-4.43     (Unix)
-
   Finally type
 
      make
@@ -94,14 +94,11 @@ To compile the packer sources
 If you want to modify the stub sources you'll also need
 -------------------------------------------------------
 
-  - GNU make 3.81 or better
-    http://savannah.gnu.org/projects/make/
-
   - Perl & Python
 
-  - A number of cross-assemblers and cross-compilers - precompiled
-    binaries for i386-linux hosts are available from
-    http://sourceforge.net/project/showfiles.php?group_id=2331
+  - 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
@@ -141,4 +138,4 @@ Patches/Contributions
       diff -uNr olddirectory newdirectory
 
 
-# vi:ts=4:et
+# vim:set ts=4 sw=4 et:

THANKS

@@ -8,8 +8,8 @@
 
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2007 Markus Oberhumer, Laszlo Molnar & John Reiser
-                        http://upx.sourceforge.net
+   Copyright (c) 1996-2016 Markus Oberhumer, Laszlo Molnar & John Reiser
+                           https://upx.github.io
 
 
 .___..        .
@@ -53,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

TODO

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

doc/elf-to-mem.txt

@@ -1,5 +1,5 @@
            Decompressing ELF Directly to Memory on Linux/x86
-        Copyright (C) 2000-2007 John F. Reiser  jreiser@BitWagon.com
+        Copyright (C) 2000-2016 John F. Reiser  jreiser@BitWagon.com
 
 References:
   <elf.h>   definitions for the ELF file format
@@ -46,8 +46,8 @@ may not be used to take the address of a function.
 
 The address  0x00400000 was chosen to be out of the way of the usual
 load address 0x08048000, and to minimize fragmentation in kernel
-page tables; one page of page tables covers 4MB. The address
-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
@@ -64,16 +64,42 @@ assuming that its automatic stack variables are initialized to zero),
 and remove (all but 4 bytes of) the decompression program (and
 compressed executable) from the address space.
 
-Because the UPX runtime stub removes all traces of the compressed file
-from the address space, then the Linux kernel erases the symlink
-/proc/self/exe.  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.  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().
+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

doc/filter.txt

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

doc/selinux.txt

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

doc/upx.pod

@@ -13,7 +13,7 @@ B<upx> S<[ I<command> ]> S<[ I<options> ]> I<filename>...
 =head1 ABSTRACT
 
                     The Ultimate Packer for eXecutables
-   Copyright (c) 1996-2007 Markus Oberhumer, Laszlo Molnar & John Reiser
+   Copyright (c) 1996-2016 Markus Oberhumer, Laszlo Molnar & John Reiser
                         http://upx.sourceforge.net
 
 
@@ -51,8 +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 on an ancient Pentium 133,
-      about 200 MB/sec on an Athlon XP 2000+.
+  - 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
@@ -139,7 +139,11 @@ B<--help>: prints the help
 B<--version>: print the version of B<UPX>
 
 B<--exact>: when compressing, require to be able to get a byte-identical file
-after decompression with option B<-d>
+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 ]
 
@@ -149,7 +153,7 @@ after decompression with option B<-d>
 
 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
 
@@ -345,7 +349,7 @@ Extra options available for this executable format:
 First of all, it is recommended to use B<UPX> *instead* of B<strip>. strip has
 the very bad habit of replacing your stub with its own (outdated) version.
 Additionally B<UPX> corrects a bug/feature in strip v2.8.x: it
-will fix the 4 KByte alignment of the stub.
+will fix the 4 KiB alignment of the stub.
 
 B<UPX> includes the full functionality of stubify. This means it will
 automatically stubify your COFF files. Use the option B<--coff> to
@@ -656,8 +660,8 @@ Specific drawbacks:
 
   - Because of temporary decompression to disk the decompression speed
     is not as fast as with the other executable formats. Still, I can see
-    no noticeable 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:
 
@@ -677,7 +681,7 @@ nostalgic feelings of one of the authors.
 Packed programs will be byte-identical to the original after uncompression,
 until further notice.
 
-Maximum uncompressed size: ~1.89 / ~7.60 Mbytes.
+Maximum uncompressed size: ~1.89 / ~7.60 MiB.
 
 Notes:
 
@@ -704,7 +708,7 @@ Extra options available for this executable format:
 
   --8-bit             Uses 8 bit size compression [default: 32 bit]
 
-  --8mb-ram           PSone has 8 MB ram available [default: 2 MB]
+  --8mib-ram          PSone has 8 MiB ram available [default: 2 MiB]
 
   --boot-only         This format is for main exes and CD-Mastering only !
                       It may slightly improve the compression ratio,
@@ -834,7 +838,7 @@ 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 kbytes range) which can be seen by specifying the "-i" command
+10 - 30 KiB range) which can be seen by specifying the "-i" command
 line switch during compression.
 
 Extra options available for this executable format:
@@ -919,7 +923,7 @@ Please report all bugs immediately to the authors.
  Markus F.X.J. Oberhumer <markus@oberhumer.com>
  http://www.oberhumer.com
 
- Laszlo Molnar <ml1050@users.sourceforge.net>
+ Laszlo Molnar <ezerotven+github@gmail.com>
 
  John F. Reiser <jreiser@BitWagon.com>
 
@@ -929,13 +933,13 @@ Please report all bugs immediately to the authors.
 
 =head1 COPYRIGHT
 
-Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
+Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
 
-Copyright (C) 1996-2007 Laszlo Molnar
+Copyright (C) 1996-2016 Laszlo Molnar
 
-Copyright (C) 2000-2007 John F. Reiser
+Copyright (C) 2000-2016 John F. Reiser
 
-Copyright (C) 2002-2007 Jens Medoch
+Copyright (C) 2002-2016 Jens Medoch
 
 This program may be used freely, and you are welcome to
 redistribute it under certain conditions.

src/Makefile

@@ -1,100 +1,126 @@
 #
 # UPX Makefile - needs GNU make 3.81 or better
 #
+# Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+#
 
-MAKEFLAGS += -rR
+# build configuration options for this Makefile
+BUILD_TYPE_DEBUG    ?= 0
+BUILD_TYPE_SANITIZE ?= 0
+BUILD_USE_DEPEND    ?= 1
+
+MAKEFLAGS += -r
 .SUFFIXES:
 export SHELL = /bin/sh
-override e = $($1) $(EXTRA_$1) $(upx_$1) $($(basename $(notdir $@)).$1)
-
-ifneq ($(findstring $(firstword $(MAKE_VERSION)),3.77 3.78 3.78.1 3.79 3.79.1 3.80),)
-$(error GNU make 3.81 or better is required)
-endif
+override ee = $($1) $(EXTRA_$1) $(upx_$1) $(upx_EXTRA_$1) $($(basename $(notdir $@)).$1)
 
 ifndef srcdir
-srcdir := $(dir $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST)))
-srcdir := $(shell echo '$(srcdir)' | sed 's,/*$$,,')
+srcdir := $(dir $(lastword $(MAKEFILE_LIST)))
+srcdir := $(shell echo '$(srcdir)' | sed 's,/*$$,,' || echo 'ERROR')
 endif
 ifndef top_srcdir
 top_srcdir := $(srcdir)/..
 endif
 include $(wildcard $(top_srcdir)/Makevars.global ./Makevars.local)
 ifneq ($(srcdir),.)
-##$(info Info: using VPATH . $(srcdir))
-VPATH := . $(srcdir)
+vpath %.cpp .:$(srcdir)
+vpath %.h   .:$(srcdir)
 endif
 
-ifeq ($(CXX),)
-CXX = g++
-endif
-ifneq ($(findstring $(firstword $(CXX)),g++),)
-USE_GNUC ?= 1
-endif
-ifeq ($(USE_GNUC),1)
-ifeq ($(DEBUG),1)
-CXXFLAGS += -O0 -g
-else
-CXXFLAGS += -O2
-endif
-CXXFLAGS += -Wall -W -Wcast-align -Wcast-qual -Wpointer-arith -Wwrite-strings -Werror
-##CXXFLAGS += -Wshadow
-endif
-CPPFLAGS += $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
-CXXLD ?= $(CXX)
-
+# toolchain
+CXX    ?= g++
+CXXLD   = $(CXX)
 exeext ?= .out
 libext ?= .a
 objext ?= .o
 
-upx_SOURCES := $(wildcard $(srcdir)/*.cpp)
+upx_SOURCES := $(sort $(wildcard $(srcdir)/*.cpp))
 upx_OBJECTS := $(notdir $(upx_SOURCES:.cpp=$(objext)))
 
+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
+
 # 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
-# you should set envvar UPX_LZMADIR to point to your unpacked lzma443.tar.bz2
-ifneq ($(wildcard $(UPX_LZMADIR)/C/7zip/.),)
-DEFS += -DWITH_LZMA=1
-INCLUDES += -I$(UPX_LZMADIR)
+# LZMA from https://github.com/upx/upx-lzma-sdk
+include $(top_srcdir)/src/stub/src/c/Makevars.lzma
+DEFS += -DWITH_LZMA=$(UPX_LZMA_VERSION)
+
+CPPFLAGS += $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES)
+ifeq ($(BUILD_TYPE_DEBUG),1)
+CXXFLAGS_OPTIMIZE ?= -O0 -g
+else
+CXXFLAGS_OPTIMIZE ?= -O2
+endif
+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)
+
+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
 
-
-all: upx$(exeext) | .depend
-.DELETE_ON_ERROR: upx$(exeext) $(upx_OBJECTS) .depend
+# rules
+all: upx$(exeext) | ./.depend
+.DELETE_ON_ERROR: upx$(exeext) $(upx_OBJECTS) ./.depend
 
 upx$(exeext): $(upx_OBJECTS) $(upx_DEPENDENCIES)
 	$($(notdir $@).PRE_LINK_STEP)
-	$(strip $(CXXLD) $(call e,CPPFLAGS) $(call e,CXXFLAGS) $(call e,LDFLAGS) -o $@ $(upx_OBJECTS) $(call e,LDADD) $(call e,LIBS))
+	$(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 e,CPPFLAGS) $(call e,CXXFLAGS) -o $@ -c $<)
+%.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 $<)
 
-.depend: $(wildcard $(srcdir)/*.cpp $(srcdir)/*.h) $(MAKEFILE_LIST)
+ifeq ($(BUILD_USE_DEPEND),1)
+./.depend: $(sort $(wildcard $(srcdir)/*.cpp $(srcdir)/*.h)) $(MAKEFILE_LIST)
 	@rm -f $@
-ifeq ($(USE_GNUC),1)
 	@echo "Updating $@"
-	@$(strip $(CXX) $(call e,CPPFLAGS) -MM) $(filter %.cpp,$^) > $@
+	@$(strip $(CXX) $(call ee,CPPFLAGS) $(call ee,CXXFLAGS) -MM) $(filter %.cpp,$^) > $@
 else
-	touch $@
+./.depend:
+.PHONY: ./.depend
 endif
 
-
-ifeq ($(USE_GNUC),1)
-##compress_lzma$(objext) : CXXFLAGS += -O3 -fomit-frame-pointer
-compress_lzma$(objext) : CXXFLAGS += -Wno-cast-qual
-compress_lzma$(objext) : CXXFLAGS += -Wno-non-virtual-dtor
-compress_lzma$(objext) : CXXFLAGS += -Wno-shadow
-compress_lzma$(objext) : CXXFLAGS += -Wno-unused
-##compress_lzma$(objext) : CXXFLAGS += -Wno-error
+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 *.map *.o *.obj *.res .depend upx.exe upx.out upx.ttp upx$(exeext)
+	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
 
@@ -102,6 +128,48 @@ 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
--include .depend
+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
+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
+
+# automatically format some C++ source code files
+ifeq ($(shell uname),Linux)
+CLANG_FORMAT_FILES += linker.cpp linker.h packhead.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
+
+# vim:set ts=8 sw=8 noet:

src/bele.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_BELE_H
-#define __UPX_BELE_H
+#define __UPX_BELE_H 1
 
 
 /*************************************************************************
@@ -88,7 +88,7 @@ inline void set_be32(void *p, unsigned v)
 #endif
 }
 
-inline acc_uint64l_t get_be64(const void *p)
+inline upx_uint64_t get_be64(const void *p)
 {
 #if defined(ACC_UA_GET_BE64)
     return ACC_UA_GET_BE64(p);
@@ -97,7 +97,7 @@ inline acc_uint64l_t get_be64(const void *p)
 #endif
 }
 
-inline void set_be64(void *p, acc_uint64l_t v)
+inline void set_be64(void *p, upx_uint64_t v)
 {
 #if defined(ACC_UA_SET_BE64)
     ACC_UA_SET_BE64(p, v);
@@ -160,7 +160,7 @@ inline void set_le32(void *p, unsigned v)
 #endif
 }
 
-inline acc_uint64l_t get_le64(const void *p)
+inline upx_uint64_t get_le64(const void *p)
 {
 #if defined(ACC_UA_GET_LE64)
     return ACC_UA_GET_LE64(p);
@@ -169,7 +169,7 @@ inline acc_uint64l_t get_le64(const void *p)
 #endif
 }
 
-inline void set_le64(void *p, acc_uint64l_t v)
+inline void set_le64(void *p, upx_uint64_t v)
 {
 #if defined(ACC_UA_SET_LE64)
     ACC_UA_SET_LE64(p, v);
@@ -187,18 +187,16 @@ inline int sign_extend(unsigned v, unsigned bits)
 {
     const unsigned sign_bit = 1u << (bits - 1);
     v &= sign_bit | (sign_bit - 1);
-    //v = (v ^ sign_bit) - sign_bit;
     v |= 0 - (v & sign_bit);
-    return (int) v;
+    return ACC_ICAST(int, v);
 }
 
-inline acc_int64l_t sign_extend(acc_uint64l_t v, unsigned bits)
+inline upx_int64_t sign_extend(upx_uint64_t v, unsigned bits)
 {
-    const acc_uint64l_t sign_bit = ACC_UINT64_C(1) << (bits - 1);
+    const upx_uint64_t sign_bit = UPX_UINT64_C(1) << (bits - 1);
     v &= sign_bit | (sign_bit - 1);
-    //v = (v ^ sign_bit) - sign_bit;
     v |= 0 - (v & sign_bit);
-    return (acc_int64l_t) v;
+    return ACC_ICAST(upx_int64_t, v);
 }
 
 inline int get_be16_signed(const void *p)
@@ -219,9 +217,9 @@ inline int get_be32_signed(const void *p)
     return sign_extend(v, 32);
 }
 
-inline acc_int64l_t get_be64_signed(const void *p)
+inline upx_int64_t get_be64_signed(const void *p)
 {
-    acc_uint64l_t v = get_be64(p);
+    upx_uint64_t v = get_be64(p);
     return sign_extend(v, 64);
 }
 
@@ -243,9 +241,9 @@ inline int get_le32_signed(const void *p)
     return sign_extend(v, 32);
 }
 
-inline acc_int64l_t get_le64_signed(const void *p)
+inline upx_int64_t get_le64_signed(const void *p)
 {
-    acc_uint64l_t v = get_le64(p);
+    upx_uint64_t v = get_le64(p);
     return sign_extend(v, 64);
 }
 
@@ -269,25 +267,25 @@ inline unsigned acc_swab32(unsigned v)
 }
 
 
-inline unsigned acc_swab16p(const acc_uint16e_t *p)
+inline unsigned acc_swab16p(const upx_uint16_t *p)
 {
     return acc_swab16(*p);
 }
 
-inline unsigned acc_swap32p(const acc_uint32e_t *p)
+inline unsigned acc_swap32p(const upx_uint32_t *p)
 {
     return acc_swab32(*p);
 }
 
 
-inline void acc_swab16s(acc_uint16e_t *p)
+inline void acc_swab16s(upx_uint16_t *p)
 {
-    *p = acc_swab16(*p);
+    *p = ACC_ICONV(upx_uint16_t, acc_swab16(*p));
 }
 
-inline void acc_swab32s(acc_uint32e_t *p)
+inline void acc_swab32s(upx_uint32_t *p)
 {
-    *p = acc_swab32(*p);
+    *p = ACC_ICONV(upx_uint32_t, acc_swab32(*p));
 }
 
 
@@ -313,13 +311,9 @@ inline void acc_ua_swab32s(void *p)
 //  to have gcc bug 17519 fixed - see http://gcc.gnu.org/PR17519 ]
 **************************************************************************/
 
-struct BE16
-{
+__packed_struct(BE16)
     unsigned char d[2];
 
-    //inline BE16() { }
-    //BE16(unsigned v) { set_be16(d, v); }
-
     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; }
@@ -331,18 +325,13 @@ struct BE16
     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 unsigned () const  { return get_be16(d); }
-}
-__attribute_packed;
+    operator unsigned () const { return get_be16(d); }
+__packed_struct_end()
 
 
-struct BE32
-{
+__packed_struct(BE32)
     unsigned char d[4];
 
-    //inline BE32() { }
-    //BE32(unsigned v) { set_be32(d, v); }
-
     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; }
@@ -354,41 +343,31 @@ struct BE32
     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 unsigned () const  { return get_be32(d); }
-}
-__attribute_packed;
+    operator unsigned () const { return get_be32(d); }
+__packed_struct_end()
 
 
-struct BE64
-{
+__packed_struct(BE64)
     unsigned char d[8];
 
-    //inline BE64() { }
-    //BE64(acc_uint64l_t v) { set_be64(d, v); }
-
-    BE64& operator =  (acc_uint64l_t v) { set_be64(d, v); return *this; }
-    BE64& operator += (acc_uint64l_t v) { set_be64(d, get_be64(d) + v); return *this; }
-    BE64& operator -= (acc_uint64l_t v) { set_be64(d, get_be64(d) - v); return *this; }
-    BE64& operator *= (acc_uint64l_t v) { set_be64(d, get_be64(d) * v); return *this; }
-    BE64& operator /= (acc_uint64l_t v) { set_be64(d, get_be64(d) / v); return *this; }
-    BE64& operator &= (acc_uint64l_t v) { set_be64(d, get_be64(d) & v); return *this; }
-    BE64& operator |= (acc_uint64l_t v) { set_be64(d, get_be64(d) | v); return *this; }
-    BE64& operator ^= (acc_uint64l_t v) { set_be64(d, get_be64(d) ^ v); return *this; }
+    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 acc_uint64l_t () const  { return get_be64(d); }
-}
-__attribute_packed;
+    operator upx_uint64_t () const { return get_be64(d); }
+__packed_struct_end()
 
 
-struct LE16
-{
+__packed_struct(LE16)
     unsigned char d[2];
 
-    //inline LE16() { }
-    //LE16(unsigned v) { set_le16(d, v); }
-
     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; }
@@ -400,18 +379,13 @@ struct LE16
     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 unsigned () const  { return get_le16(d); }
-}
-__attribute_packed;
+    operator unsigned () const { return get_le16(d); }
+__packed_struct_end()
 
 
-struct LE32
-{
+__packed_struct(LE32)
     unsigned char d[4];
 
-    //inline LE32() { }
-    //LE32(unsigned v) { set_le32(d, v); }
-
     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; }
@@ -423,32 +397,26 @@ struct LE32
     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); }
-}
-__attribute_packed;
+    operator unsigned () const { return get_le32(d); }
+__packed_struct_end()
 
 
-struct LE64
-{
+__packed_struct(LE64)
     unsigned char d[8];
 
-    //inline LE64() { }
-    //LE64(acc_uint64l_t v) { set_le64(d, v); }
-
-    LE64& operator =  (acc_uint64l_t v) { set_le64(d, v); return *this; }
-    LE64& operator += (acc_uint64l_t v) { set_le64(d, get_le64(d) + v); return *this; }
-    LE64& operator -= (acc_uint64l_t v) { set_le64(d, get_le64(d) - v); return *this; }
-    LE64& operator *= (acc_uint64l_t v) { set_le64(d, get_le64(d) * v); return *this; }
-    LE64& operator /= (acc_uint64l_t v) { set_le64(d, get_le64(d) / v); return *this; }
-    LE64& operator &= (acc_uint64l_t v) { set_le64(d, get_le64(d) & v); return *this; }
-    LE64& operator |= (acc_uint64l_t v) { set_le64(d, get_le64(d) | v); return *this; }
-    LE64& operator ^= (acc_uint64l_t v) { set_le64(d, get_le64(d) ^ v); return *this; }
+    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 acc_uint64l_t () const  { return get_le64(d); }
-}
-__attribute_packed;
+    operator upx_uint64_t () const { return get_le64(d); }
+__packed_struct_end()
 
 
 /*************************************************************************
@@ -498,15 +466,16 @@ template <class T> T* operator - (T* ptr, const LE64& v);
 // global overloads
 **************************************************************************/
 
-#if 1 && !defined(ALIGN_DOWN)
+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); }
-#endif
 
-
-#if !defined(UPX_MAX)
 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); }
@@ -526,7 +495,6 @@ inline unsigned UPX_MAX(unsigned a, const LE32& b)    { return UPX_MAX(a, (unsig
 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); }
-#endif
 
 
 /*************************************************************************
@@ -554,44 +522,8 @@ int __acc_cdecl_qsort le64_compare_signed(const void *, const void *);
 } // extern "C"
 
 
-// just for testing...
-#if !defined(ACC_CFG_NO_UNALIGNED)
-#if 0 && (ACC_ARCH_AMD64 || ACC_ARCH_I386) && (ACC_CC_GNUC >= 0x030200)
-   typedef acc_uint16e_t LE16_unaligned __attribute__((__aligned__(1)));
-   typedef acc_uint32e_t LE32_unaligned __attribute__((__aligned__(1)));
-#  ifndef LE16
-#    define LE16    LE16_unaligned
-#  endif
-#  ifndef LE32
-#    define LE32    LE32_unaligned
-#  endif
-#endif
-#if 0 && (ACC_ARCH_I386) && (ACC_CC_INTELC)
-   typedef __declspec(align(1)) acc_uint16e_t LE16_unaligned;
-   typedef __declspec(align(1)) acc_uint32e_t LE32_unaligned;
-#  ifndef LE16
-#    define LE16    LE16_unaligned
-#  endif
-#  ifndef LE32
-#    define LE32    LE32_unaligned
-#  endif
-#endif
-#if 0 && (ACC_ARCH_AMD64 || ACC_ARCH_I386) && (ACC_CC_MSC) && (_MSC_VER >= 1200)
-   typedef __declspec(align(1)) acc_uint16e_t LE16_unaligned;
-   typedef __declspec(align(1)) acc_uint32e_t LE32_unaligned;
-#  ifndef LE16
-#    define LE16    LE16_unaligned
-#  endif
-#  ifndef LE32
-#    define LE32    LE32_unaligned
-#  endif
-#  pragma warning(disable: 4244)        // Wx: conversion, possible loss of data
-#endif
-#endif
-
-
 /*************************************************************************
-// Provide namespaces and classes to abtract endianness policies.
+// Provide namespaces and classes to abstract endianness policies.
 //
 // CTP - Compile-Time Polymorphism (templates)
 // RTP - Run-Time Polymorphism (virtual functions)
@@ -599,13 +531,15 @@ int __acc_cdecl_qsort le64_compare_signed(const void *, const void *);
 
 // forward declarations
 namespace N_BELE_CTP {
-class BEPolicy; class LEPolicy;
+struct BEPolicy;
+struct LEPolicy;
 extern const BEPolicy be_policy;
 extern const LEPolicy le_policy;
 }
 namespace N_BELE_RTP {
-class AbstractPolicy;
-class BEPolicy; class LEPolicy;
+struct AbstractPolicy;
+struct BEPolicy;
+struct LEPolicy;
 extern const BEPolicy be_policy;
 extern const LEPolicy le_policy;
 }
@@ -623,23 +557,13 @@ namespace N_BELE_RTP {
 }
 
 namespace N_BELE_CTP {
-
-template <class T>
-inline const N_BELE_RTP::AbstractPolicy* getRTP();
-template <>
-inline const N_BELE_RTP::AbstractPolicy* getRTP<BEPolicy>()
-     { return &N_BELE_RTP::be_policy; }
-template <>
-inline const N_BELE_RTP::AbstractPolicy* getRTP<LEPolicy>()
-     { return &N_BELE_RTP::le_policy; }
-
+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: */

src/bele_policy.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -39,7 +39,7 @@
    // CTP - Compile-Time Polymorphism (templates)
 #  define V     static inline
 #  define S     static int __acc_cdecl_qsort
-#  define C
+#  define C     /*empty*/
 #elif defined(BELE_RTP)
    // RTP - Run-Time Polymorphism (virtual functions)
 #  define V     virtual
@@ -61,17 +61,17 @@ struct AbstractPolicy
     V unsigned get16(const void *p) C = 0;
     V unsigned get24(const void *p) C = 0;
     V unsigned get32(const void *p) C = 0;
-    V acc_uint64l_t get64(const void *p) C = 0;
+    V upx_uint64_t get64(const void *p) C = 0;
 
     V void set16(void *p, unsigned v) C = 0;
     V void set24(void *p, unsigned v) C = 0;
     V void set32(void *p, unsigned v) C = 0;
-    V void set64(void *p, acc_uint64l_t v) C = 0;
+    V void set64(void *p, upx_uint64_t v) C = 0;
 
     V unsigned get16_signed(const void *p) C = 0;
     V unsigned get24_signed(const void *p) C = 0;
     V unsigned get32_signed(const void *p) C = 0;
-    V acc_uint64l_t get64_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;
@@ -113,7 +113,7 @@ struct BEPolicy
         { return get_be24(p); }
     V unsigned get32(const void *p) C
         { return get_be32(p); }
-    V acc_uint64l_t get64(const void *p) C
+    V upx_uint64_t get64(const void *p) C
         { return get_be64(p); }
 
     V void set16(void *p, unsigned v) C
@@ -122,7 +122,7 @@ struct BEPolicy
         { set_be24(p, v); }
     V void set32(void *p, unsigned v) C
         { set_be32(p, v); }
-    V void set64(void *p, acc_uint64l_t v) C
+    V void set64(void *p, upx_uint64_t v) C
         { set_be64(p, v); }
 
     V unsigned get16_signed(const void *p) C
@@ -131,7 +131,7 @@ struct BEPolicy
         { return get_be24_signed(p); }
     V unsigned get32_signed(const void *p) C
         { return get_be32_signed(p); }
-    V acc_uint64l_t get64_signed(const void *p) C
+    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
@@ -190,7 +190,7 @@ struct LEPolicy
         { return get_le24(p); }
     V unsigned get32(const void *p) C
         { return get_le32(p); }
-    V acc_uint64l_t get64(const void *p) C
+    V upx_uint64_t get64(const void *p) C
         { return get_le64(p); }
 
     V void set16(void *p, unsigned v) C
@@ -199,7 +199,7 @@ struct LEPolicy
         { set_le24(p, v); }
     V void set32(void *p, unsigned v) C
         { set_le32(p, v); }
-    V void set64(void *p, acc_uint64l_t v) C
+    V void set64(void *p, upx_uint64_t v) C
         { set_le64(p, v); }
 
     V unsigned get16_signed(const void *p) C
@@ -208,7 +208,7 @@ struct LEPolicy
         { return get_le24_signed(p); }
     V unsigned get32_signed(const void *p) C
         { return get_le32_signed(p); }
-    V acc_uint64l_t get64_signed(const void *p) C
+    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
@@ -259,9 +259,9 @@ struct HostAlignedPolicy
     enum { isBE = HostPolicy::isBE, isLE = HostPolicy::isLE };
 #endif
 
-    typedef acc_uint16e_t U16;
-    typedef acc_uint32e_t U32;
-    typedef acc_uint64l_t U64;
+    typedef upx_uint16_t U16;
+    typedef upx_uint32_t U32;
+    typedef upx_uint64_t U64;
 
     static void compileTimeAssertions() {
         COMPILE_TIME_ASSERT(sizeof(U16) == 2)
@@ -276,8 +276,4 @@ struct HostAlignedPolicy
 #undef S
 #undef C
 
-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/bptr.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_BPTR_H
-#define __UPX_BPTR_H
+#define __UPX_BPTR_H 1
 
 
 /*************************************************************************
@@ -37,70 +37,65 @@
 template <class T>
 class BoundedPtr
 {
-//    typedef BoundedPtr<T> Self;
 public:
-    typedef T* StoredType;
-    typedef T* PointerType;
-    typedef T& ReferenceType;
+    //typedef T* StoredType;
+    //typedef T* PointerType;
+    //typedef T& ReferenceType;
 
     ~BoundedPtr() { }
 
-    explicit BoundedPtr(void* base, unsigned size, T* ptr=0)
-        : ptr_(ptr), base_(base), size_(size) { check(); }
+    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_ == other.size_);
+        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* () { check(); return ptr_; }
-    operator const T* () const { check(); return ptr_; }
+    operator       T* ()       { return ptr_; }
+    operator const T* () const { return ptr_; }
 
     BoundedPtr& operator += (size_t n) {
-        checkStrict(); ptr_ += n; checkStrict(); return *this;
+        checkNULL(); ptr_ += n; checkRange(); return *this;
     }
     BoundedPtr& operator -= (size_t n) {
-        checkStrict(); ptr_ -= n; checkStrict(); return *this;
+        checkNULL(); ptr_ -= n; checkRange(); return *this;
     }
     BoundedPtr& operator ++ (void) {
-        checkStrict(); ptr_ += 1; checkStrict(); return *this;
+        checkNULL(); ptr_ += 1; checkRange(); return *this;
     }
-//    T* operator ++ (int) {
-//        T* p = ptr_; checkStrict(); ptr_ += 1; checkStrict(); return p;
-//    }
-//    BoundedPtr& operator -- (void) {
-//        checkStrict(); ptr_ -= 1; checkStrict(); return *this;
-//    }
-
 
 private:
     void checkNULL() const {
-        if (!ptr_)
+        if __acc_very_unlikely(!ptr_)
             throwCantUnpack("unexpected NULL pointer; take care!");
     }
-    void checkRange(size_t extra=0) const {
+    void checkRange() const {
         size_t off = (const char *) ptr_ - (const char *) base_;
-        if (off > size_ || off + extra > size_)
+        if __acc_very_unlikely(off > size_in_bytes_)
             throwCantUnpack("pointer out of range; take care!");
     }
-    void checkStrict(size_t extra=0) const {
-        checkNULL();
-        checkRange(extra);
-    }
-    void check(size_t extra=0) const {
-        if (ptr_) checkRange(extra);
+    void check() const { // check ptr_ invariant: either NULL or valid checkRange()
+        if (ptr_ != NULL)
+            checkRange();
     }
 
     T* ptr_;
     void* base_;
-    size_t size_;
+    size_t size_in_bytes_;
 
     // disable copy
     BoundedPtr(const BoundedPtr&); // {}
-//    BoundedPtr& operator= (const BoundedPtr&); // { return *this; }
-
     // disable dynamic allocation
     DISABLE_NEW_DELETE
 };
@@ -108,8 +103,4 @@ private:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/c_file.cpp

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

src/c_init.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -30,7 +30,7 @@
 
 FILE *con_term = NULL;
 
-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)
 
 /*************************************************************************
 //
@@ -84,14 +84,14 @@ static int do_init(FILE *f)
     if (!acc_isatty(STDIN_FILENO) || !acc_isatty(STDOUT_FILENO) || !acc_isatty(STDERR_FILENO))
         return con_mode;
 
-#if defined(USE_ANSI)
+#if (USE_ANSI)
     try_init(&console_ansi_mono,f);
     try_init(&console_ansi_color,f);
 #endif
-#if defined(USE_SCREEN)
+#if (USE_SCREEN)
     try_init(&console_screen,f);
 #endif
-#if defined(USE_AALIB)
+#if (USE_AALIB)
     try_init(&console_aalib,f);
 #endif
 
@@ -159,8 +159,4 @@ void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...)
 
 #endif /* USE_CONSOLE */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/c_none.cpp

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

src/c_screen.cpp

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

src/compress.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,14 +22,13 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 #include "compress.h"
 #include "mem.h"
-#include <zlib.h>
 
 
 /*************************************************************************
@@ -41,12 +40,10 @@ unsigned upx_adler32(const void *buf, unsigned len, unsigned adler)
     if (len == 0)
         return adler;
     assert(buf != NULL);
-#if 0
-    return adler32(adler, (const Bytef *) buf, len); // zlib
-#elif defined(WITH_UCL)
-    return ucl_adler32(adler, (const ucl_bytep) buf, len);
+#if 1
+    return upx_ucl_adler32(buf, len, adler);
 #else
-#  error
+    return upx_zlib_adler32(buf, len, adler);
 #endif
 }
 
@@ -57,12 +54,10 @@ unsigned upx_crc32(const void *buf, unsigned len, unsigned crc)
     if (len == 0)
         return crc;
     assert(buf != NULL);
-#if 0
-    return crc32(crc, (const Bytef *) buf, len); // zlib
-#elif defined(WITH_UCL)
-    return ucl_crc32(crc, (const ucl_bytep) buf, len);
+#if 1
+    return upx_ucl_crc32(buf, len, crc);
 #else
-#  error
+    return upx_zlib_crc32(buf, len, crc);
 #endif
 }
 #endif /* UNUSED */
@@ -106,19 +101,19 @@ int upx_compress           ( const upx_bytep src, unsigned  src_len,
     cresult->c_len = 0;
 #endif
 
-    if (0) {
+    if __acc_cte(0) {
     }
-#if defined(WITH_LZMA)
+#if (WITH_LZMA)
     else if (M_IS_LZMA(method))
         r = upx_lzma_compress(src, src_len, dst, dst_len,
                               cb, method, level, cconf, cresult);
 #endif
-#if defined(WITH_NRV)
-    else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
+#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 defined(WITH_UCL)
+#if (WITH_UCL)
     else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
         r = upx_ucl_compress(src, src_len, dst, dst_len,
                              cb, method, level, cconf, cresult);
@@ -152,21 +147,21 @@ int upx_decompress         ( const upx_bytep src, unsigned  src_len,
     if (cresult && cresult->method == 0)
         cresult = NULL;
 
-    if (0) {
+    if __acc_cte(0) {
     }
-#if defined(WITH_LZMA)
+#if (WITH_LZMA)
     else if (M_IS_LZMA(method))
         r = upx_lzma_decompress(src, src_len, dst, dst_len, method, cresult);
 #endif
-#if defined(WITH_NRV)
-    else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
+#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
-#if defined(WITH_UCL)
+#if (WITH_UCL)
     else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
         r = upx_ucl_decompress(src, src_len, dst, dst_len, method, cresult);
 #endif
-#if defined(WITH_ZLIB)
+#if (WITH_ZLIB)
     else if (M_IS_DEFLATE(method))
         r = upx_zlib_decompress(src, src_len, dst, dst_len, method, cresult);
 #endif
@@ -199,17 +194,17 @@ int upx_test_overlap       ( const upx_bytep buf,
     unsigned overlap_overhead = src_off + src_len - *dst_len;
     assert((int)overlap_overhead > 0);
 
-    if (0) {
+    if __acc_cte(0) {
     }
-#if defined(WITH_LZMA)
+#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 defined(WITH_NRV)
-    else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
+#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 defined(WITH_UCL)
+#if (WITH_UCL)
     else if (M_IS_NRV2B(method) || M_IS_NRV2D(method) || M_IS_NRV2E(method))
         r = upx_ucl_test_overlap(buf, tbuf, src_off, src_len, dst_len, method, cresult);
 #endif
@@ -220,8 +215,4 @@ int upx_test_overlap       ( const upx_bytep buf,
     return r;
 }
 
-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/compress.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,19 +22,20 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_COMPRESS_H
-#define __UPX_COMPRESS_H
+#define __UPX_COMPRESS_H 1
 
 
 /*************************************************************************
 //
 **************************************************************************/
 
-#if defined(WITH_LZMA)
+#if (WITH_LZMA)
+int upx_lzma_init(void);
 const char *upx_lzma_version_string(void);
 int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
@@ -55,7 +56,8 @@ int upx_lzma_test_overlap  ( const upx_bytep buf,
 #endif
 
 
-#if defined(WITH_NRV)
+#if (WITH_NRV)
+int upx_nrv_init(void);
 const char *upx_nrv_version_string(void);
 int upx_nrv_compress       ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
@@ -76,7 +78,8 @@ int upx_nrv_test_overlap   ( const upx_bytep buf,
 #endif
 
 
-#if defined(WITH_UCL)
+#if (WITH_UCL)
+int upx_ucl_init(void);
 const char *upx_ucl_version_string(void);
 int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
                                    upx_bytep dst, unsigned* dst_len,
@@ -94,9 +97,13 @@ int upx_ucl_test_overlap   ( const upx_bytep buf,
                                    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 defined(WITH_ZLIB)
+
+#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,
@@ -114,13 +121,11 @@ int upx_zlib_test_overlap  ( const upx_bytep buf,
                                    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 */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/compress_lzma.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -30,6 +30,16 @@
 #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()
 {
@@ -47,12 +57,6 @@ void lzma_compress_config_t::reset()
 }
 
 
-#if !defined(WITH_LZMA)
-extern int compress_lzma_dummy;
-int compress_lzma_dummy = 0;
-#else
-
-
 // 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.
@@ -91,10 +95,124 @@ int compress_lzma_dummy = 0;
 
 
 /*************************************************************************
-// cruft because of pseudo-COM layer
+// compress defaults
 **************************************************************************/
 
-#undef USE_LZMA_PROPERTIES
+static int prepare(lzma_compress_result_t *res,
+                   unsigned src_len, int method, int level,
+                   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
@@ -110,6 +228,7 @@ 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) {
@@ -122,7 +241,7 @@ STDMETHODIMP InStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 {
     size_t remain = b_size - b_pos;
     if (size > remain) size = (UInt32) remain;
-    memcpy(data, b_buf + b_pos, size);
+    memmove(data, b_buf + b_pos, size);
     b_pos += size;
     if (processedSize != NULL) *processedSize = size;
     return S_OK;
@@ -130,6 +249,7 @@ STDMETHODIMP InStream::Read(void *data, UInt32 size, UInt32 *processedSize)
 
 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) {
@@ -147,7 +267,7 @@ STDMETHODIMP OutStream::Write(const void *data, UInt32 size, UInt32 *processedSi
 {
     size_t remain = b_size - b_pos;
     if (size > remain) size = (UInt32) remain, overflow = true;
-    memcpy(b_buf + b_pos, data, size);
+    memmove(b_buf + b_pos, data, size);
     b_pos += size;
     if (processedSize != NULL) *processedSize = size;
     return overflow ? E_FAIL : S_OK;
@@ -155,6 +275,7 @@ STDMETHODIMP OutStream::Write(const void *data, UInt32 size, UInt32 *processedSi
 
 struct ProgressInfo : public ICompressProgressInfo, public CMyUnknownImp
 {
+    virtual ~ProgressInfo() { }
     MY_UNKNOWN_IMP
     STDMETHOD(SetRatioInfo)(const UInt64 *inSize, const UInt64 *outSize);
     upx_callback_p cb;
@@ -169,11 +290,6 @@ STDMETHODIMP ProgressInfo::SetRatioInfo(const UInt64 *inSize, const UInt64 *outS
 
 } // namespace
 
-
-#if (ACC_CC_INTELC) && defined(__linux__)
-#  pragma warning(disable: 424)         // #424: extra ";" ignored
-#endif
-
 #include "C/Common/Alloc.cpp"
 #include "C/Common/CRC.cpp"
 //#include "C/7zip/Common/InBuffer.cpp"
@@ -222,134 +338,25 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
         NCoderPropID::kMatchFinder          // 7  mf
     };
     PROPVARIANT pr[8];
+    const unsigned nprops = 8;
+    static wchar_t matchfinder[] = L"BT4";
+    assert(NCompress::NLZMA::FindMatchFinder(matchfinder) >= 0);
+    pr[7].vt = VT_BSTR; pr[7].bstrVal = 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;
-    pr[7].vt = VT_BSTR;
-
-    // setup defaults
-    pr[0].uintVal = 2;                  // 0 .. 4
-    pr[1].uintVal = 0;                  // 0 .. 4
-    pr[2].uintVal = 3;                  // 0 .. 8
-    pr[3].uintVal = 4 * 1024 * 1024;    // 1 .. 2**30
-    pr[4].uintVal = 2;
-    pr[5].uintVal = 64;                 // 5 .. 273
-    pr[6].uintVal = 0;
-#ifdef COMPRESS_MF_BT4
-    static wchar_t matchfinder[] = L"BT4";
-#endif
-    assert(NCompress::NLZMA::FindMatchFinder(matchfinder) >= 0);
-    pr[7].bstrVal = matchfinder;
-#if 1
-    pr[0].uintVal = lzma_compress_config_t::pos_bits_t::default_value_c;
-    pr[1].uintVal = lzma_compress_config_t::lit_pos_bits_t::default_value_c;
-    pr[2].uintVal = lzma_compress_config_t::lit_context_bits_t::default_value_c;
-    pr[3].uintVal = lzma_compress_config_t::dict_size_t::default_value_c;
-    pr[5].uintVal = lzma_compress_config_t::num_fast_bytes_t::default_value_c;
-#endif
-    // method overrides
-    if (method >= 0x100) {
-        pr[0].uintVal = (method >> 16) & 15;
-        pr[1].uintVal = (method >> 12) & 15;
-        pr[2].uintVal = (method >>  8) & 15;
-    }
-#if 0
-    // DEBUG - set sizes so that we use a maxmimum amount of stack.
-    //  These settings cause res->num_probs == 3147574, i.e. we will
-    //  need about 6 MB of stack during runtime decompression.
-    pr[1].uintVal = 4;
-    pr[2].uintVal = 8;
-#endif
-
-    // FIXME: tune these settings according to level
-    switch (level)
-    {
-    case 1:
-        pr[3].uintVal = 256 * 1024;
-        pr[4].uintVal = 0;
-        pr[5].uintVal = 8;
-        break;
-    case 2:
-        pr[3].uintVal = 256 * 1024;
-        pr[4].uintVal = 0;
-        break;
-    case 3:
-        break;
-    case 4:
-        break;
-    case 5:
-        break;
-    case 6:
-        break;
-    case 7:
-        break;
-    case 8:
-        break;
-    case 9:
-        pr[3].uintVal = 8 * 1024 * 1024;
-        break;
-    case 10:
-        pr[3].uintVal = src_len;
-        break;
-    default:
+    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;
 
-    // cconf overrides
-    if (lcconf)
-    {
-        oassign(pr[0].uintVal, lcconf->pos_bits);
-        oassign(pr[1].uintVal, lcconf->lit_pos_bits);
-        oassign(pr[2].uintVal, lcconf->lit_context_bits);
-        oassign(pr[3].uintVal, lcconf->dict_size);
-        oassign(pr[5].uintVal, lcconf->num_fast_bytes);
-    }
-
-    // limit dictionary size
-    if (pr[3].uintVal > src_len)
-        pr[3].uintVal = src_len;
-
-    // limit num_probs
-    if (lcconf && lcconf->max_num_probs)
-    {
-        for (;;)
-        {
-            unsigned n = 1846 + (768 << (pr[2].uintVal + pr[1].uintVal));
-            if (n <= lcconf->max_num_probs)
-                break;
-            if (pr[1].uintVal > pr[2].uintVal)
-            {
-                if (pr[1].uintVal == 0)
-                    goto error;
-                pr[1].uintVal -= 1;
-            }
-            else
-            {
-                if (pr[2].uintVal == 0)
-                    goto error;
-                pr[2].uintVal -= 1;
-            }
-        }
-    }
-
-    res->pos_bits = pr[0].uintVal;
-    res->lit_pos_bits = pr[1].uintVal;
-    res->lit_context_bits = pr[2].uintVal;
-    res->dict_size = pr[3].uintVal;
-    res->fast_mode = pr[4].uintVal;
-    res->num_fast_bytes = pr[5].uintVal;
-    res->match_finder_cycles = pr[6].uintVal;
-    //res->num_probs = LzmaGetNumProbs(&s.Properties));
-    //res->num_probs = (LZMA_BASE_SIZE + (LZMA_LIT_SIZE << ((Properties)->lc + (Properties)->lp)))
-    res->num_probs = 1846 + (768 << (res->lit_context_bits + res->lit_pos_bits));
-    //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);
-
-#ifndef _NO_EXCEPTIONS
     try {
-#else
-#  error
-#endif
 
-    if (enc.SetCoderProperties(propIDs, pr, 8) != S_OK)
+    if (enc.SetCoderProperties(propIDs, pr, nprops) != S_OK)
         goto error;
     if (enc.WriteCoderProperties(&os) != S_OK)
         goto error;
@@ -359,21 +366,17 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
         goto error;
     }
     assert(os.b_pos == 5);
-#if defined(USE_LZMA_PROPERTIES)
-    os.b_pos = 1;
-#else
     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((t << 3) | res->pos_bits);
-    os.WriteByte((res->lit_pos_bits << 4) | (res->lit_context_bits));
-#endif
+    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);
 
-#ifndef _NO_EXCEPTIONS
-    } catch (...) { rh = E_OUTOFMEMORY; }
-#endif
+    } catch (...) {
+        rh = E_OUTOFMEMORY;
+    }
 
     assert(is.b_pos <=  src_len);
     assert(os.b_pos <= *dst_len);
@@ -392,7 +395,7 @@ int upx_lzma_compress      ( const upx_bytep src, unsigned  src_len,
     }
 
 error:
-    *dst_len = os.b_pos;
+    *dst_len = (unsigned) os.b_pos;
     //printf("\nlzma_compress: %d: %u %u %u %u %u, %u - > %u\n", r, res->pos_bits, res->lit_pos_bits, res->lit_context_bits, res->dict_size, res->num_probs, src_len, *dst_len);
     //printf("%u %u %u\n", is.__m_RefCount, os.__m_RefCount, progress.__m_RefCount);
     return r;
@@ -426,14 +429,6 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
     int r = UPX_E_ERROR;
     int rh;
 
-#if defined(USE_LZMA_PROPERTIES)
-    if (src_len < 2)
-        goto error;
-    rh = LzmaDecodeProperties(&s.Properties, src, src_len);
-    if (rh != 0)
-        goto error;
-    src += 1; src_len -= 1;
-#else
     if (src_len < 3)
         goto error;
     s.Properties.pb = src[0] & 7;
@@ -445,7 +440,6 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
     // extra
     if ((src[0] >> 3) != s.Properties.lc + s.Properties.lp) goto error;
     src += 2; src_len -= 2;
-#endif
 
     if (cresult)
     {
@@ -477,8 +471,6 @@ int upx_lzma_decompress    ( const upx_bytep src, unsigned  src_len,
 error:
     *dst_len = dst_out;
     free(s.Probs);
-
-    UNUSED(cresult);
     return r;
 }
 
@@ -506,7 +498,7 @@ int upx_lzma_test_overlap  ( const upx_bytep buf,
         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.
+    //   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;
@@ -517,16 +509,20 @@ int upx_lzma_test_overlap  ( const upx_bytep buf,
 // misc
 **************************************************************************/
 
+int upx_lzma_init(void)
+{
+    return 0;
+}
+
 const char *upx_lzma_version_string(void)
 {
-    // FIXME
-//    return NULL;
+#if (WITH_LZMA == 0x443)
     return "4.43";
+#else
+#   error "unknown WITH_LZMA version"
+    return NULL;
+#endif
 }
 
 
-#endif /* WITH_LZMA */
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/compress_ucl.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,29 +22,29 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
 #include "compress.h"
-#if !defined(WITH_UCL)
+#if !(WITH_UCL)
 extern int compress_ucl_dummy;
 int compress_ucl_dummy = 0;
 #else
 
-#if 1 && !defined(UCL_USE_ASM) && (ACC_ARCH_I386)
-#  if (ACC_CC_GNUC || ACC_CC_INTELC || ACC_CC_MSC || ACC_CC_WATCOMC)
-#    define UCL_USE_ASM
+#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 defined(UCL_NO_ASM)
+#if (UCL_NO_ASM)
 #  undef UCL_USE_ASM
 #endif
-#if defined(ACC_CFG_NO_UNALIGNED)
+#if (ACC_CFG_NO_UNALIGNED)
 #  undef UCL_USE_ASM
 #endif
-#if 1 && defined(UCL_USE_ASM)
+#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
@@ -85,7 +85,7 @@ static int convert_errno_from_ucl(int r)
 
 
 extern "C" {
-static void wrap_nprogress_ucl(ucl_uint a, ucl_uint b, int state, ucl_voidp user)
+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;
@@ -120,7 +120,7 @@ int upx_ucl_compress       ( const upx_bytep src, unsigned  src_len,
 
     ucl_compress_config_t cconf; cconf.reset();
     if (cconf_parm)
-        cconf = cconf_parm->conf_ucl; // struct copy
+        memcpy(&cconf, &cconf_parm->conf_ucl, sizeof(cconf)); // cconf = cconf_parm->conf_ucl; // struct copy
 
     ucl_uint *res = cresult->result_ucl.result;
     // assume no info available - fill in worst case results
@@ -281,14 +281,40 @@ int upx_ucl_test_overlap   ( const upx_bytep buf,
 // 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 */
-/*
-vi:ts=4:et:nowrap
-*/
 
+/* vim:set ts=4 sw=4 et: */

src/compress_zlib.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -41,7 +41,7 @@ void zlib_compress_config_t::reset()
 }
 
 
-#if !defined(WITH_ZLIB)
+#if !(WITH_ZLIB)
 extern int compress_zlib_dummy;
 int compress_zlib_dummy = 0;
 #else
@@ -99,7 +99,7 @@ int upx_zlib_compress      ( const upx_bytep src, unsigned  src_len,
     z_stream s;
     s.zalloc = (alloc_func) 0;
     s.zfree = (free_func) 0;
-    s.next_in = const_cast<upx_bytep>(src); // UNCONST
+    s.next_in = ACC_UNCONST_CAST(upx_bytep, src);
     s.avail_in = src_len;
     s.next_out = dst;
     s.avail_out = *dst_len;
@@ -153,7 +153,7 @@ int upx_zlib_decompress    ( const upx_bytep src, unsigned  src_len,
     z_stream s;
     s.zalloc = (alloc_func) 0;
     s.zfree = (free_func) 0;
-    s.next_in = const_cast<upx_bytep>(src); // UNCONST
+    s.next_in = ACC_UNCONST_CAST(upx_bytep, src);
     s.avail_in = src_len;
     s.next_out = dst;
     s.avail_out = *dst_len;
@@ -211,7 +211,7 @@ int upx_zlib_test_overlap  ( const upx_bytep buf,
         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.
+    //   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;
@@ -222,14 +222,35 @@ int upx_zlib_test_overlap  ( const upx_bytep buf,
 // 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 */
-/*
-vi:ts=4:et:nowrap
-*/
 
+/* vim:set ts=4 sw=4 et: */

src/conf.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,26 +22,48 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_CONF_H
-#define __UPX_CONF_H
+#define __UPX_CONF_H 1
 
 #include "version.h"
 
+#if !defined(_FILE_OFFSET_BITS)
+#  define _FILE_OFFSET_BITS 64
+#endif
+
 
 /*************************************************************************
 // ACC
 **************************************************************************/
 
-#include "miniacc.h"
-#if ((ACC_OS_WIN32 || ACC_OS_WIN64) && ACC_CC_MWERKS) && defined(__MSL__)
-#  undef HAVE_UTIME_H /* this pulls in <windows.h> */
+#ifndef ACC_CFG_USE_NEW_STYLE_CASTS
+#define ACC_CFG_USE_NEW_STYLE_CASTS 1
 #endif
+#include "miniacc.h"
+#if !(ACC_CC_CLANG || ACC_CC_GNUC || ACC_CC_MSC)
+   // other compilers may work, but we're NOT interested into supporting them
+#  error "only clang and gcc are officially supported"
+#endif
+// UPX sanity checks for a sane compiler
+#if !defined(UINT_MAX) || (UINT_MAX != 0xffffffffL)
+#  error "UINT_MAX"
+#endif
+ACC_COMPILE_TIME_ASSERT_HEADER(sizeof(int) == 4)
+ACC_COMPILE_TIME_ASSERT_HEADER((1u << 31) << 1 == 0)
+ACC_COMPILE_TIME_ASSERT_HEADER(((int)(1u << 31)) >> 31 == -1) // arithmetic right shift
+ACC_COMPILE_TIME_ASSERT_HEADER(CHAR_MAX == 255) // -funsigned-char
+ACC_COMPILE_TIME_ASSERT_HEADER((char)(-1) > 0) // -funsigned-char
+
+#if (ACC_CC_MSC)
+#  pragma warning(error: 4319)
+#endif
+
 // FIXME - quick hack for arm-wince-gcc-3.4 (Debian pocketpc-*.deb packages)
-#if 1 && (ACC_ARCH_ARM) && defined(__pe__) && !defined(_WIN32)
+#if 1 && (ACC_ARCH_ARM) && defined(__pe__) && !defined(__CEGCC__) && !defined(_WIN32)
 #  undef HAVE_CHMOD
 #  undef HAVE_CHOWN
 #  undef HAVE_LSTAT
@@ -49,83 +71,31 @@
 #endif
 
 
-// pragmas
-#if (ACC_CC_BORLANDC)
-#  if (__BORLANDC__ < 0x0500)
-#    error "need Borland C++ 5.0 or newer"
-#  endif
-#  pragma warn -aus     // 8004: 'x' is assigned a value that is never used
-#  pragma warn -inl     // 8026+8027: Function not expanded inline
-   // Borland compilers typically produce a number of bogus warnings, and
-   // the actual diagnostics vary from version to version...
-#  if (__BORLANDC__ < 0x0530)
-#    pragma warn -csu   // 8012: Comparing signed and unsigned values
-#  endif
-#  if (__BORLANDC__ >= 0x0530 && __BORLANDC__ < 0x0560)
-#    pragma warn -osh   // 8055: Possible overflow in shift operation
-#  endif
-#  if (__BORLANDC__ >= 0x0560)
-#    pragma warn -use   // 8080: 'x' is declared but never used
-#  endif
-#elif (ACC_CC_DMC)
-#  if (__DMC__ < 0x829)
-#    error "need Digital Mars C++ 8.29 or newer"
-#  endif
-#elif (ACC_CC_INTELC)
-#  if (__INTEL_COMPILER < 450)
-#    error "need Intel C++ 4.5 or newer"
-#  endif
-#  if (ACC_OS_WIN32 || ACC_OS_WIN64)
-#  elif defined(__linux__)
-#    pragma warning(error: 424)         // #424: extra ";" ignored
-#    pragma warning(disable: 193)       // #193: zero used for undefined preprocessing identifier
-#    pragma warning(disable: 810)       // #810: conversion from "A" to "B" may lose significant bits
-#    pragma warning(disable: 981)       // #981: operands are evaluated in unspecified order
-#    pragma warning(disable: 1418)      // #1418: external definition with no prior declaration
-#  else
-#    error "untested platform"
-#  endif
-#elif (ACC_CC_MSC)
-#  if (_MSC_VER < 1100)
-#    error "need Visual C++ 5.0 or newer"
-#  endif
-#  pragma warning(error: 4096)          // W2: '__cdecl' must be used with '...'
-#  pragma warning(disable: 4097)        // W3: typedef-name 'A' used as synonym for class-name 'B'
-#  pragma warning(disable: 4511)        // W3: 'class': copy constructor could not be generated
-#  pragma warning(disable: 4512)        // W4: 'class': assignment operator could not be generated
-#  pragma warning(disable: 4514)        // W4: 'function': unreferenced inline function has been removed
-#  pragma warning(disable: 4710)        // W4: 'function': function not inlined
-#  if (_MSC_VER >= 1300)
-#    pragma warning(disable: 4625)      // W4: 'class' : copy constructor could not be generated because a base class copy constructor is inaccessible
-#    pragma warning(disable: 4626)      // W4: 'class' : assignment operator could not be generated because a base class assignment operator is inaccessible
-#    pragma warning(disable: 4711)      // W4: 'function' selected for automatic inline expansion
-#    pragma warning(disable: 4820)      // W4: 'struct' : 'x' bytes padding added after member 'member'
-#  endif
-#  if (_MSC_VER >= 1400)
-#    pragma warning(disable: 4996)      // W1: 'function': was declared deprecated
-#  endif
-#elif (ACC_CC_SUNPROC)
-//#  pragma error_messages(off,"badargtype2w")    // FIXME
-#elif (ACC_CC_WATCOMC)
-#  if (__WATCOMC__ < 1100)
-#    error "need Watcom C++ 11.0c or newer"
-#  endif
-#  if defined(__cplusplus)
-#    pragma warning 656 9               // w5: define this function inside its class definition (may improve code quality)
-#  endif
-#endif
-
-
 #define ACC_WANT_ACC_INCD_H 1
 #define ACC_WANT_ACC_INCE_H 1
 #define ACC_WANT_ACC_LIB_H 1
 #define ACC_WANT_ACC_CXX_H 1
 #include "miniacc.h"
-#if (ACC_OS_CYGWIN || ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_EMX || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
-#  if defined(INVALID_HANDLE_VALUE) || defined(MAKEWORD) || defined(RT_CURSOR)
-#    error "something pulled in <windows.h>"
-#  endif
-#endif
+
+/* intergral types */
+typedef acc_int8_t      upx_int8_t;
+typedef acc_uint8_t     upx_uint8_t;
+typedef acc_int16_t     upx_int16_t;
+typedef acc_uint16_t    upx_uint16_t;
+typedef acc_int32_t     upx_int32_t;
+typedef acc_uint32_t    upx_uint32_t;
+typedef acc_int64_t     upx_int64_t;
+typedef acc_uint64_t    upx_uint64_t;
+typedef acc_uintptr_t   upx_uintptr_t;
+#define UPX_INT16_C     ACC_INT16_C
+#define UPX_UINT16_C    ACC_UINT16_C
+#define UPX_INT32_C     ACC_INT32_C
+#define UPX_UINT32_C    ACC_UINT32_C
+#define UPX_INT64_C     ACC_INT64_C
+#define UPX_UINT64_C    ACC_UINT64_C
+
+typedef unsigned char   upx_byte;
+#define upx_bytep       upx_byte *
 
 
 /*************************************************************************
@@ -137,38 +107,33 @@
 #endif
 
 // just in case
+#undef _
+#undef __
+#undef ___
 #undef NDEBUG
 #undef dos
 #undef linux
 #undef small
 #undef tos
-#if defined(ACC_CC_DMC)
-#  undef tell
-#endif
-#if !defined(ACC_CC_PGI)
-#  undef unix
-#endif
 #if defined(__DJGPP__)
 #  undef sopen
 #  undef __unix__
 #  undef __unix
 #endif
 
-#if !defined(WITH_UCL)
-#  define WITH_UCL 1
-#endif
-#if 0 && !defined(WITH_LZMA)
-#  define WITH_LZMA 1
+#define WITH_UCL 1
+#define WITH_ZLIB 1
+#if !defined(WITH_LZMA) || (WITH_LZMA+0 == 0)
+#  error "WITH_LZMA is missing"
+#elif (WITH_LZMA != 0x443)
+#  error "invalid WITH_LZMA version"
 #endif
 #if defined(UPX_OFFICIAL_BUILD)
-#  if !defined(WITH_LZMA) || !defined(WITH_NRV) || !defined(WITH_UCL)
+#  if !(WITH_LZMA && WITH_NRV && WITH_UCL && WITH_ZLIB)
 #    error
 #  endif
 #endif
-#if defined(WITH_NRV)
-#  include <nrv/nrvconf.h>
-#endif
-#if defined(WITH_UCL)
+#if (WITH_UCL)
 #  define ucl_compress_config_t REAL_ucl_compress_config_t
 #  include <ucl/uclconf.h>
 #  include <ucl/ucl.h>
@@ -178,17 +143,6 @@
 #  undef ucl_compress_config_t
 #  undef ucl_compress_config_p
 #endif
-#if !defined(__UPX_CHECKER)
-#  if defined(__UCL_CHECKER) || defined(__NRV_CHECKER)
-#    define __UPX_CHECKER
-#  endif
-#endif
-#if !defined(UINT_MAX) || (UINT_MAX < 0xffffffffL)
-#  error "UINT_MAX"
-#endif
-
-#define upx_byte                    unsigned char
-#define upx_bytep                   upx_byte *
 
 
 /*************************************************************************
@@ -196,29 +150,31 @@
 **************************************************************************/
 
 // malloc debuggers
-#if defined(WITH_VALGRIND)
+#if (WITH_VALGRIND)
 #  include <valgrind/memcheck.h>
 #endif
-
-#if !defined(VALGRIND_MAKE_WRITABLE)
-#  define VALGRIND_MAKE_WRITABLE(addr,len)      0
+#if !defined(VALGRIND_MAKE_MEM_DEFINED)
+#  define VALGRIND_MAKE_MEM_DEFINED(addr,len)   0
 #endif
-#if !defined(VALGRIND_MAKE_READABLE)
-#  if 0
-#    define VALGRIND_MAKE_READABLE(addr,len)    (memset(addr,0,len), 0)
-#  else
-#    define VALGRIND_MAKE_READABLE(addr,len)    0
-#  endif
+#if !defined(VALGRIND_MAKE_MEM_NOACCESS)
+#  define VALGRIND_MAKE_MEM_NOACCESS(addr,len)  0
 #endif
-#if !defined(VALGRIND_DISCARD)
-#  define VALGRIND_DISCARD(handle)              ((void)(&handle))
+#if !defined(VALGRIND_MAKE_MEM_UNDEFINED)
+#  define VALGRIND_MAKE_MEM_UNDEFINED(addr,len) 0
 #endif
 
 
-// unconditionally turn on assertions
+// IMPORTANT: unconditionally enable assertions
 #undef NDEBUG
 #include <assert.h>
 
+// protect against integer overflows and malicious header fields
+// see C 11 standard, Annex K
+typedef size_t upx_rsize_t;
+#define UPX_RSIZE_MAX       UPX_RSIZE_MAX_MEM
+#define UPX_RSIZE_MAX_MEM   (768 * 1024 * 1024)   // DO NOT CHANGE
+#define UPX_RSIZE_MAX_STR   (1024 * 1024)
+
 
 /*************************************************************************
 // portab
@@ -235,11 +191,11 @@
 #endif
 
 
-#if !defined(HAVE_STRCASECMP) && defined(HAVE_STRICMP)
-#  define strcasecmp      stricmp
+#if !(HAVE_STRCASECMP) && (HAVE_STRICMP)
+#  define strcasecmp        stricmp
 #endif
-#if !defined(HAVE_STRNCASECMP) && defined(HAVE_STRNICMP)
-#  define strncasecmp     strnicmp
+#if !(HAVE_STRNCASECMP) && (HAVE_STRNICMP)
+#  define strncasecmp       strnicmp
 #endif
 
 
@@ -292,6 +248,11 @@
 #undef PAGE_MASK
 #undef PAGE_SIZE
 
+#if !defined(O_BINARY) || (O_BINARY+0 == 0)
+#  if (ACC_OS_CYGWIN || ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_EMX || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
+#    error "missing O_BINARY"
+#  endif
+#endif
 #if !defined(O_BINARY)
 #  define O_BINARY  0
 #endif
@@ -301,30 +262,26 @@
 #endif
 
 
-#undef __attribute_packed
-#if (ACC_CC_GNUC || ACC_CC_INTELC || ACC_CC_PATHSCALE)
-#  if (ACC_ARCH_I386) && (ACC_CC_INTELC && (__INTEL_COMPILER < 800))
-#  elif (0 && (ACC_ARCH_AMD64 || ACC_ARCH_I386))
-#  else
-#    define __attribute_packed      __attribute__((__packed__,__aligned__(1)))
-#  endif
-#endif
-#if !defined(__attribute_packed)
-#  define __attribute_packed
-#endif
-
-
 /*************************************************************************
 //
 **************************************************************************/
 
-#define UNUSED(var)              ACC_UNUSED(var)
-#define COMPILE_TIME_ASSERT(e)   ACC_COMPILE_TIME_ASSERT(e)
+#if (ACC_CC_MSC)
+#define __packed_struct(s)      struct s {
+#define __packed_struct_end()   };
+#else
+#define __packed_struct(s)      __acc_struct_packed(s)
+#define __packed_struct_end()   __acc_struct_packed_end()
+#endif
+
+#define UNUSED(var)             ACC_UNUSED(var)
+#define COMPILE_TIME_ASSERT(e)  ACC_COMPILE_TIME_ASSERT(e)
 
 #define __COMPILE_TIME_ASSERT_ALIGNOF_SIZEOF(a,b) { \
      typedef a acc_tmp_a_t; typedef b acc_tmp_b_t; \
-     struct acc_tmp_t { acc_tmp_b_t x; acc_tmp_a_t y; acc_tmp_b_t z; } __attribute_packed; \
+     __packed_struct(acc_tmp_t) acc_tmp_b_t x; acc_tmp_a_t y; acc_tmp_b_t z; __packed_struct_end() \
      COMPILE_TIME_ASSERT(sizeof(struct acc_tmp_t) == 2*sizeof(b)+sizeof(a)) \
+     COMPILE_TIME_ASSERT(sizeof(((acc_tmp_t*)0)->x)+sizeof(((acc_tmp_t*)0)->y)+sizeof(((acc_tmp_t*)0)->z) == 2*sizeof(b)+sizeof(a)) \
    }
 #if defined(__acc_alignof)
 #  define __COMPILE_TIME_ASSERT_ALIGNOF(a,b) \
@@ -339,52 +296,35 @@
 #define TABLESIZE(table)    ((sizeof(table)/sizeof((table)[0])))
 
 
-#if 0
-#define ALIGN_DOWN(a,b)     (((a) / (b)) * (b))
-#define ALIGN_UP(a,b)       ALIGN_DOWN((a) + ((b) - 1), b)
-#define ALIGN_GAP(a,b)      (ALIGN_UP(a,b) - (a))
-#elif 1
 template <class T>
 inline T ALIGN_DOWN(const T& a, const T& b) { T r; r = (a / b) * b; return r; }
 template <class T>
 inline T ALIGN_UP  (const T& a, const T& b) { T r; r = ((a + b - 1) / b) * b; return r; }
 template <class T>
 inline T ALIGN_GAP (const T& a, const T& b) { T r; r = ALIGN_UP(a, b) - a; return r; }
-#else
-inline unsigned ALIGN_DOWN(unsigned a, unsigned b) { return (a / b) * b; }
-inline unsigned ALIGN_UP  (unsigned a, unsigned b) { return ((a + b - 1) / b) * b; }
-inline unsigned ALIGN_GAP (unsigned a, unsigned b) { return ALIGN_UP(a, b) - a; }
-#endif
 
-#if 0
-#define UPX_MAX(a,b)        ((a) >= (b) ? (a) : (b))
-#define UPX_MIN(a,b)        ((a) <= (b) ? (a) : (b))
-#elif 1
 template <class T>
 inline const T& UPX_MAX(const T& a, const T& b) { if (a < b) return b; return a; }
 template <class T>
 inline const T& UPX_MIN(const T& a, const T& b) { if (a < b) return a; return b; }
-#else
-inline unsigned UPX_MAX(unsigned a, unsigned b) { return a < b ? b : a; }
-inline unsigned UPX_MIN(unsigned a, unsigned b) { return a < b ? a : b; }
-#endif
 
 
 // An Array allocates memory on the heap, but automatically
 // gets destructed when leaving scope or on exceptions.
 #define Array(type, var, size) \
-    assert((int)(size) > 0); \
-    MemBuffer var ## _membuf((size)*(sizeof(type))); \
-    type * const var = ((type *) var ## _membuf.getVoidPtr())
+    MemBuffer var ## _membuf(mem_size(sizeof(type), size)); \
+    type * const var = ACC_STATIC_CAST(type *, var ## _membuf.getVoidPtr())
 
 #define ByteArray(var, size)    Array(unsigned char, var, size)
 
-struct nocopy
+class noncopyable
 {
-    inline nocopy() {}
+protected:
+    inline noncopyable() {}
+    inline ~noncopyable() {}
 private:
-    nocopy(const nocopy &); // undefined
-    nocopy& operator=(const nocopy &); // undefined
+    noncopyable(const noncopyable &); // undefined
+    const noncopyable& operator=(const noncopyable &); // undefined
 };
 
 
@@ -456,8 +396,24 @@ private:
 #define UPX_F_VMLINUX_AMD64     27
 #define UPX_F_VMLINUX_ARMEL     28
 #define UPX_F_MACH_i386         29
+#define UPX_F_LINUX_ELF32_MIPSEL 30
+#define UPX_F_VMLINUZ_ARMEL     31
+#define UPX_F_MACH_ARMEL        32
 
-#define UPX_F_PLAIN_TEXT        127
+#define UPX_F_DYLIB_i386        33
+#define UPX_F_MACH_AMD64        34
+#define UPX_F_DYLIB_AMD64       35
+
+#define UPX_F_WIN64_PEP         36
+
+#define UPX_F_MACH_ARM64EL      37
+
+#define UPX_F_MACH_PPC64LE      38
+#define UPX_F_LINUX_ELFPPC64LE  39
+#define UPX_F_VMLINUX_PPC64LE   40
+#define UPX_F_DYLIB_PPC64LE     41
+
+#define UPX_F_PLAIN_TEXT        127             // FIXME: what is this ??
 
 #define UPX_F_ATARI_TOS         129
 #define UPX_F_SOLARIS_SPARC     130
@@ -466,6 +422,9 @@ private:
 #define UPX_F_LINUX_ELF32_ARMEB 133
 #define UPX_F_MACH_FAT          134
 #define UPX_F_VMLINUX_ARMEB     135
+#define UPX_F_VMLINUX_PPC32     136
+#define UPX_F_LINUX_ELF32_MIPSEB 137
+#define UPX_F_DYLIB_PPC32       138
 
 
 // compression methods
@@ -510,13 +469,7 @@ private:
 **************************************************************************/
 
 struct upx_callback_t;
-#define upx_callback_p upx_callback_t *
-#if 0
-typedef void* (__acc_cdecl *upx_alloc_func_t)
-    (upx_callback_p self, unsigned items, unsigned size);
-typedef void      (__acc_cdecl *upx_free_func_t)
-    (upx_callback_p self, void* ptr);
-#endif
+typedef upx_callback_t *upx_callback_p;
 typedef void (__acc_cdecl *upx_progress_func_t)
     (upx_callback_p, unsigned, unsigned);
 
@@ -536,14 +489,16 @@ struct upx_callback_t
 template <class T, T default_value, T min_value, T max_value>
 struct OptVar
 {
-    typedef T Type;
+    typedef T value_type;
     static const T default_value_c = default_value;
     static const T min_value_c = min_value;
     static const T max_value_c = max_value;
 
-    void assertValue() {
-        // FIXME: this generates annoying warnings "unsigned >= 0 is always true"
-        //assert((v >= min_value) && (v <= max_value));
+    void assertValue() const {
+        // info: this generates annoying warnings "unsigned >= 0 is always true"
+        //assert(v >= min_value_c);
+        assert(v == min_value_c || v >= min_value_c + 1);
+        assert(v <= max_value_c);
     }
 
     OptVar() : v(default_value), is_set(0) { }
@@ -552,15 +507,6 @@ struct OptVar
         assertValue();
         return *this;
     }
-#if 0
-#error
-    // there is too much implicit magic in this copy operator;
-    // better introduce an explicit "oassign" function.
-    OptVar& operator= (const OptVar& other) {
-        if (other.is_set) { v = other.v; is_set += 1; }
-        assertValue(); return *this;
-    }
-#endif
 
     void reset() { v = default_value; is_set = 0; }
     operator T () const { return v; }
@@ -571,24 +517,20 @@ struct OptVar
 
 
 // optional assignments
-template <class T> inline void oassign(T& self, const T& other) {
+template <class T, T a, T b, T c>
+inline void oassign(OptVar<T,a,b,c> &self, const OptVar<T,a,b,c> &other) {
     if (other.is_set) { self.v = other.v; self.is_set += 1; }
 }
-#if 0
-template <class V, class T> inline void oassign(V& v, const T& other) {
+template <class T, T a, T b, T c>
+inline void oassign(unsigned &v, const OptVar<T,a,b,c> &other) {
     if (other.is_set) { v = other.v; }
 }
-#else
-template <class T> inline void oassign(unsigned& v, const T& other) {
-    if (other.is_set) { v = other.v; }
-}
-#endif
 
 
 struct lzma_compress_config_t
 {
     typedef OptVar<unsigned,  2u, 0u,   4u> pos_bits_t;             // pb
-    typedef OptVar<unsigned,  0u, 0u,   4u> lit_pos_bits_t;         // lb
+    typedef OptVar<unsigned,  0u, 0u,   4u> lit_pos_bits_t;         // lp
     typedef OptVar<unsigned,  3u, 0u,   8u> lit_context_bits_t;     // lc
     typedef OptVar<unsigned, (1u<<22), 1u, (1u<<30) > dict_size_t;
     typedef OptVar<unsigned, 64u, 5u, 273u> num_fast_bytes_t;
@@ -694,10 +636,7 @@ struct upx_compress_result_t
 // globals
 **************************************************************************/
 
-#include "snprintf.h"
-
-#if defined(__cplusplus)
-
+#include "snprintf.h"   // must get included first!
 #include "stdcxx.h"
 #include "options.h"
 #include "except.h"
@@ -713,8 +652,8 @@ typedef ElfLinker Linker;
 
 // main.cpp
 extern const char *progname;
-bool set_ec(int ec);
-#if (ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE)
+bool set_exit_code(int ec);
+#if (ACC_CC_CLANG || ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE)
 void e_exit(int ec) __attribute__((__noreturn__));
 #else
 void e_exit(int ec);
@@ -726,7 +665,7 @@ void printSetNl(int need_nl);
 void printClearLine(FILE *f = NULL);
 void printErr(const char *iname, const Throwable *e);
 void printUnhandledException(const char *iname, const std::exception *e);
-#if (ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE)
+#if (ACC_CC_CLANG || ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE)
 void __acc_cdecl_va printErr(const char *iname, const char *format, ...)
         __attribute__((__format__(__printf__,2,3)));
 void __acc_cdecl_va printWarn(const char *iname, const char *format, ...)
@@ -736,7 +675,7 @@ void __acc_cdecl_va printErr(const char *iname, const char *format, ...);
 void __acc_cdecl_va printWarn(const char *iname, const char *format, ...);
 #endif
 
-#if (ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE)
+#if (ACC_CC_CLANG || ACC_CC_GNUC || ACC_CC_LLVM || ACC_CC_PATHSCALE)
 void __acc_cdecl_va infoWarning(const char *format, ...)
         __attribute__((__format__(__printf__,1,2)));
 void __acc_cdecl_va infoHeader(const char *format, ...)
@@ -758,6 +697,7 @@ void do_files(int i, int argc, char *argv[]);
 
 
 // help.cpp
+extern const char gitrev[];
 void show_head(void);
 void show_help(int verbose=0);
 void show_license(void);
@@ -787,9 +727,6 @@ int upx_test_overlap       ( const upx_bytep buf,
                              const upx_compress_result_t *cresult );
 
 
-#endif /* __cplusplus */
-
-
 #if (ACC_OS_CYGWIN || ACC_OS_DOS16 || ACC_OS_DOS32 || ACC_OS_EMX || ACC_OS_OS2 || ACC_OS_OS216 || ACC_OS_WIN16 || ACC_OS_WIN32 || ACC_OS_WIN64)
 #  if defined(INVALID_HANDLE_VALUE) || defined(MAKEWORD) || defined(RT_CURSOR)
 #    error "something pulled in <windows.h>"
@@ -799,8 +736,4 @@ int upx_test_overlap       ( const upx_bytep buf,
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/console.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -39,41 +39,41 @@
 #undef USE_SCREEN_WIN32
 #undef USE_FRAMES
 
-#if defined(WITH_GUI) && !defined(NO_CONSOLE)
-#  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
+#  define USE_SCREEN 1
 #elif 1 && (ACC_OS_CYGWIN || ACC_OS_WIN32 || ACC_OS_WIN64)
-#  define USE_SCREEN
-#  define USE_SCREEN_WIN32
+#  define USE_SCREEN 1
+#  define USE_SCREEN_WIN32 1
 #elif 1 && (ACC_OS_EMX && defined(__RSXNT__))
-#  define USE_SCREEN
-#  define USE_SCREEN_WIN32
+#  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
@@ -81,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
@@ -110,7 +110,7 @@ enum {
 };
 
 
-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)
 
 typedef struct
 {
@@ -165,7 +165,7 @@ void __acc_cdecl_va con_fprintf(FILE *f, const char *format, ...);
 
 extern FILE *con_term;
 
-#if defined(USE_CONSOLE)
+#if (USE_CONSOLE)
 
 extern int con_mode;
 extern console_t *con;
@@ -187,8 +187,4 @@ extern console_t console_screen;
 
 #endif /* USE_CONSOLE */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/except.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -33,7 +33,7 @@
 //
 **************************************************************************/
 
-long Throwable::counter = 0;
+unsigned long Throwable::counter = 0;
 
 Throwable::Throwable(const char *m, int e, bool w) NOTHROW
     : super(), msg(NULL), err(e), is_warning(w)
@@ -41,7 +41,7 @@ Throwable::Throwable(const char *m, int e, bool w) NOTHROW
     if (m)
         msg = strdup(m);
 #if 0
-    fprintf(stderr, "construct exception: %s %ld\n", msg, counter);
+    fprintf(stderr, "construct exception: %s %lu\n", msg, counter);
     counter++;
 #endif
 }
@@ -53,7 +53,7 @@ Throwable::Throwable(const Throwable &other) NOTHROW
     if (other.msg)
         msg = strdup(other.msg);
 #if 0
-    fprintf(stderr, "copy exception: %s %ld\n", msg, counter);
+    fprintf(stderr, "copy exception: %s %lu\n", msg, counter);
     counter++;
 #endif
 }
@@ -63,7 +63,7 @@ Throwable::~Throwable() NOTHROW
 {
 #if 0
     counter--;
-    fprintf(stderr, "destruct exception: %s %ld\n", msg, counter);
+    fprintf(stderr, "destruct exception: %s %lu\n", msg, counter);
 #endif
     if (msg)
         free(msg);
@@ -161,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);
@@ -197,8 +205,4 @@ const char *prettyName(const char *n) NOTHROW
     return n;
 }
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/except.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_EXCEPT_H
-#define __UPX_EXCEPT_H
+#define __UPX_EXCEPT_H 1
 
 #ifdef __cplusplus
 
@@ -62,7 +62,7 @@ private:
     DISABLE_NEW_DELETE
 
 private:
-    static long counter;                // for debugging
+    static unsigned long counter;       // for debugging
 };
 
 
@@ -200,11 +200,10 @@ public:
 **************************************************************************/
 
 #undef NORET
-#if 0 && defined(__GNUC__)
-// (noreturn) is probably not the correct semantics for throwing exceptions
+#if 1 && defined(__GNUC__)
 #define NORET __attribute__((__noreturn__))
 #else
-#define NORET
+#define NORET /*empty*/
 #endif
 
 void throwCantPack(const char *msg) NORET;
@@ -220,6 +219,7 @@ void throwBadLoader() NORET;
 void throwChecksumError() NORET;
 void throwCompressedDataViolation() NORET;
 void throwInternalError(const char *msg) 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;
 
@@ -230,8 +230,4 @@ void throwEOFException(const char *msg = NULL, int e = 0) NORET;
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/file.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -37,7 +37,7 @@
 
 void File::chmod(const char *name, int mode)
 {
-#if defined(HAVE_CHMOD)
+#if (HAVE_CHMOD)
     if (::chmod(name,mode) != 0)
         throwIOException(name,errno);
 #else
@@ -88,7 +88,7 @@ FileBase::~FileBase()
 }
 
 
-void FileBase::sopen()
+bool FileBase::do_sopen()
 {
     if (_shflags < 0)
         _fd = ::open(_name, _flags, _mode);
@@ -101,13 +101,15 @@ void FileBase::sopen()
 #elif defined(SH_DENYRW)
         _fd = ::sopen(_name, _flags, _shflags, _mode);
 #else
-        assert(0);
+        throwInternalError("bad usage of do_sopen()");
 #endif
     }
-    if (!(_fd < 0)) {
-        ::fstat(_fd, &st);
-        _length = st.st_size;
-    }
+    if (_fd < 0)
+        return false;
+    if (::fstat(_fd, &st) != 0)
+        throwIOException(_name, errno);
+    _length = st.st_size;
+    return true;
 }
 
 
@@ -166,8 +168,10 @@ void FileBase::write(const void *buf, int len)
 }
 
 
-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 1");
     if (whence == SEEK_SET) {
@@ -183,6 +187,7 @@ void FileBase::seek(off_t off, int whence)
     }
     if (::lseek(_fd,off,whence) < 0)
         throwIOException("seek error",errno);
+    return off - _offset;
 }
 
 
@@ -232,8 +237,7 @@ void InputFile::sopen(const char *name, int flags, int shflags)
     _mode = 0;
     _offset = 0;
     _length = 0;
-    FileBase::sopen();
-    if (!isOpen())
+    if (!FileBase::do_sopen())
     {
         if (errno == ENOENT)
             throw FileNotFoundException(_name, errno);
@@ -242,6 +246,7 @@ void InputFile::sopen(const char *name, int flags, int shflags)
         else
             throwIOException(_name, errno);
     }
+    _length_orig = _length;
 }
 
 
@@ -282,9 +287,12 @@ int InputFile::readx(MemBuffer &buf, int len)
 }
 
 
-void InputFile::seek(off_t off, int whence)
+off_t InputFile::seek(upx_int64_t off64, int whence)
 {
-    super::seek(off,whence);
+    off_t pos = super::seek(off64, whence);
+    if (_length < pos)
+        throwIOException("bad seek 4");
+    return pos;
 }
 
 
@@ -293,6 +301,10 @@ off_t InputFile::tell() const
     return super::tell();
 }
 
+off_t InputFile::st_size_orig() const
+{
+    return _length_orig;
+}
 
 /*************************************************************************
 //
@@ -318,8 +330,7 @@ void OutputFile::sopen(const char *name, int flags, int shflags, int mode)
     _mode = mode;
     _offset = 0;
     _length = 0;
-    FileBase::sopen();
-    if (!isOpen())
+    if (!FileBase::do_sopen())
     {
 #if 0
         // don't throw FileNotFound here -- this is confusing
@@ -366,7 +377,9 @@ off_t OutputFile::st_size() const
         return bytes_written;  // too big if seek()+write() instead of rewrite()
     }
     struct stat my_st;
-    ::fstat(_fd, &my_st);
+    my_st.st_size = 0;
+    if (::fstat(_fd, &my_st) != 0)
+        throwIOException(_name, errno);
     return my_st.st_size;
 }
 
@@ -391,26 +404,54 @@ void OutputFile::rewrite(const void *buf, int len)
     bytes_written -= len;       // restore
 }
 
-void OutputFile::seek(off_t off, int whence)
+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);
-    super::seek(off,whence);
+    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) {
-        ::fstat(_fd, &st);
+        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 = ::lseek(_fd, 0, SEEK_END);
+    _length = l;
     bytes_written = _length;
     return _length;
 }
@@ -418,8 +459,8 @@ off_t OutputFile::unset_extent()
 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, 0600);
     f.write(buf, len);
@@ -455,8 +496,4 @@ void MemoryOutputFile::write(const void *buf, int len)
 
 #endif /* if 0 */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/file.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_FILE_H
-#define __UPX_FILE_H
+#define __UPX_FILE_H 1
 
 class MemBuffer;
 
@@ -63,11 +63,11 @@ public:
     virtual void set_extent(off_t offset, off_t length);
 
 protected:
-    void sopen();
+    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 seek(upx_int64_t off, int whence);
     virtual off_t tell() const;
 
     int _fd;
@@ -106,8 +106,11 @@ public:
     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 seek(upx_int64_t off, int whence);
     virtual off_t tell() const;
+    virtual off_t st_size_orig() const;
+protected:
+    off_t _length_orig;
 };
 
 
@@ -139,7 +142,7 @@ public:
     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);
+    virtual off_t seek(upx_int64_t off, int whence);
     virtual void rewrite(const void *buf, int len);
 
     // util
@@ -182,8 +185,4 @@ protected:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/filter.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -228,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: */

src/filter.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   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;
@@ -131,8 +131,4 @@ private:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/filter/ct.h

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

src/filter/cto.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -47,7 +47,7 @@ static int F(Filter *f)
     unsigned calls = 0, noncalls = 0, noncalls2 = 0;
     unsigned lastnoncall = size, lastcall = 0;
 
-    // find a 16MB large empty address space
+    // find a 16 MiB large empty address space
     {
         unsigned char buf[256];
         memset(buf,0,256);
@@ -126,7 +126,7 @@ static int F(Filter *f)
     f->noncalls = noncalls;
     f->lastcall = lastcall;
 
-#ifdef TESTING
+#if 0 || defined(TESTING)
     printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",calls,noncalls,noncalls2,size,cto);
 #endif
     return 0;
@@ -169,8 +169,4 @@ static int U(Filter *f)
 #undef F
 #undef U
 
-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/filter/ctoj.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2000-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2000-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -51,7 +51,7 @@ static int F(Filter *f)
     unsigned calls = 0, noncalls = 0, noncalls2 = 0;
     unsigned lastnoncall = size, lastcall = 0;
 
-    // find a 16MB large empty address space
+    // find a 16 MiB large empty address space
     {
         unsigned char buf[256];
         memset(buf,0,256);
@@ -125,7 +125,7 @@ static int F(Filter *f)
     f->noncalls = noncalls;
     f->lastcall = lastcall;
 
-#ifdef TESTING
+#if 0 || defined(TESTING)
     printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",calls,noncalls,noncalls2,size,cto);
 #endif
     return 0;
@@ -168,8 +168,4 @@ static int U(Filter *f)
 #undef F
 #undef U
 
-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/filter/ctojr.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2000-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2000-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -62,7 +62,7 @@ f80_jcc2(Filter const *f)
     return f80_jmp1(f);
 }
 
-static int const N_MRU = 32;  // does not have to be a power of 2
+#define N_MRU 32    // does not have to be a power of 2
 
 // Adaptively remember recent destinations.
 static void
@@ -123,8 +123,8 @@ static int F(Filter *f)
         N_MRU : 0;
 #endif  //}
 
-    // FIXME: We must fit into 8MB because we steal one bit.
-    // find a 16MB large empty address space
+    // 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];
@@ -249,11 +249,11 @@ static int F(Filter *f)
     f->noncalls = noncalls;
     f->lastcall = lastcall;
 
-/*#ifdef TESTING*/
+#if 0 || defined(TESTING)
     printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",
         calls,noncalls,noncalls2,size,cto8);
     printf("CALL/JMP/JCC  %d  %d  %d\n",wtally[0],wtally[1],wtally[2]);
-/*#endif*/
+#endif
     return 0;
 }
 
@@ -300,6 +300,9 @@ static int U(Filter *f)
                         }
                         else { // not 1st time at this destination
                             jc >>= 1;
+                            if (N_MRU <= jc) {
+                                throwCompressedDataViolation();
+                            }
                             int kh = jc + hand;
                             if (N_MRU <= kh) {
                                 kh -= N_MRU;
@@ -337,12 +340,8 @@ static int U(Filter *f)
 }
 #endif
 
-
+#undef N_MRU
 #undef F
 #undef U
 
-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/filter/ctok.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2000-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2000-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -52,7 +52,7 @@ static int F(Filter *f)
     unsigned calls = 0, noncalls = 0, noncalls2 = 0;
     unsigned lastnoncall = size, lastcall = 0;
 
-    // find a 16MB large empty address space
+    // find a 16 MiB large empty address space
     {
         unsigned char buf[256];
         memset(buf,0,256);
@@ -126,7 +126,7 @@ static int F(Filter *f)
     f->noncalls = noncalls;
     f->lastcall = lastcall;
 
-#ifdef TESTING
+#if 0 || defined(TESTING)
     printf("\ncalls=%d noncalls=%d noncalls2=%d text_size=%x calltrickoffset=%x\n",calls,noncalls,noncalls2,size,cto);
 #endif
     return 0;
@@ -171,8 +171,4 @@ static int U(Filter *f)
 #undef F
 #undef U
 
-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/filter/ctsw.h

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

src/filter/getcto.h

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

src/filter/ppcbxx.h

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

src/filter/sub.hh

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

src/filter/sub16.h

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

src/filter/sub32.h

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

src/filter/sub8.h

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

src/filter/sw.h

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

src/filteri.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -260,8 +260,4 @@ const FilterImp::FilterEntry FilterImp::filters[] = {
 
 const int FilterImp::n_filters = TABLESIZE(filters);
 
-
-/*
-vi:ts=4:et:nowrap
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/help.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -38,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;
@@ -51,14 +57,20 @@ void show_head(void)
     fg = con_fg(f,FG_GREEN);
     con_fprintf(f,
                 "                       Ultimate Packer for eXecutables\n"
-                "  Copyright (C) 1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007\n"
-                "UPX %-10s  Markus Oberhumer, Laszlo Molnar & John Reiser  %14s\n\n",
-#if (ACC_OS_DOS16 || ACC_OS_DOS32)
+                "                          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"),
-#elif 0 && defined(__linux__)
-                V("l"),
 #else
                 UPX_VERSION_STRING,
 #endif
@@ -97,14 +109,14 @@ struct PackerNames
         const char* fname;
         const char* sname;
     };
-    Entry names[32];
+    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 < 32);
+        assert(names_count < 64);
         names[names_count].fname = p->getFullName(o);
         names[names_count].sname = p->getName();
         names_count++;
@@ -113,6 +125,7 @@ struct PackerNames
     {
         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) {
@@ -134,25 +147,26 @@ static void show_all_packers(FILE *f, int verbose)
     {
         const char *fn = pn.names[i].fname;
         const char *sn = pn.names[i].sname;
-        if (verbose)
+        if (verbose > 0)
         {
-            con_fprintf(f, "    %-32s %s\n", fn, sn);
+            con_fprintf(f, "    %-36s %s\n", fn, sn);
         }
         else
         {
+            size_t fl = strlen(fn);
             if (pos == 0) {
                 con_fprintf(f, "  %s", fn);
-                pos = 2 + strlen(fn);
-            } else if (pos + 1 + strlen(fn) > 80) {
+                pos = 2 + fl;
+            } else if (pos + 1 + fl > 80) {
                 con_fprintf(f, "\n  %s", fn);
-                pos = 2 + strlen(fn);
+                pos = 2 + fl;
             } else {
                 con_fprintf(f, " %s", fn);
-                pos += 1 + strlen(fn);
+                pos += 1 + fl;
             }
         }
     }
-    if (!verbose && pn.names_count)
+    if (verbose <= 0 && pn.names_count)
         con_fprintf(f, "\n");
 }
 
@@ -224,26 +238,16 @@ void show_help(int verbose)
                     "  --overlay=skip      don't compress a file with an overlay\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"Options for atari/tos:\n");
-        fg = con_fg(f,fg);
-        con_fprintf(f,
-                    "  --all-methods       try all available compression methods\n"
-                    "\n");
-        fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for djgpp2/coff:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  --coff              produce COFF output [default: EXE]\n"
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for dos/com:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  --8086              make compressed com work on any 8086\n"
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for dos/exe:\n");
@@ -251,15 +255,12 @@ void show_help(int verbose)
         con_fprintf(f,
                     "  --8086              make compressed exe work on any 8086\n"
                     "  --no-reloc          put no relocations in to the exe header\n"
-                    "  --all-methods       try all available compression methods\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for dos/sys:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
                     "  --8086              make compressed sys work on any 8086\n"
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
                     "\n");
 #if 0
         fg = con_fg(f,FG_YELLOW);
@@ -274,27 +275,12 @@ void show_help(int verbose)
         con_fprintf(f,"Options for ps1/exe:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
-                    "  --all-methods       try all available compression methods\n"
                     "  --8-bit             uses 8 bit size compression [default: 32 bit]\n"
-                    "  --8mb-ram           8 megabyte memory limit [default: 2 mb]\n"
+                    "  --8mib-ram          8 megabyte memory limit [default: 2 MiB]\n"
                     "  --boot-only         disables client/host transfer compatibility\n"
                     "  --no-align          don't align to 2048 bytes [enables: --console-run]\n"
                     "\n");
         fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"Options for tmt/adam:\n");
-        fg = con_fg(f,fg);
-        con_fprintf(f,
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
-                    "\n");
-        fg = con_fg(f,FG_YELLOW);
-        con_fprintf(f,"Options for vmlinuz/386\n");
-        fg = con_fg(f,fg);
-        con_fprintf(f,
-                    "  --all-methods       try all available compression methods\n"
-                    "  --all-filters       try all available preprocessing filters\n"
-                    "\n");
-        fg = con_fg(f,FG_YELLOW);
         con_fprintf(f,"Options for watcom/le:\n");
         fg = con_fg(f,fg);
         con_fprintf(f,
@@ -314,8 +300,12 @@ void show_help(int verbose)
                     "  --keep-resource=list    do not compress resources specified by list\n"
                     "  --strip-relocs=0        do not strip relocations\n"
                     "  --strip-relocs=1        strip relocations [default]\n"
-                    "  --all-methods           try all available compression methods\n"
-                    "  --all-filters           try all available preprocessing filters\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");
     }
 
@@ -333,17 +323,17 @@ void show_help(int verbose)
         con_fprintf(f,"\nType '%s --help' for more detailed help.\n", progname);
     }
 
-    con_fprintf(f,"\nUPX comes with ABSOLUTELY NO WARRANTY; for details visit http://upx.sf.net\n"
+    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");
@@ -387,7 +377,7 @@ void show_license(void)
     con_fprintf(f,
         "\n"
         "   Markus F.X.J. Oberhumer              Laszlo Molnar\n"
-        "   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>\n"
+        "   <markus@oberhumer.com>               <ezerotven+github@gmail.com>\n"
     );
     fg = con_fg(f,fg);
 
@@ -406,42 +396,42 @@ void show_version(int x)
     UNUSED(x);
     UNUSED(v);
 
-    fprintf(fp, "upx %s\n", UPX_VERSION_STRING);
-#if defined(WITH_NRV)
+    fprintf(fp, "upx %s\n", UPX_VERSION_STRING
+#if defined(UPX_VERSION_GITREV)
+            "-git-" UPX_VERSION_GITREV
+#endif
+           );
+#if (WITH_NRV)
     v = upx_nrv_version_string();
     if (v != NULL && v[0])
         fprintf(fp, "NRV data compression library %s\n", v);
 #endif
-#if defined(WITH_UCL)
+#if (WITH_UCL)
     v = upx_ucl_version_string();
     if (v != NULL && v[0])
         fprintf(fp, "UCL data compression library %s\n", v);
 #endif
-#if defined(WITH_ZLIB)
+#if (WITH_ZLIB)
     v = upx_zlib_version_string();
     if (v != NULL && v[0])
         fprintf(fp, "zlib data compression library %s\n", v);
 #endif
-#if defined(WITH_LZMA)
+#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-2007 Markus Franz Xaver Johannes Oberhumer\n");
-    fprintf(fp, "Copyright (C) 1996-2007 Laszlo Molnar\n");
-    fprintf(fp, "Copyright (C) 2000-2007 John F. Reiser\n");
-    fprintf(fp, "Copyright (C) 2002-2007 Jens Medoch\n");
-#if defined(WITH_ZLIB)
+    fprintf(fp, "Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer\n");
+    fprintf(fp, "Copyright (C) 1996-2016 Laszlo Molnar\n");
+    fprintf(fp, "Copyright (C) 2000-2016 John F. Reiser\n");
+    fprintf(fp, "Copyright (C) 2002-2016 Jens Medoch\n");
+#if (WITH_ZLIB)
     fprintf(fp, "Copyright (C) 1995" "-2005 Jean-loup Gailly and Mark Adler\n");
 #endif
-#if defined(WITH_LZMA)
+#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: */

src/lefile.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -360,8 +360,4 @@ void LeFile::countFixups(unsigned *counts) const
     counts[o+1] += 4; // extra space for 0xFFFFFFFF
 }
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/lefile.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_LEFILE_H
-#define __UPX_LEFILE_H
+#define __UPX_LEFILE_H 1
 
 class InputFile;
 class OutputFile;
@@ -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,28 +117,23 @@ protected:
         LE16  device_id;
         LE16  ddk_version;
 #endif
-    }
-    __attribute_packed;
+    __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;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct le_pagemap_entry_t
-    {
+    __packed_struct(le_pagemap_entry_t)
         unsigned char h;
         unsigned char m;
         unsigned char l;
         unsigned char type;  // 0x00-legal;0x40-iterated;0x80-invalid;0xC0-zeroed
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
     virtual void readObjectTable();
     virtual void writeObjectTable();
@@ -185,8 +180,8 @@ protected:
 
     InputFile *fif;
     OutputFile *fof;
-    long le_offset;
-    long exe_offset;
+    unsigned le_offset;
+    unsigned exe_offset;
 
     le_header_t ih;
     le_header_t oh;
@@ -226,8 +221,4 @@ private:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/linker.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -21,83 +21,81 @@
    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      ml1050@users.sourceforge.net
+   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 nocopy
-{
+class ElfLinker : private noncopyable {
     friend class Packer;
+
 public:
-    const N_BELE_RTP::AbstractPolicy *bele;
+    const N_BELE_RTP::AbstractPolicy *bele; // target endianness
 protected:
-    struct      Section;
-    struct      Symbol;
-    struct      Relocation;
+    struct Section;
+    struct Symbol;
+    struct Relocation;
 
-    upx_byte    *input;
-    int         inputlen;
-    upx_byte    *output;
-    int         outputlen;
+    upx_byte *input;
+    int inputlen;
+    upx_byte *output;
+    int outputlen;
 
-    Section     *head;
-    Section     *tail;
+    Section *head;
+    Section *tail;
 
-    Section     **sections;
-    Symbol      **symbols;
-    Relocation  **relocations;
+    Section **sections;
+    Symbol **symbols;
+    Relocation **relocations;
 
-    unsigned    nsections;
-    unsigned    nsections_capacity;
-    unsigned    nsymbols;
-    unsigned    nsymbols_capacity;
-    unsigned    nrelocations;
-    unsigned    nrelocations_capacity;
+    unsigned nsections;
+    unsigned nsections_capacity;
+    unsigned nsymbols;
+    unsigned nsymbols_capacity;
+    unsigned nrelocations;
+    unsigned nrelocations_capacity;
 
-    bool        reloc_done;
+    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;
+    Section *findSection(const char *name, bool fatal = true) const;
+    Symbol *findSymbol(const char *name, bool fatal = true) const;
 
-    Symbol *addSymbol(const char *name, const char *section, unsigned offset);
+    Symbol *addSymbol(const char *name, const char *section, upx_uint64_t offset);
     Relocation *addRelocation(const char *section, unsigned off, const char *type,
-                              const char *symbol, unsigned add);
+                              const char *symbol, upx_uint64_t add);
 
 public:
     ElfLinker();
     virtual ~ElfLinker();
 
     virtual void init(const void *pdata, int plen);
-    //virtual void setLoaderAlignOffset(int phase);
+    // virtual void setLoaderAlignOffset(int phase);
     virtual int addLoader(const char *sname);
     void addLoader(const char *s, va_list ap);
-#if 1 && (ACC_CC_GNUC >= 0x040100)
+#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 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, unsigned value);
-    virtual unsigned getSymbolOffset(const char *) 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;
+    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); }
@@ -105,131 +103,149 @@ public:
 
 protected:
     virtual void relocate();
-    virtual void relocate1(const Relocation *, upx_byte *location,
-                           unsigned value, const char *type);
+    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 nocopy
-{
+struct ElfLinker::Section : private noncopyable {
     char *name;
     void *input;
     upx_byte *output;
     unsigned size;
-    unsigned offset;
-    unsigned p2align;   // log2
+    upx_uint64_t offset;
+    unsigned p2align; // log2
     Section *next;
 
-    Section(const char *n, const void *i, unsigned s, unsigned a=0);
+    Section(const char *n, const void *i, unsigned s, unsigned a = 0);
     ~Section();
 };
 
-
-struct ElfLinker::Symbol : private nocopy
-{
+struct ElfLinker::Symbol : private noncopyable {
     char *name;
     Section *section;
-    unsigned offset;
+    upx_uint64_t offset;
 
-    Symbol(const char *n, Section *s, unsigned o);
+    Symbol(const char *n, Section *s, upx_uint64_t o);
     ~Symbol();
 };
 
-
-struct ElfLinker::Relocation : private nocopy
-{
+struct ElfLinker::Relocation : private noncopyable {
     const Section *section;
     unsigned offset;
     const char *type;
     const Symbol *value;
-    unsigned add;           // used in .rela relocations
+    upx_uint64_t add; // used in .rela relocations
 
-    Relocation(const Section *s, unsigned o, const char *t,
-               const Symbol *v, unsigned a);
+    Relocation(const Section *s, unsigned o, const char *t, const Symbol *v, upx_uint64_t a);
 };
 
-
 /*************************************************************************
 // ElfLinker arch subclasses
 **************************************************************************/
 
-class ElfLinkerAMD64 : public ElfLinker
-{
+class ElfLinkerAMD64 : public ElfLinker {
     typedef ElfLinker super;
+
 protected:
     virtual void alignCode(unsigned len) { alignWithByte(len, 0x90); }
-    virtual void relocate1(const Relocation *, upx_byte *location,
-                           unsigned value, const char *type);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
 };
 
-
-class ElfLinkerArmBE : public ElfLinker
-{
+class ElfLinkerArmBE : public ElfLinker {
     typedef ElfLinker super;
+
 public:
     ElfLinkerArmBE() { bele = &N_BELE_RTP::be_policy; }
+
 protected:
-    virtual void relocate1(const Relocation *, upx_byte *location,
-                           unsigned value, const char *type);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
 };
 
-
-class ElfLinkerArmLE : public ElfLinker
-{
+class ElfLinkerArmLE : public ElfLinker {
     typedef ElfLinker super;
+
 protected:
-    virtual void relocate1(const Relocation *, upx_byte *location,
-                           unsigned value, const char *type);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
 };
 
-
-class ElfLinkerM68k : public ElfLinker
-{
+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,
-                           unsigned value, const char *type);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
 };
 
-
-class ElfLinkerMipsLE : public ElfLinker
-{
+class ElfLinkerMipsBE : public ElfLinker {
     typedef ElfLinker super;
+
+public:
+    ElfLinkerMipsBE() { bele = &N_BELE_RTP::be_policy; }
+
 protected:
-    virtual void relocate1(const Relocation *, upx_byte *location,
-                           unsigned value, const char *type);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
 };
 
-
-class ElfLinkerPpc32 : public ElfLinker
-{
+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,
-                           unsigned value, const char *type);
+    virtual void relocate1(const Relocation *, upx_byte *location, upx_uint64_t value,
+                           const char *type);
 };
 
-
-class ElfLinkerX86 : public ElfLinker
-{
+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,
-                           unsigned value, const char *type);
+    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: */

src/main.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #include "conf.h"
-#include "mygetopt.h"
+#include "compress.h"
 #include "file.h"
 #include "packer.h"
 #include "p_elf.h"
@@ -56,11 +56,14 @@ void options_t::reset()
 
     o->backup = -1;
     o->overlay = -1;
+    o->preserve_mode = true;
+    o->preserve_ownership = true;
+    o->preserve_timestamp = true;
 
     o->console = CON_FILE;
 #if defined(__DJGPP__)
     o->console = CON_INIT;
-#elif defined(USE_SCREEN_WIN32)
+#elif (USE_SCREEN_WIN32)
     o->console = CON_INIT;
 #elif 1 && defined(__linux__)
     o->console = CON_INIT;
@@ -87,6 +90,19 @@ static int done_script_name = 0;
 const char *argv0 = "";
 const char *progname = "";
 
+static acc_getopt_t mfx_getopt;
+#define mfx_optarg      mfx_getopt.optarg
+#define mfx_optind      mfx_getopt.optind
+#define mfx_option      acc_getopt_longopt_t
+static void handle_opterr(acc_getopt_p g, const char *f, void *v)
+{
+    struct A { va_list ap; };
+    struct A *a = (struct A *) v;
+    fprintf( stderr, "%s: ", g->progname);
+    vfprintf(stderr, f, a->ap);
+    fprintf( stderr, "\n");
+}
+
 
 static int num_files = -1;
 static int exit_code = EXIT_OK;
@@ -143,7 +159,7 @@ static bool set_eec(int ec, int *eec)
     return 0;
 }
 
-bool set_ec(int ec)
+bool set_exit_code(int ec)
 {
     return set_eec(ec,&exit_code);
 }
@@ -151,25 +167,27 @@ bool set_ec(int ec)
 
 void e_exit(int ec)
 {
-    (void) set_ec(ec);
+    (void) set_exit_code(ec);
     do_exit();
 }
 
 
-void e_usage(void)
+static void e_usage(void)
 {
     show_usage();
     e_exit(EXIT_USAGE);
 }
 
 
-void e_memory(void)
+#if 0 // UNUSED
+static void e_memory(void)
 {
     show_head();
     fflush(con_term);
     fprintf(stderr,"%s: out of memory\n", argv0);
     e_exit(EXIT_MEMORY);
 }
+#endif // UNUSED
 
 
 static void e_method(int m, int l)
@@ -197,7 +215,7 @@ static void e_optval(const char *n)
 
 
 #if defined(OPTIONS_VAR)
-void e_envopt(const char *n)
+static void e_envopt(const char *n)
 {
     fflush(con_term);
     if (n)
@@ -211,18 +229,20 @@ void e_envopt(const char *n)
 #endif /* defined(OPTIONS_VAR) */
 
 
-void __acc_cdecl_sighandler e_sighandler(int signum)
+#if 0 // UNUSED
+static void __acc_cdecl_sighandler e_sighandler(int signum)
 {
     UNUSED(signum);
     e_exit(EXIT_FATAL);
 }
+#endif // UNUSED
 
 
 /*************************************************************************
 // check options
 **************************************************************************/
 
-void check_not_both(bool e1, bool e2, const char *c1, const char *c2)
+static void check_not_both(bool e1, bool e2, const char *c1, const char *c2)
 {
     if (e1 && e2)
     {
@@ -233,7 +253,7 @@ void check_not_both(bool e1, bool e2, const char *c1, const char *c2)
 }
 
 
-void check_options(int i, int argc)
+static void check_options(int i, int argc)
 {
     assert(i <= argc);
 
@@ -283,7 +303,7 @@ void check_options(int i, int argc)
 // misc
 **************************************************************************/
 
-void e_help(void)
+static void e_help(void)
 {
     show_help();
     e_exit(EXIT_USAGE);
@@ -312,14 +332,9 @@ static bool set_method(int m, int l)
     {
         if (!Packer::isValidCompressionMethod(m))
             return false;
-#if 1
         // something like "--brute --lzma" should not disable "--brute"
         if (!opt->all_methods)
-#endif
-        {
             opt->method = m;
-            opt->all_methods = false;
-        }
     }
     if (l > 0)
         opt->level = l;
@@ -424,7 +439,7 @@ char* prepare_shortopts(char *buf, const char *n,
 
 
 template <class T>
-int getoptvar(T *var, const T min_value, const T max_value, const char *arg_fatal)
+static int getoptvar(T *var, const T min_value, const T max_value, const char *arg_fatal)
 {
     const char *p = mfx_optarg;
     char *endptr;
@@ -454,9 +469,8 @@ done:
     return r;
 }
 
-#if 1 && (ACC_CC_GNUC >= 0x030300)
 template <class T, T default_value, T min_value, T max_value>
-int getoptvar(OptVar<T,default_value,min_value,max_value> *var, const char *arg_fatal)
+static int getoptvar(OptVar<T,default_value,min_value,max_value> *var, const char *arg_fatal)
 {
     T v = default_value;
     int r = getoptvar(&v, min_value, max_value, arg_fatal);
@@ -464,17 +478,6 @@ int getoptvar(OptVar<T,default_value,min_value,max_value> *var, const char *arg_
         *var = v;
     return r;
 }
-#else
-template <class T>
-int getoptvar(T *var, const char *arg_fatal)
-{
-    typename T::Type v = T::default_value_c;
-    int r = getoptvar(&v, T::min_value_c, T::max_value_c, arg_fatal);
-    if (r == 0)
-        *var = v;
-    return r;
-}
-#endif
 
 
 static int do_option(int optc, const char *arg)
@@ -579,6 +582,12 @@ static int do_option(int optc, const char *arg)
         if (M_IS_LZMA(opt->method))
             opt->method = -1;
         break;
+    case 723:
+        opt->prefer_ucl = false;
+        break;
+    case 724:
+        opt->prefer_ucl = true;
+        break;
 
     // compression level
     case '1':
@@ -630,6 +639,17 @@ static int do_option(int optc, const char *arg)
         opt->debug.disable_random_id = true;
         break;
 
+    // mp (meta)
+    case 501:
+        getoptvar(&opt->mp_compress_task, 1, 999999, arg);
+        break;
+    case 502:
+        opt->mp_query_format = true;
+        break;
+    case 503:
+        opt->mp_query_num_tasks = true;
+        break;
+
     // misc
     case 512:
         opt->console = CON_FILE;
@@ -646,6 +666,15 @@ static int do_option(int optc, const char *arg)
     case 519:
         opt->no_env = true;
         break;
+    case 526:
+        opt->preserve_mode = false;
+        break;
+    case 527:
+        opt->preserve_ownership = false;
+        break;
+    case 528:
+        opt->preserve_timestamp = false;
+        break;
     // compression settings
     case 520:                               // --small
         if (opt->small < 0)
@@ -858,7 +887,13 @@ static int do_option(int optc, const char *arg)
         opt->ps1_exe.do_8bit = true;
         break;
     case 673:
-        opt->ps1_exe.do_8mb = false;
+        opt->ps1_exe.do_8mib = false;
+        break;
+    case 674:
+        opt->o_unix.unmap_all_pages = true;  // val ?
+        break;
+    case 675:
+        opt->o_unix.preserve_build_id = true;
         break;
 
     case '\0':
@@ -900,7 +935,10 @@ static const struct mfx_option longopts[] =
     {"force-compress",      0, 0, 'f'},     //   and compression of suspicious files
     {"info",                0, 0, 'i'},     // info mode
     {"no-env",           0x10, 0, 519},     // no environment var
+    {"no-mode",          0x10, 0, 526},     // do not preserve mode (permissions)
+    {"no-owner",         0x10, 0, 527},     // do not preserve ownership
     {"no-progress",         0, 0, 516},     // no progress bar
+    {"no-time",          0x10, 0, 528},     // do not preserve timestamp
     {"output",           0x21, 0, 'o'},
     {"quiet",               0, 0, 'q'},     // quiet mode
     {"silent",              0, 0, 'q'},     // quiet mode
@@ -946,7 +984,9 @@ static const struct mfx_option longopts[] =
     {"nrv2d",            0x10, 0, 704},     // --nrv2d
     {"nrv2e",            0x10, 0, 705},     // --nrv2e
     {"lzma",             0x10, 0, 721},     // --lzma
-    {"no-lzma",          0x10, 0, 722},     // (disable all_methods_use_lzma)
+    {"no-lzma",          0x10, 0, 722},     // disable all_methods_use_lzma
+    {"prefer-nrv",       0x10, 0, 723},
+    {"prefer-ucl",       0x10, 0, 724},
     // compression settings
     {"all-filters",      0x10, 0, 523},
     {"all-methods",      0x10, 0, 524},
@@ -1006,6 +1046,8 @@ static const struct mfx_option longopts[] =
     {"netbsd",           0x10, 0, 668},
     {"OpenBSD",          0x10, 0, 669},
     {"openbsd",          0x10, 0, 669},
+    {"unmap-all-pages",  0x10, 0, 674},     // linux /proc/self/exe vanishes
+    {"preserve-build-id",   0, 0, 675},
     // watcom/le
     {"le",               0x10, 0, 620},     // produce LE output
     // win32/pe
@@ -1019,19 +1061,26 @@ static const struct mfx_option longopts[] =
     {"boot-only",        0x10, 0, 670},
     {"no-align",         0x10, 0, 671},
     {"8-bit",            0x10, 0, 672},
+    {"8mib-ram",         0x10, 0, 673},
     {"8mb-ram",          0x10, 0, 673},
 
+    // mp (meta) options
+    {"mp-compress-task",        0x31, 0, 501},
+    {"mp-query-format",         0x10, 0, 502},
+    {"mp-query-num-tasks",      0x10, 0, 503},
+
     { NULL, 0, NULL, 0 }
 };
 
     int optc, longind;
-    char buf[256];
+    char shortopts[256];
 
-    prepare_shortopts(buf,"123456789hH?V",longopts),
-    mfx_optind = 0;
-    mfx_opterr = 1;
+    prepare_shortopts(shortopts, "123456789hH?V", longopts),
+    acc_getopt_init(&mfx_getopt, 1, argc, argv);
+    mfx_getopt.progname = progname;
+    mfx_getopt.opterr = handle_opterr;
     opt->o_unix.osabi0 = Elf32_Ehdr::ELFOSABI_LINUX;
-    while ((optc = mfx_getopt_long(argc, argv, buf, longopts, &longind)) >= 0)
+    while ((optc = acc_getopt(&mfx_getopt, shortopts, longopts, &longind)) >= 0)
     {
         if (do_option(optc, argv[mfx_optind-1]) != 0)
             e_usage();
@@ -1091,6 +1140,15 @@ static const struct mfx_option longopts[] =
     // compression settings
     {"exact",            0x10, 0, 525},     // user requires byte-identical decompression
 
+    // compression method
+    {"nrv2b",            0x10, 0, 702},     // --nrv2b
+    {"nrv2d",            0x10, 0, 704},     // --nrv2d
+    {"nrv2e",            0x10, 0, 705},     // --nrv2e
+    {"lzma",             0x10, 0, 721},     // --lzma
+    {"no-lzma",          0x10, 0, 722},     // disable all_methods_use_lzma
+    {"prefer-nrv",       0x10, 0, 723},
+    {"prefer-ucl",       0x10, 0, 724},
+    // compression settings
     // compression runtime parameters
 
     // win32/pe
@@ -1110,7 +1168,7 @@ static const struct mfx_option longopts[] =
     int targc;
     char **targv = NULL;
     static const char sep[] = " \t";
-    char buf[256];
+    char shortopts[256];
 
     var = getenv(OPTIONS_VAR);
     if (var == NULL || !var[0])
@@ -1166,10 +1224,11 @@ static const struct mfx_option longopts[] =
             e_envopt(targv[i]);
 
     /* handle options */
-    prepare_shortopts(buf,"123456789",longopts);
-    mfx_optind = 0;
-    mfx_opterr = 1;
-    while ((optc = mfx_getopt_long(targc, targv, buf, longopts, &longind)) >= 0)
+    prepare_shortopts(shortopts, "123456789", longopts);
+    acc_getopt_init(&mfx_getopt, 1, targc, targv);
+    mfx_getopt.progname = progname;
+    mfx_getopt.opterr = handle_opterr;
+    while ((optc = acc_getopt(&mfx_getopt, shortopts, longopts, &longind)) >= 0)
     {
         if (do_option(optc, targv[mfx_optind-1]) != 0)
             e_envopt(NULL);
@@ -1218,8 +1277,8 @@ template <class T> struct TestBELE {
 static bool test(void)
 {
     COMPILE_TIME_ASSERT_ALIGNED1(T)
-    struct test1_t { char a; T b; } __attribute_packed;
-    struct test2_t { char a; T b[3]; } __attribute_packed;
+    __packed_struct(test1_t) char a; T b;    __packed_struct_end()
+    __packed_struct(test2_t) char a; T b[3]; __packed_struct_end()
     test1_t t1[7]; UNUSED(t1); test2_t t2[7]; UNUSED(t2);
     COMPILE_TIME_ASSERT(sizeof(test1_t) == 1 + sizeof(T))
     COMPILE_TIME_ASSERT_ALIGNED1(test1_t)
@@ -1231,7 +1290,7 @@ static bool test(void)
     COMPILE_TIME_ASSERT(__acc_alignof(t1) == 1)
     COMPILE_TIME_ASSERT(__acc_alignof(t2) == 1)
 #endif
-#if 1 && !defined(xUPX_OFFICIAL_BUILD)
+#if 1 && !defined(UPX_OFFICIAL_BUILD)
     T allbits; allbits = 0; allbits -= 1;
     //++allbits; allbits++; --allbits; allbits--;
     T v1; v1 = 1; v1 *= 2; v1 -= 1;
@@ -1257,7 +1316,7 @@ static bool test(void)
 #undef ACCCHK_ASSERT
 #include "miniacc.h"
 
-void upx_sanity_check(void)
+__acc_static_noinline void upx_sanity_check(void)
 {
 #define ACC_WANT_ACC_CHK_CH 1
 #undef ACCCHK_ASSERT
@@ -1273,6 +1332,9 @@ void upx_sanity_check(void)
 
     COMPILE_TIME_ASSERT(sizeof(off_t) >= sizeof(long))
     COMPILE_TIME_ASSERT(((off_t) -1) < 0)
+#if (ACC_OS_POSIX_DARWIN || ACC_OS_POSIX_LINUX)
+    COMPILE_TIME_ASSERT(sizeof(off_t) >= 8)
+#endif
 
     COMPILE_TIME_ASSERT(sizeof(BE16) == 2)
     COMPILE_TIME_ASSERT(sizeof(BE32) == 4)
@@ -1294,7 +1356,13 @@ void upx_sanity_check(void)
     COMPILE_TIME_ASSERT(sizeof(UPX_VERSION_YEAR) == 4 + 1)
     assert(strlen(UPX_VERSION_YEAR) == 4);
     assert(memcmp(UPX_VERSION_DATE_ISO, UPX_VERSION_YEAR, 4) == 0);
-    assert(memcmp(UPX_VERSION_DATE + strlen(UPX_VERSION_DATE) - 4, UPX_VERSION_YEAR, 4) == 0);
+    assert(memcmp(&UPX_VERSION_DATE[sizeof(UPX_VERSION_DATE)-1 - 4], UPX_VERSION_YEAR, 4) == 0);
+    if (gitrev[0]) {
+        size_t revlen = strlen(gitrev);
+        if (strncmp(gitrev, "ERROR", 5) == 0) { assert(revlen == 5 || revlen == 6); }
+        else { assert(revlen == 12 || revlen == 13); }
+        if (revlen == 6 || revlen == 13) { assert(gitrev[revlen-1] == '+'); }
+    }
 
 #if 1
     assert(TestBELE<LE16>::test());
@@ -1304,29 +1372,42 @@ void upx_sanity_check(void)
     assert(TestBELE<BE32>::test());
     assert(TestBELE<BE64>::test());
     {
-    static const unsigned char dd[32] = { 0, 0, 0, 0, 0, 0, 0,
-         0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
-         0, 0, 0, 0,
-         0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78,
+    static const unsigned char dd[32]
+#if 1 && (ACC_CC_CLANG || ACC_CC_GNUC || ACC_CC_INTELC || ACC_CC_PATHSCALE) && defined(__ELF__)
+        __attribute__((__aligned__(16)))
+#endif
+        = { 0, 0, 0, 0, 0, 0, 0,
+        0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8,
+        0, 0, 0, 0,
+        0x7f, 0x7e, 0x7d, 0x7c, 0x7b, 0x7a, 0x79, 0x78,
     0, 0, 0, 0, 0 };
     const unsigned char *d;
+    const N_BELE_RTP::AbstractPolicy *bele;
     d = dd + 7;
     assert(upx_adler32(d, 4) == 0x09f003f7);
     assert(upx_adler32(d, 4, 0) == 0x09ec03f6);
     assert(upx_adler32(d, 4, 1) == 0x09f003f7);
+    bele = &N_BELE_RTP::be_policy;
     assert(get_be16(d) == 0xfffe);
+    assert(bele->get16(d) == 0xfffe);
     assert(get_be16_signed(d) == -2);
     assert(get_be24(d) == 0xfffefd);
+    assert(bele->get24(d) == 0xfffefd);
     assert(get_be24_signed(d) == -259);
     assert(get_be32(d) == 0xfffefdfc);
+    assert(bele->get32(d) == 0xfffefdfc);
     assert(get_be32_signed(d) == -66052);
+    bele = &N_BELE_RTP::le_policy;
     assert(get_le16(d) == 0xfeff);
+    assert(bele->get16(d) == 0xfeff);
     assert(get_le16_signed(d) == -257);
     assert(get_le24(d) == 0xfdfeff);
+    assert(bele->get24(d) == 0xfdfeff);
     assert(get_le24_signed(d) == -131329);
     assert(get_le32(d) == 0xfcfdfeff);
+    assert(bele->get32(d) == 0xfcfdfeff);
     assert(get_le32_signed(d) == -50462977);
-    assert(get_le64_signed(d) == ACC_INT64_C(-506097522914230529));
+    assert(get_le64_signed(d) == UPX_INT64_C(-506097522914230529));
     assert(find_be16(d, 2, 0xfffe) == 0);
     assert(find_le16(d, 2, 0xfeff) == 0);
     assert(find_be32(d, 4, 0xfffefdfc) == 0);
@@ -1335,7 +1416,7 @@ void upx_sanity_check(void)
     assert(get_be16_signed(d) == 32638);
     assert(get_be24_signed(d) == 8355453);
     assert(get_be32_signed(d) == 2138996092);
-    assert(get_be64_signed(d) == ACC_INT64_C(9186918263483431288));
+    assert(get_be64_signed(d) == UPX_INT64_C(9186918263483431288));
     }
 #endif
 }
@@ -1345,7 +1426,7 @@ void upx_sanity_check(void)
 // main entry point
 **************************************************************************/
 
-#if !defined(WITH_GUI)
+#if !(WITH_GUI)
 
 #if (ACC_ARCH_M68K && ACC_OS_TOS && ACC_CC_GNUC) && defined(__MINT__)
 extern "C" { extern long _stksize; long _stksize = 256 * 1024L; }
@@ -1360,6 +1441,9 @@ int __acc_cdecl_main main(int argc, char *argv[])
 #if 0 && defined(__DJGPP__)
     // LFN=n may cause problems with 2.03's _rename and mkdir under WinME
     putenv("LFN=y");
+#endif
+#if (ACC_OS_WIN32 || ACC_OS_WIN64) && (ACC_CC_MSC) && defined(_WRITE_ABORT_MSG) && defined(_CALL_REPORTFAULT)
+    _set_abort_behavior(_WRITE_ABORT_MSG, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
 #endif
     acc_wildargv(&argc, &argv);
 
@@ -1395,8 +1479,7 @@ int __acc_cdecl_main main(int argc, char *argv[])
 
     set_term(stderr);
 
-#if defined(WITH_UCL)
-    if (ucl_init() != UCL_E_OK)
+    if (upx_ucl_init() != 0)
     {
         show_head();
         fprintf(stderr,"ucl_init() failed - check your UCL installation !\n");
@@ -1405,17 +1488,10 @@ int __acc_cdecl_main main(int argc, char *argv[])
                     (long) UCL_VERSION, (long) ucl_version());
         e_exit(EXIT_INIT);
     }
-#endif
-#if defined(WITH_NRV)
-    if (nrv_init() != NRV_E_OK || NRV_VERSION != nrv_version())
-    {
-        show_head();
-        fprintf(stderr,"nrv_init() failed - check your NRV installation !\n");
-        if (NRV_VERSION != nrv_version())
-            fprintf(stderr,"library version conflict (%lx, %lx) - check your NRV installation !\n",
-                    (long) NRV_VERSION, (long) nrv_version());
-        e_exit(EXIT_INIT);
-    }
+    assert(upx_lzma_init() == 0);
+    assert(upx_zlib_init() == 0);
+#if (WITH_NRV)
+    assert(upx_nrv_init() == 0);
 #endif
 
     //srand((int) time(NULL));
@@ -1483,7 +1559,7 @@ int __acc_cdecl_main main(int argc, char *argv[])
     set_term(stdout);
     do_files(i,argc,argv);
 
-#if 0 && (UPX_VERSION_HEX < 0x030000)
+    if (gitrev[0])
     {
         FILE *f = stdout;
         int fg = con_fg(f,FG_RED);
@@ -1491,7 +1567,6 @@ int __acc_cdecl_main main(int argc, char *argv[])
         fg = con_fg(f,fg);
         UNUSED(fg);
     }
-#endif
 
 #if 0 && defined(__GLIBC__)
     //malloc_stats();
@@ -1499,10 +1574,6 @@ int __acc_cdecl_main main(int argc, char *argv[])
     return exit_code;
 }
 
-#endif /* !defined(WITH_GUI) */
-
-
-/*
-vi:ts=4:et:nowrap
-*/
+#endif /* !(WITH_GUI) */
 
+/* vim:set ts=4 sw=4 et: */

src/mem.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -31,40 +31,37 @@
 
 
 /*************************************************************************
-//
+// bool use_simple_mcheck()
 **************************************************************************/
 
-static int use_mcheck = -1;
-
-static int mcheck_init()
+#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()
 {
-    if (use_mcheck < 0)
-    {
-        use_mcheck = 1;
-#if defined(WITH_VALGRIND) && defined(RUNNING_ON_VALGRIND)
-        if (RUNNING_ON_VALGRIND)
-        {
-            //fprintf(stderr, "upx: detected RUNNING_ON_VALGRIND\n");
-            use_mcheck = 0;
-        }
-#endif
+    use_simple_mcheck_flag = 1;
+    if (RUNNING_ON_VALGRIND) {
+        use_simple_mcheck_flag = 0;
+        //fprintf(stderr, "upx: detected RUNNING_ON_VALGRIND\n");
     }
-    return use_mcheck;
 }
+__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() :
-    b(NULL), b_size(0)
-{
-    if (use_mcheck < 0)
-        mcheck_init();
-}
-
-MemBuffer::MemBuffer(unsigned size) :
+MemBuffer::MemBuffer(upx_uint64_t size) :
     b(NULL), b_size(0)
 {
     alloc(size);
@@ -78,10 +75,10 @@ MemBuffer::~MemBuffer()
 
 void MemBuffer::dealloc()
 {
-    if (b)
+    if (b != NULL)
     {
         checkState();
-        if (use_mcheck)
+        if (use_simple_mcheck())
         {
             // remove magic constants
             set_be32(b - 8, 0);
@@ -103,23 +100,19 @@ void MemBuffer::dealloc()
 
 unsigned MemBuffer::getSizeForCompression(unsigned uncompressed_size, unsigned extra)
 {
-    assert((int)uncompressed_size > 0);
-    assert((int)extra >= 0);
-    unsigned size = uncompressed_size + uncompressed_size/8 + 256 + extra;
-    return size;
+    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)
 {
-    assert((int)uncompressed_size > 0);
-    assert((int)extra >= 0);
-    unsigned size = uncompressed_size + extra;
-//    size += 512;   // 512 safety bytes
+    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)
-    size += 3;
+    bytes += 3;
 #endif
-    return size;
+    return ACC_ICONV(unsigned, bytes);
 }
 
 
@@ -154,7 +147,7 @@ void MemBuffer::fill(unsigned off, unsigned len, int value)
 //
 **************************************************************************/
 
-#define PTR(p)      ((unsigned) ((acc_uintptr_t)(p) & 0xffffffff))
+#define PTR(p)      ((unsigned) ((upx_uintptr_t)(p) & 0xffffffff))
 #define MAGIC1(p)   (PTR(p) ^ 0xfefdbeeb)
 #define MAGIC2(p)   (PTR(p) ^ 0xfefdbeeb ^ 0x80024001)
 
@@ -165,7 +158,7 @@ void MemBuffer::checkState() const
 {
     if (!b)
         throwInternalError("block not allocated");
-    if (use_mcheck)
+    if (use_simple_mcheck())
     {
         if (get_be32(b - 4) != MAGIC1(b))
             throwInternalError("memory clobbered before allocated block 1");
@@ -178,27 +171,19 @@ void MemBuffer::checkState() const
 }
 
 
-void MemBuffer::alloc(unsigned size)
+void MemBuffer::alloc(upx_uint64_t size)
 {
-    if (use_mcheck < 0)
-        mcheck_init();
-
     // NOTE: we don't automatically free a used buffer
     assert(b == NULL);
     assert(b_size == 0);
     //
-    assert((int)size > 0);
-    unsigned total = use_mcheck ? size + 32 : size;
-    assert((int)total > 0);
-    unsigned char *p = (unsigned char *) malloc(total);
+    assert(size > 0);
+    size_t bytes = mem_size(1, size, use_simple_mcheck() ? 32 : 0);
+    unsigned char *p = (unsigned char *) malloc(bytes);
     if (!p)
-    {
-        //throw bad_alloc();
-        throw OutOfMemoryException("out of memory");
-        //exit(1);
-    }
-    b_size = size;
-    if (use_mcheck)
+        throwOutOfMemoryException();
+    b_size = ACC_ICONV(unsigned, size);
+    if (use_simple_mcheck())
     {
         b = p + 16;
         // store magic constants to detect buffer overruns
@@ -213,8 +198,4 @@ void MemBuffer::alloc(unsigned size)
     //fill(0, b_size, (rand() & 0xff) | 1); // debug
 }
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/mem.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_MEM_H
-#define __UPX_MEM_H
+#define __UPX_MEM_H 1
 
 
 /*************************************************************************
@@ -37,14 +37,14 @@
 class MemBuffer
 {
 public:
-    MemBuffer();
-    explicit MemBuffer(unsigned size);
+    MemBuffer() : b(NULL), b_size(0) { }
+    explicit MemBuffer(upx_uint64_t size);
     ~MemBuffer();
 
     static unsigned getSizeForCompression(unsigned uncompressed_size, unsigned extra=0);
     static unsigned getSizeForUncompression(unsigned uncompressed_size, unsigned extra=0);
 
-    void alloc(unsigned size);
+    void alloc(upx_uint64_t size);
     void allocForCompression(unsigned uncompressed_size, unsigned extra=0);
     void allocForUncompression(unsigned uncompressed_size, unsigned extra=0);
 
@@ -55,7 +55,8 @@ public:
     unsigned getSize() const { return b_size; }
 
     operator       unsigned char * ()       { return b; }
-    //operator const unsigned char * () const { return b; }
+    operator const unsigned char * () const { return b; }
+
           void *getVoidPtr()                { return (void *) b; }
     const void *getVoidPtr() const          { return (const void *) b; }
 
@@ -79,8 +80,4 @@ private:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/msg.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -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);
 }
@@ -253,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: */

src/mygetopt.cpp

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

src/mygetopt.h

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

src/options.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,12 +22,12 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_OPTIONS_H
-#define __UPX_OPTIONS_H
+#define __UPX_OPTIONS_H 1
 
 
 /*************************************************************************
@@ -45,6 +45,11 @@ enum {
 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;
@@ -58,6 +63,7 @@ struct options_t {
     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
@@ -69,6 +75,9 @@ struct options_t {
     bool no_env;
     bool no_progress;
     const char *output_name;
+    bool preserve_mode;
+    bool preserve_ownership;
+    bool preserve_timestamp;
     int small;
     int verbose;
     bool to_stdout;
@@ -126,7 +135,7 @@ struct options_t {
         bool boot_only;
         bool no_align;
         bool do_8bit;
-        bool do_8mb;
+        bool do_8mib;
     } ps1_exe;
     struct {
         unsigned blocksize;
@@ -134,9 +143,11 @@ struct options_t {
         bool is_ptinterp;           // is PT_INTERP, so don't adjust auxv_t
         bool use_ptinterp;          // use PT_INTERP /opt/upx/run
         bool make_ptinterp;         // make PT_INTERP [ignore current file!]
+        bool unmap_all_pages;       // thus /proc/self/exe vanishes
         unsigned char osabi0;       // replacement if 0==.e_ident[EI_OSABI]
         enum { SCRIPT_MAX = 32 };
         const char *script_name;
+        bool preserve_build_id;     // copy the build-id to the compressed binary
     } o_unix;
     struct {
         bool le;
@@ -158,8 +169,4 @@ extern struct options_t *opt;
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_armpe.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
 #ifndef __UPX_P_ARMPE_H
-#define __UPX_P_ARMPE_H
+#define __UPX_P_ARMPE_H 1
+
 
 /*************************************************************************
 // arm/pe
 **************************************************************************/
 
-class PackArmPe : public PeFile
+class PackArmPe : public PeFile32
 {
-    typedef PeFile super;
+    typedef PeFile32 super;
 
 public:
     PackArmPe(InputFile *f);
@@ -45,19 +46,29 @@ public:
     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,
+                               Reloc &rel, 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();
-    virtual int canUnpack();
 
 protected:
     virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
-    virtual unsigned processImports();
-    virtual void processImports(unsigned, unsigned);
-    virtual void rebuildImports(upx_byte *&);
+    virtual const char *kernelDll() const { return "COREDLL.dll"; }
+    virtual void processImports2(unsigned, unsigned);
+    virtual void addStubImports();
 
     virtual void processTls(Interval *);
 
@@ -67,7 +78,4 @@ protected:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
+/* vim:set ts=4 sw=4 et: */

src/p_com.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -36,7 +36,7 @@
 static const
 #include "stub/i086-dos16.com.h"
 
-//#define TESTING
+//#define TESTING 1
 
 
 /*************************************************************************
@@ -266,8 +266,4 @@ Linker* PackCom::newLinker() const
     return new ElfLinkerX86();
 }
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_com.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   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
 
 
 /*************************************************************************
@@ -42,7 +42,8 @@ public:
     virtual int getVersion() const { return 13; }
     virtual int getFormat() const { return UPX_F_DOS_COM; }
     virtual const char *getName() const { return "dos/com"; }
-    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 *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;
 
@@ -65,8 +66,4 @@ protected:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_djgpp2.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -138,16 +138,16 @@ void PackDjgpp2::handleStub(OutputFile *fo)
 }
 
 
-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);
         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);
@@ -170,9 +170,9 @@ static void handle_allegropak(InputFile *fi, OutputFile *fo)
         if (memcmp(buf, "slh+", 4) != 0)
             return;
         pfsize = get_be32_signed(buf+4);
-        if (pfsize <= 8 || (off_t) pfsize >= (off_t) fi->st.st_size)
+        if (pfsize <= 8 || pfsize >= (off_t) fi->st.st_size)
             return;
-        fi->seek(-pfsize, SEEK_END);
+        fi->seek(-(off_t)pfsize, SEEK_END);
     } catch (const IOException&) {
         return;
     }
@@ -303,7 +303,7 @@ void PackDjgpp2::pack(OutputFile *fo)
     // 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: ~28KB stack
+    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
     compressWithFilters(&ft, 512, &cconf);
 
     // patch coff header #2
@@ -344,7 +344,7 @@ void PackDjgpp2::pack(OutputFile *fo)
 
     // 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);
+    data->size = ALIGN_UP(data->size, 4u);
 
     linker->defineSymbol("DJ2MAIN1", coff_hdr.a_entry);
     relocateLoader();
@@ -469,8 +469,4 @@ void PackDjgpp2::unpack(OutputFile *fo)
         handle_allegropak(fi, fo);
 }
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_djgpp2.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   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
 
 
 /*************************************************************************
@@ -43,7 +43,7 @@ public:
     virtual int getVersion() const { return 14; }
     virtual int getFormat() const { return UPX_F_DJGPP2_COFF; }
     virtual const char *getName() const { return "djgpp2/coff"; }
-    virtual const char *getFullName(const options_t *) const { return "i386-dos32.djgpp2"; }
+    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;
 
@@ -64,21 +64,18 @@ protected:
     virtual void buildLoader(const Filter *ft);
     virtual Linker* newLinker() const;
 
-    long coff_offset;
+    unsigned coff_offset;
 
-    struct external_scnhdr_t
-    {
+    __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
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct coff_header_t
-    {
+    __packed_struct(coff_header_t)
         // ext_file_hdr
         LE16    f_magic;
         LE16    f_nscns;
@@ -99,8 +96,7 @@ protected:
 
         // section headers
         external_scnhdr_t sh[3];
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
     coff_header_t coff_hdr;
     external_scnhdr_t *text,*data,*bss;
@@ -111,8 +107,4 @@ protected:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_elf.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   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
 
 
 /*************************************************************************
@@ -52,8 +52,7 @@ struct ElfITypes
 
 // The ELF file header. This appears at the start of every ELF file.
 template <class TElfITypes>
-struct Ehdr
-{
+__packed_struct(Ehdr)
     typedef typename TElfITypes::Half    Half;
     typedef typename TElfITypes::Word    Word;
     typedef typename TElfITypes::Addr    Addr;
@@ -76,13 +75,11 @@ struct Ehdr
 
 #   define WANT_EHDR_ENUM 1
 #   include "p_elf_enum.h"
-}
-__attribute_packed;
+__packed_struct_end()
 
 
 template <class TElfITypes>
-struct Dyn
-{
+__packed_struct(Dyn)
     typedef typename TElfITypes::Xword   Xword;
     typedef typename TElfITypes::Addr    Addr;
 
@@ -91,13 +88,32 @@ struct Dyn
 
 #   define WANT_DYN_ENUM 1
 #   include "p_elf_enum.h"
-}
-__attribute_packed;
+__packed_struct_end()
 
 
 template <class TElfITypes>
-struct External_Note
-{
+__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'
@@ -105,8 +121,7 @@ struct External_Note
     Word xn_type;
     //char xn_name[N];  // terminate with '\0'
     //char xn_data[M];  // aligned to 0 mod 4
-}
-__attribute_packed;
+__packed_struct_end()
 
 
 } // namespace N_Elf
@@ -119,8 +134,7 @@ __attribute_packed;
 namespace N_Elf32 {
 
 template <class TElfITypes>
-struct Phdr
-{
+__packed_struct(Phdr)
     typedef typename TElfITypes::Word    Word;
     typedef typename TElfITypes::Addr    Addr;
     typedef typename TElfITypes::Off     Off;
@@ -136,13 +150,11 @@ struct Phdr
 
 #   define WANT_PHDR_ENUM 1
 #   include "p_elf_enum.h"
-}
-__attribute_packed;
+__packed_struct_end()
 
 
 template <class TElfITypes>
-struct Shdr
-{
+__packed_struct(Shdr)
     typedef typename TElfITypes::Word    Word;
     typedef typename TElfITypes::Addr    Addr;
     typedef typename TElfITypes::Off     Off;
@@ -160,13 +172,11 @@ struct Shdr
 
 #   define WANT_SHDR_ENUM 1
 #   include "p_elf_enum.h"
-}
-__attribute_packed;
+__packed_struct_end()
 
 
 template <class TElfITypes>
-struct Sym
-{
+__packed_struct(Sym)
     typedef typename TElfITypes::Word    Word;
     typedef typename TElfITypes::Addr    Addr;
     typedef typename TElfITypes::Section Section;
@@ -183,9 +193,9 @@ struct Sym
 
     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 (bind<<4) + (0xf & type); }
-}
-__attribute_packed;
+    static unsigned char make_st_info(unsigned bind, unsigned type)
+        { return (unsigned char) (((bind<<4) + (0xf & type)) & 0xff); }
+__packed_struct_end()
 
 
 } // namespace N_Elf32
@@ -198,8 +208,7 @@ __attribute_packed;
 namespace N_Elf64 {
 
 template <class TElfITypes>
-struct Phdr
-{
+__packed_struct(Phdr)
     typedef typename TElfITypes::Word    Word;
     typedef typename TElfITypes::Xword   Xword;
     typedef typename TElfITypes::Addr    Addr;
@@ -216,13 +225,11 @@ struct Phdr
 
 #   define WANT_PHDR_ENUM 1
 #   include "p_elf_enum.h"
-}
-__attribute_packed;
+__packed_struct_end()
 
 
 template <class TElfITypes>
-struct Shdr
-{
+__packed_struct(Shdr)
     typedef typename TElfITypes::Word    Word;
     typedef typename TElfITypes::Xword   Xword;
     typedef typename TElfITypes::Addr    Addr;
@@ -241,13 +248,11 @@ struct Shdr
 
 #   define WANT_SHDR_ENUM 1
 #   include "p_elf_enum.h"
-}
-__attribute_packed;
+__packed_struct_end()
 
 
 template <class TElfITypes>
-struct Sym
-{
+__packed_struct(Sym)
     typedef typename TElfITypes::Word    Word;
     typedef typename TElfITypes::Xword   Xword;
     typedef typename TElfITypes::Addr    Addr;
@@ -265,9 +270,9 @@ struct Sym
 
     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 (bind<<4) + (0xf & type); }
-}
-__attribute_packed;
+    static unsigned char make_st_info(unsigned bind, unsigned type)
+        { return (unsigned char) (((bind<<4) + (0xf & type)) & 0xff); }
+__packed_struct_end()
 
 
 } // namespace N_Elf64
@@ -284,17 +289,19 @@ struct ElfClass_32
 {
     typedef TP BeLePolicy;
 
-    // integral types
-    typedef typename TP::U16 U16;
-    typedef typename TP::U32 U32;
-    typedef typename TP::U64 U64;
-    typedef N_Elf::ElfITypes<U16, U32, U32, U32, U32> ElfITypes;
+    // 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;
 
@@ -304,11 +311,15 @@ struct ElfClass_32
         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)
     }
 };
@@ -319,17 +330,19 @@ struct ElfClass_64
 {
     typedef TP BeLePolicy;
 
-    // integral types
-    typedef typename TP::U16 U16;
-    typedef typename TP::U32 U32;
-    typedef typename TP::U64 U64;
-    typedef N_Elf::ElfITypes<U16, U32, U64, U64, U64> ElfITypes;
+    // 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;
 
@@ -339,11 +352,15 @@ struct ElfClass_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)
     }
 };
@@ -368,6 +385,8 @@ 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;
 
@@ -375,6 +394,8 @@ 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;
 
@@ -382,6 +403,8 @@ 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;
 
@@ -389,6 +412,8 @@ 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;
 
@@ -396,6 +421,8 @@ 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;
 
@@ -403,14 +430,12 @@ 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;
 
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_elf_enum.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -68,10 +68,13 @@
     };
     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
+
     };
     enum { // e_version
         EV_CURRENT = 1
@@ -138,10 +141,25 @@
     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_STRSZ    = 10        /* Sizeof string 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
 
@@ -179,7 +197,53 @@
 #endif
 
 
-/*
-vi:ts=4:et
-*/
+#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: */

src/p_elks.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -171,9 +171,4 @@ void PackElks8086::unpack(OutputFile *)
 
 #endif /* if 0 */
 
-
-/*
-vi:ts=4:et
-*/
-
-
+/* vim:set ts=4 sw=4 et: */

src/p_exe.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -51,20 +51,21 @@ PackExe::PackExe(InputFile *f) :
     super(f)
 {
     bele = &N_BELE_RTP::le_policy;
-    COMPILE_TIME_ASSERT(sizeof(exe_header_t) == 32);
+    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;
-
-    // disable lzma for "--brute" unless explicitly given "--lzma"
-    if (opt->all_methods_use_lzma && !opt->method_lzma_seen)
-        opt->all_methods_use_lzma = false;
 }
 
 
 const int *PackExe::getCompressionMethods(int method, int level) const
 {
     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);
 }
 
@@ -478,7 +479,7 @@ 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, ih_imagesize, wr, ih.relocs, w, &has_9a);
@@ -506,14 +507,14 @@ void PackExe::pack(OutputFile *fo)
     // 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: ~28KB stack
+    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
     compressWithFilters(&ft, 32, &cconf);
 
     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");
 
-#ifdef TESTING
+#if TESTING
     if (opt->debug.debug_level)
     {
         printf("image+relocs %d -> %d\n",ih_imagesize+relocsize,ph.c_len);
@@ -630,7 +631,7 @@ void PackExe::pack(OutputFile *fo)
 //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 TESTING
     if (opt->debug.debug_level)
         printf("\n%d %d %d %d\n",(int)sizeof(oh),e_len,packedsize,d_len);
 #endif
@@ -869,8 +870,4 @@ DDnneelllCCCCCCCCCCCCCCCCCCCCCCCCC
 
 */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_exe.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   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
 
 
 /*************************************************************************
@@ -42,7 +42,8 @@ public:
     virtual int getVersion() const { return 13; }
     virtual int getFormat() const { return UPX_F_DOS_EXE; }
     virtual const char *getName() const { return "dos/exe"; }
-    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 *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;
 
@@ -73,8 +74,7 @@ protected:
     virtual Linker* newLinker() const;
     void addLoaderEpilogue(int flag);
 
-    struct exe_header_t
-    {
+    __packed_struct(exe_header_t)
         LE16 ident;
         LE16 m512;
         LE16 p512;
@@ -90,8 +90,7 @@ protected:
         LE16 relocoffs;
         char __[2];             // overlnum
         LE32 firstreloc;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
     exe_header_t ih, oh;
 
@@ -119,8 +118,4 @@ protected:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_lx_elf.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2000-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2000-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -31,7 +31,7 @@
 
 
 #ifndef __UPX_P_LX_ELF_H  //{
-#define __UPX_P_LX_ELF_H
+#define __UPX_P_LX_ELF_H 1
 
 
 class PackLinuxElf : public PackUnix
@@ -50,7 +50,7 @@ protected:
     // because they depend on Elf32 or Elf64 data structures, which differ.
 
     virtual void pack1(OutputFile *, Filter &) = 0;  // generate executable header
-    virtual void pack2(OutputFile *, Filter &) = 0;  // append compressed data
+    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
 
@@ -61,21 +61,42 @@ protected:
     ) = 0;
     virtual void defineSymbols(Filter const *);
     virtual void addStubEntrySections(Filter const *);
-    virtual void unpack(OutputFile *fo) = 0;
+    virtual void unpack(OutputFile *fo);
+
+    //virtual void const *elf_find_dynamic(unsigned) const = 0;
+    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:
-    char       *file_image;       // if ET_DYN investigation
+    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
+    unsigned 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
 
-    unsigned short e_machine;
+    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
@@ -85,6 +106,7 @@ public:
     PackLinuxElf32(InputFile *f);
     virtual ~PackLinuxElf32();
 protected:
+    virtual void PackLinuxElf32help1(InputFile *f);
     virtual int checkEhdr(Elf32_Ehdr const *ehdr) const;
     virtual bool canPack();
 
@@ -92,9 +114,10 @@ protected:
     // 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 void pack2(OutputFile *, Filter &);  // append compressed data
+    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);
@@ -118,57 +141,83 @@ protected:
         unsigned const e_phnum);
     virtual off_t getbase(const Elf32_Phdr *phdr, int e_phnum) const;
 
-    static unsigned elf_hash(char const *) /*const*/;
-    virtual void const *elf_find_dynamic(unsigned) const;
     virtual Elf32_Sym const *elf_lookup(char const *) const;
     virtual unsigned elf_get_offset_from_address(unsigned) const;
+    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;
+    upx_uint64_t elf_unsigned_dynamic(unsigned) const;
 
 protected:
     Elf32_Ehdr  ehdri; // from input file
     Elf32_Phdr *phdri; // for  input file
+    unsigned e_phoff;
+    unsigned e_shoff;
+    unsigned char *note_body;  // concatenated contents of PT_NOTEs, if any
+    unsigned note_size;  // total size of PT_NOTEs
+    Elf32_Shdr const *shdri; // from input file
+    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
 
-    struct cprElfHdr1 {
+    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;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct cprElfHdr2 {
+    __packed_struct(cprElfHdr2)
         Elf32_Ehdr ehdr;
         Elf32_Phdr phdr[2];
         l_info linfo;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct cprElfHdr3 {
+    __packed_struct(cprElfHdr3)
         Elf32_Ehdr ehdr;
         Elf32_Phdr phdr[3];
         l_info linfo;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    cprElfHdr3 elfout;
+    __packed_struct(cprElfHdrNetBSD)
+        Elf32_Ehdr ehdr;
+        Elf32_Phdr phdr[4];
+        unsigned char notes[512];
+    __packed_struct_end()
 
-    struct Elf32_Note {
-        unsigned namesz;  // 8
-        unsigned descsz;  // 4
-        unsigned type;    // 1
-        char text[0x18 - 4*4];  // "OpenBSD"
-        unsigned end;     // 0
-    } elfnote;
+    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)
     }
 };
 
@@ -182,10 +231,11 @@ public:
     /*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 void pack2(OutputFile *, Filter &);  // append compressed data
+    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);
@@ -208,40 +258,76 @@ protected:
     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_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;
+    upx_uint64_t elf_unsigned_dynamic(unsigned) const;
+
 protected:
     Elf64_Ehdr  ehdri; // from input file
     Elf64_Phdr *phdri; // for  input file
+    upx_uint64_t e_phoff;
+    upx_uint64_t e_shoff;
+    unsigned char *note_body;  // concatenated contents of PT_NOTEs, if any
+    unsigned note_size;  // total size of PT_NOTEs
+    Elf64_Shdr const *shdri; // from input file
+    upx_uint64_t page_mask;  // AND clears the offset-within-page
 
-    struct cprElfHdr1 {
+    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;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct cprElfHdr2 {
+    __packed_struct(cprElfHdr2)
         Elf64_Ehdr ehdr;
         Elf64_Phdr phdr[2];
         l_info linfo;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct cprElfHdr3 {
+    __packed_struct(cprElfHdr3)
         Elf64_Ehdr ehdr;
         Elf64_Phdr phdr[3];
         l_info linfo;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    cprElfHdr3 elfout;
+    __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)
     }
 };
 
@@ -249,44 +335,35 @@ class PackLinuxElf32Be : public PackLinuxElf32
 {
     typedef PackLinuxElf32 super;
 protected:
-    PackLinuxElf32Be(InputFile *f) : super(f) { bele = &N_BELE_RTP::be_policy; }
-
-    virtual acc_uint64l_t get_native64(const void *b) const { return get_be64(b); }
-    virtual unsigned get_native32(const void *b) const { return get_be32(b); }
-    virtual unsigned get_native16(const void *b) const { return get_be16(b); }
-    virtual void set_native64(void *b, acc_uint64l_t v) const { set_be64(b, v); }
-    virtual void set_native32(void *b, unsigned v) const { set_be32(b, v); }
-    virtual void set_native16(void *b, unsigned v) const { set_be16(b, v); }
+    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; }
-
-    virtual acc_uint64l_t get_native64(const void *b) const { return get_le64(b); }
-    virtual unsigned get_native32(const void *b) const { return get_le32(b); }
-    virtual unsigned get_native16(const void *b) const { return get_le16(b); }
-    virtual void set_native64(void *b, acc_uint64l_t v) const { set_le64(b, v); }
-    virtual void set_native32(void *b, unsigned v) const { set_le32(b, v); }
-    virtual void set_native16(void *b, unsigned v) const { set_le16(b, v); }
+    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) { bele = &N_BELE_RTP::le_policy; }
-
-    virtual acc_uint64l_t get_native64(const void *b) const { return get_le64(b); }
-    virtual unsigned get_native32(const void *b) const { return get_le32(b); }
-    virtual unsigned get_native16(const void *b) const { return get_le16(b); }
-    virtual void set_native64(void *b, acc_uint64l_t v) const { set_le64(b, v); }
-    virtual void set_native32(void *b, unsigned v) const { set_le32(b, v); }
-    virtual void set_native16(void *b, unsigned v) const { set_le16(b, v); }
+    PackLinuxElf64Le(InputFile *f) : super(f) {
+        lg2_page=16;
+        page_size=1u<<lg2_page;
+        bele = &N_BELE_RTP::le_policy;
+        PackLinuxElf64help1(f);
+    }
 };
 
+
 /*************************************************************************
 // linux/elf64amd
 **************************************************************************/
@@ -298,7 +375,7 @@ public:
     PackLinuxElf64amd(InputFile *f);
     virtual ~PackLinuxElf64amd();
     virtual int getFormat() const { return UPX_F_LINUX_ELF64_AMD; }
-    virtual const char *getName() const { return "linux/ElfAMD"; }
+    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();
@@ -310,6 +387,7 @@ protected:
     virtual void defineSymbols(Filter const *);
 };
 
+
 /*************************************************************************
 // linux/elf32ppc
 **************************************************************************/
@@ -321,7 +399,7 @@ public:
     PackLinuxElf32ppc(InputFile *f);
     virtual ~PackLinuxElf32ppc();
     virtual int getFormat() const { return UPX_F_LINUX_ELFPPC32; }
-    virtual const char *getName() const { return "linux/ElfPPC"; }
+    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:
@@ -330,6 +408,30 @@ protected:
     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
 **************************************************************************/
@@ -341,12 +443,10 @@ public:
     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 char *getName() const { return "linux/i386"; }
     virtual const char *getFullName(const options_t *) const { return "i386-linux.elf"; }
     virtual const int *getFilters() const;
 
-    virtual void unpack(OutputFile *fo);
-
 protected:
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
 
@@ -362,8 +462,9 @@ class PackBSDElf32x86 : public PackLinuxElf32x86
 public:
     PackBSDElf32x86(InputFile *f);
     virtual ~PackBSDElf32x86();
-    virtual int getFormat() const { return UPX_F_BSD_ELF_i386; }
-    virtual const char *getName() const { return "BSD/elf386"; }
+    virtual int getFormat() const = 0;
+    virtual const char *getName() const = 0;
+    virtual const char *getFullName(const options_t *) const = 0;
 
 protected:
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
@@ -377,16 +478,27 @@ class PackFreeBSDElf32x86 : public PackBSDElf32x86
 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 PackBSDElf32x86
+class PackNetBSDElf32x86 : public PackLinuxElf32x86
 {
-    typedef PackBSDElf32x86 super;
+    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
@@ -395,6 +507,8 @@ class PackOpenBSDElf32x86 : public PackBSDElf32x86
 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:
@@ -406,6 +520,7 @@ protected:
     );
 };
 
+
 /*************************************************************************
 // linux/elfarm
 **************************************************************************/
@@ -417,7 +532,7 @@ public:
     PackLinuxElf32armLe(InputFile *f);
     virtual ~PackLinuxElf32armLe();
     virtual int getFormat() const { return UPX_F_LINUX_ELF32_ARMEL; }
-    virtual const char *getName() const { return "linux/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;
 
@@ -450,10 +565,45 @@ protected:
     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: */

src/p_lx_exc.cpp

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2001-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2001-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -132,8 +132,8 @@ PackLinuxI386::generateElfHdr(
     unsigned const brka
 )
 {
-    cprElfHdr2 *const h2 = (cprElfHdr2 *)&elfout;
-    cprElfHdr3 *const h3 = (cprElfHdr3 *)&elfout;
+    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));
@@ -375,7 +375,7 @@ PackLinuxI386::buildLinuxLoader(
     addLoader("FOLDEXEC", NULL);
     if (M_IS_LZMA(ph.method)) {
         const lzma_compress_result_t *res = &ph.compress_result.result_lzma;
-        acc_uint32e_t properties = // lc, lp, pb, dummy
+        upx_uint32_t properties = // lc, lp, pb, dummy
             (res->lit_context_bits << 0) |
             (res->lit_pos_bits << 8) |
             (res->pos_bits << 16);
@@ -449,7 +449,7 @@ int PackLinuxI386::getLoaderPrefixSize() const
 // some ELF utitlity functions
 **************************************************************************/
 
-// basic check of an Linux ELF Ehdr
+// basic check of a Linux ELF Ehdr
 int PackLinuxI386::checkEhdr(const Elf_LE32_Ehdr *ehdr) const
 {
     const unsigned char * const buf = ehdr->e_ident;
@@ -526,28 +526,31 @@ bool PackLinuxI386::canPack()
                 ei_osabi = osabi0;  // Proudly declares its osabi in Ehdr.
                 break;
             default:
-            unsigned const e_phnum = get_native16(&ehdr.e_phnum);
+            unsigned const e_phnum = get_te16(&ehdr.e_phnum);
             if (e_phnum<=(512/sizeof(Elf32_Phdr))) {
-                char buf2[512];
-                fi->seek(get_native32(&ehdr.e_phoff), SEEK_SET);
-                fi->readx(buf2, sizeof(buf2));
+                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 const *)buf2;
+                Elf32_Phdr const *phdr = (Elf32_Phdr *) u.buf2;
                 for (unsigned j=0; j < e_phnum; ++phdr, ++j) {
-                    if (phdr->PT_NOTE == get_native32(&phdr->p_type)) {
-                        unsigned const offset = get_native32(&phdr->p_offset);
+                    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_native32(&note.descsz)
-                        &&  1==get_native32(&note.type)
+                        if (4==get_te32(&note.descsz)
+                        &&  1==get_te32(&note.type)
                         &&  0==note.end ) {
-                            if (0==strcmp("NetBSD", (char const *)&note.text)) {
+                            if (0==strcmp("NetBSD", (char const *)note.text)) {
                                 ei_osabi = Elf32_Ehdr::ELFOSABI_NETBSD;
                                 break;
                             }
-                            if (0==strcmp("OpenBSD", (char const *)&note.text)) {
+                            if (0==strcmp("OpenBSD", (char const *)note.text)) {
                                 ei_osabi = Elf32_Ehdr::ELFOSABI_OPENBSD;
                                 break;
                             }
@@ -598,11 +601,11 @@ void PackLinuxI386::patchLoaderChecksum()
     // checksum for loader + p_info
     lp->l_checksum = 0;
     lp->l_magic = UPX_ELF_MAGIC;
-    lp->l_lsize = (unsigned short) lsize;
+    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
-    lp->l_checksum = upx_adler32(ptr, lsize);
+    set_te32(&lp->l_checksum, upx_adler32(ptr, lsize));
 }
 
 
@@ -611,8 +614,4 @@ void PackLinuxI386::updateLoader(OutputFile *fo)
     elfout.ehdr.e_entry = fo->getBytesWritten() + elfout.phdr[0].p_vaddr;
 }
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_lx_exc.h

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -22,7 +22,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -30,7 +30,7 @@
 
 
 #ifndef __UPX_P_LX_EXC_H
-#define __UPX_P_LX_EXC_H
+#define __UPX_P_LX_EXC_H 1
 
 
 /*************************************************************************
@@ -48,7 +48,7 @@ public:
         unsigned const brka
     );
     virtual int getFormat() const { return UPX_F_LINUX_i386; }
-    virtual const char *getName() const { return "linux/386"; }
+    virtual const char *getName() const { return "linux.exec/i386"; }
     virtual const char *getFullName(const options_t *) const { return "i386-linux.elf.execve"; }
     virtual const int *getCompressionMethods(int method, int level) const;
     virtual const int *getFilters() const;
@@ -87,26 +87,23 @@ protected:
 
     unsigned n_mru;
 
-    struct cprElfHdr1 {
+    __packed_struct(cprElfHdr1)
         Elf_LE32_Ehdr ehdr;
         Elf_LE32_Phdr phdr[1];
         l_info linfo;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct cprElfHdr2 {
+    __packed_struct(cprElfHdr2)
         Elf_LE32_Ehdr ehdr;
         Elf_LE32_Phdr phdr[2];
         l_info linfo;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct cprElfHdr3 {
+    __packed_struct(cprElfHdr3)
         Elf_LE32_Ehdr ehdr;
         Elf_LE32_Phdr phdr[3];
         l_info linfo;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
     cprElfHdr3 elfout;
 
@@ -138,7 +135,7 @@ class PackBSDI386 : public PackLinuxI386
 public:
     PackBSDI386(InputFile *f);
     virtual int getFormat() const { return UPX_F_BSD_i386; }
-    virtual const char *getName() const { return "*BSD/386"; }
+    virtual const char *getName() const { return "bsd.exec/i386"; }
     virtual const char *getFullName(const options_t *) const { return "i386-bsd.elf.execve"; }
 
 protected:
@@ -148,8 +145,4 @@ protected:
 };
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_lx_interp.cpp

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2000-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2000-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -114,7 +114,7 @@ void PackLinuxElf32x86interp::pack1(OutputFile *fo, Filter &)
     h3.phdr[2].p_align = 1;
 
     if (opt->o_unix.make_ptinterp) { // unusual "once per release"
-        elfout = h3;
+        *(cprElfHdr3 *)(void *)&elfout = h3;
         elfout.ehdr.e_phnum = 1;
         fo->write(&elfout, elfout.ehdr.e_ehsize + elfout.ehdr.e_phentsize);
     }
@@ -124,12 +124,12 @@ void PackLinuxElf32x86interp::pack1(OutputFile *fo, Filter &)
 #undef E
 }
 
-void PackLinuxElf32x86interp::pack2(OutputFile *fo, Filter &ft)
+int PackLinuxElf32x86interp::pack2(OutputFile *fo, Filter &ft)
 {
     if (opt->o_unix.make_ptinterp) {
-        return;  // ignore current input file!
+        return 1;  // ignore current input file!
     }
-    super::pack2(fo, ft);
+    return super::pack2(fo, ft);
 }
 
 #undef PAGE_MASK
@@ -197,15 +197,18 @@ void PackLinuxElf32x86interp::pack3(OutputFile *fo, Filter &/*ft*/)
 void PackLinuxElf32x86interp::unpack(OutputFile *fo)
 {
 #define MAX_INTERP_HDR 512
-    char bufehdr[MAX_INTERP_HDR];
-    Elf32_Ehdr *const ehdr = (Elf32_Ehdr *)bufehdr;
-    Elf32_Phdr const *phdr = (Elf32_Phdr *)(1+ehdr);
+    union {
+        unsigned char buf[MAX_INTERP_HDR];
+        //struct { Elf32_Ehdr ehdr; Elf32_Phdr phdr; } e;
+    } u;
+    Elf32_Ehdr *const ehdr = (Elf32_Ehdr *) u.buf;
+    Elf32_Phdr const *phdr = (Elf32_Phdr *) (u.buf + sizeof(*ehdr));
 
     unsigned szb_info = sizeof(b_info);
     {
         fi->seek(0, SEEK_SET);
-        fi->readx(bufehdr, MAX_INTERP_HDR);
-        unsigned const e_entry = get_native32(&ehdr->e_entry);
+        fi->readx(u.buf, MAX_INTERP_HDR);
+        unsigned const e_entry = get_te32(&ehdr->e_entry);
         if (e_entry < 0x401180) { /* old style, 8-byte b_info */
             szb_info = 2*sizeof(unsigned);
         }
@@ -214,16 +217,16 @@ void PackLinuxElf32x86interp::unpack(OutputFile *fo)
     fi->seek(overlay_offset, SEEK_SET);
     p_info hbuf;
     fi->readx(&hbuf, sizeof(hbuf));
-    unsigned orig_file_size = get_native32(&hbuf.p_filesize);
-    blocksize = get_native32(&hbuf.p_blocksize);
+    unsigned orig_file_size = get_te32(&hbuf.p_filesize);
+    blocksize = get_te32(&hbuf.p_blocksize);
     if (file_size > (off_t)orig_file_size || blocksize > orig_file_size)
         throwCantUnpack("file header corrupted");
 
     ibuf.alloc(blocksize + OVERHEAD);
     b_info bhdr; memset(&bhdr, 0, sizeof(bhdr));
     fi->readx(&bhdr, szb_info);
-    ph.u_len = get_native32(&bhdr.sz_unc);
-    ph.c_len = get_native32(&bhdr.sz_cpr);
+    ph.u_len = get_te32(&bhdr.sz_unc);
+    ph.c_len = get_te32(&bhdr.sz_cpr);
     ph.filter_cto = bhdr.b_cto8;
 
     // Uncompress Ehdr and Phdrs.
@@ -277,7 +280,7 @@ void PackLinuxElf32x86interp::unpack(OutputFile *fo)
 
     // check for end-of-file
     fi->readx(&bhdr, szb_info);
-    unsigned const sz_unc = ph.u_len = get_native32(&bhdr.sz_unc);
+    unsigned const sz_unc = ph.u_len = get_te32(&bhdr.sz_unc);
 
     if (sz_unc == 0) { // uncompressed size 0 -> EOF
         // note: magic is always stored le32
@@ -303,8 +306,4 @@ void PackLinuxElf32x86interp::unpack(OutputFile *fo)
 #undef MAX_INTERP_HDR
 }
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_lx_interp.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2000-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2000-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -31,7 +31,7 @@
 
 
 #ifndef __UPX_P_LX_INTERP_H  //{
-#define __UPX_P_LX_INTERP_H
+#define __UPX_P_LX_INTERP_H 1
 
 
 /*************************************************************************
@@ -54,15 +54,11 @@ public:
 
 protected:
     virtual void pack1(OutputFile *, Filter &);  // generate executable header
-    virtual void pack2(OutputFile *, Filter &);  // append compressed data
+    virtual int  pack2(OutputFile *, Filter &);  // append compressed data
     virtual void pack3(OutputFile *, Filter &);  // build loader
 };
 
 
 #endif /*} already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_lx_sh.cpp

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2000-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2000-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -91,7 +91,7 @@ PackLinuxI386sh::buildLoader(Filter const *ft)
     // filter
     optimizeFilter(&fold_ft, buf, sz_fold);
     unsigned fold_hdrlen = sizeof(l_info) + sizeof(Elf32_Ehdr) +
-        sizeof(Elf32_Phdr) * get_native32(&((Elf32_Ehdr const *)(void *)buf)->e_phnum);
+        sizeof(Elf32_Phdr) * get_te32(&((Elf32_Ehdr const *)(void *)buf)->e_phnum);
     if (0 == get_le32(fold_hdrlen + buf)) {
         // inconsistent SIZEOF_HEADERS in *.lds (ld, binutils)
         fold_hdrlen = umax(0x80, fold_hdrlen);
@@ -168,7 +168,4 @@ PackLinuxI386sh::pack3(OutputFile *fo, Filter &ft)
     elfout.phdr[0].p_filesz = fo->getBytesWritten();
 }
 
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_lx_sh.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2000-2007 John F. Reiser
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2000-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    John F. Reiser
    <jreiser@users.sourceforge.net>
@@ -31,7 +31,7 @@
 
 
 #ifndef __UPX_P_LX_SH_H  //{
-#define __UPX_P_LX_SH_H
+#define __UPX_P_LX_SH_H 1
 
 
 /*************************************************************************
@@ -46,7 +46,7 @@ public:
     virtual ~PackLinuxI386sh();
     virtual int getVersion() const { return 13; }
     virtual int getFormat() const { return UPX_F_LINUX_SH_i386; }
-    virtual const char *getName() const { return "linux/sh386"; }
+    virtual const char *getName() const { return "linux.sh/i386"; }
     virtual const char *getFullName(const options_t *) const { return "i386-linux.elf.shell"; }
     virtual const int *getFilters() const { return NULL; }
     virtual void buildLoader(const Filter *);
@@ -71,8 +71,4 @@ protected:
 
 #endif /*} already included */
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_mach_enum.h

@@ -2,7 +2,7 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 2007 John F. Reiser
+   Copyright (C) 2007-2016 John F. Reiser
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -40,25 +40,61 @@
     };
     enum { // cputype
         CPU_TYPE_I386      =          7,
+        CPU_TYPE_X86_64    = 0x01000007,
+        CPU_TYPE_ARM       =         12,
         CPU_TYPE_POWERPC   = 0x00000012,
-        CPU_TYPE_POWERPC64 = 0x01000012
+        CPU_TYPE_POWERPC64 = 0x01000012,
+        CPU_TYPE_POWERPC64LE = 0x01000021
+    };
+    enum { // cpusubtype
+        CPU_SUBTYPE_ARM_ALL = 0,
+        CPU_SUBTYPE_ARM_V4T = 5,
+        CPU_SUBTYPE_ARM_V6  = 6
     };
     enum { // filetype
-        MH_EXECUTE = 2
+        MH_EXECUTE = 2,
+        MH_DYLIB   = 6,
+        MH_BUNDLE  = 8      /* dynamically bound bundle file */
     };
     enum { // flags
-        MH_NOUNDEFS = 1
+        MH_NOUNDEFS = 1,
+        MH_DYLDLINK = 4,    /* code signing demands this */
+        MH_BINDATLOAD = 0x8,   // DT_BIND_NOW
+        MH_TWOLEVEL = 0x80,
+        MH_PIE      = 0x200000   // ASLR
     };
 #endif  /*}*/
 
 #ifdef WANT_MACH_SEGMENT_ENUM  /*{*/
 #undef WANT_MACH_SEGMENT_ENUM
     enum { // cmd
+        LC_REQ_DYLD      = 0x80000000,  // OR'ed ==> must not ignore
         LC_SEGMENT       = 0x1,
+        LC_SYMTAB        = 0x2,
         LC_THREAD        = 0x4,
         LC_UNIXTHREAD    = 0x5,
+        LC_DYSYMTAB      = 0xb,
+        LC_LOAD_DYLIB    = 0xc,
+        LC_ID_DYLIB      = 0xd,
         LC_LOAD_DYLINKER = 0xe,
-        LC_SEGMENT_64    = 0x19
+        LC_ROUTINES      = 0x11,
+        LC_TWOLEVEL_HINTS= 0x16,
+        LC_SEGMENT_64    = 0x19,
+        LC_ROUTINES_64   = 0x1a,
+        LC_UUID          = 0x1b,
+        LC_RPATH         = 0x1c,
+        LC_CODE_SIGNATURE = 0x1d,
+        LC_SEGMENT_SPLIT_INFO = 0x1e,
+        LC_REEXPORT_DYLIB = 0x1f,
+        LC_LAZY_LOAD_DYLIB= 0x20,
+        LC_ENCRYPTION_INFO= 0x21,
+        LC_DYLD_INFO      = 0x22,  // compressed dyld information (10.6.x)
+        LC_DYLD_INFO_ONLY = (0x22|LC_REQ_DYLD),
+        LC_VERSION_MIN_MACOSX= 0x24,
+        LC_FUNCTION_STARTS= 0x26,
+        LC_MAIN           = (0x28|LC_REQ_DYLD),
+        LC_DATA_IN_CODE   = 0x29,
+        LC_SOURCE_VERSION = 0x2a,
     };
     enum { // maxprot
         VM_PROT_READ = 1,
@@ -69,24 +105,32 @@
 
 #ifdef WANT_MACH_SECTION_ENUM  /*{*/
 #undef WANT_MACH_SECTION_ENUM
-    enum { // section flags
+    enum { // section type  (low byte only)
         S_REGULAR = 0,
         S_ZEROFILL,
         S_CSTRING_LITERALS,
         S_4BYTE_LITERALS,
         S_8BYTE_LITERALS,
         S_LITERAL_POINTERS,
-        S_NON_LAZY_SYMBOL_POINTERS,
-        S_LAZY_SYMBOL_POINTERS,
+        S_NON_LAZY_SYMBOL_POINTERS,  // sectname __nl_symbol_ptr
+        S_LAZY_SYMBOL_POINTERS,      // sectname __la_symbol_ptr
         S_SYMBOL_STUBS,
-        S_MOD_INIT_FUNC_POINTERS,
-        S_MOD_TERM_FNC_POINTERS,
-        S_COALESCED
+        S_MOD_INIT_FUNC_POINTERS,    // sectname __mod_init_func
+        S_MOD_TERM_FUNC_POINTERS,
+        S_COALESCED,
+        S_GB_ZEROFILL,
+        S_INTERPOSING,
+        S_16BYTE_LITERALS,
+        S_DTRACE_DOF
     };
-    enum {
+    enum { // section flags (high 24 bits)
         S_ATTR_PURE_INSTRUCTIONS = 0x80000000,
         S_ATTR_NO_TOC            = 0x40000000,
         S_ATTR_STRIP_STATIC_SYMS = 0x20000000,
+        S_ATTR_NO_DEAD_STRIP     = 0x10000000,
+        S_ATTR_LIVE_SUPPORT      = 0x08000000,
+        S_ATTR_SELF_MODIFYING_CODE = 0x04000000,
+        S_ATTR_DEBUG             = 0x02000000,
         S_ATTR_SOME_INSTRUCTIONS = 0x00000400,
         S_ATTR_EXT_RELOC         = 0x00000200,
         S_ATTR_LOC_RELOC         = 0x00000100
@@ -97,12 +141,12 @@
 #undef WANT_MACH_THREAD_ENUM
     enum { // thread flavor
         PPC_THREAD_STATE = 1,
-        i386_THREAD_STATE = 1,
-        i386_OLD_THREAD_STATE = -1
+        PPC_THREAD_STATE64 = 5,
+        x86_THREAD_STATE32 = 1,
+        x86_THREAD_STATE64 = 4,
+        i386_OLD_THREAD_STATE = -1,
+        ARM_THREAD_STATE = 1
     };
 #endif  /*}*/
 
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */

src/p_ps1.cpp

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2002-2007 Jens Medoch
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2002-2016 Jens Medoch
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    Jens Medoch
    <jssg@users.sourceforge.net>
@@ -95,7 +95,7 @@ PackPs1::PackPs1(InputFile *f) :
     COMPILE_TIME_ASSERT(SZ_IH_BKUP == 40)
 
     fdata_size = file_size - PS_HDR_SIZE;
-    ram_size = !opt->ps1_exe.do_8mb ? 0x200000 : 0x800000;
+    ram_size = !opt->ps1_exe.do_8mib ? 0x200000 : 0x800000;
 }
 
 const int *PackPs1::getCompressionMethods(int method, int level) const
@@ -127,8 +127,8 @@ int PackPs1::readFileHeader()
 {
     fi->seek(0, SEEK_SET);
     fi->readx(&ih, sizeof(ih));
-    if (memcmp(&ih.id, "PS-X EXE", 8) != 0 &&
-        memcmp(&ih.id, "EXE X-SP", 8) != 0)
+    if (memcmp(&ih.id[0], "PS-X EXE", 8) != 0 &&
+        memcmp(&ih.id[0], "EXE X-SP", 8) != 0)
         return 0;
     if (ih.text != 0 || ih.data != 0)
         return 0;
@@ -194,6 +194,8 @@ bool PackPs1::getBkupHeader(unsigned char *p, unsigned char *dst)
         unsigned sz_bh = SZ_IH_BKUP;
         int r = upx_decompress((const unsigned char *)&src->ih_bkup, src->len,
                                unc_bh, &sz_bh, M_NRV2E_8, NULL );
+        if (r == UPX_E_OUT_OF_MEMORY)
+            throwOutOfMemoryException();
         if (r != UPX_E_OK || sz_bh != SZ_IH_BKUP)
             throwInternalError("header decompression failed");
         unsigned ad = upx_adler32(unc_bh, SZ_IH_BKUP);
@@ -254,8 +256,9 @@ bool PackPs1::canPack()
     fi->readx(buf, sizeof(buf));
     checkAlreadyPacked(buf, sizeof(buf));
 
-    for (unsigned i = 0; i < sizeof(buf); i++)
+    for (size_t i = 0; i < sizeof(buf); i++)
         if (buf[i] != 0)
+        {
             if (!opt->force)
                 throwCantPack("unknown data in header (try --force)");
             else
@@ -265,6 +268,7 @@ bool PackPs1::canPack()
                 opt->backup = 1;
                 break;
             }
+        }
     if (!checkFileHeader())
         throwCantPack("unsupported header flags (try --force)");
     if (!opt->force && file_size < PS_MIN_SIZE)
@@ -318,7 +322,7 @@ void PackPs1::buildLoader(const Filter *)
             sa_tmp += overlap = ALIGN_UP((ph.overlap_overhead - sa_tmp), 4u);
     }
 
-    if (isCon || !isCon && M_IS_LZMA(ph.method))
+    if (isCon || M_IS_LZMA(ph.method))
         foundBss = findBssSection();
 
     if (M_IS_LZMA(ph.method) && !buildPart2)
@@ -414,7 +418,7 @@ void PackPs1::buildLoader(const Filter *)
 bool PackPs1::findBssSection()
 {
     unsigned char reg;
-    LE32 *p1 = (LE32 *)(ibuf + (ih.epc - ih.tx_ptr));
+    const LE32 * const p1 = ACC_CCAST(const LE32 *, ibuf + (ih.epc - ih.tx_ptr));
 
     if ((ih.epc - ih.tx_ptr + (BSS_CHK_LIMIT * 4)) > fdata_size)
         return false;
@@ -422,15 +426,15 @@ bool PackPs1::findBssSection()
     // check 18 opcodes for sw zero,0(x)
     for (signed i = BSS_CHK_LIMIT; i >= 0; i--)
     {
-        unsigned short op = p1[i] >> 16;
+        upx_uint16_t op = p1[i] >> 16;
         if (IS_SW_ZERO(op))
         {
             // found! get reg (x) for bss_start
             reg = REG1(op);
             for (; i >= 0; i--)
             {
-                bss_nfo *p = (bss_nfo *)&p1[i];
-                unsigned short op1 = p->op1, op2 = p->op2;
+                const bss_nfo * const p = ACC_CCAST(const bss_nfo *, &p1[i]);
+                upx_uint16_t op1 = p->op1, op2 = p->op2;
 
                 // check for la (x),bss_start
                 if ((IS_LUI(op1) && REG2(op1) == reg) &&
@@ -496,7 +500,7 @@ void PackPs1::pack(OutputFile *fo)
     // compress (max_match = 65535)
     upx_compress_config_t cconf; cconf.reset();
     cconf.conf_ucl.max_match = 65535;
-    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28KB stack
+    cconf.conf_lzma.max_num_probs = 1846 + (768 << 4); // ushort: ~28 KiB stack
     compressWithFilters(&ft, sa_cnt, &cconf);
 
     if (overlap)
@@ -543,7 +547,7 @@ void PackPs1::pack(OutputFile *fo)
 
     const int lsize = getLoaderSize();
 
-    unsigned filelen = ALIGN_UP(ih.tx_len, 4);
+    unsigned filelen = ALIGN_UP(ih.tx_len, 4u);
 
     const unsigned decomp_data_start = ih.tx_ptr;
     const unsigned comp_data_start = (decomp_data_start + filelen + overlap) - ph.c_len;
@@ -572,11 +576,13 @@ void PackPs1::pack(OutputFile *fo)
     linker->defineSymbol("ldr_sz", M_IS_LZMA(ph.method) ? sz_lunc + 16 : (d_len-pad_code));
 
     if (foundBss)
+    {
         if (M_IS_LZMA(ph.method))
             linker->defineSymbol("wrkmem", bss_end - 160 - getDecompressorWrkmemSize()
                                            - (sz_lunc + 16));
         else
             linker->defineSymbol("wrkmem", bss_end - 16 - (d_len - pad_code));
+    }
 
 
     const unsigned entry = comp_data_start - e_len;
@@ -588,7 +594,7 @@ void PackPs1::pack(OutputFile *fo)
     if (!opt->ps1_exe.no_align || !isCon)
     {
         pad = oh.tx_len;
-        oh.tx_len = ALIGN_UP(oh.tx_len, CD_SEC);
+        oh.tx_len = ALIGN_UP(oh.tx_len, CD_SEC+0u);
         pad = oh.tx_len - pad;
         oh.tx_ptr -= pad;
     }
@@ -732,7 +738,4 @@ void PackPs1::unpack(OutputFile *fo)
     }
 }
 
-
-/*
-vi:ts=4:et:nowrap
-*/
+/* vim:set ts=4 sw=4 et: */

src/p_ps1.h

@@ -2,9 +2,9 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
-   Copyright (C) 2002-2007 Jens Medoch
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 Laszlo Molnar
+   Copyright (C) 2002-2016 Jens Medoch
    All Rights Reserved.
 
    UPX and the UCL library are free software; you can redistribute them
@@ -23,7 +23,7 @@
    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
    Markus F.X.J. Oberhumer              Laszlo Molnar
-   <mfx@users.sourceforge.net>          <ml1050@users.sourceforge.net>
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
 
    Jens Medoch
    <jssg@users.sourceforge.net>
@@ -31,7 +31,7 @@
 
 
 #ifndef __UPX_P_PS1_H
-#define __UPX_P_PS1_H
+#define __UPX_P_PS1_H 1
 
 
 /*************************************************************************
@@ -67,8 +67,7 @@ protected:
     virtual int readFileHeader();
     virtual bool checkFileHeader();
 
-    struct ps1_exe_t
-    {
+    __packed_struct(ps1_exe_t)
         // ident string
         char id[8];
         // is NULL
@@ -91,33 +90,26 @@ protected:
         char origin[60];
         // backup of the original header (epc - is_len)
         // id & the upx header ...
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
     // for unpack
-    struct ps1_exe_hb_t
-    {
+    __packed_struct(ps1_exe_hb_t)
         LE32 ih_bkup[10];
         // plus checksum for the backup
         LE32 ih_csum;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct ps1_exe_chb_t
-    {
+    __packed_struct(ps1_exe_chb_t)
         unsigned char id;
         unsigned char len;
         LE16          ih_csum;
         unsigned char ih_bkup;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
-    struct bss_nfo
-    {
+    __packed_struct(bss_nfo)
         LE16    hi1, op1, lo1, op2;
         LE16    hi2, op3, lo2, op4;
-    }
-    __attribute_packed;
+    __packed_struct_end()
 
     ps1_exe_t ih, oh;
     ps1_exe_hb_t bh;
@@ -138,7 +130,4 @@ protected:
 
 #endif /* already included */
 
-
-/*
-vi:ts=4:et
-*/
+/* vim:set ts=4 sw=4 et: */

src/p_sys.cpp

@@ -2,8 +2,8 @@
 
    This file is part of the UPX executable compressor.
 
-   Copyright (C) 1996-2007 Markus Franz Xaver Johannes Oberhumer
-   Copyright (C) 1996-2007 Laszlo Molnar
+   Copyright (C) 1996-2016 Markus Franz Xaver Johannes Oberhumer
+   Copyright (C) 1996-2016 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.com      ml1050@users.sourceforge.net
+   Markus F.X.J. Oberhumer              Laszlo Molnar
+   <markus@oberhumer.com>               <ezerotven+github@gmail.com>
  */
 
 
@@ -125,8 +125,4 @@ void PackSys::buildLoader(const Filter *ft)
              );
 }
 
-
-/*
-vi:ts=4:et
-*/
-
+/* vim:set ts=4 sw=4 et: */