NAME

       llvm-reduce - LLVM automatic testcase reducer.

SYNOPSIS

       llvm-reduce [options] [input...]

DESCRIPTION

       The  llvm-reduce  tool  project that can be used for reducing the size of LLVM test cases.
       It works by removing redundant or unnecessary  code  from  LLVM  test  cases  while  still
       preserving their ability to detect bugs.

       If  input  is "-", llvm-reduce reads from standard input. Otherwise, it will read from the
       specified filenames.

       LLVM-Reduce is a useful tool for reducing the size and  complexity  of  LLVM  test  cases,
       making it easier to identify and debug issues in the LLVM compiler infrastructure.

GENERIC OPTIONS

       --help Display available options (--help-hidden for more).

       --abort-on-invalid-reduction
              Abort if any reduction results in invalid IR

       --in-place
              WARNING: This option will replace your input file with the reduced version!

       --ir-passes=<string>
              A textual description of the pass pipeline, same as what's passed to opt -passes.

       -j <uint>
              Maximum  number  of  threads  to  use  to  process  chunks.  Set  to  1  to disable
              parallelism.

       --max-pass-iterations=<int>
              Maximum number of times to run the full set of delta passes (default=5).

       --mtriple=<string>
              Set the target triple.

       --preserve-debug-environment
              Don't disable features used for crash debugging (crash reports, llvm-symbolizer and
              core dumps)

       --print-delta-passes
              Print list of delta passes, passable to --delta-passes as a comma separated liste.

       --skip-delta-passes=<string>
              Delta passes to not run, separated by commas. By default, run all delta passes.

       --starting-granularity-level=<uint>
              Number of times to divide chunks prior to first test.

              Note  :  Granularity  refers  to the level of detail at which the reduction process
              operates.  A lower granularity means that the reduction process operates at a  more
              coarse-grained  level,  while a higher granularity means that it operates at a more
              fine-grained level.

       --test=<string>
              Name of the interesting-ness test to be run.

       --test-arg=<string>
              Arguments passed onto the interesting-ness test.

       --verbose
              Print extra debugging information.

       --write-tmp-files-as-bitcode
              Always write temporary files as bitcode instead of textual IR.

       -x={ir|mir}
              Input language as ir or mir.

EXIT STATUS

       llvm-reduce returns 0 under normal operation. It returns a non-zero  exit  code  if  there
       were any errors.

EXAMPLE

       llvm-reduce can be used to simplify a test that causes a compiler crash.

       For  example,  let's assume that opt is crashing on the IR file test.ll with error message
       Assertion failed at line 1234 of WhateverFile.cpp, when running at -O2.

       The test case of test.ll can be reduced by invoking the following command:

          $(LLVM_BUILD_FOLDER)/bin/llvm-reduce --test=script.sh <path to>/test.ll

       The shell script passed to the option test consists of the following:

          $(LLVM_BUILD_FOLDER)/bin/opt -O2 -disable-output $1 \
            |& grep "Assertion failed at line 1234 of WhateverFile.cpp"

       (In this script, grep exits with 0 if it finds the  string  and  that  becomes  the  whole
       script's status.)

       This example can be generalized to other tools that process IR files, for example llc.

AUTHOR

       Maintained by the LLVM Team (https://llvm.org/).

COPYRIGHT

       2003-2024, LLVM Project