Rilascio del linguaggio di programmazione Rust 1.59 con supporto per inserimenti in assembler

È stato pubblicato il rilascio del linguaggio di programmazione generale Rust 1.59, originariamente sviluppato da Mozilla e attualmente gestito dalla Rust Foundation, un'organizzazione indipendente e no-profit. Il linguaggio si concentra sulla gestione sicura della memoria e offre strumenti per raggiungere un elevato parallelismo nell'esecuzione dei compiti, senza fare uso di garbage collector e runtime (il runtime è limitato all'inizializzazione di base e al supporto della libreria standard).

I metodi di gestione della memoria in Rust liberano gli sviluppatori dagli errori nella manipolazione dei puntatori e li proteggono da problematiche derivanti dal lavoro a basso livello con la memoria, come l'accesso a zone di memoria dopo la loro liberazione, la dereferenziazione di puntatori nulli, il superamento dei limiti del buffer, e così via. Per la distribuzione delle librerie, la gestione della compilazione e delle dipendenze, si è sviluppato un gestore di pacchetti chiamato Cargo. Le librerie sono ospitate nel repository crates.io.

La gestione sicura della memoria in Rust è garantita durante la compilazione tramite il controllo dei riferimenti, il tracciamento della proprietà degli oggetti, la gestione della durata degli oggetti (scope) e la valutazione della correttezza dell'accesso alla memoria durante l'esecuzione del codice. Rust offre anche strumenti per proteggere da overflow interi, richiede l'inizializzazione obbligatoria dei valori delle variabili prima dell'uso, gestisce meglio gli errori nella libreria standard, applica il concetto di riferimenti e variabili immutabili per impostazione predefinita e offre una forte tipizzazione statica per ridurre al minimo gli errori logici.

Novità principali:

• È stata introdotta la possibilità di utilizzare inserimenti assembly, richiesti nelle applicazioni che necessitano di controllare l'esecuzione a basso livello o di poter utilizzare istruzioni macchina specializzate. Gli inserimenti assembly vengono aggiunti tramite le macro «asm!» e «global_asm!» utilizzando una sintassi di formattazione delle stringhe per la denominazione dei registri, simile a quella utilizzata nei segnaposto delle stringhe in Rust. Il compilatore supporta istruzioni assembly per le architetture x86, x86-64, ARM, AArch64 e RISC-V. Esempio di inserimento: use std::arch::asm; // Moltiplica x per 6 usando shift e addi 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);
• È stata aggiunta la supporto per assegnazioni destrutturate (parallele), in cui nel lato sinistro dell'espressione vengono specificati più trait, slice o strutture. Ad esempio: 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]);
• È stata fornita la possibilità di specificare valori predefiniti per i generici costanti («const generics»): struct ArrayStorage { arr: [T; N], } impl ArrayStorage { fn new(a: T, b: T) -> ArrayStorage { ArrayStorage { arr: [a, b], } } }
• Nel gestore di pacchetti Cargo è stato implementato un avviso riguardante l'uso di costrutti non validi nelle dipendenze, gestiti a causa di errori del compilatore (ad esempio, a causa di un errore, era permessa l'acquisizione di campi di strutture incapsulate in blocchi safe). Il supporto per tali costrutti verrà interrotto in una futura versione di Rust.
• In cargo e rustc è stata incorporata la possibilità di generare file eseguibili privi di dati di debug (strip = «debuginfo») e simboli (strip = «symbols»), senza la necessità di chiamare un'utilità separata. La configurazione della pulizia è implementata tramite il parametro «strip» in Cargo.toml: [profile.release] strip = «debuginfo», «symbols»
• Per impostazione predefinita, la compilazione incrementale è disabilitata. La causa è un bypass temporaneo di un errore nel compilatore che provoca arresti anomali e errori di deserializzazione. La correzione dell'errore è già pronta e sarà inclusa nella prossima versione. Per riattivare la compilazione incrementale, è possibile utilizzare la variabile di ambiente RUSTC_FORCE_INCREMENTAL=1.
• Una nuova serie di API è stata traslata nella categoria stabile, stabilizzando i metodi e le implementazioni dei tipi:
  • std::thread::available_parallelism
  • Result::copied
  • Result::cloned
  • arch::asm!
  • arch::global_asm!
  • ops::ControlFlow::is_break
  • ops::ControlFlow::is_continue
  • TryFrom for 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 per la struttura ToLowercase
  • DoubleEndedIterator per la struttura ToUppercase
  • TryFrom<&mut [T]> per [T; N]
  • UnwindSafe per la struttura Once
  • RefUnwindSafe per Once
  • funzioni di supporto armv8 neon integrate nel compilatore per aarch64
• L'indicatore «const», che determina la possibilità di utilizzo in qualsiasi contesto al posto delle costanti, è stato applicato nelle funzioni:
  • mem::MaybeUninit::as_ptr
  • mem::MaybeUninit::assume_init
  • mem::MaybeUninit::assume_init_ref
  • ffi::CStr::from_bytes_with_nul_unchecked

Fonte: opennet.ru