diff options
| -rw-r--r-- | pkgs/applications/networking/browsers/firefox/bindgen-0.64-clang-18.patch | 39 | ||||
| -rw-r--r-- | pkgs/applications/networking/browsers/firefox/common.nix | 13 | ||||
| -rw-r--r-- | pkgs/applications/networking/browsers/firefox/rust-1.78.patch | 77 | ||||
| -rw-r--r-- | pkgs/development/compilers/rust/1_77.nix | 59 | ||||
| -rw-r--r-- | pkgs/development/compilers/rust/1_78.nix | 59 | ||||
| -rw-r--r-- | pkgs/os-specific/linux/kernel/patches.nix | 16 | ||||
| -rw-r--r-- | pkgs/os-specific/linux/kernel/rust-1.77-6.8.patch | 799 | ||||
| -rw-r--r-- | pkgs/os-specific/linux/kernel/rust-1.77.patch | 159 | ||||
| -rw-r--r-- | pkgs/top-level/all-packages.nix | 10 | ||||
| -rw-r--r-- | pkgs/top-level/linux-kernels.nix | 2 |
10 files changed, 1086 insertions, 147 deletions
diff --git a/pkgs/applications/networking/browsers/firefox/bindgen-0.64-clang-18.patch b/pkgs/applications/networking/browsers/firefox/bindgen-0.64-clang-18.patch new file mode 100644 index 0000000000000..ee0b916bdcd9c --- /dev/null +++ b/pkgs/applications/networking/browsers/firefox/bindgen-0.64-clang-18.patch @@ -0,0 +1,39 @@ +From 043ab6ab28df63fd1b3459df5c52fd8c87c0ba21 Mon Sep 17 00:00:00 2001 +From: David Tolnay <dtolnay@gmail.com> +Date: Tue, 28 Nov 2023 11:21:18 -0800 +Subject: [PATCH] Handle CXCursor_LinkageSpec in Clang 18+ + +(cherry picked from commit 86f3dbe846020e2ba573d6eb38d1434d0cbcbb40) +--- + third_party/rust/bindgen/.cargo-checksum.json | 2 +- + third_party/rust/bindgen/ir/item.rs | 5 +++-- + 2 files changed, 4 insertions(+), 3 deletions(-) + +diff --git a/third_party/rust/bindgen/.cargo-checksum.json b/third_party/rust/bindgen/.cargo-checksum.json +index 2242180..88718bd 100644 +--- a/third_party/rust/bindgen/.cargo-checksum.json ++++ b/third_party/rust/bindgen/.cargo-checksum.json +@@ -1 +1 @@ +-{"files":{"Cargo.toml":"ae6de5b309f8bf07c259436b1113ccf405b2d7dd862e1b289bfef47a550956d1","LICENSE":"c23953d9deb0a3312dbeaf6c128a657f3591acee45067612fa68405eaa4525db","build.rs":"4a9c4ac3759572e17de312a9d3f4ced3b6fd3c71811729e5a8d06bfbd1ac8f82","callbacks.rs":"9cbda648159897f93a07dbe90a1ee9ba92e2b020a02bc9725b87db4d025df3b6","clang.rs":"a38d153516c6685b46723010793b2f4e8b16468f3cd3296781dea6e485cd66da","codegen/bitfield_unit.rs":"fddeaeab5859f4e82081865595b7705f5c0774d997df95fa5c655b81b9cae125","codegen/bitfield_unit_tests.rs":"9df86490de5e9d66ccea583dcb686dd440375dc1a3c3cf89a89d5de3883bf28a","codegen/dyngen.rs":"7d727a737c616f7f2d3a07d825be8baad9078b3f35ad96277904559b4534ffcc","codegen/error.rs":"5e308b8c54b68511fc8ea2ad15ddac510172c4ff460a80a265336440b0c9653d","codegen/helpers.rs":"5f24007a09e50db7bd2b49b07100cfed649c7b22232558e28c99c759d5d14152","codegen/impl_debug.rs":"71d8e28873ba2de466f2637a824746963702f0511728037d72ee5670c51194cb","codegen/impl_partialeq.rs":"f4599e32c66179ae515a6518a3e94b686689cf59f7dd9ab618c3fb69f17d2c77","codegen/mod.rs":"25ef86b9dd894b40724d78b99e2743654f09bb427a23ccf5940a620c6408688e","codegen/postprocessing/merge_extern_blocks.rs":"be5c5ff6d3d3d4e940814c4dc77f8d687aa6b053dcfbd2185c09616ba9022bf2","codegen/postprocessing/mod.rs":"d1e8c2864d5194a4cb2f6731c0ef582a55b363df9c4f888c26942ff37f728e1c","codegen/postprocessing/sort_semantically.rs":"3071dd509f2e5d3dfd99cafa6ee19bbacb9fec1c61a0b3f6e284a75c1f2c3db6","codegen/serialize.rs":"b1d8fff0bd9717ee7ca883fd3f376cf7b93adb65dc5bb89ede467b087e985a5f","codegen/struct_layout.rs":"7dfc814d3c914a0c53d8ed031baf543dab1def5959e8ab85220cad69a506383a","deps.rs":"5ee2332fdb10325f3b0a0c6d9ba94e13eb631ef39e955fa958afc3625bdb5448","extra_assertions.rs":"494534bd4f18b80d89b180c8a93733e6617edcf7deac413e9a73fd6e7bc9ced7","features.rs":"af20bd617cce27f6716ab3d61a1c8ddfaa46227f4a0d435b08a19d5f277cf8ba","ir/analysis/derive.rs":"ec514585eb40f0e3306bf3302aec0152a2e95e8dce13a67c36b5f00c0cbb76ef","ir/analysis/has_destructor.rs":"7a82f01e7e0595a31b56f7c398fa3019b3fe9100a2a73b56768f7e6943dcc3ce","ir/analysis/has_float.rs":"58ea1e38a59ef208400fd65d426cb5b288949df2d383b3a194fa01b99d2a87fa","ir/analysis/has_type_param_in_array.rs":"d1b9eb119dc14f662eb9bd1394c859f485479e4912589709cdd33f6752094e22","ir/analysis/has_vtable.rs":"368cf30fbe3fab7190fab48718b948caac5da8c9e797b709488716b919315636","ir/analysis/mod.rs":"0c10d8eeb26d7e6f4ce18e9dfb74ea1f9deff5cd350298aca3dc1041b17c20c4","ir/analysis/sizedness.rs":"944443d6aab35d2dd80e4f5e59176ac1e1c463ba2f0eb25d33f1d95dfac1a6d0","ir/analysis/template_params.rs":"d3cc41041b1c45e0b5be2c9f3f1cc0c2341481b9ff51589cba2428df4e6a1ea9","ir/annotations.rs":"f79de09803a3f3ccb33e366a10a707da98cd00a56ba18312ea927d6c977220a4","ir/comment.rs":"5dcfab0095d967daad9b2927093fce3786b1a2146171580afbf526ba56855e36","ir/comp.rs":"b7b28b96e4206b3215881d814661c63c5dd182f34b1163d54bcedbe85998cb06","ir/context.rs":"a7608f7d3dd607647f2af5f45fc7c09483d2a694f91265bba353a71652e2d419","ir/derive.rs":"e5581852eec87918901a129284b4965aefc8a19394187a8095779a084f28fabe","ir/dot.rs":"2d79d698e6ac59ce032840e62ff11103abed1d5e9e700cf383b492333eeebe1f","ir/enum_ty.rs":"0b612e0b57112068455eee519f894016d0a8f425d6a67b98c56b858f57d99f4a","ir/function.rs":"60407267473d785ea33ac854a70c8ca34749bc868024270992deca68a951f74c","ir/int.rs":"68a86182743ec338d58e42203364dc7c8970cb7ec3550433ca92f0c9489b4442","ir/item.rs":"880c982df0843cbdff38b9f9c3829a2d863a224e4de2260c41c3ac69e9148ad4","ir/item_kind.rs":"7666a1ff1b8260978b790a08b4139ab56b5c65714a5652bbcec7faa7443adc36","ir/layout.rs":"61a0e4250ceab889606973f930f4d692837a13a69ae2579738ff09843fed3d65","ir/mod.rs":"713cd537434567003197a123cbae679602c715e976d22f7b23dafd0826ea4c70","ir/module.rs":"7cae5561bcf84a5c3b1ee8f1c3336a33b7f44f0d5ffe885fb108289983fe763e","ir/objc.rs":"4eecdb754542d78acea27d2f547d18d49164047e6efaff8a8d283d6c2dc9875b","ir/template.rs":"4f0e3736558aa8ec359cd9749dc48f87bfff494dd195a67b39cfee7d8a7542ef","ir/traversal.rs":"0c37a0898801ad39bffc8dddd1ee8baa61bb7cf4f3fdc25c8fdd56b6c96ada65","ir/ty.rs":"ba0d7b16a1080caf4960cc7dea0d0800365da0dd5c6e735d508ec448e87b1d40","ir/var.rs":"ced3496cf0683fef91ce94aa09b0ee37255db8425ea8634d52bd73b1b5c160f6","lib.rs":"0bed6f10b2dd25753a40e6e7fa11239f08c05be414ad264c6d7e2f7a8b71f1b2","log_stubs.rs":"9f974e041e35c8c7e29985d27ae5cd0858d68f8676d1dc005c6388d7d011707f","parse.rs":"ccb2c506f08123708ae673b8216404fb22b4c951330662f9b7140b412b063260","regex_set.rs":"7dcc1ad52194f057ea00e8ebc9c23c465ffa6761eed6ba41560d2d02e03c43a6","time.rs":"8efe317e7c6b5ba8e0865ce7b49ca775ee8a02590f4241ef62f647fa3c22b68e"},"package":"c4243e6031260db77ede97ad86c27e501d646a27ab57b59a574f725d98ab1fb4"} +\ No newline at end of file ++{"files":{"Cargo.toml":"ae6de5b309f8bf07c259436b1113ccf405b2d7dd862e1b289bfef47a550956d1","LICENSE":"c23953d9deb0a3312dbeaf6c128a657f3591acee45067612fa68405eaa4525db","build.rs":"4a9c4ac3759572e17de312a9d3f4ced3b6fd3c71811729e5a8d06bfbd1ac8f82","callbacks.rs":"9cbda648159897f93a07dbe90a1ee9ba92e2b020a02bc9725b87db4d025df3b6","clang.rs":"a38d153516c6685b46723010793b2f4e8b16468f3cd3296781dea6e485cd66da","codegen/bitfield_unit.rs":"fddeaeab5859f4e82081865595b7705f5c0774d997df95fa5c655b81b9cae125","codegen/bitfield_unit_tests.rs":"9df86490de5e9d66ccea583dcb686dd440375dc1a3c3cf89a89d5de3883bf28a","codegen/dyngen.rs":"7d727a737c616f7f2d3a07d825be8baad9078b3f35ad96277904559b4534ffcc","codegen/error.rs":"5e308b8c54b68511fc8ea2ad15ddac510172c4ff460a80a265336440b0c9653d","codegen/helpers.rs":"5f24007a09e50db7bd2b49b07100cfed649c7b22232558e28c99c759d5d14152","codegen/impl_debug.rs":"71d8e28873ba2de466f2637a824746963702f0511728037d72ee5670c51194cb","codegen/impl_partialeq.rs":"f4599e32c66179ae515a6518a3e94b686689cf59f7dd9ab618c3fb69f17d2c77","codegen/mod.rs":"25ef86b9dd894b40724d78b99e2743654f09bb427a23ccf5940a620c6408688e","codegen/postprocessing/merge_extern_blocks.rs":"be5c5ff6d3d3d4e940814c4dc77f8d687aa6b053dcfbd2185c09616ba9022bf2","codegen/postprocessing/mod.rs":"d1e8c2864d5194a4cb2f6731c0ef582a55b363df9c4f888c26942ff37f728e1c","codegen/postprocessing/sort_semantically.rs":"3071dd509f2e5d3dfd99cafa6ee19bbacb9fec1c61a0b3f6e284a75c1f2c3db6","codegen/serialize.rs":"b1d8fff0bd9717ee7ca883fd3f376cf7b93adb65dc5bb89ede467b087e985a5f","codegen/struct_layout.rs":"7dfc814d3c914a0c53d8ed031baf543dab1def5959e8ab85220cad69a506383a","deps.rs":"5ee2332fdb10325f3b0a0c6d9ba94e13eb631ef39e955fa958afc3625bdb5448","extra_assertions.rs":"494534bd4f18b80d89b180c8a93733e6617edcf7deac413e9a73fd6e7bc9ced7","features.rs":"af20bd617cce27f6716ab3d61a1c8ddfaa46227f4a0d435b08a19d5f277cf8ba","ir/analysis/derive.rs":"ec514585eb40f0e3306bf3302aec0152a2e95e8dce13a67c36b5f00c0cbb76ef","ir/analysis/has_destructor.rs":"7a82f01e7e0595a31b56f7c398fa3019b3fe9100a2a73b56768f7e6943dcc3ce","ir/analysis/has_float.rs":"58ea1e38a59ef208400fd65d426cb5b288949df2d383b3a194fa01b99d2a87fa","ir/analysis/has_type_param_in_array.rs":"d1b9eb119dc14f662eb9bd1394c859f485479e4912589709cdd33f6752094e22","ir/analysis/has_vtable.rs":"368cf30fbe3fab7190fab48718b948caac5da8c9e797b709488716b919315636","ir/analysis/mod.rs":"0c10d8eeb26d7e6f4ce18e9dfb74ea1f9deff5cd350298aca3dc1041b17c20c4","ir/analysis/sizedness.rs":"944443d6aab35d2dd80e4f5e59176ac1e1c463ba2f0eb25d33f1d95dfac1a6d0","ir/analysis/template_params.rs":"d3cc41041b1c45e0b5be2c9f3f1cc0c2341481b9ff51589cba2428df4e6a1ea9","ir/annotations.rs":"f79de09803a3f3ccb33e366a10a707da98cd00a56ba18312ea927d6c977220a4","ir/comment.rs":"5dcfab0095d967daad9b2927093fce3786b1a2146171580afbf526ba56855e36","ir/comp.rs":"b7b28b96e4206b3215881d814661c63c5dd182f34b1163d54bcedbe85998cb06","ir/context.rs":"a7608f7d3dd607647f2af5f45fc7c09483d2a694f91265bba353a71652e2d419","ir/derive.rs":"e5581852eec87918901a129284b4965aefc8a19394187a8095779a084f28fabe","ir/dot.rs":"2d79d698e6ac59ce032840e62ff11103abed1d5e9e700cf383b492333eeebe1f","ir/enum_ty.rs":"0b612e0b57112068455eee519f894016d0a8f425d6a67b98c56b858f57d99f4a","ir/function.rs":"60407267473d785ea33ac854a70c8ca34749bc868024270992deca68a951f74c","ir/int.rs":"68a86182743ec338d58e42203364dc7c8970cb7ec3550433ca92f0c9489b4442","ir/item.rs":"f215cc40c013cdd6151149dd92b73e13a635a1056f5724174c0f0ff7da9286f8","ir/item_kind.rs":"7666a1ff1b8260978b790a08b4139ab56b5c65714a5652bbcec7faa7443adc36","ir/layout.rs":"61a0e4250ceab889606973f930f4d692837a13a69ae2579738ff09843fed3d65","ir/mod.rs":"713cd537434567003197a123cbae679602c715e976d22f7b23dafd0826ea4c70","ir/module.rs":"7cae5561bcf84a5c3b1ee8f1c3336a33b7f44f0d5ffe885fb108289983fe763e","ir/objc.rs":"4eecdb754542d78acea27d2f547d18d49164047e6efaff8a8d283d6c2dc9875b","ir/template.rs":"4f0e3736558aa8ec359cd9749dc48f87bfff494dd195a67b39cfee7d8a7542ef","ir/traversal.rs":"0c37a0898801ad39bffc8dddd1ee8baa61bb7cf4f3fdc25c8fdd56b6c96ada65","ir/ty.rs":"ba0d7b16a1080caf4960cc7dea0d0800365da0dd5c6e735d508ec448e87b1d40","ir/var.rs":"ced3496cf0683fef91ce94aa09b0ee37255db8425ea8634d52bd73b1b5c160f6","lib.rs":"0bed6f10b2dd25753a40e6e7fa11239f08c05be414ad264c6d7e2f7a8b71f1b2","log_stubs.rs":"9f974e041e35c8c7e29985d27ae5cd0858d68f8676d1dc005c6388d7d011707f","parse.rs":"ccb2c506f08123708ae673b8216404fb22b4c951330662f9b7140b412b063260","regex_set.rs":"7dcc1ad52194f057ea00e8ebc9c23c465ffa6761eed6ba41560d2d02e03c43a6","time.rs":"8efe317e7c6b5ba8e0865ce7b49ca775ee8a02590f4241ef62f647fa3c22b68e"},"package":"c4243e6031260db77ede97ad86c27e501d646a27ab57b59a574f725d98ab1fb4"} +\ No newline at end of file +diff --git a/third_party/rust/bindgen/ir/item.rs b/third_party/rust/bindgen/ir/item.rs +index 40f6f7d..d443bda 100644 +--- a/third_party/rust/bindgen/ir/item.rs ++++ b/third_party/rust/bindgen/ir/item.rs +@@ -1427,8 +1427,9 @@ impl Item { + } + } + +- // Guess how does clang treat extern "C" blocks? +- if cursor.kind() == CXCursor_UnexposedDecl { ++ // On Clang 18+, extern "C" is reported accurately as a LinkageSpec. ++ // Older LLVM treat it as UnexposedDecl. ++ if cursor.kind() == CXCursor_LinkageSpec || cursor.kind() == CXCursor_UnexposedDecl { + Err(ParseError::Recurse) + } else { + // We allowlist cursors here known to be unhandled, to prevent being +-- +2.44.0 + diff --git a/pkgs/applications/networking/browsers/firefox/common.nix b/pkgs/applications/networking/browsers/firefox/common.nix index 56dda27e54c92..d518aeec23fe2 100644 --- a/pkgs/applications/networking/browsers/firefox/common.nix +++ b/pkgs/applications/networking/browsers/firefox/common.nix @@ -254,9 +254,22 @@ buildStdenv.mkDerivation { hash = "sha256-cWOyvjIPUU1tavPRqg61xJ53XE4EJTdsFzadfVxyTyM="; }) ] + ++ lib.optionals (lib.versionOlder version "122") [ + ./bindgen-0.64-clang-18.patch + ] ++ lib.optionals (lib.versionAtLeast version "122" && lib.versionOlder version "123") [ ./122.0-libvpx-mozbz1875201.patch ] + ++ lib.optionals (lib.versionOlder version "123") [ + (fetchpatch { + name = "clang-18.patch"; + url = "https://hg.mozilla.org/mozilla-central/raw-rev/ba6abbd36b496501cea141e17b61af674a18e279"; + hash = "sha256-2IpdSyye3VT4VB95WurnyRFtdN1lfVtYpgEiUVhfNjw="; + }) + ] + ++ lib.optionals (lib.versionOlder version "125") [ + ./rust-1.78.patch + ] ++ extraPatches; postPatch = '' diff --git a/pkgs/applications/networking/browsers/firefox/rust-1.78.patch b/pkgs/applications/networking/browsers/firefox/rust-1.78.patch new file mode 100644 index 0000000000000..8484109d5b08d --- /dev/null +++ b/pkgs/applications/networking/browsers/firefox/rust-1.78.patch @@ -0,0 +1,77 @@ +From 9dd8048e28b65da0b904dfbace482f70ae768fd8 Mon Sep 17 00:00:00 2001 +From: Jeff Muizelaar <jmuizelaar@mozilla.com> +Date: Tue, 5 Mar 2024 04:12:28 +0100 +Subject: [PATCH] Bug 1882291. Switch to stdarch_arm_neon_intrinsics feature on + rust >=1.78. r=glandium + +We only need this on ARM32 because the ARM64 intrinsics are stable. + +stdarch_arm_neon_intrinsics was split out from stdsimd here: +https://github.com/rust-lang/stdarch/pull/1486 + +Differential Revision: https://phabricator.services.mozilla.com/D203039 +--- + Cargo.lock | 1 + + gfx/qcms/Cargo.toml | 3 +++ + gfx/qcms/build.rs | 7 +++++++ + gfx/qcms/src/lib.rs | 6 ++++-- + 4 files changed, 15 insertions(+), 2 deletions(-) + create mode 100644 gfx/qcms/build.rs + +diff --git a/Cargo.lock b/Cargo.lock +index aba397832e..8f0a879a87 100644 +--- a/Cargo.lock ++++ b/Cargo.lock +@@ -4276,6 +4276,7 @@ name = "qcms" + version = "0.2.0" + dependencies = [ + "libc", ++ "version_check", + ] + + [[package]] +diff --git a/gfx/qcms/Cargo.toml b/gfx/qcms/Cargo.toml +index e976054a7b..f50d6623a1 100644 +--- a/gfx/qcms/Cargo.toml ++++ b/gfx/qcms/Cargo.toml +@@ -20,3 +20,6 @@ cmyk = [] + + [dependencies] + libc = {version = "0.2", optional = true } ++ ++[build-dependencies] ++version_check = "0.9" +diff --git a/gfx/qcms/build.rs b/gfx/qcms/build.rs +new file mode 100644 +index 0000000000..6810a8828e +--- /dev/null ++++ b/gfx/qcms/build.rs +@@ -0,0 +1,7 @@ ++extern crate version_check as rustc; ++ ++fn main() { ++ if rustc::is_min_version("1.78.0").unwrap_or(false) { ++ println!("cargo:rustc-cfg=stdsimd_split"); ++ } ++} +diff --git a/gfx/qcms/src/lib.rs b/gfx/qcms/src/lib.rs +index c311964ee3..fc496816a8 100644 +--- a/gfx/qcms/src/lib.rs ++++ b/gfx/qcms/src/lib.rs +@@ -7,9 +7,11 @@ + #![allow(non_upper_case_globals)] + // These are needed for the neon SIMD code and can be removed once the MSRV supports the + // instrinsics we use +-#![cfg_attr(feature = "neon", feature(stdsimd))] ++#![cfg_attr(all(stdsimd_split, target_arch = "arm", feature = "neon"), feature(stdarch_arm_neon_intrinsics))] ++#![cfg_attr(all(stdsimd_split, target_arch = "arm", feature = "neon"), feature(stdarch_arm_feature_detection))] ++#![cfg_attr(all(not(stdsimd_split), target_arch = "arm", feature = "neon"), feature(stdsimd))] + #![cfg_attr( +- feature = "neon", ++ all(target_arch = "arm", feature = "neon"), + feature(arm_target_feature, raw_ref_op) + + )] +-- +2.44.0 + diff --git a/pkgs/development/compilers/rust/1_77.nix b/pkgs/development/compilers/rust/1_77.nix deleted file mode 100644 index ab501aba8ffbe..0000000000000 --- a/pkgs/development/compilers/rust/1_77.nix +++ /dev/null @@ -1,59 +0,0 @@ -# New rust versions should first go to staging. -# Things to check after updating: -# 1. Rustc should produce rust binaries on x86_64-linux, aarch64-linux and x86_64-darwin: -# i.e. nix-shell -p fd or @GrahamcOfBorg build fd on github -# This testing can be also done by other volunteers as part of the pull -# request review, in case platforms cannot be covered. -# 2. The LLVM version used for building should match with rust upstream. -# Check the version number in the src/llvm-project git submodule in: -# https://github.com/rust-lang/rust/blob/<version-tag>/.gitmodules -# 3. Firefox and Thunderbird should still build on x86_64-linux. - -{ stdenv, lib -, newScope, callPackage -, CoreFoundation, Security, SystemConfiguration -, pkgsBuildTarget, pkgsBuildBuild, pkgsBuildHost, pkgsTargetTarget -, makeRustPlatform -, wrapRustcWith -, llvmPackages_17, llvm_17 -} @ args: - -import ./default.nix { - rustcVersion = "1.77.2"; - rustcSha256 = "xhRX749ZZjj928dxZ3iy9rmf8SUTo7DxOZTDvFIWOMM="; - - llvmSharedForBuild = pkgsBuildBuild.llvmPackages_17.libllvm.override { enableSharedLibraries = true; }; - llvmSharedForHost = pkgsBuildHost.llvmPackages_17.libllvm.override { enableSharedLibraries = true; }; - llvmSharedForTarget = pkgsBuildTarget.llvmPackages_17.libllvm.override { enableSharedLibraries = true; }; - - # For use at runtime - llvmShared = llvm_17.override { enableSharedLibraries = true; }; - - # Expose llvmPackages used for rustc from rustc via passthru for LTO in Firefox - llvmPackages = llvmPackages_17; - - # Note: the version MUST be one version prior to the version we're - # building - bootstrapVersion = "1.76.0"; - - # fetch hashes by running `print-hashes.sh ${bootstrapVersion}` - bootstrapHashes = { - i686-unknown-linux-gnu = "4c3eefc9341b8809235e6c4fbcbc19ab52a5cbe771292c400df068c12984fa3e"; - x86_64-unknown-linux-gnu = "9d589d2036b503cc45ecc94992d616fb3deec074deb36cacc2f5c212408f7399"; - x86_64-unknown-linux-musl = "aa8568f4d262468aaf4f622bd421c5435b24454d8fbcdae48da1162962205384"; - arm-unknown-linux-gnueabihf = "7d1da067362fc64bcad198d90a61e024d5712aed76e17b28e1cd7e8ba263cc6f"; - armv7-unknown-linux-gnueabihf = "c03346d56d4a860cd3a8d2d2a7ea75c510b68204e3ad97b3770076595261c913"; - aarch64-unknown-linux-gnu = "2e8313421e8fb673efdf356cdfdd4bc16516f2610d4f6faa01327983104c05a0"; - aarch64-unknown-linux-musl = "a1d1c8ccb8ea00cfa2b79d80411b8eb22b2bef5214f86536825361e98d7c617a"; - x86_64-apple-darwin = "7bdbe085695df8e46389115e99eda7beed37a9494f6b961b45554c658e53b8e7"; - aarch64-apple-darwin = "17496f15c3cb6ff73d5c36f5b54cc110f1ac31fa09521a7991c0d7ddd890dceb"; - powerpc64le-unknown-linux-gnu = "44b3494675284d26b04747a824dc974e32fd8fd46fc0aa06a7c8ebe851332d2c"; - riscv64gc-unknown-linux-gnu = "4a9db321874fc441235b71eb8aa295fc50251305e461540b25b4eef89fb56255"; - }; - - selectRustPackage = pkgs: pkgs.rust_1_77; - - rustcPatches = [ ]; -} - -(builtins.removeAttrs args [ "llvmPackages_17" "llvm_17"]) diff --git a/pkgs/development/compilers/rust/1_78.nix b/pkgs/development/compilers/rust/1_78.nix new file mode 100644 index 0000000000000..3ce368e8d99fb --- /dev/null +++ b/pkgs/development/compilers/rust/1_78.nix @@ -0,0 +1,59 @@ +# New rust versions should first go to staging. +# Things to check after updating: +# 1. Rustc should produce rust binaries on x86_64-linux, aarch64-linux and x86_64-darwin: +# i.e. nix-shell -p fd or @GrahamcOfBorg build fd on github +# This testing can be also done by other volunteers as part of the pull +# request review, in case platforms cannot be covered. +# 2. The LLVM version used for building should match with rust upstream. +# Check the version number in the src/llvm-project git submodule in: +# https://github.com/rust-lang/rust/blob/<version-tag>/.gitmodules +# 3. Firefox and Thunderbird should still build on x86_64-linux. + +{ stdenv, lib +, newScope, callPackage +, CoreFoundation, Security, SystemConfiguration +, pkgsBuildTarget, pkgsBuildBuild, pkgsBuildHost, pkgsTargetTarget +, makeRustPlatform +, wrapRustcWith +, llvmPackages_18, llvm_18 +} @ args: + +import ./default.nix { + rustcVersion = "1.78.0"; + rustcSha256 = "/1RII6XLJ/JzgShXfx5+AO6PTIPyo0h4GuT8NV6R1ak="; + + llvmSharedForBuild = pkgsBuildBuild.llvmPackages_18.libllvm.override { enableSharedLibraries = true; }; + llvmSharedForHost = pkgsBuildHost.llvmPackages_18.libllvm.override { enableSharedLibraries = true; }; + llvmSharedForTarget = pkgsBuildTarget.llvmPackages_18.libllvm.override { enableSharedLibraries = true; }; + + # For use at runtime + llvmShared = llvm_18.override { enableSharedLibraries = true; }; + + # Expose llvmPackages used for rustc from rustc via passthru for LTO in Firefox + llvmPackages = llvmPackages_18; + + # Note: the version MUST be one version prior to the version we're + # building + bootstrapVersion = "1.77.2"; + + # fetch hashes by running `print-hashes.sh ${bootstrapVersion}` + bootstrapHashes = { + i686-unknown-linux-gnu = "168e653fbc30b3a80801bc7735a79ff644651618434234959925f669bf77d1a2"; + x86_64-unknown-linux-gnu = "b7d12b1b162c36c1fd5234b4b16856aa7eafca91d17c49787f6487cb26f4062d"; + x86_64-unknown-linux-musl = "2e08fe23c4837a780a40ebfac601760cd6297581d21eae2f88cb59060243a375"; + arm-unknown-linux-gnueabihf = "9f14a31dbef0153c0a7463a79cf8f9e8295b355354de41aa054953027beb70d7"; + armv7-unknown-linux-gnueabihf = "b37649399081228244b3ff3acc6047f6c138e602c721cd500efe43715d043c5e"; + aarch64-unknown-linux-gnu = "297c6201edd42e580f242fcd75b521b0392f6f3be02cf03ca76690fece4a74da"; + aarch64-unknown-linux-musl = "fdd9c485f93c73a085c113b4f0fbad0989f79153079d394ec4bbac2b3804f71b"; + x86_64-apple-darwin = "16bbbfcf0c982b35271d8904977d80fda1bb7caa7f898abceed3569a867d9cea"; + aarch64-apple-darwin = "415bb2bc198feb0f2d8329e33c57d0890bbd57977d1ae48b17f6c7e1f632eaa7"; + powerpc64le-unknown-linux-gnu = "79582acb339bd2d79fef095b977049049ffa04616011f1af1793fb8e98194b19"; + riscv64gc-unknown-linux-gnu = "300fe4861e2d1f6e4c4f5e36ae7997beca8a979343a7f661237ab78a37a54648"; + }; + + selectRustPackage = pkgs: pkgs.rust_1_78; + + rustcPatches = [ ]; +} + +(builtins.removeAttrs args [ "llvmPackages_18" "llvm_18"]) diff --git a/pkgs/os-specific/linux/kernel/patches.nix b/pkgs/os-specific/linux/kernel/patches.nix index 20100774395e1..c1715a91e5fbc 100644 --- a/pkgs/os-specific/linux/kernel/patches.nix +++ b/pkgs/os-specific/linux/kernel/patches.nix @@ -82,15 +82,21 @@ rust_1_77-6_8 = { name = "rust-1.77.patch"; - patch = fetchurl { - name = "rust-1.77.patch"; - url = "https://lore.kernel.org/rust-for-linux/20240217002717.57507-1-ojeda@kernel.org/raw"; - hash = "sha256-0KW9nHpJeMSDssCPXWZbrN8kxq5bA434t+XuPfwslUc="; - }; + patch = ./rust-1.77-6.8.patch; }; rust_1_77-6_9 = { name = "rust-1.77.patch"; patch = ./rust-1.77.patch; }; + + rust_1_78 = { + name = "rust-1.78.patch"; + patch = fetchpatch { + name = "rust-1.78.patch"; + url = "https://lore.kernel.org/rust-for-linux/20240401212303.537355-4-ojeda@kernel.org/raw"; + excludes = [ "Documentation/process/changes.rst" ]; # Conflicts on 6.8. + hash = "sha256-EZ+Qa9z1AtAv08e72M7BEsCZi9UK572gmW+AR62a8EM="; + }; + }; } diff --git a/pkgs/os-specific/linux/kernel/rust-1.77-6.8.patch b/pkgs/os-specific/linux/kernel/rust-1.77-6.8.patch new file mode 100644 index 0000000000000..4b25d3e60e39d --- /dev/null +++ b/pkgs/os-specific/linux/kernel/rust-1.77-6.8.patch @@ -0,0 +1,799 @@ +From 82a754271336c7736fb0350692be85fecb30e38e Mon Sep 17 00:00:00 2001 +From: Miguel Ojeda <ojeda@kernel.org> +Date: Sat, 17 Feb 2024 01:27:17 +0100 +Subject: [PATCH] rust: upgrade to Rust 1.77.1 + +This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.1 +(i.e. the latest) [1]. + +See the upgrade policy [2] and the comments on the first upgrade in +commit 3ed03f4da06e ("rust: upgrade to Rust 1.68.2"). + +# Unstable features + +The `offset_of` feature (single-field `offset_of!`) that we were using +got stabilized in Rust 1.77.0 [3]. + +Therefore, now the only unstable features allowed to be used outside the +`kernel` crate is `new_uninit`, though other code to be upstreamed may +increase the list. + +Please see [4] for details. + +# Required changes + +Rust 1.77.0 merged the `unused_tuple_struct_fields` lint into `dead_code`, +thus upgrading it from `allow` to `warn` [5]. In turn, this made `rustc` +complain about the `ThisModule`'s pointer field being never read, but +the previous patch adds the `as_ptr` method to it, needed by Binder [6], +so that we do not need to locally `allow` it. + +# Other changes + +Rust 1.77.0 introduces the `--check-cfg` feature [7], for which there +is a Call for Testing going on [8]. We were requested to test it and +we found it useful [9] -- we will likely enable it in the future. + +# `alloc` upgrade and reviewing + +The vast majority of changes are due to our `alloc` fork being upgraded +at once. + +There are two kinds of changes to be aware of: the ones coming from +upstream, which we should follow as closely as possible, and the updates +needed in our added fallible APIs to keep them matching the newer +infallible APIs coming from upstream. + +Instead of taking a look at the diff of this patch, an alternative +approach is reviewing a diff of the changes between upstream `alloc` and +the kernel's. This allows to easily inspect the kernel additions only, +especially to check if the fallible methods we already have still match +the infallible ones in the new version coming from upstream. + +Another approach is reviewing the changes introduced in the additions in +the kernel fork between the two versions. This is useful to spot +potentially unintended changes to our additions. + +To apply these approaches, one may follow steps similar to the following +to generate a pair of patches that show the differences between upstream +Rust and the kernel (for the subset of `alloc` we use) before and after +applying this patch: + + # Get the difference with respect to the old version. + git -C rust checkout $(linux/scripts/min-tool-version.sh rustc) + git -C linux ls-tree -r --name-only HEAD -- rust/alloc | + cut -d/ -f3- | + grep -Fv README.md | + xargs -IPATH cp rust/library/alloc/src/PATH linux/rust/alloc/PATH + git -C linux diff --patch-with-stat --summary -R > old.patch + git -C linux restore rust/alloc + + # Apply this patch. + git -C linux am rust-upgrade.patch + + # Get the difference with respect to the new version. + git -C rust checkout $(linux/scripts/min-tool-version.sh rustc) + git -C linux ls-tree -r --name-only HEAD -- rust/alloc | + cut -d/ -f3- | + grep -Fv README.md | + xargs -IPATH cp rust/library/alloc/src/PATH linux/rust/alloc/PATH + git -C linux diff --patch-with-stat --summary -R > new.patch + git -C linux restore rust/alloc + +Now one may check the `new.patch` to take a look at the additions (first +approach) or at the difference between those two patches (second +approach). For the latter, a side-by-side tool is recommended. + +Link: https://github.com/rust-lang/rust/blob/stable/RELEASES.md#version-1770-2024-03-21 [1] +Link: https://rust-for-linux.com/rust-version-policy [2] +Link: https://github.com/rust-lang/rust/pull/118799 [3] +Link: https://github.com/Rust-for-Linux/linux/issues/2 [4] +Link: https://github.com/rust-lang/rust/pull/118297 [5] +Link: https://lore.kernel.org/rust-for-linux/20231101-rust-binder-v1-2-08ba9197f637@google.com/#Z31rust:kernel:lib.rs [6] +Link: https://doc.rust-lang.org/nightly/unstable-book/compiler-flags/check-cfg.html [7] +Link: https://github.com/rust-lang/rfcs/pull/3013#issuecomment-1936648479 [8] +Link: https://github.com/rust-lang/rust/issues/82450#issuecomment-1947462977 [9] +Reviewed-by: Alice Ryhl <aliceryhl@google.com> +Tested-by: Boqun Feng <boqun.feng@gmail.com> +Link: https://lore.kernel.org/r/20240217002717.57507-1-ojeda@kernel.org +[ Upgraded to 1.77.1. Removed `allow(dead_code)` thanks to the previous + patch. Reworded accordingly. No changes to `alloc` during the beta. ] +Signed-off-by: Miguel Ojeda <ojeda@kernel.org> +Signed-off-by: Alyssa Ross <hi@alyssa.is> + +# Conflicts: +# Documentation/process/changes.rst +# rust/kernel/lib.rs +--- + Documentation/process/changes.rst | 2 +- + rust/alloc/alloc.rs | 6 +- + rust/alloc/boxed.rs | 4 +- + rust/alloc/lib.rs | 7 +- + rust/alloc/raw_vec.rs | 13 ++-- + rust/alloc/slice.rs | 4 +- + rust/alloc/vec/into_iter.rs | 104 +++++++++++++++++++----------- + rust/alloc/vec/mod.rs | 101 ++++++++++++++++++++--------- + rust/kernel/lib.rs | 1 - + scripts/Makefile.build | 2 +- + scripts/min-tool-version.sh | 2 +- + 11 files changed, 158 insertions(+), 88 deletions(-) + +diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst +index c78ecc1e176f..641d67363b92 100644 +--- a/Documentation/process/changes.rst ++++ b/Documentation/process/changes.rst +@@ -31,7 +31,7 @@ you probably needn't concern yourself with pcmciautils. + ====================== =============== ======================================== + GNU C 5.1 gcc --version + Clang/LLVM (optional) 11.0.0 clang --version +-Rust (optional) 1.76.0 rustc --version ++Rust (optional) 1.77.1 rustc --version + bindgen (optional) 0.65.1 bindgen --version + GNU make 3.82 make --version + bash 4.2 bash --version +diff --git a/rust/alloc/alloc.rs b/rust/alloc/alloc.rs +index abb791cc2371..b1204f87227b 100644 +--- a/rust/alloc/alloc.rs ++++ b/rust/alloc/alloc.rs +@@ -5,7 +5,7 @@ + #![stable(feature = "alloc_module", since = "1.28.0")] + + #[cfg(not(test))] +-use core::intrinsics; ++use core::hint; + + #[cfg(not(test))] + use core::ptr::{self, NonNull}; +@@ -210,7 +210,7 @@ unsafe fn grow_impl( + let new_size = new_layout.size(); + + // `realloc` probably checks for `new_size >= old_layout.size()` or something similar. +- intrinsics::assume(new_size >= old_layout.size()); ++ hint::assert_unchecked(new_size >= old_layout.size()); + + let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; +@@ -301,7 +301,7 @@ unsafe fn shrink( + // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller + new_size if old_layout.align() == new_layout.align() => unsafe { + // `realloc` probably checks for `new_size <= old_layout.size()` or something similar. +- intrinsics::assume(new_size <= old_layout.size()); ++ hint::assert_unchecked(new_size <= old_layout.size()); + + let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); + let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; +diff --git a/rust/alloc/boxed.rs b/rust/alloc/boxed.rs +index c93a22a5c97f..5fc39dfeb8e7 100644 +--- a/rust/alloc/boxed.rs ++++ b/rust/alloc/boxed.rs +@@ -26,6 +26,7 @@ + //! Creating a recursive data structure: + //! + //! ``` ++//! ##[allow(dead_code)] + //! #[derive(Debug)] + //! enum List<T> { + //! Cons(T, Box<List<T>>), +@@ -194,8 +195,7 @@ + #[fundamental] + #[stable(feature = "rust1", since = "1.0.0")] + // The declaration of the `Box` struct must be kept in sync with the +-// `alloc::alloc::box_free` function or ICEs will happen. See the comment +-// on `box_free` for more details. ++// compiler or ICEs will happen. + pub struct Box< + T: ?Sized, + #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, +diff --git a/rust/alloc/lib.rs b/rust/alloc/lib.rs +index 36f79c075593..39afd55ec074 100644 +--- a/rust/alloc/lib.rs ++++ b/rust/alloc/lib.rs +@@ -105,7 +105,6 @@ + #![feature(allocator_api)] + #![feature(array_chunks)] + #![feature(array_into_iter_constructors)] +-#![feature(array_methods)] + #![feature(array_windows)] + #![feature(ascii_char)] + #![feature(assert_matches)] +@@ -122,7 +121,6 @@ + #![feature(const_size_of_val)] + #![feature(const_waker)] + #![feature(core_intrinsics)] +-#![feature(core_panic)] + #![feature(deprecated_suggestion)] + #![feature(dispatch_from_dyn)] + #![feature(error_generic_member_access)] +@@ -132,6 +130,7 @@ + #![feature(fmt_internals)] + #![feature(fn_traits)] + #![feature(hasher_prefixfree_extras)] ++#![feature(hint_assert_unchecked)] + #![feature(inline_const)] + #![feature(inplace_iteration)] + #![feature(iter_advance_by)] +@@ -141,6 +140,8 @@ + #![feature(maybe_uninit_slice)] + #![feature(maybe_uninit_uninit_array)] + #![feature(maybe_uninit_uninit_array_transpose)] ++#![feature(non_null_convenience)] ++#![feature(panic_internals)] + #![feature(pattern)] + #![feature(ptr_internals)] + #![feature(ptr_metadata)] +@@ -149,7 +150,6 @@ + #![feature(set_ptr_value)] + #![feature(sized_type_properties)] + #![feature(slice_from_ptr_range)] +-#![feature(slice_group_by)] + #![feature(slice_ptr_get)] + #![feature(slice_ptr_len)] + #![feature(slice_range)] +@@ -182,6 +182,7 @@ + #![feature(const_ptr_write)] + #![feature(const_trait_impl)] + #![feature(const_try)] ++#![feature(decl_macro)] + #![feature(dropck_eyepatch)] + #![feature(exclusive_range_pattern)] + #![feature(fundamental)] +diff --git a/rust/alloc/raw_vec.rs b/rust/alloc/raw_vec.rs +index 98b6abf30af6..1839d1c8ee7a 100644 +--- a/rust/alloc/raw_vec.rs ++++ b/rust/alloc/raw_vec.rs +@@ -4,7 +4,7 @@ + + use core::alloc::LayoutError; + use core::cmp; +-use core::intrinsics; ++use core::hint; + use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties}; + use core::ptr::{self, NonNull, Unique}; + use core::slice; +@@ -317,7 +317,7 @@ fn current_memory(&self) -> Option<(NonNull<u8>, Layout)> { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Aborts + /// +@@ -358,7 +358,7 @@ pub fn try_reserve(&mut self, len: usize, additional: usize) -> Result<(), TryRe + } + unsafe { + // Inform the optimizer that the reservation has succeeded or wasn't needed +- core::intrinsics::assume(!self.needs_to_grow(len, additional)); ++ hint::assert_unchecked(!self.needs_to_grow(len, additional)); + } + Ok(()) + } +@@ -381,7 +381,7 @@ pub fn try_reserve_for_push(&mut self, len: usize) -> Result<(), TryReserveError + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Aborts + /// +@@ -402,7 +402,7 @@ pub fn try_reserve_exact( + } + unsafe { + // Inform the optimizer that the reservation has succeeded or wasn't needed +- core::intrinsics::assume(!self.needs_to_grow(len, additional)); ++ hint::assert_unchecked(!self.needs_to_grow(len, additional)); + } + Ok(()) + } +@@ -553,7 +553,7 @@ fn finish_grow<A>( + debug_assert_eq!(old_layout.align(), new_layout.align()); + unsafe { + // The allocator checks for alignment equality +- intrinsics::assume(old_layout.align() == new_layout.align()); ++ hint::assert_unchecked(old_layout.align() == new_layout.align()); + alloc.grow(ptr, old_layout, new_layout) + } + } else { +@@ -591,7 +591,6 @@ fn handle_reserve(result: Result<(), TryReserveError>) { + // `> isize::MAX` bytes will surely fail. On 32-bit and 16-bit we need to add + // an extra guard for this in case we're running on a platform which can use + // all 4GB in user-space, e.g., PAE or x32. +- + #[inline] + fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> { + if usize::BITS < 64 && alloc_size > isize::MAX as usize { +diff --git a/rust/alloc/slice.rs b/rust/alloc/slice.rs +index 1181836da5f4..a36b072c9519 100644 +--- a/rust/alloc/slice.rs ++++ b/rust/alloc/slice.rs +@@ -53,14 +53,14 @@ + pub use core::slice::{from_mut_ptr_range, from_ptr_range}; + #[stable(feature = "rust1", since = "1.0.0")] + pub use core::slice::{from_raw_parts, from_raw_parts_mut}; ++#[stable(feature = "slice_group_by", since = "1.77.0")] ++pub use core::slice::{ChunkBy, ChunkByMut}; + #[stable(feature = "rust1", since = "1.0.0")] + pub use core::slice::{Chunks, Windows}; + #[stable(feature = "chunks_exact", since = "1.31.0")] + pub use core::slice::{ChunksExact, ChunksExactMut}; + #[stable(feature = "rust1", since = "1.0.0")] + pub use core::slice::{ChunksMut, Split, SplitMut}; +-#[unstable(feature = "slice_group_by", issue = "80552")] +-pub use core::slice::{GroupBy, GroupByMut}; + #[stable(feature = "rust1", since = "1.0.0")] + pub use core::slice::{Iter, IterMut}; + #[stable(feature = "rchunks", since = "1.31.0")] +diff --git a/rust/alloc/vec/into_iter.rs b/rust/alloc/vec/into_iter.rs +index 136bfe94af6c..0f11744c44b3 100644 +--- a/rust/alloc/vec/into_iter.rs ++++ b/rust/alloc/vec/into_iter.rs +@@ -20,6 +20,17 @@ + use core::ptr::{self, NonNull}; + use core::slice::{self}; + ++macro non_null { ++ (mut $place:expr, $t:ident) => {{ ++ #![allow(unused_unsafe)] // we're sometimes used within an unsafe block ++ unsafe { &mut *(ptr::addr_of_mut!($place) as *mut NonNull<$t>) } ++ }}, ++ ($place:expr, $t:ident) => {{ ++ #![allow(unused_unsafe)] // we're sometimes used within an unsafe block ++ unsafe { *(ptr::addr_of!($place) as *const NonNull<$t>) } ++ }}, ++} ++ + /// An iterator that moves out of a vector. + /// + /// This `struct` is created by the `into_iter` method on [`Vec`](super::Vec) +@@ -43,10 +54,12 @@ pub struct IntoIter< + // the drop impl reconstructs a RawVec from buf, cap and alloc + // to avoid dropping the allocator twice we need to wrap it into ManuallyDrop + pub(super) alloc: ManuallyDrop<A>, +- pub(super) ptr: *const T, +- pub(super) end: *const T, // If T is a ZST, this is actually ptr+len. This encoding is picked so that +- // ptr == end is a quick test for the Iterator being empty, that works +- // for both ZST and non-ZST. ++ pub(super) ptr: NonNull<T>, ++ /// If T is a ZST, this is actually ptr+len. This encoding is picked so that ++ /// ptr == end is a quick test for the Iterator being empty, that works ++ /// for both ZST and non-ZST. ++ /// For non-ZSTs the pointer is treated as `NonNull<T>` ++ pub(super) end: *const T, + } + + #[stable(feature = "vec_intoiter_debug", since = "1.13.0")] +@@ -70,7 +83,7 @@ impl<T, A: Allocator> IntoIter<T, A> { + /// ``` + #[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")] + pub fn as_slice(&self) -> &[T] { +- unsafe { slice::from_raw_parts(self.ptr, self.len()) } ++ unsafe { slice::from_raw_parts(self.ptr.as_ptr(), self.len()) } + } + + /// Returns the remaining items of this iterator as a mutable slice. +@@ -99,7 +112,7 @@ pub fn allocator(&self) -> &A { + } + + fn as_raw_mut_slice(&mut self) -> *mut [T] { +- ptr::slice_from_raw_parts_mut(self.ptr as *mut T, self.len()) ++ ptr::slice_from_raw_parts_mut(self.ptr.as_ptr(), self.len()) + } + + /// Drops remaining elements and relinquishes the backing allocation. +@@ -126,7 +139,7 @@ pub(super) fn forget_allocation_drop_remaining(&mut self) { + // this creates less assembly + self.cap = 0; + self.buf = unsafe { NonNull::new_unchecked(RawVec::NEW.ptr()) }; +- self.ptr = self.buf.as_ptr(); ++ self.ptr = self.buf; + self.end = self.buf.as_ptr(); + + // Dropping the remaining elements can panic, so this needs to be +@@ -138,9 +151,9 @@ pub(super) fn forget_allocation_drop_remaining(&mut self) { + + /// Forgets to Drop the remaining elements while still allowing the backing allocation to be freed. + pub(crate) fn forget_remaining_elements(&mut self) { +- // For th ZST case, it is crucial that we mutate `end` here, not `ptr`. ++ // For the ZST case, it is crucial that we mutate `end` here, not `ptr`. + // `ptr` must stay aligned, while `end` may be unaligned. +- self.end = self.ptr; ++ self.end = self.ptr.as_ptr(); + } + + #[cfg(not(no_global_oom_handling))] +@@ -162,7 +175,7 @@ pub(crate) fn into_vecdeque(self) -> VecDeque<T, A> { + // say that they're all at the beginning of the "allocation". + 0..this.len() + } else { +- this.ptr.sub_ptr(buf)..this.end.sub_ptr(buf) ++ this.ptr.sub_ptr(this.buf)..this.end.sub_ptr(buf) + }; + let cap = this.cap; + let alloc = ManuallyDrop::take(&mut this.alloc); +@@ -189,29 +202,35 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { + + #[inline] + fn next(&mut self) -> Option<T> { +- if self.ptr == self.end { +- None +- } else if T::IS_ZST { +- // `ptr` has to stay where it is to remain aligned, so we reduce the length by 1 by +- // reducing the `end`. +- self.end = self.end.wrapping_byte_sub(1); ++ if T::IS_ZST { ++ if self.ptr.as_ptr() == self.end as *mut _ { ++ None ++ } else { ++ // `ptr` has to stay where it is to remain aligned, so we reduce the length by 1 by ++ // reducing the `end`. ++ self.end = self.end.wrapping_byte_sub(1); + +- // Make up a value of this ZST. +- Some(unsafe { mem::zeroed() }) ++ // Make up a value of this ZST. ++ Some(unsafe { mem::zeroed() }) ++ } + } else { +- let old = self.ptr; +- self.ptr = unsafe { self.ptr.add(1) }; ++ if self.ptr == non_null!(self.end, T) { ++ None ++ } else { ++ let old = self.ptr; ++ self.ptr = unsafe { old.add(1) }; + +- Some(unsafe { ptr::read(old) }) ++ Some(unsafe { ptr::read(old.as_ptr()) }) ++ } + } + } + + #[inline] + fn size_hint(&self) -> (usize, Option<usize>) { + let exact = if T::IS_ZST { +- self.end.addr().wrapping_sub(self.ptr.addr()) ++ self.end.addr().wrapping_sub(self.ptr.as_ptr().addr()) + } else { +- unsafe { self.end.sub_ptr(self.ptr) } ++ unsafe { non_null!(self.end, T).sub_ptr(self.ptr) } + }; + (exact, Some(exact)) + } +@@ -219,7 +238,7 @@ fn size_hint(&self) -> (usize, Option<usize>) { + #[inline] + fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { + let step_size = self.len().min(n); +- let to_drop = ptr::slice_from_raw_parts_mut(self.ptr as *mut T, step_size); ++ let to_drop = ptr::slice_from_raw_parts_mut(self.ptr.as_ptr(), step_size); + if T::IS_ZST { + // See `next` for why we sub `end` here. + self.end = self.end.wrapping_byte_sub(step_size); +@@ -261,7 +280,7 @@ fn count(self) -> usize { + // Safety: `len` indicates that this many elements are available and we just checked that + // it fits into the array. + unsafe { +- ptr::copy_nonoverlapping(self.ptr, raw_ary.as_mut_ptr() as *mut T, len); ++ ptr::copy_nonoverlapping(self.ptr.as_ptr(), raw_ary.as_mut_ptr() as *mut T, len); + self.forget_remaining_elements(); + return Err(array::IntoIter::new_unchecked(raw_ary, 0..len)); + } +@@ -270,7 +289,7 @@ fn count(self) -> usize { + // Safety: `len` is larger than the array size. Copy a fixed amount here to fully initialize + // the array. + return unsafe { +- ptr::copy_nonoverlapping(self.ptr, raw_ary.as_mut_ptr() as *mut T, N); ++ ptr::copy_nonoverlapping(self.ptr.as_ptr(), raw_ary.as_mut_ptr() as *mut T, N); + self.ptr = self.ptr.add(N); + Ok(raw_ary.transpose().assume_init()) + }; +@@ -288,7 +307,7 @@ unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item + // Also note the implementation of `Self: TrustedRandomAccess` requires + // that `T: Copy` so reading elements from the buffer doesn't invalidate + // them for `Drop`. +- unsafe { if T::IS_ZST { mem::zeroed() } else { ptr::read(self.ptr.add(i)) } } ++ unsafe { if T::IS_ZST { mem::zeroed() } else { self.ptr.add(i).read() } } + } + } + +@@ -296,18 +315,25 @@ unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item + impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> { + #[inline] + fn next_back(&mut self) -> Option<T> { +- if self.end == self.ptr { +- None +- } else if T::IS_ZST { +- // See above for why 'ptr.offset' isn't used +- self.end = self.end.wrapping_byte_sub(1); ++ if T::IS_ZST { ++ if self.end as *mut _ == self.ptr.as_ptr() { ++ None ++ } else { ++ // See above for why 'ptr.offset' isn't used ++ self.end = self.end.wrapping_byte_sub(1); + +- // Make up a value of this ZST. +- Some(unsafe { mem::zeroed() }) ++ // Make up a value of this ZST. ++ Some(unsafe { mem::zeroed() }) ++ } + } else { +- self.end = unsafe { self.end.sub(1) }; ++ if non_null!(self.end, T) == self.ptr { ++ None ++ } else { ++ let new_end = unsafe { non_null!(self.end, T).sub(1) }; ++ *non_null!(mut self.end, T) = new_end; + +- Some(unsafe { ptr::read(self.end) }) ++ Some(unsafe { ptr::read(new_end.as_ptr()) }) ++ } + } + } + +@@ -333,7 +359,11 @@ fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { + #[stable(feature = "rust1", since = "1.0.0")] + impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> { + fn is_empty(&self) -> bool { +- self.ptr == self.end ++ if T::IS_ZST { ++ self.ptr.as_ptr() == self.end as *mut _ ++ } else { ++ self.ptr == non_null!(self.end, T) ++ } + } + } + +diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs +index 220fb9d6f45b..0be27fff4554 100644 +--- a/rust/alloc/vec/mod.rs ++++ b/rust/alloc/vec/mod.rs +@@ -360,7 +360,7 @@ + /// + /// `vec![x; n]`, `vec![a, b, c, d]`, and + /// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec` +-/// with exactly the requested capacity. If <code>[len] == [capacity]</code>, ++/// with at least the requested capacity. If <code>[len] == [capacity]</code>, + /// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to + /// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements. + /// +@@ -447,7 +447,7 @@ pub const fn new() -> Self { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -690,7 +690,7 @@ pub const fn new_in(alloc: A) -> Self { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -1013,7 +1013,7 @@ pub fn capacity(&self) -> usize { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -1043,7 +1043,7 @@ pub fn reserve(&mut self, additional: usize) { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -1140,8 +1140,11 @@ pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveE + + /// Shrinks the capacity of the vector as much as possible. + /// +- /// It will drop down as close as possible to the length but the allocator +- /// may still inform the vector that there is space for a few more elements. ++ /// The behavior of this method depends on the allocator, which may either shrink the vector ++ /// in-place or reallocate. The resulting vector might still have some excess capacity, just as ++ /// is the case for [`with_capacity`]. See [`Allocator::shrink`] for more details. ++ /// ++ /// [`with_capacity`]: Vec::with_capacity + /// + /// # Examples + /// +@@ -1191,10 +1194,10 @@ pub fn shrink_to(&mut self, min_capacity: usize) { + + /// Converts the vector into [`Box<[T]>`][owned slice]. + /// +- /// If the vector has excess capacity, its items will be moved into a +- /// newly-allocated buffer with exactly the right capacity. ++ /// Before doing the conversion, this method discards excess capacity like [`shrink_to_fit`]. + /// + /// [owned slice]: Box ++ /// [`shrink_to_fit`]: Vec::shrink_to_fit + /// + /// # Examples + /// +@@ -2017,7 +2020,7 @@ fn drop(&mut self) { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -2133,7 +2136,7 @@ pub fn pop(&mut self) -> Option<T> { + } else { + unsafe { + self.len -= 1; +- core::intrinsics::assume(self.len < self.capacity()); ++ core::hint::assert_unchecked(self.len < self.capacity()); + Some(ptr::read(self.as_ptr().add(self.len()))) + } + } +@@ -2143,7 +2146,7 @@ pub fn pop(&mut self) -> Option<T> { + /// + /// # Panics + /// +- /// Panics if the new capacity exceeds `isize::MAX` bytes. ++ /// Panics if the new capacity exceeds `isize::MAX` _bytes_. + /// + /// # Examples + /// +@@ -2315,6 +2318,12 @@ pub fn is_empty(&self) -> bool { + /// `[at, len)`. After the call, the original vector will be left containing + /// the elements `[0, at)` with its previous capacity unchanged. + /// ++ /// - If you want to take ownership of the entire contents and capacity of ++ /// the vector, see [`mem::take`] or [`mem::replace`]. ++ /// - If you don't need the returned vector at all, see [`Vec::truncate`]. ++ /// - If you want to take ownership of an arbitrary subslice, or you don't ++ /// necessarily want to store the removed items in a vector, see [`Vec::drain`]. ++ /// + /// # Panics + /// + /// Panics if `at > len`. +@@ -2346,14 +2355,6 @@ fn assert_failed(at: usize, len: usize) -> ! { + assert_failed(at, self.len()); + } + +- if at == 0 { +- // the new vector can take over the original buffer and avoid the copy +- return mem::replace( +- self, +- Vec::with_capacity_in(self.capacity(), self.allocator().clone()), +- ); +- } +- + let other_len = self.len - at; + let mut other = Vec::with_capacity_in(other_len, self.allocator().clone()); + +@@ -3027,6 +3028,50 @@ fn index_mut(&mut self, index: I) -> &mut Self::Output { + } + } + ++/// Collects an iterator into a Vec, commonly called via [`Iterator::collect()`] ++/// ++/// # Allocation behavior ++/// ++/// In general `Vec` does not guarantee any particular growth or allocation strategy. ++/// That also applies to this trait impl. ++/// ++/// **Note:** This section covers implementation details and is therefore exempt from ++/// stability guarantees. ++/// ++/// Vec may use any or none of the following strategies, ++/// depending on the supplied iterator: ++/// ++/// * preallocate based on [`Iterator::size_hint()`] ++/// * and panic if the number of items is outside the provided lower/upper bounds ++/// * use an amortized growth strategy similar to `pushing` one item at a time ++/// * perform the iteration in-place on the original allocation backing the iterator ++/// ++/// The last case warrants some attention. It is an optimization that in many cases reduces peak memory ++/// consumption and improves cache locality. But when big, short-lived allocations are created, ++/// only a small fraction of their items get collected, no further use is made of the spare capacity ++/// and the resulting `Vec` is moved into a longer-lived structure, then this can lead to the large ++/// allocations having their lifetimes unnecessarily extended which can result in increased memory ++/// footprint. ++/// ++/// In cases where this is an issue, the excess capacity can be discarded with [`Vec::shrink_to()`], ++/// [`Vec::shrink_to_fit()`] or by collecting into [`Box<[T]>`][owned slice] instead, which additionally reduces ++/// the size of the long-lived struct. ++/// ++/// [owned slice]: Box ++/// ++/// ```rust ++/// # use std::sync::Mutex; ++/// static LONG_LIVED: Mutex<Vec<Vec<u16>>> = Mutex::new(Vec::new()); ++/// ++/// for i in 0..10 { ++/// let big_temporary: Vec<u16> = (0..1024).collect(); ++/// // discard most items ++/// let mut result: Vec<_> = big_temporary.into_iter().filter(|i| i % 100 == 0).collect(); ++/// // without this a lot of unused capacity might be moved into the global ++/// result.shrink_to_fit(); ++/// LONG_LIVED.lock().unwrap().push(result); ++/// } ++/// ``` + #[cfg(not(no_global_oom_handling))] + #[stable(feature = "rust1", since = "1.0.0")] + impl<T> FromIterator<T> for Vec<T> { +@@ -3069,14 +3114,8 @@ fn into_iter(self) -> Self::IntoIter { + begin.add(me.len()) as *const T + }; + let cap = me.buf.capacity(); +- IntoIter { +- buf: NonNull::new_unchecked(begin), +- phantom: PhantomData, +- cap, +- alloc, +- ptr: begin, +- end, +- } ++ let buf = NonNull::new_unchecked(begin); ++ IntoIter { buf, phantom: PhantomData, cap, alloc, ptr: buf, end } + } + } + } +@@ -3598,8 +3637,10 @@ fn from(s: Box<[T], A>) -> Self { + impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> { + /// Convert a vector into a boxed slice. + /// +- /// If `v` has excess capacity, its items will be moved into a +- /// newly-allocated buffer with exactly the right capacity. ++ /// Before doing the conversion, this method discards excess capacity like [`Vec::shrink_to_fit`]. ++ /// ++ /// [owned slice]: Box ++ /// [`Vec::shrink_to_fit`]: Vec::shrink_to_fit + /// + /// # Examples + /// +diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs +index 75efe47522e4..f07bc5a2c6b4 100644 +--- a/rust/kernel/lib.rs ++++ b/rust/kernel/lib.rs +@@ -17,7 +17,6 @@ + #![feature(const_maybe_uninit_zeroed)] + #![feature(dispatch_from_dyn)] + #![feature(new_uninit)] +-#![feature(offset_of)] + #![feature(ptr_metadata)] + #![feature(receiver_trait)] + #![feature(unsize)] +diff --git a/scripts/Makefile.build b/scripts/Makefile.build +index 1633175846df..0bc7c5fe64b1 100644 +--- a/scripts/Makefile.build ++++ b/scripts/Makefile.build +@@ -262,7 +262,7 @@ $(obj)/%.lst: $(src)/%.c FORCE + # Compile Rust sources (.rs) + # --------------------------------------------------------------------------- + +-rust_allowed_features := new_uninit,offset_of ++rust_allowed_features := new_uninit + + # `--out-dir` is required to avoid temporaries being created by `rustc` in the + # current working directory, which may be not accessible in the out-of-tree +diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh +index e217683b10d6..db2b0bc5866b 100755 +--- a/scripts/min-tool-version.sh ++++ b/scripts/min-tool-version.sh +@@ -33,7 +33,7 @@ llvm) + fi + ;; + rustc) +- echo 1.76.0 ++ echo 1.77.1 + ;; + bindgen) + echo 0.65.1 +-- +2.44.0 + diff --git a/pkgs/os-specific/linux/kernel/rust-1.77.patch b/pkgs/os-specific/linux/kernel/rust-1.77.patch index 8bd0a5e337154..ed9eb56bf6d7e 100644 --- a/pkgs/os-specific/linux/kernel/rust-1.77.patch +++ b/pkgs/os-specific/linux/kernel/rust-1.77.patch @@ -1,14 +1,16 @@ -From d69265b7d756931b2e763a3262f22ba4100895a0 Mon Sep 17 00:00:00 2001 +From b256fc507d4710287b22077834c16d18cee4ab17 Mon Sep 17 00:00:00 2001 From: Miguel Ojeda <ojeda@kernel.org> Date: Sat, 17 Feb 2024 01:27:17 +0100 -Subject: [PATCH] rust: upgrade to Rust 1.77.0 +Subject: [PATCH] rust: upgrade to Rust 1.77.1 -This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.0 +This is the next upgrade to the Rust toolchain, from 1.76.0 to 1.77.1 (i.e. the latest) [1]. See the upgrade policy [2] and the comments on the first upgrade in commit 3ed03f4da06e ("rust: upgrade to Rust 1.68.2"). +# Unstable features + The `offset_of` feature (single-field `offset_of!`) that we were using got stabilized in Rust 1.77.0 [3]. @@ -18,16 +20,22 @@ increase the list. Please see [4] for details. +# Required changes + Rust 1.77.0 merged the `unused_tuple_struct_fields` lint into `dead_code`, -thus upgrading it from `allow` to `warn` [5]. In turn, this makes `rustc` -complain about the `ThisModule`'s pointer field being never read. Thus -locally `allow` it for the moment, since we will have users later on -(e.g. Binder needs a `as_ptr` method [6]). +thus upgrading it from `allow` to `warn` [5]. In turn, this made `rustc` +complain about the `ThisModule`'s pointer field being never read, but +the previous patch adds the `as_ptr` method to it, needed by Binder [6], +so that we do not need to locally `allow` it. + +# Other changes Rust 1.77.0 introduces the `--check-cfg` feature [7], for which there is a Call for Testing going on [8]. We were requested to test it and we found it useful [9] -- we will likely enable it in the future. +# `alloc` upgrade and reviewing + The vast majority of changes are due to our `alloc` fork being upgraded at once. @@ -85,9 +93,12 @@ Link: https://lore.kernel.org/rust-for-linux/20231101-rust-binder-v1-2-08ba9197f Link: https://doc.rust-lang.org/nightly/unstable-book/compiler-flags/check-cfg.html [7] Link: https://github.com/rust-lang/rfcs/pull/3013#issuecomment-1936648479 [8] Link: https://github.com/rust-lang/rust/issues/82450#issuecomment-1947462977 [9] -Signed-off-by: Miguel Ojeda <ojeda@kernel.org> +Reviewed-by: Alice Ryhl <aliceryhl@google.com> +Tested-by: Boqun Feng <boqun.feng@gmail.com> Link: https://lore.kernel.org/r/20240217002717.57507-1-ojeda@kernel.org -Link: https://github.com/Rust-for-Linux/linux/commit/d69265b7d756931b2e763a3262f22ba4100895a0 +[ Upgraded to 1.77.1. Removed `allow(dead_code)` thanks to the previous + patch. Reworded accordingly. No changes to `alloc` during the beta. ] +Signed-off-by: Miguel Ojeda <ojeda@kernel.org> Signed-off-by: Alyssa Ross <hi@alyssa.is> --- Documentation/process/changes.rst | 2 +- @@ -96,15 +107,15 @@ Signed-off-by: Alyssa Ross <hi@alyssa.is> rust/alloc/lib.rs | 7 +- rust/alloc/raw_vec.rs | 13 ++-- rust/alloc/slice.rs | 4 +- - rust/alloc/vec/into_iter.rs | 108 +++++++++++++++++++----------- - rust/alloc/vec/mod.rs | 101 +++++++++++++++++++--------- - rust/kernel/lib.rs | 3 +- + rust/alloc/vec/into_iter.rs | 104 +++++++++++++++++++----------- + rust/alloc/vec/mod.rs | 101 ++++++++++++++++++++--------- + rust/kernel/lib.rs | 1 - scripts/Makefile.build | 2 +- scripts/min-tool-version.sh | 2 +- - 11 files changed, 161 insertions(+), 91 deletions(-) + 11 files changed, 158 insertions(+), 88 deletions(-) diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst -index 7ef8de58f7f892..879ee628893ae1 100644 +index 7ef8de58f7f8..b5d3107c6734 100644 --- a/Documentation/process/changes.rst +++ b/Documentation/process/changes.rst @@ -31,7 +31,7 @@ you probably needn't concern yourself with pcmciautils. @@ -112,12 +123,12 @@ index 7ef8de58f7f892..879ee628893ae1 100644 GNU C 5.1 gcc --version Clang/LLVM (optional) 13.0.1 clang --version -Rust (optional) 1.76.0 rustc --version -+Rust (optional) 1.77.0 rustc --version ++Rust (optional) 1.77.1 rustc --version bindgen (optional) 0.65.1 bindgen --version GNU make 3.82 make --version bash 4.2 bash --version diff --git a/rust/alloc/alloc.rs b/rust/alloc/alloc.rs -index abb791cc23715a..b1204f87227b23 100644 +index abb791cc2371..b1204f87227b 100644 --- a/rust/alloc/alloc.rs +++ b/rust/alloc/alloc.rs @@ -5,7 +5,7 @@ @@ -129,7 +140,7 @@ index abb791cc23715a..b1204f87227b23 100644 #[cfg(not(test))] use core::ptr::{self, NonNull}; -@@ -210,7 +210,7 @@ impl Global { +@@ -210,7 +210,7 @@ unsafe fn grow_impl( let new_size = new_layout.size(); // `realloc` probably checks for `new_size >= old_layout.size()` or something similar. @@ -138,7 +149,7 @@ index abb791cc23715a..b1204f87227b23 100644 let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; -@@ -301,7 +301,7 @@ unsafe impl Allocator for Global { +@@ -301,7 +301,7 @@ unsafe fn shrink( // SAFETY: `new_size` is non-zero. Other conditions must be upheld by the caller new_size if old_layout.align() == new_layout.align() => unsafe { // `realloc` probably checks for `new_size <= old_layout.size()` or something similar. @@ -148,7 +159,7 @@ index abb791cc23715a..b1204f87227b23 100644 let raw_ptr = realloc(ptr.as_ptr(), old_layout, new_size); let ptr = NonNull::new(raw_ptr).ok_or(AllocError)?; diff --git a/rust/alloc/boxed.rs b/rust/alloc/boxed.rs -index c93a22a5c97f14..5fc39dfeb8e7bf 100644 +index c93a22a5c97f..5fc39dfeb8e7 100644 --- a/rust/alloc/boxed.rs +++ b/rust/alloc/boxed.rs @@ -26,6 +26,7 @@ @@ -159,7 +170,7 @@ index c93a22a5c97f14..5fc39dfeb8e7bf 100644 //! #[derive(Debug)] //! enum List<T> { //! Cons(T, Box<List<T>>), -@@ -194,8 +195,7 @@ mod thin; +@@ -194,8 +195,7 @@ #[fundamental] #[stable(feature = "rust1", since = "1.0.0")] // The declaration of the `Box` struct must be kept in sync with the @@ -170,7 +181,7 @@ index c93a22a5c97f14..5fc39dfeb8e7bf 100644 T: ?Sized, #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global, diff --git a/rust/alloc/lib.rs b/rust/alloc/lib.rs -index 36f79c07559338..39afd55ec0749e 100644 +index 36f79c075593..39afd55ec074 100644 --- a/rust/alloc/lib.rs +++ b/rust/alloc/lib.rs @@ -105,7 +105,6 @@ @@ -223,7 +234,7 @@ index 36f79c07559338..39afd55ec0749e 100644 #![feature(exclusive_range_pattern)] #![feature(fundamental)] diff --git a/rust/alloc/raw_vec.rs b/rust/alloc/raw_vec.rs -index 98b6abf30af6e4..1839d1c8ee7a04 100644 +index 98b6abf30af6..1839d1c8ee7a 100644 --- a/rust/alloc/raw_vec.rs +++ b/rust/alloc/raw_vec.rs @@ -4,7 +4,7 @@ @@ -235,7 +246,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 use core::mem::{self, ManuallyDrop, MaybeUninit, SizedTypeProperties}; use core::ptr::{self, NonNull, Unique}; use core::slice; -@@ -317,7 +317,7 @@ impl<T, A: Allocator> RawVec<T, A> { +@@ -317,7 +317,7 @@ fn current_memory(&self) -> Option<(NonNull<u8>, Layout)> { /// /// # Panics /// @@ -244,7 +255,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 /// /// # Aborts /// -@@ -358,7 +358,7 @@ impl<T, A: Allocator> RawVec<T, A> { +@@ -358,7 +358,7 @@ pub fn try_reserve(&mut self, len: usize, additional: usize) -> Result<(), TryRe } unsafe { // Inform the optimizer that the reservation has succeeded or wasn't needed @@ -253,7 +264,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 } Ok(()) } -@@ -381,7 +381,7 @@ impl<T, A: Allocator> RawVec<T, A> { +@@ -381,7 +381,7 @@ pub fn try_reserve_for_push(&mut self, len: usize) -> Result<(), TryReserveError /// /// # Panics /// @@ -262,7 +273,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 /// /// # Aborts /// -@@ -402,7 +402,7 @@ impl<T, A: Allocator> RawVec<T, A> { +@@ -402,7 +402,7 @@ pub fn try_reserve_exact( } unsafe { // Inform the optimizer that the reservation has succeeded or wasn't needed @@ -271,7 +282,7 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 } Ok(()) } -@@ -553,7 +553,7 @@ where +@@ -553,7 +553,7 @@ fn finish_grow<A>( debug_assert_eq!(old_layout.align(), new_layout.align()); unsafe { // The allocator checks for alignment equality @@ -289,10 +300,10 @@ index 98b6abf30af6e4..1839d1c8ee7a04 100644 fn alloc_guard(alloc_size: usize) -> Result<(), TryReserveError> { if usize::BITS < 64 && alloc_size > isize::MAX as usize { diff --git a/rust/alloc/slice.rs b/rust/alloc/slice.rs -index 1181836da5f462..a36b072c95195f 100644 +index 1181836da5f4..a36b072c9519 100644 --- a/rust/alloc/slice.rs +++ b/rust/alloc/slice.rs -@@ -53,14 +53,14 @@ pub use core::slice::{from_mut, from_ref}; +@@ -53,14 +53,14 @@ pub use core::slice::{from_mut_ptr_range, from_ptr_range}; #[stable(feature = "rust1", since = "1.0.0")] pub use core::slice::{from_raw_parts, from_raw_parts_mut}; @@ -310,10 +321,10 @@ index 1181836da5f462..a36b072c95195f 100644 pub use core::slice::{Iter, IterMut}; #[stable(feature = "rchunks", since = "1.31.0")] diff --git a/rust/alloc/vec/into_iter.rs b/rust/alloc/vec/into_iter.rs -index 136bfe94af6c83..0f11744c44b34c 100644 +index 136bfe94af6c..0f11744c44b3 100644 --- a/rust/alloc/vec/into_iter.rs +++ b/rust/alloc/vec/into_iter.rs -@@ -20,6 +20,17 @@ use core::ops::Deref; +@@ -20,6 +20,17 @@ use core::ptr::{self, NonNull}; use core::slice::{self}; @@ -357,7 +368,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } /// Returns the remaining items of this iterator as a mutable slice. -@@ -99,7 +112,7 @@ impl<T, A: Allocator> IntoIter<T, A> { +@@ -99,7 +112,7 @@ pub fn allocator(&self) -> &A { } fn as_raw_mut_slice(&mut self) -> *mut [T] { @@ -366,7 +377,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } /// Drops remaining elements and relinquishes the backing allocation. -@@ -126,7 +139,7 @@ impl<T, A: Allocator> IntoIter<T, A> { +@@ -126,7 +139,7 @@ pub(super) fn forget_allocation_drop_remaining(&mut self) { // this creates less assembly self.cap = 0; self.buf = unsafe { NonNull::new_unchecked(RawVec::NEW.ptr()) }; @@ -375,7 +386,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 self.end = self.buf.as_ptr(); // Dropping the remaining elements can panic, so this needs to be -@@ -138,9 +151,9 @@ impl<T, A: Allocator> IntoIter<T, A> { +@@ -138,9 +151,9 @@ pub(super) fn forget_allocation_drop_remaining(&mut self) { /// Forgets to Drop the remaining elements while still allowing the backing allocation to be freed. pub(crate) fn forget_remaining_elements(&mut self) { @@ -387,7 +398,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } #[cfg(not(no_global_oom_handling))] -@@ -162,7 +175,7 @@ impl<T, A: Allocator> IntoIter<T, A> { +@@ -162,7 +175,7 @@ pub(crate) fn into_vecdeque(self) -> VecDeque<T, A> { // say that they're all at the beginning of the "allocation". 0..this.len() } else { @@ -406,9 +417,6 @@ index 136bfe94af6c83..0f11744c44b34c 100644 - // `ptr` has to stay where it is to remain aligned, so we reduce the length by 1 by - // reducing the `end`. - self.end = self.end.wrapping_byte_sub(1); -- -- // Make up a value of this ZST. -- Some(unsafe { mem::zeroed() }) + if T::IS_ZST { + if self.ptr.as_ptr() == self.end as *mut _ { + None @@ -416,7 +424,9 @@ index 136bfe94af6c83..0f11744c44b34c 100644 + // `ptr` has to stay where it is to remain aligned, so we reduce the length by 1 by + // reducing the `end`. + self.end = self.end.wrapping_byte_sub(1); -+ + +- // Make up a value of this ZST. +- Some(unsafe { mem::zeroed() }) + // Make up a value of this ZST. + Some(unsafe { mem::zeroed() }) + } @@ -446,7 +456,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 }; (exact, Some(exact)) } -@@ -219,7 +238,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -219,7 +238,7 @@ fn size_hint(&self) -> (usize, Option<usize>) { #[inline] fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { let step_size = self.len().min(n); @@ -455,7 +465,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 if T::IS_ZST { // See `next` for why we sub `end` here. self.end = self.end.wrapping_byte_sub(step_size); -@@ -261,7 +280,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -261,7 +280,7 @@ fn count(self) -> usize { // Safety: `len` indicates that this many elements are available and we just checked that // it fits into the array. unsafe { @@ -464,7 +474,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 self.forget_remaining_elements(); return Err(array::IntoIter::new_unchecked(raw_ary, 0..len)); } -@@ -270,7 +289,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -270,7 +289,7 @@ fn count(self) -> usize { // Safety: `len` is larger than the array size. Copy a fixed amount here to fully initialize // the array. return unsafe { @@ -473,7 +483,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 self.ptr = self.ptr.add(N); Ok(raw_ary.transpose().assume_init()) }; -@@ -288,7 +307,7 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -288,7 +307,7 @@ unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item // Also note the implementation of `Self: TrustedRandomAccess` requires // that `T: Copy` so reading elements from the buffer doesn't invalidate // them for `Drop`. @@ -482,7 +492,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } } -@@ -296,18 +315,25 @@ impl<T, A: Allocator> Iterator for IntoIter<T, A> { +@@ -296,18 +315,25 @@ unsafe fn __iterator_get_unchecked(&mut self, i: usize) -> Self::Item impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> { #[inline] fn next_back(&mut self) -> Option<T> { @@ -491,16 +501,15 @@ index 136bfe94af6c83..0f11744c44b34c 100644 - } else if T::IS_ZST { - // See above for why 'ptr.offset' isn't used - self.end = self.end.wrapping_byte_sub(1); -- -- // Make up a value of this ZST. -- Some(unsafe { mem::zeroed() }) + if T::IS_ZST { + if self.end as *mut _ == self.ptr.as_ptr() { + None + } else { + // See above for why 'ptr.offset' isn't used + self.end = self.end.wrapping_byte_sub(1); -+ + +- // Make up a value of this ZST. +- Some(unsafe { mem::zeroed() }) + // Make up a value of this ZST. + Some(unsafe { mem::zeroed() }) + } @@ -518,7 +527,7 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } } -@@ -333,7 +359,11 @@ impl<T, A: Allocator> DoubleEndedIterator for IntoIter<T, A> { +@@ -333,7 +359,11 @@ fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize> { #[stable(feature = "rust1", since = "1.0.0")] impl<T, A: Allocator> ExactSizeIterator for IntoIter<T, A> { fn is_empty(&self) -> bool { @@ -532,10 +541,10 @@ index 136bfe94af6c83..0f11744c44b34c 100644 } diff --git a/rust/alloc/vec/mod.rs b/rust/alloc/vec/mod.rs -index 220fb9d6f45b3f..0be27fff4554a1 100644 +index 220fb9d6f45b..0be27fff4554 100644 --- a/rust/alloc/vec/mod.rs +++ b/rust/alloc/vec/mod.rs -@@ -360,7 +360,7 @@ mod spec_extend; +@@ -360,7 +360,7 @@ /// /// `vec![x; n]`, `vec![a, b, c, d]`, and /// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec` @@ -544,7 +553,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to /// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements. /// -@@ -447,7 +447,7 @@ impl<T> Vec<T> { +@@ -447,7 +447,7 @@ pub const fn new() -> Self { /// /// # Panics /// @@ -553,7 +562,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -690,7 +690,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -690,7 +690,7 @@ pub const fn new_in(alloc: A) -> Self { /// /// # Panics /// @@ -562,7 +571,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -1013,7 +1013,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -1013,7 +1013,7 @@ pub fn capacity(&self) -> usize { /// /// # Panics /// @@ -571,7 +580,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -1043,7 +1043,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -1043,7 +1043,7 @@ pub fn reserve(&mut self, additional: usize) { /// /// # Panics /// @@ -580,7 +589,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -1140,8 +1140,11 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -1140,8 +1140,11 @@ pub fn try_reserve_exact(&mut self, additional: usize) -> Result<(), TryReserveE /// Shrinks the capacity of the vector as much as possible. /// @@ -594,7 +603,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -1191,10 +1194,10 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -1191,10 +1194,10 @@ pub fn shrink_to(&mut self, min_capacity: usize) { /// Converts the vector into [`Box<[T]>`][owned slice]. /// @@ -607,7 +616,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -2017,7 +2020,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2017,7 +2020,7 @@ fn drop(&mut self) { /// /// # Panics /// @@ -616,7 +625,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -2133,7 +2136,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2133,7 +2136,7 @@ pub fn pop(&mut self) -> Option<T> { } else { unsafe { self.len -= 1; @@ -625,7 +634,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 Some(ptr::read(self.as_ptr().add(self.len()))) } } -@@ -2143,7 +2146,7 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2143,7 +2146,7 @@ pub fn pop(&mut self) -> Option<T> { /// /// # Panics /// @@ -634,7 +643,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// /// # Examples /// -@@ -2315,6 +2318,12 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2315,6 +2318,12 @@ pub fn is_empty(&self) -> bool { /// `[at, len)`. After the call, the original vector will be left containing /// the elements `[0, at)` with its previous capacity unchanged. /// @@ -647,7 +656,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// # Panics /// /// Panics if `at > len`. -@@ -2346,14 +2355,6 @@ impl<T, A: Allocator> Vec<T, A> { +@@ -2346,14 +2355,6 @@ fn assert_failed(at: usize, len: usize) -> ! { assert_failed(at, self.len()); } @@ -662,7 +671,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 let other_len = self.len - at; let mut other = Vec::with_capacity_in(other_len, self.allocator().clone()); -@@ -3027,6 +3028,50 @@ impl<T, I: SliceIndex<[T]>, A: Allocator> IndexMut<I> for Vec<T, A> { +@@ -3027,6 +3028,50 @@ fn index_mut(&mut self, index: I) -> &mut Self::Output { } } @@ -713,7 +722,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 #[cfg(not(no_global_oom_handling))] #[stable(feature = "rust1", since = "1.0.0")] impl<T> FromIterator<T> for Vec<T> { -@@ -3069,14 +3114,8 @@ impl<T, A: Allocator> IntoIterator for Vec<T, A> { +@@ -3069,14 +3114,8 @@ fn into_iter(self) -> Self::IntoIter { begin.add(me.len()) as *const T }; let cap = me.buf.capacity(); @@ -730,7 +739,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 } } } -@@ -3598,8 +3637,10 @@ impl<T, A: Allocator> From<Box<[T], A>> for Vec<T, A> { +@@ -3598,8 +3637,10 @@ fn from(s: Box<[T], A>) -> Self { impl<T, A: Allocator> From<Vec<T, A>> for Box<[T], A> { /// Convert a vector into a boxed slice. /// @@ -744,7 +753,7 @@ index 220fb9d6f45b3f..0be27fff4554a1 100644 /// # Examples /// diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs -index be68d5e567b1a1..71f95e5aa09abd 100644 +index 6858e2f8a3ed..9e9b245ebab5 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -16,7 +16,6 @@ @@ -755,17 +764,8 @@ index be68d5e567b1a1..71f95e5aa09abd 100644 #![feature(receiver_trait)] #![feature(unsize)] -@@ -78,7 +77,7 @@ pub trait Module: Sized + Sync { - /// Equivalent to `THIS_MODULE` in the C API. - /// - /// C header: [`include/linux/export.h`](srctree/include/linux/export.h) --pub struct ThisModule(*mut bindings::module); -+pub struct ThisModule(#[allow(dead_code)] *mut bindings::module); - - // SAFETY: `THIS_MODULE` may be used from all threads within a module. - unsafe impl Sync for ThisModule {} diff --git a/scripts/Makefile.build b/scripts/Makefile.build -index baf86c0880b6d7..367cfeea74c5f5 100644 +index 533a7799fdfe..5a6ab6d965bc 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -263,7 +263,7 @@ $(obj)/%.lst: $(src)/%.c FORCE @@ -778,7 +778,7 @@ index baf86c0880b6d7..367cfeea74c5f5 100644 # `--out-dir` is required to avoid temporaries being created by `rustc` in the # current working directory, which may be not accessible in the out-of-tree diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh -index 5927cc6b7de338..cc5141b67b4a71 100755 +index 5927cc6b7de3..6086e00e640e 100755 --- a/scripts/min-tool-version.sh +++ b/scripts/min-tool-version.sh @@ -33,7 +33,7 @@ llvm) @@ -786,7 +786,10 @@ index 5927cc6b7de338..cc5141b67b4a71 100755 ;; rustc) - echo 1.76.0 -+ echo 1.77.0 ++ echo 1.77.1 ;; bindgen) echo 0.65.1 +-- +2.44.0 + diff --git a/pkgs/top-level/all-packages.nix b/pkgs/top-level/all-packages.nix index fc073da2b3c00..4ef1a3e517673 100644 --- a/pkgs/top-level/all-packages.nix +++ b/pkgs/top-level/all-packages.nix @@ -16545,11 +16545,11 @@ with pkgs; wrapRustcWith = { rustc-unwrapped, ... } @ args: callPackage ../build-support/rust/rustc-wrapper args; wrapRustc = rustc-unwrapped: wrapRustcWith { inherit rustc-unwrapped; }; - rust_1_77 = callPackage ../development/compilers/rust/1_77.nix { + rust_1_78 = callPackage ../development/compilers/rust/1_78.nix { inherit (darwin.apple_sdk.frameworks) CoreFoundation Security SystemConfiguration; - llvm_17 = llvmPackages_17.libllvm; + llvm_18 = llvmPackages_18.libllvm; }; - rust = rust_1_77; + rust = rust_1_78; mrustc = callPackage ../development/compilers/mrustc { }; mrustc-minicargo = callPackage ../development/compilers/mrustc/minicargo.nix { }; @@ -16557,8 +16557,8 @@ with pkgs; openssl = openssl_1_1; }; - rustPackages_1_77 = rust_1_77.packages.stable; - rustPackages = rustPackages_1_77; + rustPackages_1_78 = rust_1_78.packages.stable; + rustPackages = rustPackages_1_78; inherit (rustPackages) cargo cargo-auditable cargo-auditable-cargo-wrapper clippy rustc rustPlatform; diff --git a/pkgs/top-level/linux-kernels.nix b/pkgs/top-level/linux-kernels.nix index 0a248521a4375..d5c5b7f945f9b 100644 --- a/pkgs/top-level/linux-kernels.nix +++ b/pkgs/top-level/linux-kernels.nix @@ -193,6 +193,7 @@ in { kernelPatches.rust_1_75 kernelPatches.rust_1_76 kernelPatches.rust_1_77-6_8 + kernelPatches.rust_1_78 ]; }; @@ -213,6 +214,7 @@ in { kernelPatches = [ kernelPatches.bridge_stp_helper kernelPatches.request_key_helper + kernelPatches.rust_1_78 ]; }; latest = packageAliases.linux_latest.kernel; |