AccueilActualités informatiqueLe langage de programmation Rust 1.59 intègre du code assembleur

Le langage de programmation Rust 1.59 intègre du code assembleur

La version 1.59 de Rust est sortie comme prévu toutes les six semaines. Par rapport aux deux versions ponctuelles précédentes, la version actuelle apporte plus de nouveautés. Entre autres, le code assembleur peut être utilisé dans les programmes Rust pour certaines plates-formes. De plus, les tuples peuvent désormais être placés à gauche des affectations déstructurantes et les types génériques peuvent contenir des spécifications par défaut pour les génériques Const.

Sommaire

Rust 1.59 introduit du code assembleur en ligne et pour cela les macros asm! et global_asm! est inséré. La syntaxe pour intégrer le code assembleur est la même que pour les chaînes de format. L’équipe Rust a étendu cette dernière dans la version 1.58. Comme Rust ne peut pas garantir la sécurité de la mémoire pour les instructions en langage d’assemblage, les macros doivent être placées à l’intérieur d’un fichier de données. unsafe-sont placées dans un bloc. L’exemple suivant, tiré du blog de Rust, montre l’intégration avec deux instructions logiques Shift-Left (shl) et une addition :

use std::arch::asm;

// Multiply x by 6 using shifts and adds
let mut x: u64 = 4;
unsafe {
    asm!(
        "mov {tmp}, {x}",
        "shl {tmp}, 1",
        "shl {x}, 2",
        "add {x}, {tmp}",
        x = inout(reg) x,
        tmp = out(reg) _,
    );
}
assert_eq!(x, 4 * 6);

Les instructions disponibles dépendent de l’architecture sous-jacente. Au démarrage, Rust intègre le langage d’assemblage pour x86 et x64, ARM, AArch64 ainsi que RISC-V. Quelques exemples pour différentes applications sont disponibles dans la documentation de Rust.

Lire aussi

La dernière version étend également les assignations déstructurantes afin d’extraire le contenu d’ensembles tels que les tuples, les tableaux ou les ensembles. Depuis peu, les tranches, les tuples et les structures peuvent être placés non seulement à droite, mais aussi à gauche des instructions, afin d’insérer directement les éléments dans les collections.

En plus d’une affectation directe pour les éléments d’ensembles de même taille, la syntaxe d’étalement est autorisée :

let (a, b, c, d, e);

(a, b) = (1, 2);
[c, .., d, _] = [1, 2, 3, 4, 5];
Struct { e, .. } = Struct { e: 5, f: 3 };

assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);

Rust n’autorise cependant qu’une affectation directe via = et pas d’opérateurs arithmétiques comme l’affectation d’addition via +=.

Pour les Const Generics introduits dans Rust 1.51, il y a deux adaptations mineures mais utiles dans la version actuelle : D’une part, l’ordre strict selon lequel les paramètres de type doivent être placés avant les paramètres constants est supprimé et d’autre part, les types génériques peuvent désormais contenir des valeurs par défaut pour les Const Generics.

Pour le processus de construction, Rust 1.59 apporte également quelques adaptations. Entre autres, il est désormais possible de créer automatiquement des binaires strippés qui sont débarrassés des informations superflues comme les informations de débogage. Pour cela, le paramètre strip dans le fichier de manifeste Cargo.toml : strip = "symbols" supprime tous les symboles lors de la liaison du binaire et strip = "debuginfo" ne conserve que les informations de débogage.

Autre nouveauté : l’outil de gestion des paquets Cargo prévient des incompatibilités avec les futures versions de Rust dans les dépendances. Celui qui, lors de la construction ou de la vérification d’un crate, c’est-à-dire d’un paquet Rust, passe par cargo build ou cargo check reçoit l’avertissement « warning : the following packages contain code that will be rejected by a future version of Rust », peut se connecter à l’adresse suivante cargo report pour obtenir une description détaillée du problème.

Pendant ce temps, la compilation incrémentale est temporairement désactivée par défaut. La raison en est un bug qui peut conduire à des erreurs de désérialisation. La version bêta de Rust 1.60 contient probablement déjà une correction de bug. L’équipe invite à tester les builds bêta et nightly afin que la version prévue dans six semaines puisse compiler de manière incrémentielle et stable.

Indépendamment de la version actuelle et du bug, l’équipe Rust a publié les plans de développement du compilateur. Concrètement, des extensions pour la programmation asynchrone sont notamment prévues pour cette année. Ainsi, il devrait être possible à l’avenir async fn dans les traits. L’initiative Async-Crashdump devrait en outre donner plus de visibilité sur le flux de contrôle lors du crash de programmes asynchrones.

En plus des plans concrets pour cette année, il existe des efforts pour étendre le compilateur, pour lesquels les ressources manquent encore actuellement.

(Image : rust-lang.org)

En outre, il est prévu d’améliorer les performances et un groupe de travail spécifique s’occupe de l’amélioration des informations de débogage et de l’intégration dans des débogueurs basés sur la trace comme rr.

Vous trouverez plus de détails sur Rust 1.59 sur le blog de Rust. Comme d’habitude, les développeurs qui ont déjà installé Rust peuvent télécharger la dernière version via le lien suivant rustup update stable pour la télécharger. Pour ceux qui n’utilisent pas encore Rust, l’outil rustup est disponible séparément sur la page de téléchargement. Pour savoir comment installer les nightly builds pour tester la correction du compilateur, consultez la documentation de Rust.

Plus d'articles