glfs/general/prog/rust.xml
2022-12-13 12:19:29 -06:00

840 lines
30 KiB
XML

<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE sect1 PUBLIC "-//OASIS//DTD DocBook XML V4.5//EN"
"http://www.oasis-open.org/docbook/xml/4.5/docbookx.dtd" [
<!ENTITY % general-entities SYSTEM "../../general.ent">
%general-entities;
<!ENTITY rust-download-http "https://static.rust-lang.org/dist/rustc-&rust-version;-src.tar.xz">
<!ENTITY rust-download-ftp " ">
<!ENTITY rust-md5sum "e77ac3a786d013604061b17f99dd9b27">
<!ENTITY rust-size "131 MB">
<!-- Gentle Reminder: buildsize is how much the user requires for the real
install, i.e. the source with its DESTDIR *plus* the DESTDIR. You
can 'mkdir /tmp/RUST ; cp -a install/* /tmp/RUST' and then run 'du -sch'
to measure it, or du -sm to look at the size of the build tree before and
after the tests. -->
<!ENTITY rust-buildsize "10 GB (516 MB installed) including 266 MB of ~/.cargo files for the user building this. Add 6.2 GB including extra 243 MB of ~/.cargo files if running the tests">
<!ENTITY rust-time "21 SBU (including download time; add 10 SBU for tests, both on a 4-core machine)">
]>
<sect1 id="rust" xreflabel="rustc-&rust-version;">
<?dbhtml filename="rust.html"?>
<title>Rustc-&rust-version;</title>
<indexterm zone="rust">
<primary sortas="a-rust">Rust</primary>
</indexterm>
<sect2 role="package">
<title>Introduction to Rust</title>
<para>
The <application>Rust</application> programming language is designed
to be a safe, concurrent, practical language.
</para>
<para>
This package is updated on a six-weekly release cycle. Because it is
such a large and slow package to build, is at the moment only required
by a few packages in this book, and particularly because newer versions
tend to break older mozilla packages, the BLFS editors take the view that
it should only be updated when that is necessary (either to fix problems,
or to allow a new version of a package to build).
</para>
<para>
As with many other programming languages, rustc (the rust compiler)
needs a binary from which to bootstrap. It will download a stage0 binary
and many cargo crates (these are actually .tar.gz source archives) at
the start of the build, so you cannot compile it without an internet
connection.
</para>
<para>
These crates will then remain in various forms (cache, directories of
extracted source), in <filename class="directory">~/.cargo</filename> for
ever more. It is common for large <application>rust</application> packages
to use multiple versions of some crates. If you purge the files before
updating this package, very few crates will need to be updated by the
packages in this book which use it (and they will be downloaded as
required). But if you retain an older version as a fallback option and
then use it (when <emphasis>not</emphasis> building in
<filename class="directory">/usr</filename>), it is likely that it will
then have to re-download some crates. For a full download (i.e. starting
with an empty or missing <filename class="directory">~/.cargo</filename>)
downloading the external cargo files for this version only takes a minute
or so on a fast network.
</para>
<note>
<para>
Although BLFS usually installs in <filename
class="directory">/usr</filename>, when you later upgrade to a newer
version of <application>rust</application> the old libraries in <filename
class="directory">/usr/lib/rustlib</filename> will remain, with various
hashes in their names, but will not be usable and will waste space. The
editors recommend placing the files in the <filename
class="directory">/opt</filename> directory. In particular, if you
have reason to rebuild with a modified configuration (e.g. using the
shipped LLVM after building with shared LLVM, perhaps to compile crates
for architectures which the BLFS LLVM build does not support)
it is possible for the install to leave a broken
<command>cargo</command> program. In such a situation, either remove
the existing installation first, or use a different prefix such as
/opt/rustc-&rust-version;-build2.
</para>
<para>
If you prefer, you can of course change the prefix to <filename
class="directory">/usr</filename> and omit the
<command>ldconfig</command> and the actions to add rustc to the PATH.
</para>
</note>
<para>
The current <application>rustbuild</application> build-system will use
all processors, although it does not scale well and often falls
back to just using one core while waiting for a library to compile.
However it can be mostly limited to a specified number of processors by
a combination of adding the switch <literal>--jobs &lt;N&gt;</literal>
(e.g. '--jobs 4' to limit to 4 processors) on each invocation of
<command>python3 ./x.py</command> <emphasis>and</emphasis> using an
environment variable <envar>CARGO_BUILD_JOBS=&lt;N&gt;</envar>. At the
moment this is not effective when some of the rustc tests are run.
</para>
<para>
The current version of rust's num_cpus crate now recognizes that cgroups
can be used to restrict which processors it is allowed to use. So if your
machine lacks DRAM (typically, less than 2GB DRAM per core) that might be
an alternative to taking CPUs offline.
<phrase revision="sysv">In sysv systems cgroups requires <ulink
url="https://sourceforge.net/projects/libcg/">libcgroup</ulink>.</phrase>
<phrase revision="systemd">That can be achieved by using
<command>systemd-run</command> command with
<parameter>-p User=$(whoami)</parameter> and
<parameter>-p AllowedCPUs=0-<replaceable>x</replaceable></parameter>
(with <replaceable>x</replaceable> replaced with the number of CPU
cores you want to use minus one) options.</phrase>
</para>
<para>
At the moment <application>Rust</application> does not provide any
guarantees of a stable ABI.
</para>
<note>
<para>
Rustc defaults to building for ALL supported architectures, using a
shipped copy of LLVM. In BLFS the build is only for the X86
architecture.
If you intend to develop rust crates, this build may not be good
enough for your purposes.
</para>
<para>
The build times of this version when repeated on the same machine are
often reasonably consistent, but as with all compilations using
<command>rustc</command> there can be some very slow outliers.
</para>
<para>
Unusually, a DESTDIR-style method is being used to install this package.
This is because running the install as root not only downloads all of the
cargo files again (to <filename>/root/.cargo</filename>), it then spends
a very long time recompiling. Using this method saves a lot of time, at
the cost of extra disk space.
</para>
</note>
&lfs112_checked;
<bridgehead renderas="sect3">Package Information</bridgehead>
<itemizedlist spacing="compact">
<listitem>
<para>
Download (HTTP): <ulink url="&rust-download-http;"/>
</para>
</listitem>
<listitem>
<para>
Download (FTP): <ulink url="&rust-download-ftp;"/>
</para>
</listitem>
<listitem>
<para>
Download MD5 sum: &rust-md5sum;
</para>
</listitem>
<listitem>
<para>
Download size: &rust-size;
</para>
</listitem>
<listitem>
<para>
Estimated disk space required: &rust-buildsize;
</para>
</listitem>
<listitem>
<para>
Estimated build time: &rust-time;
</para>
</listitem>
</itemizedlist>
<!--<bridgehead renderas="sect3">Additional Downloads</bridgehead>
<itemizedlist spacing="compact">
<listitem>
<para>
Required patch:
<ulink url="&patch-root;/rustc-&rust-version;-llvm9_fixes-1.patch"/>
</para>
</listitem>
</itemizedlist>-->
<bridgehead renderas="sect3">Rust Dependencies</bridgehead>
<bridgehead renderas="sect4">Required</bridgehead>
<para role="required">
<xref linkend="cmake"/>
</para>
<bridgehead renderas="sect4">Recommended</bridgehead>
<para role="recommended">
<xref linkend="curl"/>,
<xref linkend="libssh2"/>, and
<xref linkend="llvm"/>
(built with -DLLVM_LINK_LLVM_DYLIB=ON so that rust can link to
system LLVM instead of building its shipped version)
</para>
<note>
<para>
If a recommended dependency is not installed, a shipped copy in the
Rustc source tarball will be built and used.
</para>
</note>
<bridgehead renderas="sect4">Optional</bridgehead>
<para role="optional">
<xref linkend="gdb"/> (used by the test suite if it is present) and
<ulink url='https://libgit2.org/'>libgit2</ulink>
</para>
<para condition="html" role="usernotes">
User Notes: <ulink url="&blfs-wiki;/rust"/>
</para>
</sect2>
<sect2 role="installation">
<title>Installation of Rust</title>
<note>
<para>
Currently Rust compiler produces SSE2 instructions for 32-bit x86,
causing the generated code broken on 32-bit systems without a
SSE2-capable processor. All x86 processor models released after
2004 should be SSE2-capable. Run
<command>lscpu | grep sse2</command> as a test. If it outputs
anything, your CPU is SSE2-capable and OK. Otherwise you may try
to build this package <emphasis>on a SSE2-capable system</emphasis>
with the following fix applied:
</para>
<!-- computeroutput used deliberately to stop anyone from copying
blindly -->
<screen role="nodump"><computeroutput>sed 's@pentium4@pentiumpro@' -i \
compiler/rustc_target/src/spec/i686_unknown_linux_gnu.rs</computeroutput></screen>
<para>
And copy the resulting
<filename class="directory">/opt/rustc-&rust-version;</filename>
to the system without SSE2 capability. But this change is still
under upstream review and not tested by BLFS editors.
</para>
</note>
<para>
To install into the
<filename class="directory">/opt</filename> directory, remove the symlink
and create a new directory (i.e. with a different name if trying a
modified build).
As the <systemitem class="username">root</systemitem>
user:
</para>
<screen role="root"><userinput>mkdir /opt/rustc-&rust-version; &amp;&amp;
ln -svfn rustc-&rust-version; /opt/rustc</userinput></screen>
<note>
<para>
If multiple versions of <application>Rust</application> are installed
in <filename class="directory">/opt</filename>, changing to another
version only requires changing the <filename> /opt/rustc</filename>
symbolic link and then running <command>ldconfig</command>.
</para>
</note>
<para>
Create a suitable <filename>config.toml</filename> file which will
configure the build.
</para>
<screen><userinput>cat &lt;&lt; EOF &gt; config.toml
<literal># see config.toml.example for more possible options
# See the 8.4 book for an example using shipped LLVM
# e.g. if not installing clang, or using a version before 10.0
[llvm]
# by default, rust will build for a myriad of architectures
targets = "X86"
# When using system llvm prefer shared libraries
link-shared = true
[build]
# omit docs to save time and space (default is to build them)
docs = false
# install cargo as well as rust
extended = true
[install]
prefix = "/opt/rustc-&rust-version;"
docdir = "share/doc/rustc-&rust-version;"
[rust]
channel = "stable"
rpath = false
# BLFS does not install the FileCheck executable from llvm,
# so disable codegen tests
codegen-tests = false
[target.x86_64-unknown-linux-gnu]
# NB the output of llvm-config (i.e. help options) may be
# dumped to the screen when config.toml is parsed.
llvm-config = "/usr/bin/llvm-config"
[target.i686-unknown-linux-gnu]
# NB the output of llvm-config (i.e. help options) may be
# dumped to the screen when config.toml is parsed.
llvm-config = "/usr/bin/llvm-config"
</literal>
EOF</userinput></screen>
<!--<para>
Adapt rustc to allow it to build and function with the changes in LLVM-9:
</para>
<screen><userinput remap="pre">patch -Np1 -i ../rustc-&rust-version;-llvm9_fixes-1.patch</userinput></screen>-->
<para>
Compile <application>Rust</application> by running the following
commands:
</para>
<!-- fixed in 1.58.0, retain as a reminder that fixed crates can be used
<screen><userinput>sed -i -e '/^curl /s/0.4.38/0.4.40/' \
-e '/^curl-sys /s/0.4.48/0.4.50/' \
src/tools/cargo/Cargo.toml &amp;&amp; -->
<screen><userinput>export RUSTFLAGS="$RUSTFLAGS -C link-args=-lffi" &amp;&amp;
{ [ ! -e /usr/include/libssh2.h ] ||
export LIBSSH2_SYS_USE_PKG_CONFIG=1; } &amp;&amp;
python3 ./x.py build --exclude src/tools/miri</userinput></screen>
<note>
<para>
The test suite will generate some messages in the
<phrase revision="sysv">system log</phrase>
<phrase revision="systemd">systemd journal</phrase>
for traps on invalid opcodes, and for segmentation faults.
In themselves these are nothing to worry about, just a way for the
test to be terminated.
</para>
</note>
<para>
To run the tests issue <command>python3 ./x.py test --verbose
--no-fail-fast | tee rustc-testlog</command>: as with the build, that
will use all available CPUs.
</para>
<para>
At a minimum, 51 tests will fail: all 46 of the tests in
the <quote>assembly</quote> suite which are not skipped (various lints
cause the warnings in these tests to be treated as errors), and
5 other tests, 4 of which involve the
<filename>rustdoc-ui/issue-98690.rs</filename> file, and another one,
<filename>run-make-fulldeps/long-linker-command-lines</filename>.
<!-- If <command>gdb</command> is installed, another failure
(debuginfo/function-names.rs) can be expected.
# seems ok with 11.2 ken -->
</para>
<para>
As with all large test suites, other tests might fail on some machines -
if the number of additional failures is in the single digits,
check the log for 'failures:' and review lines above that, particularly the
'stderr:' lines. Any mention of
SIGSEGV or signal 11 in a failing test is a cause for concern.
</para>
<para>
If you get any <emphasis>other</emphasis> failing test which reports an
issue number then you should search for that issue. For example, when
rustc &gt;= 1.41.1 was built with a version of sysllvm before 10.0 the test
for issue 69225 failed <ulink
url="https://github.com/rust-lang/rust/issues/69225"/> and that should be
regarded as a critical failure (they released 1.41.1 because of it).
Most other failures will not be critical.
</para>
<para>
Therefore, you should determine the number of failures.
</para>
<!--
The total number
of tests varies depending on which dependencies are present, e.g. more
will be run if <command>gdb</command> is available. If you wish, the
total number which were considered can be found if you run:
</para>
<screen remap="test"><userinput>egrep 'running [[:digit:]]+ test' rustc-testlog | awk '{ sum += $2 } END { print sum }'</userinput></screen>-->
<para>
The number of tests which failed can be found by running:
</para>
<screen remap="test"><userinput>grep '^test result:' rustc-testlog | awk '{ sum += $6 } END { print sum }'</userinput></screen>
<para>
And similarly if you care about how many tests passed use $4, for those
which were ignored (i.e. skipped) use $8 (and $10 for 'measured', $12 for
'filtered out' but both are probably zero).
</para>
<para>
Still as your normal user, do a DESTDIR install:
</para>
<screen><userinput>DESTDIR=${PWD}/install python3 ./x.py install &amp;&amp;
unset LIBSSH2_SYS_USE_PKG_CONFIG</userinput></screen>
<para>
Now, as the <systemitem class="username">root</systemitem> user
install the files from the DESTDIR:
</para>
<screen role="root"><userinput>chown -R root:root install &amp;&amp;
cp -a install/* /</userinput></screen>
</sect2>
<sect2 role="commands">
<title>Command Explanations</title>
<para>
<command>ln -svfn rustc-&rust-version; /opt/rustc</command>: if this is
not the first use of the <filename class="directory">/opt/rustc</filename>
symlink, overwrite it by forcing, and use the '-n' flag to avoid getting
confusing results from e.g. <command>ls -l</command>.
</para>
<para>
<command>targets = "X86"</command>: this avoids building all the available
linux cross-compilers (Aarch64, MIPS, PowerPC, SystemZ, etc). Unfortunately,
rust insists on installing source files for these below
<filename class="directory">/opt/rustc/lib/src</filename>.
</para>
<para>
<command>extended = true</command>: this installs Cargo alongside Rust.
</para>
<para>
<command>channel = "stable"</command>: this ensures only stable features
can be used, the default in <filename>config.toml</filename> is to use
development features, which is not appropriate for a released version.
</para>
<para>
<command>rpath = false</command>: by default, <command>rust</command> can
be run from where it was built, without being installed. That adds DT_RPATH
entries to all of the ELF files, which produces very messy output from
<command>ldd</command>, showing the libraries in the place they were built,
even if they have been deleted from there after the install.
</para>
<!-- comment while using shipped LLVM -->
<para>
<command>[target.x86_64-unknown-linux-gnu]</command>: the syntax of
<filename>config.toml</filename> requires an <literal>llvm-config</literal>
entry for each target for which system-llvm is to be used. Change the target
to <literal>[target.i686-unknown-linux-gnu]</literal> if you are building
on 32-bit x86. This whole section may be omitted if you wish to build
against the shipped llvm, or do not have clang, but the resulting build will
be larger and take longer.
</para>
<!--<para>
<command>sed -i -e '/^curl /s/0.4.38/0.4.40/' ... </command>: two crates
normally downloaded for this release do not correctly initialise
<application>curl</application> if using
<application>openssl-3.0.0</application>. Upstream has fixed that for a
future release, this sed causes the fixed versions to be used.
</para>-->
<para>
<command>export RUSTFLAGS="$RUSTFLAGS -C link-args=-lffi"</command>:
This adds a link to libffi to any RUSTFLAGS you may already be passing
to the build. On some systems, linking fails to include libffi unless
this is used. The reason why this is needed is not clear.
</para>
<para>
<command>--exclude src/tools/miri</command>: For a long time, the miri
crate (an interpreter for the Midlevel Intermediate Representation)
has failed to build on releases. It is optional, but the failure
messages can persuade people that the whole build failed. However,
although it is not built in the main compile, with rustc-1.35.0 it
now got compiled during the install, but it was broken in that version.
<!-- might be unbroken in 1.36.0, if so remove broken from description
of miri below. https://github.com/rust-lang/rust/issues/61830 -->
Omitting it should save a little time. Even if this switch is
not given, miri is not installed.
</para>
<para>
<command>--verbose</command>: this switch can sometimes provide more
information about a test which fails.
</para>
<para>
<command>--no-fail-fast</command>: this switch ensures that the test suite
will not stop at the first error.
</para>
<!-- https://github.com/alexcrichton/ssh2-rs/issues/173 -->
<para>
<command>export LIBSSH2_SYS_USE_PKG_CONFIG=1</command>: Allow
<command>cargo</command> to link to system libssh2.
</para>
<para>
<command>DESTDIR=${PWD}/install python3 ./x.py install</command>: This
effects a DESTDIR-style install in the source tree,creating an <filename
class="directory">install</filename> directory. Note that DESTDIR installs
need an absolute path, passing 'install' will not work.
</para>
<para>
<command>chown -R root:root install</command>: the DESTDIR install
was run by a regular user, who owns the files. For security, change their
owner before doing a simple copy to install them.
</para>
</sect2>
<sect2 role="configuration">
<title>Configuring Rust</title>
<sect3 id="rustc-config">
<title>Configuration Information</title>
<para>
If you installed <application>rustc</application> in
<filename class="directory">/opt</filename>, you need to update the
following configuration files so that <application>rustc</application>
is correctly found by other packages and system processes.
</para>
<para>
As the <systemitem class="username">root</systemitem> user, update
the <filename>/etc/ld.so.conf</filename> file and the dynamic linker's
run-time cache file:
</para>
<screen role="root"><userinput>cat &gt;&gt; /etc/ld.so.conf &lt;&lt; EOF
<literal># Begin rustc addition
/opt/rustc/lib
# End rustc addition</literal>
EOF
ldconfig</userinput></screen>
<indexterm zone="rust rustc-config">
<primary sortas="e-etc-ld.so.conf">/etc/ld.so.conf</primary>
</indexterm>
<para>
As the <systemitem class="username">root</systemitem> user, create
the <filename>/etc/profile.d/rustc.sh</filename> file:
</para>
<screen role="root"><userinput>cat &gt; /etc/profile.d/rustc.sh &lt;&lt; "EOF"
<literal># Begin /etc/profile.d/rustc.sh
pathprepend /opt/rustc/bin PATH
# Include /opt/rustc/man in the MANPATH variable to access manual pages
pathappend /opt/rustc/share/man MANPATH
# End /etc/profile.d/rustc.sh</literal>
EOF</userinput></screen>
<para>
Immediately after installation, update the current PATH
for your current shell as a normal user:
</para>
<screen><userinput>source /etc/profile.d/rustc.sh</userinput></screen>
</sect3>
</sect2>
<sect2 role="content">
<title>Contents</title>
<segmentedlist>
<segtitle>Installed Programs</segtitle>
<segtitle>Installed Libraries</segtitle>
<segtitle>Installed Directories</segtitle>
<seglistitem>
<seg>
cargo-clippy, cargo-fmt, cargo-miri (optional), cargo, clippy-driver,
miri (optional), rls, rust-analyzer, rust-demangler, rust-gdb,
rust-gdbgui, rust-lldb, rustc, rustdoc, and rustfmt
</seg>
<seg>
librustc-driver-&lt;16-byte-hash&gt;.so,
libstd-&lt;16-byte-hash&gt;.so, and
libtest-&lt;16-byte-hash&gt;.so
</seg>
<seg>
~/.cargo,
/opt/rustc, symbolic link to
/opt/rustc-&rust-version;
</seg>
</seglistitem>
</segmentedlist>
<variablelist>
<bridgehead renderas="sect3">Short Descriptions</bridgehead>
<?dbfo list-presentation="list"?>
<?dbhtml list-presentation="table"?>
<varlistentry id="cargo-clippy">
<term><command>cargo-clippy</command></term>
<listitem>
<para>
provides lint checks for a cargo package
</para>
<indexterm zone="rust cargo-clippy">
<primary sortas="b-cargo-clippy">cargo-clippy</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="cargo-fmt">
<term><command>cargo-fmt</command></term>
<listitem>
<para>
formats all bin and lib files of the current crate using
rustfmt
</para>
<indexterm zone="rust cargo-fmt">
<primary sortas="b-cargo-fmt">cargo-fmt</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="cargo-miri">
<term><command>cargo-miri</command></term>
<listitem>
<para>
is for use by Miri to interpret bin crates and tests. It is
not installed by default.
</para>
<indexterm zone="rust cargo-miri">
<primary sortas="b-cargo-miri">cargo-miri</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="cargo">
<term><command>cargo</command></term>
<listitem>
<para>
is the Package Manager for Rust
</para>
<indexterm zone="rust cargo">
<primary sortas="b-cargo">cargo</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="clippy-driver">
<term><command>clippy-driver</command></term>
<listitem>
<para>
provides lint checks for Rust
</para>
<indexterm zone="rust clippy-driver">
<primary sortas="b-clippy-driver">clippy-driver</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="miri">
<term><command>miri</command></term>
<listitem>
<para>
is an interpreter for Rust's mid-level intermediate representation
(MIR). It is not installed by default.
</para>
<indexterm zone="rust miri">
<primary sortas="b-miri">miri</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rls">
<term><command>rls</command></term>
<listitem>
<para>
is the Rust Language Server. This can run in the background to
provide IDEs, editors, and other tools with information about Rust
programs
</para>
<indexterm zone="rust rls">
<primary sortas="b-rls">rls</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rust-analyzer">
<term><command>rust-analyzer</command></term>
<listitem>
<para>
is an implementation of Language Server Protocol for the Rust
programming language.
</para>
<indexterm zone="rust rust-analyzer">
<primary sortas="b-rust-analyzer">rust-analyzer</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rust-demangler">
<term><command>rust-demangler</command></term>
<listitem>
<para>
converts a list of Rust mangled symbols into a
corresponding list of demangled symbols
</para>
<indexterm zone="rust rust-demangler">
<primary sortas="b-rust-demangler">rust-demangler</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rust-gdb">
<term><command>rust-gdb</command></term>
<listitem>
<para>
is a wrapper script for gdb, pulling in Python pretty-printing
modules installed in
<filename class="directory">/opt/rustc-&rust-version;/lib/rustlib/etc</filename>
</para>
<indexterm zone="rust rust-gdb">
<primary sortas="b-rust-gdb">rust-gdb</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rust-gdbgui">
<term><command>rust-gdbgui</command></term>
<listitem>
<para>
is a wrapper script for a graphical front end to gdb that runs in a
browser
</para>
<indexterm zone="rust rust-gdbgui">
<primary sortas="b-rust-gdbgui">rust-gdbgui</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rust-lldb">
<term><command>rust-lldb</command></term>
<listitem>
<para>
is a wrapper script for LLDB (the LLVM debugger)
pulling in the Python pretty-printing modules
</para>
<indexterm zone="rust rust-lldb">
<primary sortas="b-rust-lldb">rust=lldb</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rustc">
<term><command>rustc</command></term>
<listitem>
<para>
is the rust compiler
</para>
<indexterm zone="rust rustc">
<primary sortas="b-rustc">rustc</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rustdoc">
<term><command>rustdoc</command></term>
<listitem>
<para>
generates documentation from rust source code
</para>
<indexterm zone="rust rustdoc">
<primary sortas="b-rustdoc">rustdoc</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="rustfmt">
<term><command>rustfmt</command></term>
<listitem>
<para>
formats rust code
</para>
<indexterm zone="rust rustfmt">
<primary sortas="b-rustfmt">rustfmt</primary>
</indexterm>
</listitem>
</varlistentry>
<varlistentry id="libstd">
<term><filename class="libraryfile">libstd-&lt;16-byte-hash&gt;.so</filename></term>
<listitem>
<para>
is the Rust Standard Library, the foundation of portable Rust software
</para>
<indexterm zone="rust libstd">
<primary sortas="c-libstd">libstd-&lt;16-byte-hash&gt;.so</primary>
</indexterm>
</listitem>
</varlistentry>
</variablelist>
</sect2>
</sect1>