Rustc-1.22.1

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 montre 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. En plus, le constructeur et l'utilisateur qui lance l'installation devront télécharger les recettes cargo s'ils ne sont pas déjà présents dans ~/.cargo.

Si vous utilisez la méthode DESTDIR pour l'installation, vous devrez seulement télécharger les recettes une fois, pour la construction, ce qui fait gagner environ un tiers du temps de construction et d'installation (mais utilise plus de place pour l'installation). Pareillement si vous construisez en root, ou si votre utilisateur a le droit de lancer sudo ./x.py install - mais ces méthodes sont dangereuses.

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

Informations sur le paquet

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

  • Téléchargement (FTP) :

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

  • Taille du téléchargement : 53 Mo

  • Estimation de l'espace disque requis : 4.1 Go (437 Mo installés), (plus 1.2 Go pour les tests) plus 226 Mo pour les fichiers ~/.cargo pour le constructeur et la racine (depuis l'installation)

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

Dépendances de Rust

Requises

cURL-7.58.0, CMake-3.10.2, Python-2.7.14

Facultatives

GDB-8.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 toutes les six semaines. Comme c'est un gros paquet long à construire et qu'il n'est actuellement utilisé que par deux 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"

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

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

[rust]
channel = "stable"
rpath = false
EOF

Maintenant installez Rust en lançant les commandes suivantes :

./x.py build

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), trois peuvent échouer : compile-fail/issue-37131.rs et run-make/target-without-atomics essayent tous les deux de compiler pour la cible thumbv6m-none-eabi, mais la construction de BLFS ne le permet pas et les 105 tests de debuginfo-gdb échoueront tous si gdb n'est pas installé. Plusieurs autres tests dans run-make peuvent aussi échouer. Avec glibc-2.27, la page de garde de la pile se trouve maintenant juste au-delà de la pile, plutôt qu'à l'intérieur. Cela fait échouer trois tests (out-of-stack.rs, stack-probes-lto.rs, stack-probes.rs).

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 14854 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.

Maintenant, en tant qu'utilisateur root :

./x.py install

Explication des commandes

targets = "X86" : Cela évite de construire tous les compilateurs croisés pour Linux (Aarch64, MIPS, PowerPC, SystemZ, etc).

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.

--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.

PYTHON=/usr/bin/python3 ... tee buildlog : Comme rust peut utiliser Python3 qui a été installé dans LFS, cette commande lui dit de l'utiliser plutôt que l'obsolète Python2. Pour le moment cela devrait être considéré comme expérimental et des problèmes peuvent survenir. Comme rust utilisera tous les CPU, si une erreur arrive, le message peut avoir défilé en dehors du tampon du terminal. Garde un log permet de comprendre ce qui s'est passé.

Contents

Programmes installés: cargo, rls, rust-gdb, rust-lldb, rustc, rustdoc.
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.22.1 et /usr/share/zsh/site-functions/

Descriptions courtes

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 Python enveloppe pour gdb

rust-lldb

est un script Python enveloppe pour LLDB (le débogueur de LLVM)

rustc

est le compilateur rust.

rustdoc

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

libstd-<16-byte-hash>.so

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

Last updated on 2018-02-26 10:09:38 +0100