Au-delà de Linux® From Scratch - Version 8.3

Chapitre 13. Programmation

Rustc-1.25.0

Introduction à Rust

Le langage de programmation Rust est conçu pour être un langage sûr, concurrent et pratique.

Comme avec tous les langages de programmation, rustc (le compilateur rust) requiert un binaire à partir duquel bootstraper. Il téléchargera un binaire stage0, et plusieurs fichier cargo (ce sont en fait des archives de source en .tar.gz) au début de la construction, donc vous ne pouvez pas le compiler sans connexion internet.

Le système de construction rustbuild actuel utilisera tous les processeurs disponible, bien qu'il ne passe pas bien à l'échelle et n'utilisera souvent qu'un cœur en attendant qu'une bibliothèque se compile.

Pour l'instant Rust ne donne aucune garantie de stabilité de son ABI.

[Note]

Note

Des constructions répétées de ce paquet sur la même machine montrent une vaste gamme de temps de construction. Une partie des différences peut s'expliquer par le temps pris à télécharger les fichiers cargo requis s'ils ne sont pas déjà présents, mais ne semble pas expliquer correctement toutes les variations.

De manière inhabituelle, la méthode DESTDIR est utilisée pour installer ce paquet. Cela est dû au fait que lancer l'installation en root télécharge tous les fichiers cargo de nouveau (dans /root/.cargo) puis passe encore beaucoup de temps à tout recompiler. Cette méthode réduit le temps de 30 SBU sur une machine à 4 cœurs où cela a été testé, au pris de 60 Mo d'espace disque supplémentaire pour les fichiers supplémentaires.

Ce paquet est connu pour se construire correctement sur une plateforme LFS-8.3.

Informations sur le paquet

  • Téléchargement (HTTP) : https://static.rust-lang.org/dist/rustc-1.25.0-src.tar.gz

  • Téléchargement (FTP) :

  • Somme de contrôle MD5 du téléchargement : d8d4d30c8d0b905f978bee3fdd618db5

  • Taille du téléchargement : 95 Mo

  • Estimation de l'espace disque requis : 5.1 Go (440 Mo installés), dont 379 Mo de fichiers ~/.cargo pour les utilisateurs qui le construit ce paquet et 440 Mo de fichiers de fichiers dans DESTDIR (plus 1.2 Go si vous lancez les tests)

  • Estimation du temps de construction : 33 SBU (plus 17 SBU pour les tests, dans les deux cas avec 4 processeurs)

Dépendances de Rust

Requises

cURL-7.61.0, CMake-3.12.1, libssh2-1.8.0, Python-2.7.15

Recommandées

clang de LLVM-6.0.1 (construit avec -DLLVM_LINK_LLVM_DYLIB=ON)

Facultatives

GDB-8.1.1 (souvent requis pour la suite de tests)

Notes utilisateur : http://wiki.linuxfromscratch.org/blfs/wiki/rust

Installation de Rust

[Note]

Note

Ce paquet est mis à jour sur un cycle de publication de six semaines. Comme c'est un gros paquet long à construire et qu'il n'est actuellement utilisé que par trois paquets dans le livre, les éditeurs de BLFS pensent qu'il ne devrait être mis à jour que lorsque cela est nécessaire.

Tout d'abord créez un fichier config.toml correct qui configurera la construction : 

cat << EOF > config.toml
# see config.toml.example for more possible options
[llvm]
targets = "X86"

# When using system llvm prefer shared libraries
link-shared = true

[build]
# install cargo as well as rust
extended = true

[install]
prefix = "/usr"
docdir = "share/doc/rustc-1.25.0"

[rust]
channel = "stable"
rpath = false

# get reasonably clean output from the test harness
quiet-tests = true

# BLFS does not install the FileCheck executable from llvm,
# so disable codegen tests
codegen-tests = false

[target.x86_64-unknown-linux-gnu]
# delete this *section* if you are not using system llvm.
# 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"

EOF

Maintenant installez Rust en lançant les commandes suivantes : 

export RUSTFLAGS="$RUSTFLAGS -C link-args=-lffi" &&
./x.py build

La construction rapportera un échec de construction de miri à cause de diverses sources potentielles pour « log » mais il devrait être suivit par un message indiquant que la construction s'est bien fini.

[Attention]

Attention

Sur les processeurs AMD Ryzen (famille 17h), la version non optimisée de libstd compilée au début des tests contient deux opcodes qui ne sont pas implémentés sur cette famille de CPU. Ils seront enregistrés dans le journal système et sera suivit quelques minutes plus tard par une erreur de segmentation. Cependant, les tests continuent a priori normalement. Mais le système peut redémarrer avant la fin des tests. Les bibliothèques optimisées normales fonctionnent sans ce problèmes.

Un contournement consiste à installer gdb et lancer lancer les tests avec 'ulimit -C disabled' mais cela n'évite pas toujours le redémarrage du système.

Pour lancer les tests lancez ./x.py test --verbose --no-fail-fast >../rustc-testlog : comme avec la construction, cela utilisera tous les CPU disponibles. Cela lance plusieurs suites de tests (dans un ordre apparemment aléatoire), au moins un test échoue : compile-fail/issue-37131.rs essaie de compiler pour la cible thumbv6m-none-eabi, mais la construction de BLFS ne le permet pas et les plusieurs tests de debuginfo-gdb échoueront si gdb n'est pas installé. Plusieurs autres tests dans run-make peuvent aussi échouer.

Si vous souhaitez regarder les résultats, vous pouvez trouvez le nombre total de tests lancés avec : 

grep 'running .* tests' ../rustc-testlog | awk '{ sum += $2 } END { print sum }'

Cela devrait rapporter 13224 tests. De même, le nombre de tests échoués peut être trouvé avec : 

grep '^test result:' ../rustc-testlog | awk  '{ sum += $6 } END { print sum }'

Et pareil pour les tests qui ont réussi, utilisez $4, pour ceux qui sont ignoré (c'est-à-dire passés) utilisez $8 (et $10 pour les tests mesurés, $12 pour ceux qui ont été filtrés mais ces deux-là sont probablement à 0). La somme ne correspond pas au total.

Toujours en tant qu'utilisateur normal, installez avec la méthode DESTDIR : 

DESTDIR=${PWD}/install ./x.py install

Maintenant, en tant qu'utilisateur root installez les fichiers du DESTDIR : 

chown -R root:root install &&
cp -a install/* /

Explication des commandes

targets = "X86" : Cela évite de construire tous les compilateurs croisés (Aarch64, MIPS, PowerPC, SystemZ, etc). Malheureusement, rust insiste pour installer leurs fichiers sources sous /usr/lib/rustlib/src.

extended = true : Cela installe Cargo avec Rust.

channel = "stable" : cela s'assure que seules les fonctionnalités stables peuvent être utilisée, la valeur par défaut dans config.toml est d'utiliser les fonctionnalités de développement, qui ne sont pas appropriées pour une version publique.

rpath = false : par défaut, rust peut être lancé depuis son emplacement de construction sans être installé. Cela ajoute des entrées DT_RPATH à tous les fichiers ELF, ce qui produit une sortie très chargée de la part de ldd, contenant les bibliothèques à l'emplacement de leur construction, même si elles ont été supprimées de là après l'installation.

[target.x86_64-unknown-linux-gnu] : la syntaxe de config.toml requiert une entrée llvm-config pour chaque cible pour laquelle system-llvm doit être utilisé. Modifiez la cible en [target.i686-unknown-linux-gnu] si vous construisez sur x86 32 bits. La section complète peut être omise si vous souhaitez construire avec la version de llvm incluse ou que vous n'avez pas clang, mais la construction qui en résultera sera plus grande et prendra un peu plus de temps.

export RUSTFLAGS="$RUSTFLAGS -C link-args=-lffi" : Cela ajoute un lien vers libffi dans les RUSTFLAGS que vous pourriez déjà passer à la construction. Sur certains systèmes, l'édition de lien échoue à inclure libffi à moins d'utiliser cela. La raison n'est pas très claire.

--verbose : ce paramètre peut parfois fournir plus d'informations sur un test qui échoue.

--no-fail-fast : ce paramètre s'assure que la suite de tests ne s'arrêtera pas après la première erreur.

DESTDIR=${PWD}/install ./x.py install : Cela fait une installation DESTDIR dans l'arborescence des sources, en créant un répertoire install. Remarquez que les installation DESTDIR ont besoin d'un chemin absolu. Passer « install » ne fonctionnera pas.

chown -R root:root install : l'installation DESTDIR a été lancée par un utilsateur normal qui possède les fichiers. Par sécurité, changez l'appartenance avant de faire une copie pour les installer.

Contents

Programmes installés: cargo-fmt, cargo, rls, rust-gdb, rust-lldb, rustc, rustdoc, rustfmt.
Bibliothèques installées: Beaucoup de bibliothèques lib*<16-byte-hash>.so.
Répertoires installés: ~/.cargo, /usr/lib/rustlib, /usr/share/doc/rustc-1.25.0 et /usr/share/zsh/site-functions/

Descriptions courtes

cargo-fmt

formate tous les fichiers bin et lib de la source courante avec rustfmt.

cargo

est le gestionnaire de paquets de Rust

rls

est le serveur du langage Rust. Il peut être lancé en tâche de fond pour fournir des informations sur les programmes Rust à des IDE, des éditeurs et d'autres outils.

rust-gdb

est un script enveloppe pour gdb qui récupère les modules d'affichage Python installés dans /usr/lib/rustlib/etc.

rust-lldb

est un script Python enveloppe pour LLDB (le débogueur de LLVM) qui récupère les modules d'affichage Python.

rustc

est le compilateur rust.

rustdoc

génère de la documentation à partir de code source rust.

rustfmt

formatte du code rust.

libstd-<16-byte-hash>.so

est la Bibliothèque Standard de Rust, le fondement des logiciels Rust portables.

Last updated on 2018-08-19 23:04:57 +0200