Provided by: rustc_1.61.0+dfsg1-1~exp1ubuntu1_amd64 bug


       rustc - The Rust compiler


       rustc [OPTIONS] INPUT


       This program is a compiler for the Rust language, available at


       -h, --help
              Display the help message.

       --cfg SPEC
              Configure the compilation environment.

       -L [KIND=]PATH
              Add a directory to the library search path.  The optional KIND can be one of:

                     only lookup transitive dependencies here

              crate  only lookup local `extern crate` directives here

              native only lookup native libraries here

                     only look for OSX frameworks here

              all    look for anything here (the default)

       -l [KIND=]NAME
              Link  the  generated crate(s) to the specified library NAME.  The optional KIND can
              be one of static, dylib, or framework.  If omitted, dylib is assumed.

       --crate-type [bin|lib|rlib|dylib|cdylib|staticlib]
              Comma separated list of types of crates for the compiler to emit.

       --crate-name NAME
              Specify the name of the crate being built.

       --emit [asm|llvm-bc|llvm-ir|obj|link|dep-info|mir][=PATH]
              Configure the output that rustc will  produce.  Each  emission  may  also  have  an
              optional  explicit  output  PATH  specified for that particular emission kind. This
              path takes precedence over the -o option.

       --print        [crate-name|file-names|sysroot|cfg|target-list|target-cpus|target-features|
              Comma separated list of compiler information to print on stdout.

       -g     Equivalent to -C debuginfo=2.

       -O     Equivalent to -C opt-level=2.

       -o FILENAME
              Write  output  to  FILENAME. Ignored if multiple --emit outputs are specified which
              don't have an explicit path otherwise.

       --out-dir DIR
              Write output to compiler‐chosen filename  in  DIR.  Ignored  if  -o  is  specified.
              Defaults to the current directory.

       --explain OPT
              Provide a detailed explanation of an error message.

       --test Build a test harness.

       --target TARGET
              Target  triple  for  which the code is compiled. This option defaults to the host’s
              target    triple.    The    target    triple     has     the     general     format
              <arch><sub>-<vendor>-<sys>-<abi>, where:

              <arch> x86, arm, thumb, mips, etc.

              <sub>  for example on ARM: v5, v6m, v7a, v7m, etc.

                     pc, apple, nvidia, ibm, etc.

              <sys>  none, linux, win32, darwin, cuda, etc.

              <abi>  eabi, gnu, android, macho, elf, etc.

       -W help
              Print 'lint' options and default settings.

       -W OPT, --warn OPT
              Set lint warnings.

       -A OPT, --allow OPT
              Set lint allowed.

       -D OPT, --deny OPT
              Set lint denied.

       -F OPT, --forbid OPT
              Set lint forbidden.

       -C FLAG[=VAL], --codegen FLAG[=VAL]
              Set  a codegen‐related flag to the value specified.  Use -C help to print available
              flags.  See CODEGEN OPTIONS below.

       -V, --version
              Print version info and exit.

       -v, --verbose
              Use verbose output.

       --remap-path-prefix from=to
              Remap source path prefixes in all output,  including  compiler  diagnostics,  debug
              information,  macro expansions, etc. The from=to parameter is scanned from right to
              left, so from may contain '=', but to may not.

              This is useful for normalizing build products, for example by removing the  current
              directory out of pathnames emitted into the object files. The replacement is purely
              textual, with no consideration of the current system's pathname syntax. For example
              --remap-path-prefix foo=bar will match foo/ but not ./foo/

       --extern NAME=PATH
              Specify  where  an  external  rust  library  is  located. These should match extern
              declarations in the crate's source code.

       --sysroot PATH
              Override the system root.

       -Z FLAG
              Set internal debugging options.  Use -Z help to print available options.

       --color auto|always|never
              Configure coloring of output:

              auto   colorize, if output goes to a tty (default);

              always always colorize output;

              never  never colorize output.


              Path to the linker utility to use when linking libraries, executables, and objects.

       link-args='-flag1 -flag2'
              A space‐separated list of extra arguments to pass to the linker when the linker  is

       lto    Perform LLVM link‐time optimizations.

              Selects  a target processor.  If the value is 'help', then a list of available CPUs
              is printed.

              A comma‐separated list of  features  to  enable  or  disable  for  the  target.   A
              preceding  '+'  enables  a  feature  while  a preceding '-' disables it.  Available
              features can be discovered through llc -mcpu=help.

              A space‐separated list of extra LLVM passes to run.  A value of 'list'  will  cause
              rustc to print all known passes and exit.  The passes specified are appended at the
              end of the normal pass manager.

       llvm-args='-arg1 -arg2'
              A space‐separated list of arguments to pass through to LLVM.

              If specified, the compiler will save more files  (.bc,  .o,  .no-opt.bc)  generated
              throughout compilation in the output directory.

       rpath  If  specified,  then  the  rpath  value for dynamic libraries will be set in either
              dynamic library or executable outputs.

              Suppresses pre‐population of the LLVM pass manager that is run over the module.

              Suppresses running the loop vectorization LLVM  pass,  regardless  of  optimization

              Suppresses  running  the  LLVM  SLP  vectorization pass, regardless of optimization

              Generates software floating point library calls instead of hardware instructions.

              Prefers dynamic linking to static linking.

              Force usage of an external assembler rather than LLVM's integrated one.

              Disable the use of the redzone.

              The relocation model to use.  (Default: pic)

              Choose the code model to use.

              Metadata to mangle symbol names with.

              Extra data to put in each output filename.

              Divide crate into n units to optimize in parallel.

              Print remarks for these optimization passes (space separated, or "all").

              Disable checks for stack exhaustion (a memory‐safety hazard!).

              Debug info emission level:

              0      no debug info;

              1      line‐tables only (for stacktraces and breakpoints);

              2      full debug info with variable and type information.

              Optimize with possible levels 0–3, s (optimize for size), or z (for minimal size)


       Some of these affect only test harness  programs  (generated  via  rustc  --test);  others
       affect all programs which link to the Rust standard library.

              The test framework Rust provides executes tests in parallel. This variable sets the
              maximum number of threads used for this purpose. This setting is overridden by  the
              --test-threads option.

              If set to a value other than "0", a synonym for the --nocapture flag.

              Sets the minimum stack size for new threads.

              If  set  to  a  value  different  than "0", produces a backtrace in the output of a
              program which panics.


       To build an executable from a source file with a main function:
           $ rustc -o hello

       To build a library from a source file:
           $ rustc --crate-type=lib

       To build either with a crate (.rs) file:
           $ rustc

       To build an executable with debug info:
           $ rustc -g -o hello




       See for issues.


       See   or   use   `git   log   --all
       --format='%cN <%cE>' | sort -u` in the rust source distribution.


       This work is dual‐licensed under Apache 2.0 and MIT terms.  See COPYRIGHT file in the rust
       source distribution.