upx.doc

PT2258,文件下载

NAME
    upx - compress or expand executable files

SYNOPSIS
    upx [ *command* ] [ *options* ] *filename*...

ABSTRACT
                        The Ultimate Packer for eXecutables
       Copyright (c) 1996-2006 Markus Oberhumer, Laszlo Molnar & John Reiser
                            http://upx.sourceforge.net

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

    While you may use UPX freely for both non-commercial and commercial
    executables (for details see the file LICENSE), we would highly
    appreciate if you credit UPX and ourselves in the documentation,
    possibly including a reference to the UPX home page. Thanks.

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

DISCLAIMER
    UPX comes with ABSOLUTELY NO WARRANTY; for details see the file LICENSE.

    This is the first production quality release, and we plan that future
    1.xx releases will be backward compatible with this version.

    Please report all problems or suggestions to the authors. Thanks.

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

      - no memory overhead for your compressed executables for most of the
          supported formats

      - safe: you can list, test and unpack your executables
          Also, a checksum of both the compressed and uncompressed file is
          maintained internally.

      - universal: UPX can pack a number of executable formats:
          * atari/tos
          * bvmlinuz/386    [bootable Linux kernel]
          * djgpp2/coff
          * dos/com
          * dos/exe
          * dos/sys
          * linux/386
          * linux/elf386
          * linux/sh386
          * ps1/exe
          * rtm32/pe
          * tmt/adam
          * vmlinuz/386     [bootable Linux kernel]
          * vmlinux/386
          * watcom/le (supporting DOS4G, PMODE/W, DOS32a and CauseWay)
          * win32/pe (exe and dll)
          * arm/pe (exe and dll)
          * linux/elfamd64
          * linux/elfppc32
          * mach/elfppc32

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

      - extendable: because of the class layout it's very easy to support
          new executable formats or add new compression algorithms

      - free: UPX can be distributed and used freely. And from version 0.99
          the full source code of UPX is released under the GNU General Public
          License (GPL) !

    You probably understand now why we call UPX the "*ultimate*" executable
    packer.

COMMANDS
  Compress
    This is the default operation, eg. upx yourfile.exe will compress the
    file specified on the command line.

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

  Test
    The -t command tests the integrity of the compressed and uncompressed
    data, eg. upx -t yourfile.exe check whether your file can be safely
    decompressed. Note, that this command doesn't check the whole file, only
    the part that will be uncompressed during program execution. This means
    that you should not use this command instead of a virus checker.

  List
    The -l command prints out some information about the compressed files
    specified on the command line as parameters, eg upx -l yourfile.exe
    shows the compressed / uncompressed size and the compression ratio of
    *yourfile.exe*.

OPTIONS
    -q: be quiet, suppress warnings

    -q -q (or -qq): be very quiet, suppress errors

    -q -q -q (or -qqq): produce no output at all

    --help: prints the help

    --version: print the version of UPX

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

COMPRESSION LEVELS & TUNING
    UPX offers ten different compression levels from -1 to -9, and --best.
    The default compression level is -8 for files smaller than 512 kB, and
    -7 otherwise.

    *   Compression levels 1, 2 and 3 are pretty fast.

    *   Compression levels 4, 5 and 6 achieve a good time/ratio performance.

    *   Compression levels 7, 8 and 9 favor compression ratio over speed.

    *   Compression level --best may take a long time.

    Note that compression level --best can be somewhat slow for large files,
    but you definitely should use it when releasing a final version of your
    program.

    Quick start for achieving the best compression ratio:

        Try upx --brute myfile.exe.

    Details for achieving the best compression ratio:

    *   Use the compression level --best.

    *   Try one or both of the options --all-methods and --all-filters.

    *   Try the option --crp-ms=NUMBER. This uses more memory during
        compression to achieve a (slightly) better compression ratio.

        NUMBER must be a decimal value from 10000 to 999999, inclusive. The
        default value is 10000 (ten thousand).

    *   Info: the option --brute is an abbrevation for the options --best
        --all-methods --all-filters --crp-ms=999999.

    *   Try if --overlay=strip works.

    *   For win32/pe programs there's --strip-relocs=0. See notes below.

OVERLAY HANDLING OPTIONS
    Info: An "overlay" means auxillary data atached after the logical end of
    an executable, and it often contains application specific data (this is
    a common practice to avoid an extra data file, though it would be better
    to use resource sections).

    UPX handles overlays like many other executable packers do: it simply
    copies the overlay after the compressed image. This works with some
    files, but doesn't work with others, depending on how an application
    actually accesses this overlayed data.

      --overlay=copy    Copy any extra data attached to the file. [DEFAULT]

      --overlay=strip   Strip any overlay from the program instead of
                        copying it. Be warned, this may make the compressed
                        program crash or otherwise unusable.

      --overlay=skip    Refuse to compress any program which has an overlay.

ENVIRONMENT
    The environment variable UPX can hold a set of default options for UPX.
    These options are interpreted first and can be overwritten by explicit
    command line parameters. For example:

        for DOS/Windows:   set UPX=-9 --compress-icons#0
        for sh/ksh/zsh:    UPX="-9 --compress-icons=0"; export UPX
        for csh/tcsh:      setenv UPX "-9 --compress-icons=0"

    Under DOS/Windows you must use '#' instead of '=' when setting the
    environment variable because of a COMMAND.COM limitation.

    Not all of the options are valid in the environment variable - UPX will
    tell you.

    You can explicitly use the --no-env option to ignore the environment
    variable.

NOTES FOR THE SUPPORTED EXECUTABLE FORMATS
  NOTES FOR ATARI/TOS
    This is the executable format used by the Atari ST/TT, a Motorola 68000
    based personal computer which was popular in the late '80s. Support of
    this format is only because of nostalgic feelings of one of the authors
    and serves no practical purpose :-). See http://www.freemint.de for more
    info.

    Packed programs will be byte-identical to the original after
    uncompression. All debug information will be stripped, though.

    Extra options available for this executable format:

      --all-methods       Compress the program several times, using all
                          available compression methods. This may improve
                          the compression ratio in some cases, but usually
                          the default method gives the best results anyway.

  NOTES FOR BVMLINUZ/I386
    Same as vmlinuz/i386.

  NOTES FOR DOS/COM
    Obviously UPX won't work with executables that want to read data from
    themselves (like some commandline utilities that ship with Win95/98/ME).

    Compressed programs only work on a 286+.

    Packed programs will be byte-identical to the original after
    uncompression.

    Maximum uncompressed size: ~65100 bytes.

    Extra options available for this executable format:

      --8086              Create an executable that works on any 8086 CPU.

      --all-methods       Compress the program several times, using all
                          available compression methods. This may improve
                          the compression ratio in some cases, but usually
                          the default method gives the best results anyway.

      --all-filters       Compress the program several times, using all
                          available preprocessing filters. This may improve
                          the compression ratio in some cases, but usually
                          the default filter gives the best results anyway.

  NOTES FOR DOS/EXE
    dos/exe stands for all "normal" 16-bit DOS executables.

    Obviously UPX won't work with executables that want to read data from
    themselves (like some command line utilities that ship with
    Win95/98/ME).

    Compressed programs only work on a 286+.

    Extra options available for this executable format:

      --8086              Create an executable that works on any 8086 CPU.

      --no-reloc          Use no relocation records in the exe header.

      --all-methods       Compress the program several times, using all
                          available compression methods. This may improve
                          the compression ratio in some cases, but usually
                          the default method gives the best results anyway.

  NOTES FOR DOS/SYS
    Compressed programs only work on a 286+.

    Packed programs will be byte-identical to the original after
    uncompression.

    Maximum uncompressed size: ~65350 bytes.

    Extra options available for this executable format:

      --8086              Create an executable that works on any 8086 CPU.

      --all-methods       Compress the program several times, using all
                          available compression methods. This may improve
                          the compression ratio in some cases, but usually
                          the default method gives the best results anyway.

      --all-filters       Compress the program several times, using all
                          available preprocessing filters. This may improve
                          the compression ratio in some cases, but usually