Skip to content

Commit

Permalink
Add a package for rust version 1.82.0.
Browse files Browse the repository at this point in the history
Pkgsrc changes:
 * Adapt patches, apply to new vendored crates where needed.
 * Back-port rust pull request 130110, "make dist vendoring configurable"
 * Disable "dist vendoring", otherwise cargo would try to access
   the network during the build phase.

Upstream changes:

Version 1.82.0 (2024-10-17)
==========================

Language
--------
- [Don't make statement nonterminals match pattern nonterminals]
  (rust-lang/rust#120221)
- [Patterns matching empty types can now be omitted in common cases]
  (rust-lang/rust#122792)
- [Enforce supertrait outlives obligations when using trait impls]
  (rust-lang/rust#124336)
- [`addr_of(_mut)!` macros and the newly stabilized `&raw (const|mut)`
  are now safe to use with all static items]
  (rust-lang/rust#125834)
- [size_of_val_raw: for length 0 this is safe to call]
  (rust-lang/rust#126152)
- [Reorder trait bound modifiers *after* `for<...>` binder in trait bounds]
  (rust-lang/rust#127054)
- [Stabilize opaque type precise capturing (RFC 3617)]
  (rust-lang/rust#127672)
- [Stabilize `&raw const` and `&raw mut` operators (RFC 2582)]
  (rust-lang/rust#127679)
- [Stabilize unsafe extern blocks (RFC 3484)]
  (rust-lang/rust#127921)
- [Stabilize nested field access in `offset_of!`]
  (rust-lang/rust#128284)
- [Do not require `T` to be live when dropping `[T; 0]`]
  (rust-lang/rust#128438)
- [Stabilize `const` operands in inline assembly]
  (rust-lang/rust#128570)
- [Stabilize floating-point arithmetic in `const fn`]
  (rust-lang/rust#128596)
- [Stabilize explicit opt-in to unsafe attributes]
  (rust-lang/rust#128771)
- [Document NaN bit patterns guarantees]
  (rust-lang/rust#129559)

Compiler
--------
- [Promote riscv64gc-unknown-linux-musl to tier 2]
  (rust-lang/rust#122049)
- [Promote Mac Catalyst targets `aarch64-apple-ios-macabi` and
  `x86_64-apple-ios-macabi` to Tier 2, and ship them with rustup]
  (rust-lang/rust#126450)
- [Add tier 3 NuttX based targets for RISC-V and ARM]
  (rust-lang/rust#127755)
- [Add tier 3 powerpc-unknown-linux-muslspe target]
  (rust-lang/rust#127905)
- [Improved diagnostics to explain why a pattern is unreachable]
  (rust-lang/rust#128034)
- [The compiler now triggers the unreachable code warning properly
  for async functions that don't return/are `-> !`]
  (rust-lang/rust#128443)
- [Promote `aarch64-apple-darwin` to Tier 1]
  (rust-lang/rust#128592)
- [Add Trusty OS target `aarch64-unknown-trusty` and `armv7-unknown-trusty`
  as tier 3 targets] (rust-lang/rust#129490)
- [Promote `wasm32-wasip2` to Tier 2.]
  (rust-lang/rust#126967)

Libraries
---------
- [Generalize `{Rc,Arc}::make_mut()` to `Path`, `OsStr`, and `CStr`.]
  (rust-lang/rust#126877)

Stabilized APIs
---------------
- [`std::thread::Builder::spawn_unchecked`]
  (https://doc.rust-lang.org/stable/std/thread/struct.Builder.html#method.spawn_unchecked)
- [`std::str::CharIndices::offset`]
  (https://doc.rust-lang.org/nightly/std/str/struct.CharIndices.html#method.offset)
- [`std::option::Option::is_none_or`]
  (https://doc.rust-lang.org/nightly/std/option/enum.Option.html#method.is_none_or)
- [`[T]::is_sorted`]
  (https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted)
- [`[T]::is_sorted_by`]
  (https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted_by)
- [`[T]::is_sorted_by_key`]
  (https://doc.rust-lang.org/nightly/std/primitive.slice.html#method.is_sorted_by_key)
- [`Iterator::is_sorted`]
  (https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted)
- [`Iterator::is_sorted_by`]
  (https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted_by)
- [`Iterator::is_sorted_by_key`]
  (https://doc.rust-lang.org/nightly/std/iter/trait.Iterator.html#method.is_sorted_by_key)
- [`std::future::Ready::into_inner`]
  (https://doc.rust-lang.org/nightly/std/future/struct.Ready.html#method.into_inner)
- [`std::iter::repeat_n`]
  (https://doc.rust-lang.org/nightly/std/iter/fn.repeat_n.html)
- [`impl<T: Clone> DoubleEndedIterator for Take<Repeat<T>>`]
  (https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-DoubleEndedIterator-for-Take%3CRepeat%3CT%3E%3E)
- [`impl<T: Clone> ExactSizeIterator for Take<Repeat<T>>`]
  (https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-ExactSizeIterator-for-Take%3CRepeat%3CT%3E%3E)
- [`impl<T: Clone> ExactSizeIterator for Take<RepeatWith<T>>`]
  (https://doc.rust-lang.org/nightly/std/iter/struct.Take.html#impl-ExactSizeIterator-for-Take%3CRepeatWith%3CF%3E%3E)
- [`impl Default for std::collections::binary_heap::Iter`]
  (https://doc.rust-lang.org/nightly/std/collections/binary_heap/struct.Iter.html#impl-Default-for-Iter%3C'_,+T%3E)
- [`impl Default for std::collections::btree_map::RangeMut`]
  (https://doc.rust-lang.org/nightly/std/collections/btree_map/struct.RangeMut.html#impl-Default-for-RangeMut%3C'_,+K,+V%3E)
- [`impl Default for std::collections::btree_map::ValuesMut`]
  (https://doc.rust-lang.org/nightly/std/collections/btree_map/struct.ValuesMut.html#impl-Default-for-ValuesMut%3C'_,+K,+V%3E)
- [`impl Default for std::collections::vec_deque::Iter`]
  (https://doc.rust-lang.org/nightly/std/collections/vec_deque/struct.Iter.html#impl-Default-for-Iter%3C'_,+T%3E)
- [`impl Default for std::collections::vec_deque::IterMut`]
  (https://doc.rust-lang.org/nightly/std/collections/vec_deque/struct.IterMut.html#impl-Default-for-IterMut%3C'_,+T%3E)
- [`Rc<T>::new_uninit`]
  (https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new_uninit)
- [`Rc<T>::assume_init`]
  (https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.assume_init)
- [`Rc<[T]>::new_uninit_slice`]
  (https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.new_uninit_slice)
- [`Rc<[MaybeUninit<T>]>::assume_init`]
  (https://doc.rust-lang.org/nightly/std/rc/struct.Rc.html#method.assume_init-1)
- [`Arc<T>::new_uninit`]
  (https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.new_uninit)
- [`Arc<T>::assume_init`]
  (https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.assume_init)
- [`Arc<[T]>::new_uninit_slice`]
  (https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.new_uninit_slice)
- [`Arc<[MaybeUninit<T>]>::assume_init`]
  (https://doc.rust-lang.org/nightly/std/sync/struct.Arc.html#method.assume_init-1)
- [`Box<T>::new_uninit`]
  (https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.new_uninit)
- [`Box<T>::assume_init`]
  (https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.assume_init)
- [`Box<[T]>::new_uninit_slice`]
  (https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.new_uninit_slice)
- [`Box<[MaybeUninit<T>]>::assume_init`]
  (https://doc.rust-lang.org/nightly/std/boxed/struct.Box.html#method.assume_init-1)
- [`core::arch::x86_64::_bextri_u64`]
  (https://doc.rust-lang.org/stable/core/arch/x86_64/fn._bextri_u64.html)
- [`core::arch::x86_64::_bextri_u32`]
  (https://doc.rust-lang.org/stable/core/arch/x86_64/fn._bextri_u32.html)
- [`core::arch::x86::_mm_broadcastsi128_si256`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_broadcastsi128_si256.html)
- [`core::arch::x86::_mm256_stream_load_si256`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm256_stream_load_si256.html)
- [`core::arch::x86::_tzcnt_u16`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._tzcnt_u16.html)
- [`core::arch::x86::_mm_extracti_si64`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_extracti_si64.html)
- [`core::arch::x86::_mm_inserti_si64`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_inserti_si64.html)
- [`core::arch::x86::_mm_storeu_si16`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si16.html)
- [`core::arch::x86::_mm_storeu_si32`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si32.html)
- [`core::arch::x86::_mm_storeu_si64`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_storeu_si64.html)
- [`core::arch::x86::_mm_loadu_si16`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_loadu_si16.html)
- [`core::arch::x86::_mm_loadu_si32`]
  (https://doc.rust-lang.org/stable/core/arch/x86/fn._mm_loadu_si32.html)
- [`core::arch::wasm32::u8x16_relaxed_swizzle`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u8x16_relaxed_swizzle.html)
- [`core::arch::wasm32::i8x16_relaxed_swizzle`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i8x16_relaxed_swizzle.html)
- [`core::arch::wasm32::i32x4_relaxed_trunc_f32x4`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_trunc_f32x4.html)
- [`core::arch::wasm32::u32x4_relaxed_trunc_f32x4`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_trunc_f32x4.html)
- [`core::arch::wasm32::i32x4_relaxed_trunc_f64x2_zero`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_trunc_f64x2_zero.html)
- [`core::arch::wasm32::u32x4_relaxed_trunc_f64x2_zero`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_trunc_f64x2_zero.html)
- [`core::arch::wasm32::f32x4_relaxed_madd`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_madd.html)
- [`core::arch::wasm32::f32x4_relaxed_nmadd`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_nmadd.html)
- [`core::arch::wasm32::f64x2_relaxed_madd`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_madd.html)
- [`core::arch::wasm32::f64x2_relaxed_nmadd`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_nmadd.html)
- [`core::arch::wasm32::i8x16_relaxed_laneselect`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i8x16_relaxed_laneselect.html)
- [`core::arch::wasm32::u8x16_relaxed_laneselect`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u8x16_relaxed_laneselect.html)
- [`core::arch::wasm32::i16x8_relaxed_laneselect`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_laneselect.html)
- [`core::arch::wasm32::u16x8_relaxed_laneselect`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_laneselect.html)
- [`core::arch::wasm32::i32x4_relaxed_laneselect`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_laneselect.html)
- [`core::arch::wasm32::u32x4_relaxed_laneselect`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_laneselect.html)
- [`core::arch::wasm32::i64x2_relaxed_laneselect`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i64x2_relaxed_laneselect.html)
- [`core::arch::wasm32::u64x2_relaxed_laneselect`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u64x2_relaxed_laneselect.html)
- [`core::arch::wasm32::f32x4_relaxed_min`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_min.html)
- [`core::arch::wasm32::f32x4_relaxed_max`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f32x4_relaxed_max.html)
- [`core::arch::wasm32::f64x2_relaxed_min`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_min.html)
- [`core::arch::wasm32::f64x2_relaxed_max`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.f64x2_relaxed_max.html)
- [`core::arch::wasm32::i16x8_relaxed_q15mulr`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_q15mulr.html)
- [`core::arch::wasm32::u16x8_relaxed_q15mulr`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_q15mulr.html)
- [`core::arch::wasm32::i16x8_relaxed_dot_i8x16_i7x16`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i16x8_relaxed_dot_i8x16_i7x16.html)
- [`core::arch::wasm32::u16x8_relaxed_dot_i8x16_i7x16`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u16x8_relaxed_dot_i8x16_i7x16.html)
- [`core::arch::wasm32::i32x4_relaxed_dot_i8x16_i7x16_add`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.i32x4_relaxed_dot_i8x16_i7x16_add.html)
- [`core::arch::wasm32::u32x4_relaxed_dot_i8x16_i7x16_add`]
  (https://doc.rust-lang.org/nightly/core/arch/wasm32/fn.u32x4_relaxed_dot_i8x16_i7x16_add.html)

These APIs are now stable in const contexts:

- [`std::task::Waker::from_raw`]
  (https://doc.rust-lang.org/nightly/std/task/struct.Waker.html#method.from_raw)
- [`std::task::Waker::waker`]
  (https://doc.rust-lang.org/nightly/std/task/struct.Waker.html#method.from_raw)
- [`std::task::Context::from_waker`]
  (https://doc.rust-lang.org/nightly/std/task/struct.Context.html#method.from_waker)
- [`std::task::Context::waker`]
  (https://doc.rust-lang.org/nightly/std/task/struct.Context.html#method.waker)
- [`$integer::from_str_radix`]
  (https://doc.rust-lang.org/nightly/std/primitive.u32.html#method.from_str_radix)
- [`std::num::ParseIntError::kind`]
  (https://doc.rust-lang.org/nightly/std/num/struct.ParseIntError.html#method.kind)

Cargo
-----
- [feat: Add `info` cargo subcommand]
  (rust-lang/cargo#14141)

Compatibility Notes
-------------------
 - We now [disallow setting some built-in cfgs via the
   command-line](rust-lang/rust#126158) with
   the newly added
   [`explicit_builtin_cfgs_in_flags`]
   (https://doc.rust-lang.org/rustc/lints/listing/deny-by-default.html#explicit-builtin-cfgs-in-flags)
   lint in order to prevent incoherent state, eg. `windows` cfg active
   but target is Linux based. The appropriate [`rustc` flag]
   (https://doc.rust-lang.org/rustc/command-line-arguments.html)
   should be used instead.

- The standard library has a new implementation of `binary_search`
  which is significantly improves performance
  ([#128254](rust-lang/rust#128254)). However
  when a sorted slice has multiple values which compare equal, the
  new implementation may select a different value among the equal
  ones than the old implementation.

- [illumos/Solaris now sets `MSG_NOSIGNAL` when writing to
  sockets](rust-lang/rust#128259). This avoids
  killing the process with SIGPIPE when writing to a closed socket,
  which matches the existing behavior on other UNIX targets.

- [Removes a problematic hack that always passed the --whole-archive
  linker flag for tests, which may cause linker errors for code
  accidentally relying on it.]
  (rust-lang/rust#128400)

- The WebAssembly target features `multivalue` and `reference-types`
  are now both enabled by default. These two features both have
  subtle changes implied for generated WebAssembly binaries. For
  the `multivalue` feature, WebAssembly target support has changed
  when upgrading to LLVM 19. Support for generating functions with
  multiple returns no longer works and `-Ctarget-feature=+multivalue`
  has a different meaning than it did in LLVM 18 and prior. There
  is no longer any supported means to generate a module that has
  a function with multiple returns in WebAssembly from Rust source
  code. For the `reference-types` feature the encoding of immediates
  in the `call_indirect`, a commonly used instruction by the
  WebAssembly backend, has changed. Validators and parsers which
  don't understand the `reference-types` proposal will no longer
  accept modules produced by LLVM due to this change in encoding
  of immediates. Additionally these features being enabled are
  encoded in the `target_features` custom section and may affect
  downstream tooling such as `wasm-opt` consuming the module.
  Generating a WebAssembly module that disables default features
  requires `-Zbuild-std` support from Cargo and more information
  can be found at
  [rust-lang/rust#128511](rust-lang/rust#128511).
- [Rust now raises unsafety errors for union patterns in parameter-position]
  (rust-lang/rust#130531)

Internal Changes
----------------

These changes do not affect any public interfaces of Rust, but they
represent significant improvements to the performance or internals
of rustc and related tools.

- [Update to LLVM 19]
  (rust-lang/rust#127513)
  • Loading branch information
he32 committed Oct 27, 2024
1 parent 36273dc commit bcbbdff
Show file tree
Hide file tree
Showing 59 changed files with 3,146 additions and 0 deletions.
13 changes: 13 additions & 0 deletions rust182/DESCR
Original file line number Diff line number Diff line change
@@ -0,0 +1,13 @@
Rust is a systems programming language focused on three goals: safety,
speed, and concurrency. It maintains these goals without having a
garbage collector, making it a useful language for a number of use cases
other languages aren't good at: embedding in other languages, programs
with specific space and time requirements, and writing low-level code,
like device drivers and operating systems.

It improves on current languages targeting this space by having a number
of compile-time safety checks that produce no runtime overhead, while
eliminating all data races. Rust also aims to achieve "zero-cost
abstractions" even though some of these abstractions feel like those of
a high-level language. Even then, Rust still allows precise control
like a low-level language would.
85 changes: 85 additions & 0 deletions rust182/HOWTO-BOOTSTRAP
Original file line number Diff line number Diff line change
@@ -0,0 +1,85 @@
How to build a rust bootstrap kit using pkgsrc
----------------------------------------------

A rust bootstrap kit is simply a pre-compiled binary of rust and
the rust standard library, and contains the "rust" and "rust-std"
build results, found in

work/rustc-<version>/build/dist/
as
rust-<version>-<target>.tar.xz
and
rust-std-<version>-<target>.tar.xz

These result files are produced when the "dist" build target is
used, ref. BUILD_TARGET. For a normal native build of the rust
pkgsrc package, the default BUILD_TARGET is "build", not "dist".

There are two possible ways to produce a bootstrap kit:

1) a native build. This requires minimum preparation, except
possibly for setting rust.BUILD_TARGET to "dist" via e.g.
/etc/mk.conf. Note that on NetBSD, using the "BUILD_TARGET" ==
"dist" results in the "rust-cargo-static" option being set, ref.
options.mk. This is so that the resulting bootstrap kits are
built with mostly-static linking, reducing the run-time dependencies
of the bootstrap kits.

2) a cross-build. This requires a bit of preparation:

For each target you want to cross-build rust for, you need
- the cross toolchain resulting from "build.sh tools" for
the intended target
- an OS distribution extracted, including the comp.tgz
set so that the target's include files can be used
- for 32-bit ports, the "libatomic" package needs to be
available. I'm sure there's a clever and long-winded
use of pkg_install which can be used to effect this;
I on my hand have always just extracted the tgz file
and done the minimal cleanup of the "cruft" files
which are part of the package meta-data.
- Pick a root directory for the target, e.g. /u/i386.
Below this directory place the "tools" containing
the cross-compiler in a "tools" sub-directory.
Similarly, the extracted OS distribution in the "dest"
sub-directory.

There are two methods available for doing the cross-compile:

a) Using the "cross.mk" file. For an i386 build against i586, the
following settings should be active:

CROSS_ROOT= /u/i386
MAKE_ENV+= CROSS_ROOT=${CROSS_ROOT}
GNU_CROSS_TARGET= i486--netbsdelf
MAKE_ENV+= GNU_CROSS_TARGET=${GNU_CROSS_TARGET}
TARGET= i586-unknown-netbsd
SCRIPTS= ${WRKDIR}/scripts
CONFIGURE_ARGS+= --host=${TARGET}
CONFIGURE_ARGS+= --target=${TARGET}
CONFIGURE_ARGS+= --set=target.${TARGET}.cc=${SCRIPTS}/gcc-wrap
CONFIGURE_ARGS+= --set=target.${TARGET}.cxx=${SCRIPTS}/c++-wrap
CONFIGURE_ARGS+= --set=target.${TARGET}.linker=${SCRIPTS}/gcc-wrap
CONFIGURE_ARGS+= --set=target.${TARGET}.ar=${CROSS_ROOT}/tools/bin/${GNU_CROSS_TARGET}-ar

Then doing a "make" will cross-build rust, including the LLVM
embedded in the rust distribution, ref. the defaulting of that
option when TARGET is defined ref. options.mk.

Note that when TARGET is set, the default build target for
the rust makefile becomes "dist", so there's no need to set
rust.BUILD_TARGET for cross-builds.

b) Using the "do-cross.mk" Makefile. This will attempt to
cross-build rust for all the targets listed in the SHORT_TARGETS
variable in that file. Overriding the root directories for
the various targets can be done by making your own "local-roots.mk"
file, ref. "do-cross.mk".

This will create a "dist" subdirectory in the rust pkgsrc
directory, and the bootstrap kits for each architecture, plus
the library source kit will be placed in this directory.

The bootstrap kits can then be placed in /usr/pkgsrc/distfiles, and
be used by the "next" rust version, where you can use "make makesum"
to compute the updated checksums for the bootstrap kits.
Loading

0 comments on commit bcbbdff

Please sign in to comment.