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

name
description
see also

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