Ubuntu Manpage: creduce - C and C++ program reducer

Provided by: creduce_2.5.0-0ubuntu1_amd64

NAME

       creduce - C and C++ program reducer

DESCRIPTION

       creduce 2.5.0 (18e04be) -- a C and C++ program reducer

       C-Reduce requires an "interestingness test" and one or more files to reduce, which must be
       writable. The interestingness test is an executable program (usually a shell script)  that
       returns 0 when a partially reduced file is interesting (a candidate for further reduction)
       and returns non-zero when a partially reduced file is not interesting (not a candidate for
       further reduction -- all uninteresting files are discarded).

       C-Reduce  runs the interestingness test in a fresh temporary directory containing only the
       partially reduced file(s). Thus,  when  the  interestingness  test  examines  a  partially
       reduced file, it must do so using a relative path to the current working directory. On the
       other hand, when the interestingness test refers to any file that is  not  being  reduced,
       this should be done using an absolute path.

       The  interestingness  test  should  not  expect  any command line arguments.  It should be
       deterministic and might want to enforce resource limits on sub-commands  that  it  invokes
       (e.g.  using  ulimit). In particular, C-Reduce is known to sometimes introduce an infinite
       loop into the program being reduced. Therefore,  if  the  interestingness  test  runs  the
       compiled program, it probably should do so under a timeout.

       As  a  quick  example,  if you consider a file to be interesting if GCC's vectorizer fires
       while compiling it, you might use this interestingness test:

              gcc -w -O3 foo.c -S && grep xmm foo.s

       To see if your interestingness test is working, try running these commands:

              DIR=`mktemp -d` cp file_to_reduce [optionally, more files to reduce] $DIR  cd  $DIR
              /path/to/interestingness_test echo $?

       This  should  result  in  "0"  being  echoed to the terminal. If this does not happen, the
       interestingness test is flawed and C-Reduce won't be able to make use of it.

       If you haven't written an interestingness test before, please refer to this  tutorial  for
       additional guidance:

              https://embed.cs.utah.edu/creduce/using/

       If at all possible, run C-Reduce on preprocessed code, generated for example using:

              gcc -E -P file.c

       If  you  cannot  reduce preprocessed code, you can either reduce just the non-preprocessed
       file or else perform a multi-file reduction on the file and its  transitive  includes  (or
       any  subset  of  them).  In  the  first  case  you  need  to  set the CREDUCE_INCLUDE_PATH
       environment variable to  a  colonseparated  list  of  include  directories  in  order  for
       clang_delta to find them.

       If  your  interestingness  test  involves  a cross compiler and the characteristics of the
       cross target differs from the host you will need to set CREDUCE_TARGET_TRIPLE to match the
       cross target. This is particularly important if you are working with non-preprocessed code
       and use CREDUCE_INCLUDE_PATH.

       Press "s" at any time to skip to the next pass (this feature is disabled unless  the  Perl
       module Term::ReadKey is available on your system).

   Summary of options:
       --add-pass <pass> <sub-pass> <priority>
              Add the specified pass to the schedule

       --also-interesting <exitcode>
              A  process  exit  code  (somewhere  in  the range 64-113 would be usual) that, when
              returned by the interestingness test, will cause C-Reduce to save  a  copy  of  the
              variant [default: -1]

       --debug
              Print debug information

       --die-on-pass-bug
              Terminate C-Reduce if a pass encounters an otherwise non-fatal problem

       --max-improvement <bytes>
              Largest  improvement in file size from a single transformation that C-Reduce should
              accept (useful only to slow C-Reduce down)

       --n <N>
              Number of cores to use; C-Reduce tries to automatically pick a good setting but its
              choice may be too low or high for your situation [default: 2]

       --no-default-passes
              Start with an empty pass schedule

       --no-give-up
              Don't give up on a pass that hasn't made progress for 50000 iterations

       --nokill
              Wait for parallel instances to terminate on their own instead of killing them (only
              useful for debugging)

       --print-diff
              Show changes made by transformations, for debugging

       --sanitize
              Attempt to obscure details from the original source file

       --save-temps
              Don't delete /tmp/creduce-xxxxxx directories on termination

       --shaddap
              Suppress output about non-fatal internal errors

       --skip-initial-passes
              Skip initial passes (useful if input is already partially reduced)

       --skip-key-off
              Disable skipping the rest of the current pass when "s" is pressed

       --sllooww
              Try harder to reduce, but perhaps take a long time to do so

       --tidy Do not make a backup copy of each file to reduce as file.orig

       --timing
              Print timestamps about reduction progress

       usage: creduce [options] interestingness_test file_to_reduce [optionally,  more  files  to
       reduce]

              creduce --help for more information

NAME

DESCRIPTION

SEE ALSO