Rust 1.25 Moves to LLVM 6

综合技术 2018-04-03

Rust 1.25
upgrades its LLVM to LLVM 6, adds support for nested import groups in use
statements, custom struct
alignment, and library stabilizations. This latest Rust release does not include, though, much awaited features such as impl Trait
, stable SIMD support, and 128-bit integers.

The update to LLVM 6 is motivated by a number of benefits
, such as assorted bug fixes, including SIMD-related compilation errors, but mostly by the fact it allows to keep up with LLVM’s upstream Wasm backend more easily, so new Wasm features can be supported quickly. This has an important exception for the Emscripted-powered JavaScript backend, which is using a locked up LLVM 4 version
. According to Rust developer Steve Klabnik, LLVM 6 does not necessarily bring any performance improvements in the general case
, and it will depend on the exact code whether it will provide faster or slower compilation.

The new use
statement syntax allows developers to specify nested import groups
, aiming to make the code more readable and concise. For example, the following set of imports:

use std::fs::File;
use std::io::Read;
use std::path::{Path, PathBuf};

can now be written as:

use std::{fs::File, io::Read, path::{Path, PathBuf}};

Additionally, you can set the alignment of Rust 1.25 structs
using
#[repr(align(x))]

annotation s:

struct Number(i32);

assert_eq!(std::mem::align_of::(), 4);
assert_eq!(std::mem::size_of::(), 4);

#[repr(align(16))]
struct Align16(i32);

assert_eq!(std::mem::align_of::(), 16);
assert_eq!(std::mem::size_of::(), 16);

This feature can be useful when using hardware with specific alignment requirements, for better interoperability with C code, e.g. to make it easier to correctly pass a struct that some C code expects to be aligned in a given manner, and for advanced cases such as statically allocating page tables in a kernel.

On the library front, the most significant change is the introduction of
std::ptr::NonNull

, which is like *mut T
but with the guarantee of being non-zero and covariant. Its use is mostly appropriate when building data structures with unsafe code.

As it stands, Rust 1.25 is not the Rust big release many developers are waiting for, since it does not include major features that the Rust team has been working on for quite some time, including impl Trait
(which should allow for improved performance, simpler generics syntax and diagnostics), 128-bit integers, stable SIMD library support, and others. The good news, according to Klabnik, is they are likely going to land in the next two releases, 1.26 and 1.27.

InfoQ

责编内容by:InfoQ (源链)。感谢您的支持!

您可能感兴趣的

PostgreSQL getting LLVM JIT support for faster per... PostgreSQL Begins Landing LLVM JIT Support For Faster Performance Writte...
Is functional programming in Rust cost-free&qu... I've made some tests on functional style programming in Rust. let iteration...
Implementing a Custom Directive Handler in Clang Pragma and Annotations The C and C++ languages have a built-in mechanism for ...
Benchmarking In Stable Rust With Criterion.rs When I initially announced the release of Criterion.rs, I didn’t expect that the...
Rust Berlin Meetup September 2017 Rust Berlin Meetup September 2017 Talks: An overview of the Serv...