Die Veröffentlichung der Programmiersprache Rust 1.59 mit Unterstützung für Inline-Assembler.

Die Veröffentlichung der allgemein verwendeten Programmiersprache Rust 1.59 wurde angekündigt. Ursprünglich von Mozilla entwickelt, steht sie mittlerweile unter der Schirmherrschaft der unabhängigen Non-Profit-Organisation Rust Foundation. Der Fokus der Sprache liegt auf sicherem Speichermanagement und bietet Mittel zur Erreichung hohen Parallelismus bei der Ausführung von Aufgaben, ohne dabei auf Garbage Collection und Runtime angewiesen zu sein (die Runtime beschränkt sich auf die grundlegende Initialisierung und die Verwaltung der Standardbibliothek).

Die Speicherverwaltungsmethoden in Rust befreien Entwickler von Fehlern beim Umgang mit Zeigern und schützen vor Problemen, die durch die Programmierung auf niedriger Ebene entstehen, wie z.B. den Zugriff auf freigegebenen Speicher, Dereferenzierung von Nullzeigern, Pufferüberläufe usw. Zur Verteilung von Bibliotheken, zur Gewährleistung des Builds und zum Management von Abhängigkeiten wird der Paketmanager Cargo entwickelt. Für die Bereitstellung von Bibliotheken wird das Repository crates.io unterstützt.

Die sichere Handhabung von Speicher in Rust wird während der Kompilierung durch die Überprüfung von Referenzen, das Verfolgen des Besitztums von Objekten, das Management der Lebensdauer von Objekten (Sichtbarkeitsbereiche) und die Bewertung der Korrektheit des Zugriffs auf den Speicher zur Laufzeit sichergestellt. Rust bietet außerdem Mechanismen zum Schutz vor ganzzahligen Überläufen, erfordert die verpflichtende Initialisierung von Variablenwerten vor der Verwendung, behandelt Fehler in der Standardbibliothek effektiver, implementiert das Konzept der Unveränderlichkeit (immutable) von Referenzen und Variablen standardmäßig und bietet eine starke statische Typisierung zur Minimierung logischer Fehler.

Hauptneuheiten:

• Es wurde die Möglichkeit zur Verwendung von Assembler-Einfügungen bereitgestellt, die in Anwendungen gefragt sind, die eine Steuerung auf niedriger Ebene benötigen oder die Verwendung spezialisierter Maschinenanweisungen ermöglichen. Assembler-Einfügungen werden mit den Makros „asm!“ und „global_asm!“ hinzugefügt, wobei die Namensgebung der Register einer Formatierungssyntax folgt, die analog zu den Platzhaltern in Rust verwendet wird. Der Compiler unterstützt Assembler-Anweisungen für die Architekturen x86, x86-64, ARM, AArch64 und RISC-V. Beispiel für eine Einfügung: use std::arch::asm; // Multipliziere x mit 6 unter Verwendung von Verschiebungen und Addition; 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);
• Die Unterstützung für destrukturierte (parallele) Zuweisungen wurde hinzugefügt, bei denen auf der linken Seite des Ausdrucks mehrere Traits, Slices oder Strukturen angegeben werden. Zum Beispiel: 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]);
• Die Möglichkeit, Standardwerte für konstante Generics anzugeben, wurde eingeführt: struct ArrayStorage { arr: [T; N], } impl ArrayStorage { fn new(a: T, b: T) -> ArrayStorage { ArrayStorage { arr: [a, b], } } }
• Der Paketmanager Cargo bietet Warnmeldungen für die Verwendung ungültiger Konstrukte in Abhängigkeiten, die aufgrund von Compilerfehlern verarbeitet werden (z. B. wurde durch einen Fehler das Ausleihen von Feldern in verpackten Strukturen in safe-Blöcken erlaubt). Die Unterstützung solcher Konstrukte wird in einer zukünftigen Version von Rust eingestellt.
• In Cargo und rustc wurde die Möglichkeit integriert, ausführbare Dateien zu generieren, die von Debugging-Daten (strip = „debuginfo“) und Symbolen (strip = „symbols“) bereinigt sind, ohne dass ein separater Utility-Aufruf erforderlich ist. Die Bereinigung wird über den Parameter „strip“ in Cargo.toml eingerichtet: [profile.release] strip = „debuginfo“, „symbols“
• Die inkrementelle Kompilierung ist standardmäßig deaktiviert. Der Grund dafür ist ein temporärer Workaround für einen Compilerfehler, der zu Abstürzen und Deserialisierungsfehlern führt. Ein Fix ist bereits vorbereitet und wird in der nächsten Version enthalten sein. Um die inkrementelle Kompilierung wieder zu aktivieren, kann die Umgebungsvariable RUSTC_FORCE_INCREMENTAL=1 verwendet werden.
• Eine neue Reihe von APIs wurde stabilisiert und in die stabile Version überführt, einschließlich stabilisierter Methoden und Implementierungen von Traits:
  • std::thread::available_parallelism
  • Result::copied
  • Result::cloned
  • arch::asm!
  • arch::global_asm!
  • ops::ControlFlow::is_break
  • ops::ControlFlow::is_continue
  • TryFrom für u8
  • char::TryFromCharError (Clone, Debug, Display, PartialEq, Copy, Eq, Error)
  • iter::zip
  • NonZeroU8::is_power_of_two
  • NonZeroU16::is_power_of_two
  • NonZeroU32::is_power_of_two
  • NonZeroU64::is_power_of_two
  • NonZeroU128::is_power_of_two
  • DoubleEndedIterator für die Struktur ToLowercase
  • DoubleEndedIterator für die Struktur ToUppercase
  • TryFrom für [T; N]
  • UnwindSafe für die Struktur Once
  • RefUnwindSafe für Once
  • In den Compiler integrierte Funktionen zur Unterstützung von armv8 neon für aarch64
• Das „const“-Merkmal, das die Verwendung in jedem Kontext anstelle von Konstanten ermöglicht, wurde in den Funktionen angewendet:
  • mem::MaybeUninit::as_ptr
  • mem::MaybeUninit::assume_init
  • mem::MaybeUninit::assume_init_ref
  • ffi::CStr::from_bytes_with_nul_unchecked

Quelle: opennet.ru