From 643350269d3518eebea5ca0a7bd4a0631d4d5ee6 Mon Sep 17 00:00:00 2001 From: Mikael Urankar Date: Wed, 17 Aug 2022 19:35:40 +0200 Subject: [PATCH 1/5] lang/rust: Update to 1.63.0 Announce: https://blog.rust-lang.org/2022/08/11/Rust-1.63.0.html ChangeLog: https://github.com/rust-lang/rust/releases/tag/1.63.0 --- Mk/Uses/cargo.mk | 2 +- Mk/bsd.gecko.mk | 2 +- lang/rust-bootstrap/Makefile | 2 +- lang/rust-bootstrap/distinfo | 6 +- lang/rust/Makefile | 6 +- lang/rust/distinfo | 126 +++++++++--------- .../no-hardlinks/patch-src_bootstrap_lib.rs | 31 +++-- 7 files changed, 95 insertions(+), 80 deletions(-) diff --git a/Mk/Uses/cargo.mk b/Mk/Uses/cargo.mk index 0a9455fb97..55bedf30b1 100644 --- a/Mk/Uses/cargo.mk +++ b/Mk/Uses/cargo.mk @@ -97,7 +97,7 @@ WRKSRC_crate_${_crate}= ${WRKDIR}/${_wrksrc} CARGO_BUILDDEP?= yes . if ${CARGO_BUILDDEP:tl} == "yes" -BUILD_DEPENDS+= ${RUST_DEFAULT}>=1.62.0:lang/${RUST_DEFAULT} +BUILD_DEPENDS+= ${RUST_DEFAULT}>=1.63.0:lang/${RUST_DEFAULT} . endif # Location of toolchain (default to lang/rust's toolchain) diff --git a/Mk/bsd.gecko.mk b/Mk/bsd.gecko.mk index 2ea394ae99..047310846c 100644 --- a/Mk/bsd.gecko.mk +++ b/Mk/bsd.gecko.mk @@ -79,7 +79,7 @@ BUNDLE_LIBS= yes BUILD_DEPENDS+= llvm${LLVM_DEFAULT}>0:devel/llvm${LLVM_DEFAULT} \ rust-cbindgen>=0.24.3:devel/rust-cbindgen \ - ${RUST_DEFAULT}>=1.62.0:lang/${RUST_DEFAULT} \ + ${RUST_DEFAULT}>=1.63.0:lang/${RUST_DEFAULT} \ node:www/node LIB_DEPENDS+= libdrm.so:graphics/libdrm RUN_DEPENDS+= ${LOCALBASE}/lib/libpci.so:devel/libpci diff --git a/lang/rust-bootstrap/Makefile b/lang/rust-bootstrap/Makefile index 15eb5696dd..45d0358fc8 100644 --- a/lang/rust-bootstrap/Makefile +++ b/lang/rust-bootstrap/Makefile @@ -2,7 +2,7 @@ # to upload them to ~/public_distfiles on freefall in preparation # for the next lang/rust update. PORTNAME= rust -PORTVERSION= 1.62.0 +PORTVERSION= 1.63.0 CATEGORIES= lang MASTER_SITES= https://static.rust-lang.org/dist/ PKGNAMEPREFIX= ${FLAVOR:S/_/-/g}- diff --git a/lang/rust-bootstrap/distinfo b/lang/rust-bootstrap/distinfo index 16c3bdd739..26b57a90a3 100644 --- a/lang/rust-bootstrap/distinfo +++ b/lang/rust-bootstrap/distinfo @@ -1,3 +1,3 @@ -TIMESTAMP = 1656497768 -SHA256 (rust/rustc-1.62.0-src.tar.xz) = 6c00ef115c894c2645e60b5049a4f5dacf1dc0c993f3074f7ae4fdf4c755dd5e -SIZE (rust/rustc-1.62.0-src.tar.xz) = 135644992 +TIMESTAMP = 1660646335 +SHA256 (rust/rustc-1.63.0-src.tar.xz) = 8f44af6dc44cc4146634a4dd5e4cc5470b3052a2337019b870c0e025e8987e0c +SIZE (rust/rustc-1.63.0-src.tar.xz) = 136597192 diff --git a/lang/rust/Makefile b/lang/rust/Makefile index 10d8809ccd..919e33e6b2 100644 --- a/lang/rust/Makefile +++ b/lang/rust/Makefile @@ -1,5 +1,5 @@ PORTNAME= rust -PORTVERSION?= 1.62.1 +PORTVERSION?= 1.63.0 PORTREVISION?= 0 CATEGORIES= lang MASTER_SITES= https://static.rust-lang.org/dist/:src \ @@ -68,8 +68,8 @@ WASM_VARS= _COMPONENTS+="rust-analysis-${_PACKAGE_VERS}-wasm32-unknown-unknown WASM_VARS_OFF= _RUST_BUILD_WASM=false # See WRKSRC/src/stage0.json for the date and version values -BOOTSTRAPS_DATE?= 2022-05-19 -RUST_BOOTSTRAP_VERSION?= 1.61.0 +BOOTSTRAPS_DATE?= 2022-08-11 +RUST_BOOTSTRAP_VERSION?= 1.62.0 BOOTSTRAPS_SUFFIX?= ${BOOTSTRAPS_SUFFIX_${ARCH}} BOOTSTRAPS_SUFFIX_powerpc64?= -${PPC_ABI:tl} diff --git a/lang/rust/distinfo b/lang/rust/distinfo index 7dcf1e2985..62c1950596 100644 --- a/lang/rust/distinfo +++ b/lang/rust/distinfo @@ -1,63 +1,63 @@ -TIMESTAMP = 1658240928 -SHA256 (rust/rustc-1.62.1-src.tar.xz) = 02066a93c2f6596cc046a897d5716c86e3607c1cd0f54db9a867ae8c8265072e -SIZE (rust/rustc-1.62.1-src.tar.xz) = 135644156 -SHA256 (rust/2022-05-19/rustc-1.61.0-aarch64-unknown-freebsd.tar.xz) = 042eec2e8a6eff9bf754594e989f4d82b9a45bd86e32c8782146ccb55b1845b0 -SIZE (rust/2022-05-19/rustc-1.61.0-aarch64-unknown-freebsd.tar.xz) = 41988500 -SHA256 (rust/2022-05-19/rust-std-1.61.0-aarch64-unknown-freebsd.tar.xz) = 518aa33a3fad35cf65f91b9816664c82f6e421d57389a45193f3e032b03d4e73 -SIZE (rust/2022-05-19/rust-std-1.61.0-aarch64-unknown-freebsd.tar.xz) = 23570368 -SHA256 (rust/2022-05-19/cargo-1.61.0-aarch64-unknown-freebsd.tar.xz) = 3f294d64552351f159885868ffeac107fd1dbc62c550506ad4b8b595747a8c1e -SIZE (rust/2022-05-19/cargo-1.61.0-aarch64-unknown-freebsd.tar.xz) = 4794716 -SHA256 (rust/2022-05-19/rustc-1.61.0-x86_64-unknown-freebsd.tar.xz) = e3ec7b3e7913e1613e973202a915539922cda424fe0e22f17a0106f075158152 -SIZE (rust/2022-05-19/rustc-1.61.0-x86_64-unknown-freebsd.tar.xz) = 37986400 -SHA256 (rust/2022-05-19/rust-std-1.61.0-x86_64-unknown-freebsd.tar.xz) = a35bd8f17d2141e1c5384b02f0775838c08e6c4e8b5d74c5d42681f80268cab5 -SIZE (rust/2022-05-19/rust-std-1.61.0-x86_64-unknown-freebsd.tar.xz) = 23842720 -SHA256 (rust/2022-05-19/cargo-1.61.0-x86_64-unknown-freebsd.tar.xz) = 70e78458896f94ed172ac4e3caf3f54eddb2a9bcca81c42800117383ba988c95 -SIZE (rust/2022-05-19/cargo-1.61.0-x86_64-unknown-freebsd.tar.xz) = 5502300 -SHA256 (rust/2022-05-19/rustc-1.61.0-armv6-unknown-freebsd.tar.xz) = 9268265126c7ae989c03d1f8710ed29182a6d1a9c5217fd7ee6558e5b8b29076 -SIZE (rust/2022-05-19/rustc-1.61.0-armv6-unknown-freebsd.tar.xz) = 42901832 -SHA256 (rust/2022-05-19/rust-std-1.61.0-armv6-unknown-freebsd.tar.xz) = a0f00fc1b3dca64e4fe32ea7ef96409519cced71e58841425cb444b7189e09a6 -SIZE (rust/2022-05-19/rust-std-1.61.0-armv6-unknown-freebsd.tar.xz) = 21817044 -SHA256 (rust/2022-05-19/cargo-1.61.0-armv6-unknown-freebsd.tar.xz) = 6593e951345c557fa90c7732130bddfb89a6df7dc4b5d79e701740e7fc48d98a -SIZE (rust/2022-05-19/cargo-1.61.0-armv6-unknown-freebsd.tar.xz) = 4747396 -SHA256 (rust/2022-05-19/rustc-1.61.0-armv7-unknown-freebsd.tar.xz) = d83086bf4355cc92baf908b313c3f83821ab7407a59edc2e99a234b6f56db71c -SIZE (rust/2022-05-19/rustc-1.61.0-armv7-unknown-freebsd.tar.xz) = 42713712 -SHA256 (rust/2022-05-19/rust-std-1.61.0-armv7-unknown-freebsd.tar.xz) = 5bbdccac7a91bcbdeea3295f12e10a86515f550ece6118383f90657a247e022e -SIZE (rust/2022-05-19/rust-std-1.61.0-armv7-unknown-freebsd.tar.xz) = 22793208 -SHA256 (rust/2022-05-19/cargo-1.61.0-armv7-unknown-freebsd.tar.xz) = 24814d99e7811cfac6a51848d6a63fd6f38f9b845b29dbad550585067d6beb8d -SIZE (rust/2022-05-19/cargo-1.61.0-armv7-unknown-freebsd.tar.xz) = 4733024 -SHA256 (rust/2022-05-19/rustc-1.61.0-i686-unknown-freebsd.tar.xz) = 9aef4d35438a70b8239976364b6b7266f6f15e64b40463f81329938cda167576 -SIZE (rust/2022-05-19/rustc-1.61.0-i686-unknown-freebsd.tar.xz) = 47040012 -SHA256 (rust/2022-05-19/rust-std-1.61.0-i686-unknown-freebsd.tar.xz) = 2f4b31a12a46cf4d778b6ff44503c0b4f5019870a8f27472b6c26cd387aabbf0 -SIZE (rust/2022-05-19/rust-std-1.61.0-i686-unknown-freebsd.tar.xz) = 23667232 -SHA256 (rust/2022-05-19/cargo-1.61.0-i686-unknown-freebsd.tar.xz) = c3cc0f5e0b57fa220fb0d44813409584ad1d6352c2a5dc77ffe9211338c412ae -SIZE (rust/2022-05-19/cargo-1.61.0-i686-unknown-freebsd.tar.xz) = 5650840 -SHA256 (rust/2022-05-19/rustc-1.61.0-powerpc-unknown-freebsd.tar.xz) = 0ca81deb0faa343ff420b7f9e6f325eac366a15128b1e096eb3062516e48e36b -SIZE (rust/2022-05-19/rustc-1.61.0-powerpc-unknown-freebsd.tar.xz) = 44567188 -SHA256 (rust/2022-05-19/rust-std-1.61.0-powerpc-unknown-freebsd.tar.xz) = a3a26ab34a9f62d1b9a0dba45f4d63c25994d222ddabdf909be9217b93ce6415 -SIZE (rust/2022-05-19/rust-std-1.61.0-powerpc-unknown-freebsd.tar.xz) = 21657860 -SHA256 (rust/2022-05-19/cargo-1.61.0-powerpc-unknown-freebsd.tar.xz) = 4d3f3da61d993e8698d9bb13aa6eb75f00e0567b23a4e2809adde47b0e8372f0 -SIZE (rust/2022-05-19/cargo-1.61.0-powerpc-unknown-freebsd.tar.xz) = 5232608 -SHA256 (rust/2022-05-19/rustc-1.61.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 5f8878946c10350ce2ed4751baa1dd467cbbce223899086c631dc4e714bad09f -SIZE (rust/2022-05-19/rustc-1.61.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 51265100 -SHA256 (rust/2022-05-19/rust-std-1.61.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 45eea66649936ccc789309381a0e2cb82ee63bf7fc902262eab664cd40d373a8 -SIZE (rust/2022-05-19/rust-std-1.61.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 21767000 -SHA256 (rust/2022-05-19/cargo-1.61.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 91dfca32008126f8f526cd4913e487341c968b82b6e094df15a4760dfca400ea -SIZE (rust/2022-05-19/cargo-1.61.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 5345408 -SHA256 (rust/2022-05-19/rustc-1.61.0-powerpc64le-unknown-freebsd.tar.xz) = 0f22827e20c6aed0b67450f228bfdc44b5b83abbffd9bb8bf1d529ee94aa9b95 -SIZE (rust/2022-05-19/rustc-1.61.0-powerpc64le-unknown-freebsd.tar.xz) = 44874472 -SHA256 (rust/2022-05-19/rust-std-1.61.0-powerpc64le-unknown-freebsd.tar.xz) = bae7067eac67fede90defecb5250985fc8b7fdcd22435acb795901e8a75f1f96 -SIZE (rust/2022-05-19/rust-std-1.61.0-powerpc64le-unknown-freebsd.tar.xz) = 21828580 -SHA256 (rust/2022-05-19/cargo-1.61.0-powerpc64le-unknown-freebsd.tar.xz) = 2fe81b4ee62a5370f6e5a6dc5a46d00871a9c77513eb165664e871cd66f8adac -SIZE (rust/2022-05-19/cargo-1.61.0-powerpc64le-unknown-freebsd.tar.xz) = 5265304 -SHA256 (rust/2022-05-19/rustc-1.61.0-riscv64gc-unknown-freebsd.tar.xz) = d2d371908a8dcd49db81bd2db048c57a968e0ec8a00918ad2f80fcd306862855 -SIZE (rust/2022-05-19/rustc-1.61.0-riscv64gc-unknown-freebsd.tar.xz) = 139529684 -SHA256 (rust/2022-05-19/rust-std-1.61.0-riscv64gc-unknown-freebsd.tar.xz) = 0ee3a580304386a75ec500f0c9f1e853a9922c4b9521d4577a559b120e865795 -SIZE (rust/2022-05-19/rust-std-1.61.0-riscv64gc-unknown-freebsd.tar.xz) = 29642992 -SHA256 (rust/2022-05-19/cargo-1.61.0-riscv64gc-unknown-freebsd.tar.xz) = 89522660fbc8718ab394566fb7daf5ce95fdbabec49e7a322d561f8d81c53e1f -SIZE (rust/2022-05-19/cargo-1.61.0-riscv64gc-unknown-freebsd.tar.xz) = 26543872 -SHA256 (rust/2022-05-19/rustc-1.61.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 16d5a9a0b8f7b75ad76efcdf4bf3b7ad51d5ffae21cf04c64696803879081ffb -SIZE (rust/2022-05-19/rustc-1.61.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 42802348 -SHA256 (rust/2022-05-19/rust-std-1.61.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 5526d0f46a2829a3b4ce5147f8ce9cdc5144a811e7362cbe5666df0a35420fe0 -SIZE (rust/2022-05-19/rust-std-1.61.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 21712780 -SHA256 (rust/2022-05-19/cargo-1.61.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 5b6fc2baa3647abee442373006da6cbccbe16b6720520bdc7ecc3b998e003538 -SIZE (rust/2022-05-19/cargo-1.61.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 4966568 +TIMESTAMP = 1660637971 +SHA256 (rust/rustc-1.63.0-src.tar.xz) = 8f44af6dc44cc4146634a4dd5e4cc5470b3052a2337019b870c0e025e8987e0c +SIZE (rust/rustc-1.63.0-src.tar.xz) = 136597192 +SHA256 (rust/2022-08-11/rustc-1.62.0-aarch64-unknown-freebsd.tar.xz) = cc389cc6054c2761b55329f996107d02453187149b3597cbebdc4c7a994e4b9f +SIZE (rust/2022-08-11/rustc-1.62.0-aarch64-unknown-freebsd.tar.xz) = 43229728 +SHA256 (rust/2022-08-11/rust-std-1.62.0-aarch64-unknown-freebsd.tar.xz) = 18264b1c019d89f564e3583fae40667eb26a4b918ede59632f7bbb8eb5901ae6 +SIZE (rust/2022-08-11/rust-std-1.62.0-aarch64-unknown-freebsd.tar.xz) = 22683064 +SHA256 (rust/2022-08-11/cargo-1.62.0-aarch64-unknown-freebsd.tar.xz) = be972aa3d1ced03ee216e6d366b46f505ba83cbac682f116ea5cdef5f10963d4 +SIZE (rust/2022-08-11/cargo-1.62.0-aarch64-unknown-freebsd.tar.xz) = 4884760 +SHA256 (rust/2022-08-11/rustc-1.62.0-x86_64-unknown-freebsd.tar.xz) = 2de14a9ca4307453111a82d8733b0d986284d8e78b5bb2d0c5f6a483794502bc +SIZE (rust/2022-08-11/rustc-1.62.0-x86_64-unknown-freebsd.tar.xz) = 36186780 +SHA256 (rust/2022-08-11/rust-std-1.62.0-x86_64-unknown-freebsd.tar.xz) = 0b2a78ec3636a90cab0923612c6ef4f68fe05e788306c33065425093de2846c7 +SIZE (rust/2022-08-11/rust-std-1.62.0-x86_64-unknown-freebsd.tar.xz) = 22828324 +SHA256 (rust/2022-08-11/cargo-1.62.0-x86_64-unknown-freebsd.tar.xz) = b8e36aa5a71d645a0c41eaf2ddeab96d244a6427a05c664a86090cc3d1dc93fd +SIZE (rust/2022-08-11/cargo-1.62.0-x86_64-unknown-freebsd.tar.xz) = 5581840 +SHA256 (rust/2022-08-11/rustc-1.62.0-armv6-unknown-freebsd.tar.xz) = 31112bc0634e805c3dc9ce5cfb7fb8de76610ec75c31f3d8db6d6539600e506a +SIZE (rust/2022-08-11/rustc-1.62.0-armv6-unknown-freebsd.tar.xz) = 44097768 +SHA256 (rust/2022-08-11/rust-std-1.62.0-armv6-unknown-freebsd.tar.xz) = 704d095ef94d0f3ecb27decee036a908c4eeabf9833bec88d7061151c0660dd9 +SIZE (rust/2022-08-11/rust-std-1.62.0-armv6-unknown-freebsd.tar.xz) = 21001436 +SHA256 (rust/2022-08-11/cargo-1.62.0-armv6-unknown-freebsd.tar.xz) = 9eeeea39fac336f4c91563fdb0c1c89052d76095553d7bddc1ca1f14c506a1f8 +SIZE (rust/2022-08-11/cargo-1.62.0-armv6-unknown-freebsd.tar.xz) = 4835312 +SHA256 (rust/2022-08-11/rustc-1.62.0-armv7-unknown-freebsd.tar.xz) = 26b902e38d7f4d98cb5756d821d3917c204d161b47c43d90cbc1b98714392d01 +SIZE (rust/2022-08-11/rustc-1.62.0-armv7-unknown-freebsd.tar.xz) = 43670920 +SHA256 (rust/2022-08-11/rust-std-1.62.0-armv7-unknown-freebsd.tar.xz) = abe9b2841781330618888ff97e0d8cc7e2891ec6e205cbad0ec947c37d415ecc +SIZE (rust/2022-08-11/rust-std-1.62.0-armv7-unknown-freebsd.tar.xz) = 21926488 +SHA256 (rust/2022-08-11/cargo-1.62.0-armv7-unknown-freebsd.tar.xz) = 1c1d0099bac23d31b1f5a9754b10316cce9afacd49c581dc6cb822a0249e95ad +SIZE (rust/2022-08-11/cargo-1.62.0-armv7-unknown-freebsd.tar.xz) = 4823300 +SHA256 (rust/2022-08-11/rustc-1.62.0-i686-unknown-freebsd.tar.xz) = 0fee2caf1ffc5c5769dfac6affcbe7fc77f22fdf9af61f9c6b4e24cae9a846cd +SIZE (rust/2022-08-11/rustc-1.62.0-i686-unknown-freebsd.tar.xz) = 49032044 +SHA256 (rust/2022-08-11/rust-std-1.62.0-i686-unknown-freebsd.tar.xz) = f50746696a7141f279c3dad031e9a26240eb6a831e150758df117063536aa2f2 +SIZE (rust/2022-08-11/rust-std-1.62.0-i686-unknown-freebsd.tar.xz) = 22732580 +SHA256 (rust/2022-08-11/cargo-1.62.0-i686-unknown-freebsd.tar.xz) = 4308d5097b754d09b4124b4f5b461d835a1929ece5195931bd853d1aea8c4123 +SIZE (rust/2022-08-11/cargo-1.62.0-i686-unknown-freebsd.tar.xz) = 5744176 +SHA256 (rust/2022-08-11/rustc-1.62.0-powerpc-unknown-freebsd.tar.xz) = 3de22d8843ce97bf04d606c7731e7fcf35feae5c17871df5f7bd7568a5dac1ca +SIZE (rust/2022-08-11/rustc-1.62.0-powerpc-unknown-freebsd.tar.xz) = 46413824 +SHA256 (rust/2022-08-11/rust-std-1.62.0-powerpc-unknown-freebsd.tar.xz) = a7c0ea9c3163a1375ac268a34ef85bafc1173ce31082b76e7ce82a7b74d38614 +SIZE (rust/2022-08-11/rust-std-1.62.0-powerpc-unknown-freebsd.tar.xz) = 20653544 +SHA256 (rust/2022-08-11/cargo-1.62.0-powerpc-unknown-freebsd.tar.xz) = e37fab0dfd028fac8c530aa685c47aa12ba2d89ffb34d72e403f457f05b040d9 +SIZE (rust/2022-08-11/cargo-1.62.0-powerpc-unknown-freebsd.tar.xz) = 5318004 +SHA256 (rust/2022-08-11/rustc-1.62.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 1e2b2fdde88775c872b3b0c6b7df48c0edbe4334ac859997123ad272c6ef6028 +SIZE (rust/2022-08-11/rustc-1.62.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 52646328 +SHA256 (rust/2022-08-11/rust-std-1.62.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 4a65020427f638a6e948040676934eedcaa416e183db8139f83d83b06eebafd8 +SIZE (rust/2022-08-11/rust-std-1.62.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 20886148 +SHA256 (rust/2022-08-11/cargo-1.62.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 73047a7b498f5a7403f7c722e6ced16639538e6ef1040eca6fe80911eca20380 +SIZE (rust/2022-08-11/cargo-1.62.0-powerpc64-unknown-freebsd-elfv1.tar.xz) = 5421660 +SHA256 (rust/2022-08-11/rustc-1.62.0-powerpc64le-unknown-freebsd.tar.xz) = a0a990c2e459f06cdc16d509e2a7046528d870df0974eff3eacad11654f0a990 +SIZE (rust/2022-08-11/rustc-1.62.0-powerpc64le-unknown-freebsd.tar.xz) = 46361760 +SHA256 (rust/2022-08-11/rust-std-1.62.0-powerpc64le-unknown-freebsd.tar.xz) = 510b7ae43543acffc27ea788725ab7e683236323652296fb117443bdb87e4bca +SIZE (rust/2022-08-11/rust-std-1.62.0-powerpc64le-unknown-freebsd.tar.xz) = 21088000 +SHA256 (rust/2022-08-11/cargo-1.62.0-powerpc64le-unknown-freebsd.tar.xz) = 007e4c54449cf95ae5bbc86c559767feaae543a129b3a4d4dbc99822697765ab +SIZE (rust/2022-08-11/cargo-1.62.0-powerpc64le-unknown-freebsd.tar.xz) = 5354032 +SHA256 (rust/2022-08-11/rustc-1.62.0-riscv64gc-unknown-freebsd.tar.xz) = fe0551721b4a4e0c17236a7527eb5c8006d3dcbba1e18bfd997bba1aff7320f3 +SIZE (rust/2022-08-11/rustc-1.62.0-riscv64gc-unknown-freebsd.tar.xz) = 151000056 +SHA256 (rust/2022-08-11/rust-std-1.62.0-riscv64gc-unknown-freebsd.tar.xz) = 26e3296d3e665a0049c638216c5da194dc500ae94942f5bd37c41d7512b95202 +SIZE (rust/2022-08-11/rust-std-1.62.0-riscv64gc-unknown-freebsd.tar.xz) = 28966484 +SHA256 (rust/2022-08-11/cargo-1.62.0-riscv64gc-unknown-freebsd.tar.xz) = 4f72f54faebca015d674a53394eda4ec7b07bc70547186dbefca45b71a9c00ea +SIZE (rust/2022-08-11/cargo-1.62.0-riscv64gc-unknown-freebsd.tar.xz) = 27235120 +SHA256 (rust/2022-08-11/rustc-1.62.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 85282443cc7972af82999c24093a792143a642fb5f32a636c900019e0df30109 +SIZE (rust/2022-08-11/rustc-1.62.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 44366840 +SHA256 (rust/2022-08-11/rust-std-1.62.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = eea977e6cbffdb226056091c3ab565c2b3c933d37ab1a30a2baa5eccc47e2c9b +SIZE (rust/2022-08-11/rust-std-1.62.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 20893088 +SHA256 (rust/2022-08-11/cargo-1.62.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = a36cd48122c84601cf2610d0cb381e3482bc25ef3f37d6d790eaa6a1a5a1e500 +SIZE (rust/2022-08-11/cargo-1.62.0-powerpc64-unknown-freebsd-elfv2.tar.xz) = 5048488 diff --git a/lang/rust/files/no-hardlinks/patch-src_bootstrap_lib.rs b/lang/rust/files/no-hardlinks/patch-src_bootstrap_lib.rs index 081c2056ad..03a24563bf 100644 --- a/lang/rust/files/no-hardlinks/patch-src_bootstrap_lib.rs +++ b/lang/rust/files/no-hardlinks/patch-src_bootstrap_lib.rs @@ -15,14 +15,29 @@ links during the build, so let's try that. --- src/bootstrap/lib.rs.orig 2020-07-23 20:16:43 UTC +++ src/bootstrap/lib.rs -@@ -1173,10 +1173,6 @@ impl Build { - if metadata.file_type().is_symlink() { - let link = t!(fs::read_link(src)); - t!(symlink_file(link, dst)); -- } else if let Ok(()) = fs::hard_link(src, dst) { +@@ -1450,19 +1450,13 @@ impl Build { + return; + } + } +- if let Ok(()) = fs::hard_link(&src, dst) { - // Attempt to "easy copy" by creating a hard link - // (symlinks don't work on windows), but if that fails - // just fall back to a slow `copy` operation. - } else { - if let Err(e) = fs::copy(src, dst) { - panic!("failed to copy `{}` to `{}`: {}", src.display(), dst.display(), e) +- } else { +- if let Err(e) = fs::copy(&src, dst) { +- panic!("failed to copy `{}` to `{}`: {}", src.display(), dst.display(), e) +- } +- t!(fs::set_permissions(dst, metadata.permissions())); +- let atime = FileTime::from_last_access_time(&metadata); +- let mtime = FileTime::from_last_modification_time(&metadata); +- t!(filetime::set_file_times(dst, atime, mtime)); ++ if let Err(e) = fs::copy(&src, dst) { ++ panic!("failed to copy `{}` to `{}`: {}", src.display(), dst.display(), e) + } ++ t!(fs::set_permissions(dst, metadata.permissions())); ++ let atime = FileTime::from_last_access_time(&metadata); ++ let mtime = FileTime::from_last_modification_time(&metadata); ++ t!(filetime::set_file_times(dst, atime, mtime)); + } + + /// Copies the `src` directory recursively to `dst`. Both are assumed to exist -- 2.37.1 From 7a74c104b42a7338b74273317a5f7ae0cb5ccea7 Mon Sep 17 00:00:00 2001 From: Mikael Urankar Date: Wed, 17 Aug 2022 19:23:43 +0200 Subject: [PATCH 2/5] textproc/ripgrep: Fix build with rust 1.63.0 - Update packed_simd_2 to 0.3.8 which fixed the build with rust 1.63.0 --- textproc/ripgrep/Makefile | 2 +- textproc/ripgrep/distinfo | 6 +++--- textproc/ripgrep/files/{patch-rust-1.60 => patch-rust-1.63} | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) rename textproc/ripgrep/files/{patch-rust-1.60 => patch-rust-1.63} (92%) diff --git a/textproc/ripgrep/Makefile b/textproc/ripgrep/Makefile index aa8db07629..45d5933728 100644 --- a/textproc/ripgrep/Makefile +++ b/textproc/ripgrep/Makefile @@ -57,7 +57,7 @@ CARGO_CRATES= aho-corasick-0.7.18 \ memmap2-0.3.0 \ num_cpus-1.13.0 \ once_cell-1.7.2 \ - packed_simd_2-0.3.7 \ + packed_simd_2-0.3.8 \ pcre2-0.2.3 \ pcre2-sys-0.2.5 \ pkg-config-0.3.19 \ diff --git a/textproc/ripgrep/distinfo b/textproc/ripgrep/distinfo index e679a22245..9e307d9b2e 100644 --- a/textproc/ripgrep/distinfo +++ b/textproc/ripgrep/distinfo @@ -1,4 +1,4 @@ -TIMESTAMP = 1649425059 +TIMESTAMP = 1660728123 SHA256 (rust/crates/aho-corasick-0.7.18.crate) = 1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f SIZE (rust/crates/aho-corasick-0.7.18.crate) = 112923 SHA256 (rust/crates/atty-0.2.14.crate) = d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8 @@ -77,8 +77,8 @@ SHA256 (rust/crates/num_cpus-1.13.0.crate) = 05499f3756671c15885fee9034446956fff SIZE (rust/crates/num_cpus-1.13.0.crate) = 14704 SHA256 (rust/crates/once_cell-1.7.2.crate) = af8b08b04175473088b46763e51ee54da5f9a164bc162f615b91bc179dbf15a3 SIZE (rust/crates/once_cell-1.7.2.crate) = 28250 -SHA256 (rust/crates/packed_simd_2-0.3.7.crate) = defdcfef86dcc44ad208f71d9ff4ce28df6537a4e0d6b0e8e845cb8ca10059a6 -SIZE (rust/crates/packed_simd_2-0.3.7.crate) = 97413 +SHA256 (rust/crates/packed_simd_2-0.3.8.crate) = a1914cd452d8fccd6f9db48147b29fd4ae05bea9dc5d9ad578509f72415de282 +SIZE (rust/crates/packed_simd_2-0.3.8.crate) = 97388 SHA256 (rust/crates/pcre2-0.2.3.crate) = 85b30f2f69903b439dd9dc9e824119b82a55bf113b29af8d70948a03c1b11ab1 SIZE (rust/crates/pcre2-0.2.3.crate) = 19605 SHA256 (rust/crates/pcre2-sys-0.2.5.crate) = dec30e5e9ec37eb8fbf1dea5989bc957fd3df56fbee5061aa7b7a99dbb37b722 diff --git a/textproc/ripgrep/files/patch-rust-1.60 b/textproc/ripgrep/files/patch-rust-1.63 similarity index 92% rename from textproc/ripgrep/files/patch-rust-1.60 rename to textproc/ripgrep/files/patch-rust-1.63 index f0010da169..2d7ce8f19d 100644 --- a/textproc/ripgrep/files/patch-rust-1.60 +++ b/textproc/ripgrep/files/patch-rust-1.63 @@ -1,4 +1,4 @@ ---- Cargo.lock.orig 2022-04-08 15:28:37 UTC +--- Cargo.lock.orig 2021-06-12 14:12:24 UTC +++ Cargo.lock @@ -62,12 +62,6 @@ name = "cfg-if" @@ -54,10 +54,10 @@ [[package]] name = "packed_simd_2" -version = "0.3.5" -+version = "0.3.7" ++version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e64858a2d3733fdd61adfdd6da89aa202f7ff0e741d2fc7ed1e452ba9dc99d7" -+checksum = "defdcfef86dcc44ad208f71d9ff4ce28df6537a4e0d6b0e8e845cb8ca10059a6" ++checksum = "a1914cd452d8fccd6f9db48147b29fd4ae05bea9dc5d9ad578509f72415de282" dependencies = [ - "cfg-if 0.1.10", + "cfg-if", -- 2.37.1 From d5f1eb73a54a59331742446290a5410ccad0be40 Mon Sep 17 00:00:00 2001 From: Mikael Urankar Date: Wed, 17 Aug 2022 19:28:25 +0200 Subject: [PATCH 3/5] games/veloren: Fix build with rust 1.63.0 - Update packed_simd_2 to 0.3.8 which fixed the build with rust 1.63.0 - lazy::OnceCell is moved to cell::OnceCell --- games/veloren/Makefile | 2 +- games/veloren/distinfo | 6 ++--- games/veloren/files/patch-rust-1.63 | 36 +++++++++++++++++++++++++++++ 3 files changed, 40 insertions(+), 4 deletions(-) create mode 100644 games/veloren/files/patch-rust-1.63 diff --git a/games/veloren/Makefile b/games/veloren/Makefile index 4badfde398..5a84669e10 100644 --- a/games/veloren/Makefile +++ b/games/veloren/Makefile @@ -409,7 +409,7 @@ CARGO_CRATES= ab_glyph-0.2.15 \ os_str_bytes-6.0.0 \ owned_ttf_parser-0.6.0 \ owned_ttf_parser-0.15.0 \ - packed_simd_2-0.3.7 \ + packed_simd_2-0.3.8 \ parking_lot-0.10.2 \ parking_lot-0.11.2 \ parking_lot-0.12.0 \ diff --git a/games/veloren/distinfo b/games/veloren/distinfo index 566198c1e6..52400ab98f 100644 --- a/games/veloren/distinfo +++ b/games/veloren/distinfo @@ -1,4 +1,4 @@ -TIMESTAMP = 1658582101 +TIMESTAMP = 1660732539 SHA256 (rust/crates/ab_glyph-0.2.15.crate) = 24606928a235e73cdef55a0c909719cadd72fce573e5713d58cb2952d8f5794c SIZE (rust/crates/ab_glyph-0.2.15.crate) = 15906 SHA256 (rust/crates/ab_glyph_rasterizer-0.1.5.crate) = a13739d7177fbd22bb0ed28badfff9f372f8bef46c863db4e1c6248f6b223b6e @@ -751,8 +751,8 @@ SHA256 (rust/crates/owned_ttf_parser-0.6.0.crate) = 9f923fb806c46266c02ab4a5b239 SIZE (rust/crates/owned_ttf_parser-0.6.0.crate) = 20574 SHA256 (rust/crates/owned_ttf_parser-0.15.0.crate) = 4fb1e509cfe7a12db2a90bfa057dfcdbc55a347f5da677c506b53dd099cfec9d SIZE (rust/crates/owned_ttf_parser-0.15.0.crate) = 23088 -SHA256 (rust/crates/packed_simd_2-0.3.7.crate) = defdcfef86dcc44ad208f71d9ff4ce28df6537a4e0d6b0e8e845cb8ca10059a6 -SIZE (rust/crates/packed_simd_2-0.3.7.crate) = 97413 +SHA256 (rust/crates/packed_simd_2-0.3.8.crate) = a1914cd452d8fccd6f9db48147b29fd4ae05bea9dc5d9ad578509f72415de282 +SIZE (rust/crates/packed_simd_2-0.3.8.crate) = 97388 SHA256 (rust/crates/parking_lot-0.10.2.crate) = d3a704eb390aafdc107b0e392f56a82b668e3a71366993b5340f5833fd62505e SIZE (rust/crates/parking_lot-0.10.2.crate) = 39536 SHA256 (rust/crates/parking_lot-0.11.2.crate) = 7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99 diff --git a/games/veloren/files/patch-rust-1.63 b/games/veloren/files/patch-rust-1.63 new file mode 100644 index 0000000000..5050354349 --- /dev/null +++ b/games/veloren/files/patch-rust-1.63 @@ -0,0 +1,36 @@ +--- Cargo.lock.orig 2022-08-17 12:36:05 UTC ++++ Cargo.lock +@@ -4025,9 +4025,9 @@ name = "packed_simd_2" + + [[package]] + name = "packed_simd_2" +-version = "0.3.7" ++version = "0.3.8" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "defdcfef86dcc44ad208f71d9ff4ce28df6537a4e0d6b0e8e845cb8ca10059a6" ++checksum = "a1914cd452d8fccd6f9db48147b29fd4ae05bea9dc5d9ad578509f72415de282" + dependencies = [ + "cfg-if 1.0.0", + "libm 0.1.4", +@@ -6241,7 +6241,7 @@ dependencies = [ + source = "registry+https://github.com/rust-lang/crates.io-index" + checksum = "4ee73e6e4924fe940354b8d4d98cad5231175d615cd855b758adc658c0aac6a0" + dependencies = [ +- "cfg-if 1.0.0", ++ "cfg-if 0.1.10", + "rand 0.8.5", + "static_assertions", + ] + + +--- voxygen/src/scene/terrain.rs.orig 2022-08-17 11:42:07.587067000 +0000 ++++ voxygen/src/scene/terrain.rs 2022-08-17 11:43:10.451160000 +0000 +@@ -555,7 +557,7 @@ impl SpriteRenderContext { + } + }); + +- let init = core::lazy::OnceCell::new(); ++ let init = core::cell::OnceCell::new(); + let mut join_handle = Some(join_handle); + let mut closure = move |renderer: &mut Renderer| { + // The second unwrap can only fail if the sprite meshing thread panics, which -- 2.37.1 From 02254a3b3935183d9f5fc6e3b9f67d762c6835ad Mon Sep 17 00:00:00 2001 From: Mikael Urankar Date: Wed, 17 Aug 2022 19:26:17 +0200 Subject: [PATCH 4/5] www/firefox-esr: Fix build with rust 1.63.0 - Fix packed_simd with the relevant parts of https://hg.mozilla.org/releases/mozilla-beta/raw-rev/c37c77a20f96 --- www/firefox-esr/files/patch-rust-1.63 | 767 ++++++++++++++++++++++++++ 1 file changed, 767 insertions(+) create mode 100644 www/firefox-esr/files/patch-rust-1.63 diff --git a/www/firefox-esr/files/patch-rust-1.63 b/www/firefox-esr/files/patch-rust-1.63 new file mode 100644 index 0000000000..15c50810ed --- /dev/null +++ b/www/firefox-esr/files/patch-rust-1.63 @@ -0,0 +1,767 @@ +Backport of https://hg.mozilla.org/releases/mozilla-beta/raw-rev/c37c77a20f96 +Only the rust code is present (not the .toml, .json and .lock files) + + +diff --git a/third_party/rust/packed_simd/build.rs b/third_party/rust/packed_simd/build.rs +--- third_party/rust/packed_simd/build.rs ++++ third_party/rust/packed_simd/build.rs +@@ -1,6 +1,11 @@ ++use rustc_version::{version, Version}; ++ + fn main() { + let target = std::env::var("TARGET").expect("TARGET environment variable not defined"); + if target.contains("neon") { + println!("cargo:rustc-cfg=libcore_neon"); + } ++ if version().unwrap() < Version::parse("1.61.0-alpha").unwrap() { ++ println!("cargo:rustc-cfg=aarch64_target_feature"); ++ } + } +diff --git a/third_party/rust/packed_simd/src/api.rs b/third_party/rust/packed_simd/src/api.rs +--- third_party/rust/packed_simd/src/api.rs ++++ third_party/rust/packed_simd/src/api.rs +@@ -1,13 +1,13 @@ + //! Implements the Simd<[T; N]> APIs + + #[macro_use] + mod bitmask; +-crate mod cast; ++pub(crate) mod cast; + #[macro_use] + mod cmp; + #[macro_use] + mod default; + #[macro_use] + mod fmt; + #[macro_use] + mod from; +@@ -32,17 +32,17 @@ mod shuffle1_dyn; + #[macro_use] + mod slice; + #[macro_use] + mod swap_bytes; + #[macro_use] + mod bit_manip; + + #[cfg(feature = "into_bits")] +-crate mod into_bits; ++pub(crate) mod into_bits; + + macro_rules! impl_i { + ([$elem_ty:ident; $elem_n:expr]: $tuple_id:ident, $mask_ty:ident + | $ielem_ty:ident, $ibitmask_ty:ident | $test_tt:tt | $($elem_ids:ident),* + | From: $($from_vec_ty:ident),* | $(#[$doc:meta])*) => { + impl_minimal_iuf!([$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt + | $($elem_ids),* | $(#[$doc])*); + impl_ops_vector_arithmetic!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +diff --git a/third_party/rust/packed_simd/src/codegen.rs b/third_party/rust/packed_simd/src/codegen.rs +--- third_party/rust/packed_simd/src/codegen.rs ++++ third_party/rust/packed_simd/src/codegen.rs +@@ -1,24 +1,24 @@ + //! Code-generation utilities + +-crate mod bit_manip; +-crate mod llvm; +-crate mod math; +-crate mod reductions; +-crate mod shuffle; +-crate mod shuffle1_dyn; +-crate mod swap_bytes; ++pub(crate) mod bit_manip; ++pub(crate) mod llvm; ++pub(crate) mod math; ++pub(crate) mod reductions; ++pub(crate) mod shuffle; ++pub(crate) mod shuffle1_dyn; ++pub(crate) mod swap_bytes; + + macro_rules! impl_simd_array { + ([$elem_ty:ident; $elem_count:expr]: + $tuple_id:ident | $($elem_tys:ident),*) => { + #[derive(Copy, Clone)] + #[repr(simd)] +- pub struct $tuple_id($(crate $elem_tys),*); ++ pub struct $tuple_id($(pub(crate) $elem_tys),*); + //^^^^^^^ leaked through SimdArray + + impl crate::sealed::Seal for [$elem_ty; $elem_count] {} + + impl crate::sealed::SimdArray for [$elem_ty; $elem_count] { + type Tuple = $tuple_id; + type T = $elem_ty; + const N: usize = $elem_count; +@@ -30,33 +30,33 @@ macro_rules! impl_simd_array { + type Element = $elem_ty; + const LANES: usize = $elem_count; + type LanesType = [u32; $elem_count]; + } + + } + } + +-crate mod pointer_sized_int; ++pub(crate) mod pointer_sized_int; + +-crate mod v16; +-crate use self::v16::*; ++pub(crate) mod v16; ++pub(crate) use self::v16::*; + +-crate mod v32; +-crate use self::v32::*; ++pub(crate) mod v32; ++pub(crate) use self::v32::*; + +-crate mod v64; +-crate use self::v64::*; ++pub(crate) mod v64; ++pub(crate) use self::v64::*; + +-crate mod v128; +-crate use self::v128::*; ++pub(crate) mod v128; ++pub(crate) use self::v128::*; + +-crate mod v256; +-crate use self::v256::*; ++pub(crate) mod v256; ++pub(crate) use self::v256::*; + +-crate mod v512; +-crate use self::v512::*; ++pub(crate) mod v512; ++pub(crate) use self::v512::*; + +-crate mod vSize; +-crate use self::vSize::*; ++pub(crate) mod vSize; ++pub(crate) use self::vSize::*; + +-crate mod vPtr; +-crate use self::vPtr::*; ++pub(crate) mod vPtr; ++pub(crate) use self::vPtr::*; +diff --git a/third_party/rust/packed_simd/src/codegen/bit_manip.rs b/third_party/rust/packed_simd/src/codegen/bit_manip.rs +--- third_party/rust/packed_simd/src/codegen/bit_manip.rs ++++ third_party/rust/packed_simd/src/codegen/bit_manip.rs +@@ -1,12 +1,12 @@ + //! LLVM bit manipulation intrinsics. + #[rustfmt::skip] + +-use crate::*; ++pub(crate) use crate::*; + + #[allow(improper_ctypes, dead_code)] + extern "C" { + #[link_name = "llvm.ctlz.v2i8"] + fn ctlz_u8x2(x: u8x2, is_zero_undef: bool) -> u8x2; + #[link_name = "llvm.ctlz.v4i8"] + fn ctlz_u8x4(x: u8x4, is_zero_undef: bool) -> u8x4; + #[link_name = "llvm.ctlz.v8i8"] +@@ -142,17 +142,17 @@ extern "C" { + #[link_name = "llvm.ctpop.v1i128"] + fn ctpop_u128x1(x: u128x1) -> u128x1; + #[link_name = "llvm.ctpop.v2i128"] + fn ctpop_u128x2(x: u128x2) -> u128x2; + #[link_name = "llvm.ctpop.v4i128"] + fn ctpop_u128x4(x: u128x4) -> u128x4; + } + +-crate trait BitManip { ++pub(crate) trait BitManip { + fn ctpop(self) -> Self; + fn ctlz(self) -> Self; + fn cttz(self) -> Self; + } + + macro_rules! impl_bit_manip { + (inner: $ty:ident, $scalar:ty, $uty:ident, + $ctpop:ident, $ctlz:ident, $cttz:ident) => { +diff --git a/third_party/rust/packed_simd/src/codegen/llvm.rs b/third_party/rust/packed_simd/src/codegen/llvm.rs +--- third_party/rust/packed_simd/src/codegen/llvm.rs ++++ third_party/rust/packed_simd/src/codegen/llvm.rs +@@ -71,58 +71,58 @@ pub unsafe fn __shuffle_vector64::Element: Shuffle<[u32; 64], Output = U>, + { + simd_shuffle64(x, y, IDX) + } + + extern "platform-intrinsic" { +- crate fn simd_eq(x: T, y: T) -> U; +- crate fn simd_ne(x: T, y: T) -> U; +- crate fn simd_lt(x: T, y: T) -> U; +- crate fn simd_le(x: T, y: T) -> U; +- crate fn simd_gt(x: T, y: T) -> U; +- crate fn simd_ge(x: T, y: T) -> U; ++ pub(crate) fn simd_eq(x: T, y: T) -> U; ++ pub(crate) fn simd_ne(x: T, y: T) -> U; ++ pub(crate) fn simd_lt(x: T, y: T) -> U; ++ pub(crate) fn simd_le(x: T, y: T) -> U; ++ pub(crate) fn simd_gt(x: T, y: T) -> U; ++ pub(crate) fn simd_ge(x: T, y: T) -> U; + +- crate fn simd_insert(x: T, idx: u32, val: U) -> T; +- crate fn simd_extract(x: T, idx: u32) -> U; ++ pub(crate) fn simd_insert(x: T, idx: u32, val: U) -> T; ++ pub(crate) fn simd_extract(x: T, idx: u32) -> U; + +- crate fn simd_cast(x: T) -> U; ++ pub(crate) fn simd_cast(x: T) -> U; + +- crate fn simd_add(x: T, y: T) -> T; +- crate fn simd_sub(x: T, y: T) -> T; +- crate fn simd_mul(x: T, y: T) -> T; +- crate fn simd_div(x: T, y: T) -> T; +- crate fn simd_rem(x: T, y: T) -> T; +- crate fn simd_shl(x: T, y: T) -> T; +- crate fn simd_shr(x: T, y: T) -> T; +- crate fn simd_and(x: T, y: T) -> T; +- crate fn simd_or(x: T, y: T) -> T; +- crate fn simd_xor(x: T, y: T) -> T; ++ pub(crate) fn simd_add(x: T, y: T) -> T; ++ pub(crate) fn simd_sub(x: T, y: T) -> T; ++ pub(crate) fn simd_mul(x: T, y: T) -> T; ++ pub(crate) fn simd_div(x: T, y: T) -> T; ++ pub(crate) fn simd_rem(x: T, y: T) -> T; ++ pub(crate) fn simd_shl(x: T, y: T) -> T; ++ pub(crate) fn simd_shr(x: T, y: T) -> T; ++ pub(crate) fn simd_and(x: T, y: T) -> T; ++ pub(crate) fn simd_or(x: T, y: T) -> T; ++ pub(crate) fn simd_xor(x: T, y: T) -> T; + +- crate fn simd_reduce_add_unordered(x: T) -> U; +- crate fn simd_reduce_mul_unordered(x: T) -> U; +- crate fn simd_reduce_add_ordered(x: T, acc: U) -> U; +- crate fn simd_reduce_mul_ordered(x: T, acc: U) -> U; +- crate fn simd_reduce_min(x: T) -> U; +- crate fn simd_reduce_max(x: T) -> U; +- crate fn simd_reduce_min_nanless(x: T) -> U; +- crate fn simd_reduce_max_nanless(x: T) -> U; +- crate fn simd_reduce_and(x: T) -> U; +- crate fn simd_reduce_or(x: T) -> U; +- crate fn simd_reduce_xor(x: T) -> U; +- crate fn simd_reduce_all(x: T) -> bool; +- crate fn simd_reduce_any(x: T) -> bool; ++ pub(crate) fn simd_reduce_add_unordered(x: T) -> U; ++ pub(crate) fn simd_reduce_mul_unordered(x: T) -> U; ++ pub(crate) fn simd_reduce_add_ordered(x: T, acc: U) -> U; ++ pub(crate) fn simd_reduce_mul_ordered(x: T, acc: U) -> U; ++ pub(crate) fn simd_reduce_min(x: T) -> U; ++ pub(crate) fn simd_reduce_max(x: T) -> U; ++ pub(crate) fn simd_reduce_min_nanless(x: T) -> U; ++ pub(crate) fn simd_reduce_max_nanless(x: T) -> U; ++ pub(crate) fn simd_reduce_and(x: T) -> U; ++ pub(crate) fn simd_reduce_or(x: T) -> U; ++ pub(crate) fn simd_reduce_xor(x: T) -> U; ++ pub(crate) fn simd_reduce_all(x: T) -> bool; ++ pub(crate) fn simd_reduce_any(x: T) -> bool; + +- crate fn simd_select(m: M, a: T, b: T) -> T; ++ pub(crate) fn simd_select(m: M, a: T, b: T) -> T; + +- crate fn simd_fmin(a: T, b: T) -> T; +- crate fn simd_fmax(a: T, b: T) -> T; ++ pub(crate) fn simd_fmin(a: T, b: T) -> T; ++ pub(crate) fn simd_fmax(a: T, b: T) -> T; + +- crate fn simd_fsqrt(a: T) -> T; +- crate fn simd_fma(a: T, b: T, c: T) -> T; ++ pub(crate) fn simd_fsqrt(a: T) -> T; ++ pub(crate) fn simd_fma(a: T, b: T, c: T) -> T; + +- crate fn simd_gather(value: T, pointers: P, mask: M) -> T; +- crate fn simd_scatter(value: T, pointers: P, mask: M); ++ pub(crate) fn simd_gather(value: T, pointers: P, mask: M) -> T; ++ pub(crate) fn simd_scatter(value: T, pointers: P, mask: M); + +- crate fn simd_bitmask(value: T) -> U; ++ pub(crate) fn simd_bitmask(value: T) -> U; + } +diff --git a/third_party/rust/packed_simd/src/codegen/math.rs b/third_party/rust/packed_simd/src/codegen/math.rs +--- third_party/rust/packed_simd/src/codegen/math.rs ++++ third_party/rust/packed_simd/src/codegen/math.rs +@@ -1,3 +1,3 @@ + //! Vertical math operations + +-crate mod float; ++pub(crate) mod float; +diff --git a/third_party/rust/packed_simd/src/codegen/math/float.rs b/third_party/rust/packed_simd/src/codegen/math/float.rs +--- third_party/rust/packed_simd/src/codegen/math/float.rs ++++ third_party/rust/packed_simd/src/codegen/math/float.rs +@@ -1,18 +1,18 @@ + //! Vertical floating-point math operations. + #![allow(clippy::useless_transmute)] + + #[macro_use] +-crate mod macros; +-crate mod abs; +-crate mod cos; +-crate mod cos_pi; +-crate mod exp; +-crate mod ln; +-crate mod mul_add; +-crate mod mul_adde; +-crate mod powf; +-crate mod sin; +-crate mod sin_cos_pi; +-crate mod sin_pi; +-crate mod sqrt; +-crate mod sqrte; ++pub(crate) mod macros; ++pub(crate) mod abs; ++pub(crate) mod cos; ++pub(crate) mod cos_pi; ++pub(crate) mod exp; ++pub(crate) mod ln; ++pub(crate) mod mul_add; ++pub(crate) mod mul_adde; ++pub(crate) mod powf; ++pub(crate) mod sin; ++pub(crate) mod sin_cos_pi; ++pub(crate) mod sin_pi; ++pub(crate) mod sqrt; ++pub(crate) mod sqrte; +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/abs.rs b/third_party/rust/packed_simd/src/codegen/math/float/abs.rs +--- third_party/rust/packed_simd/src/codegen/math/float/abs.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/abs.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `fabs` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors fabs + + use crate::*; + +-crate trait Abs { ++pub(crate) trait Abs { + fn abs(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.fabs.v2f32"] + fn fabs_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.fabs.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/cos.rs b/third_party/rust/packed_simd/src/codegen/math/float/cos.rs +--- third_party/rust/packed_simd/src/codegen/math/float/cos.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/cos.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `cos` + #![allow(unused)] + + // FIXME 64-bit 1 elem vector cos + + use crate::*; + +-crate trait Cos { ++pub(crate) trait Cos { + fn cos(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.cos.v2f32"] + fn cos_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.cos.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs b/third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs +--- third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `cos` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors cos_pi + + use crate::*; + +-crate trait CosPi { ++pub(crate) trait CosPi { + fn cos_pi(self) -> Self; + } + + gen_unary_impl_table!(CosPi, cos_pi); + + macro_rules! impl_def { + ($vid:ident, $PI:path) => { + impl CosPi for $vid { +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/exp.rs b/third_party/rust/packed_simd/src/codegen/math/float/exp.rs +--- third_party/rust/packed_simd/src/codegen/math/float/exp.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/exp.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `exp` + #![allow(unused)] + + // FIXME 64-bit expgle elem vectors misexpg + + use crate::*; + +-crate trait Exp { ++pub(crate) trait Exp { + fn exp(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.exp.v2f32"] + fn exp_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.exp.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/ln.rs b/third_party/rust/packed_simd/src/codegen/math/float/ln.rs +--- third_party/rust/packed_simd/src/codegen/math/float/ln.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/ln.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `ln` + #![allow(unused)] + + // FIXME 64-bit lngle elem vectors mislng + + use crate::*; + +-crate trait Ln { ++pub(crate) trait Ln { + fn ln(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.log.v2f32"] + fn ln_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.log.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs b/third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs +--- third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs +@@ -1,15 +1,15 @@ + //! Vertical floating-point `mul_add` + #![allow(unused)] + use crate::*; + + // FIXME: 64-bit 1 element mul_add + +-crate trait MulAdd { ++pub(crate) trait MulAdd { + fn mul_add(self, y: Self, z: Self) -> Self; + } + + #[cfg(not(target_arch = "s390x"))] + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.fma.v2f32"] + fn fma_v2f32(x: f32x2, y: f32x2, z: f32x2) -> f32x2; +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs b/third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs +--- third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs +@@ -1,14 +1,14 @@ + //! Approximation for floating-point `mul_add` + use crate::*; + + // FIXME: 64-bit 1 element mul_adde + +-crate trait MulAddE { ++pub(crate) trait MulAddE { + fn mul_adde(self, y: Self, z: Self) -> Self; + } + + #[cfg(not(target_arch = "s390x"))] + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.fmuladd.v2f32"] + fn fmuladd_v2f32(x: f32x2, y: f32x2, z: f32x2) -> f32x2; +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/powf.rs b/third_party/rust/packed_simd/src/codegen/math/float/powf.rs +--- third_party/rust/packed_simd/src/codegen/math/float/powf.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/powf.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `powf` + #![allow(unused)] + + // FIXME 64-bit powfgle elem vectors mispowfg + + use crate::*; + +-crate trait Powf { ++pub(crate) trait Powf { + fn powf(self, x: Self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.pow.v2f32"] + fn powf_v2f32(x: f32x2, y: f32x2) -> f32x2; + #[link_name = "llvm.pow.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sin.rs b/third_party/rust/packed_simd/src/codegen/math/float/sin.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sin.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sin.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `sin` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sin + + use crate::*; + +-crate trait Sin { ++pub(crate) trait Sin { + fn sin(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.sin.v2f32"] + fn sin_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.sin.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs b/third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `sin_cos` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sin_cos + + use crate::*; + +-crate trait SinCosPi: Sized { ++pub(crate) trait SinCosPi: Sized { + type Output; + fn sin_cos_pi(self) -> Self::Output; + } + + macro_rules! impl_def { + ($vid:ident, $PI:path) => { + impl SinCosPi for $vid { + type Output = (Self, Self); +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs b/third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `sin_pi` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sin_pi + + use crate::*; + +-crate trait SinPi { ++pub(crate) trait SinPi { + fn sin_pi(self) -> Self; + } + + gen_unary_impl_table!(SinPi, sin_pi); + + macro_rules! impl_def { + ($vid:ident, $PI:path) => { + impl SinPi for $vid { +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs b/third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `sqrt` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sqrt + + use crate::*; + +-crate trait Sqrt { ++pub(crate) trait Sqrt { + fn sqrt(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.sqrt.v2f32"] + fn sqrt_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.sqrt.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs b/third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs +@@ -1,17 +1,17 @@ + //! Vertical floating-point `sqrt` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sqrte + + use crate::llvm::simd_fsqrt; + use crate::*; + +-crate trait Sqrte { ++pub(crate) trait Sqrte { + fn sqrte(self) -> Self; + } + + gen_unary_impl_table!(Sqrte, sqrte); + + cfg_if! { + if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { + use sleef_sys::*; +diff --git a/third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs b/third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs +--- third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs ++++ third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs +@@ -1,28 +1,28 @@ + //! Provides `isize` and `usize` + + use cfg_if::cfg_if; + + cfg_if! { + if #[cfg(target_pointer_width = "8")] { +- crate type isize_ = i8; +- crate type usize_ = u8; ++ pub(crate) type isize_ = i8; ++ pub(crate) type usize_ = u8; + } else if #[cfg(target_pointer_width = "16")] { +- crate type isize_ = i16; +- crate type usize_ = u16; ++ pub(crate) type isize_ = i16; ++ pub(crate) type usize_ = u16; + } else if #[cfg(target_pointer_width = "32")] { +- crate type isize_ = i32; +- crate type usize_ = u32; ++ pub(crate) type isize_ = i32; ++ pub(crate) type usize_ = u32; + + } else if #[cfg(target_pointer_width = "64")] { +- crate type isize_ = i64; +- crate type usize_ = u64; ++ pub(crate) type isize_ = i64; ++ pub(crate) type usize_ = u64; + } else if #[cfg(target_pointer_width = "64")] { +- crate type isize_ = i64; +- crate type usize_ = u64; ++ pub(crate) type isize_ = i64; ++ pub(crate) type usize_ = u64; + } else if #[cfg(target_pointer_width = "128")] { +- crate type isize_ = i128; +- crate type usize_ = u128; ++ pub(crate) type isize_ = i128; ++ pub(crate) type usize_ = u128; + } else { + compile_error!("unsupported target_pointer_width"); + } + } +diff --git a/third_party/rust/packed_simd/src/codegen/reductions.rs b/third_party/rust/packed_simd/src/codegen/reductions.rs +--- third_party/rust/packed_simd/src/codegen/reductions.rs ++++ third_party/rust/packed_simd/src/codegen/reductions.rs +@@ -1,1 +1,1 @@ +-crate mod mask; ++pub(crate) mod mask; +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask.rs +--- third_party/rust/packed_simd/src/codegen/reductions/mask.rs ++++ third_party/rust/packed_simd/src/codegen/reductions/mask.rs +@@ -2,21 +2,21 @@ + //! + //! Works around [LLVM bug 36702]. + //! + //! [LLVM bug 36702]: https://bugs.llvm.org/show_bug.cgi?id=36702 + #![allow(unused_macros)] + + use crate::*; + +-crate trait All: crate::marker::Sized { ++pub(crate) trait All: crate::marker::Sized { + unsafe fn all(self) -> bool; + } + +-crate trait Any: crate::marker::Sized { ++pub(crate) trait Any: crate::marker::Sized { + unsafe fn any(self) -> bool; + } + + #[macro_use] + mod fallback_impl; + + cfg_if! { + if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { +diff --git a/third_party/rust/packed_simd/src/codegen/swap_bytes.rs b/third_party/rust/packed_simd/src/codegen/swap_bytes.rs +--- third_party/rust/packed_simd/src/codegen/swap_bytes.rs ++++ third_party/rust/packed_simd/src/codegen/swap_bytes.rs +@@ -1,26 +1,26 @@ + //! Horizontal swap bytes reductions. + + // FIXME: investigate using `llvm.bswap` + // https://github.com/rust-lang-nursery/packed_simd/issues/19 + + use crate::*; + +-crate trait SwapBytes { ++pub(crate) trait SwapBytes { + fn swap_bytes(self) -> Self; + } + + macro_rules! impl_swap_bytes { + (v16: $($id:ident,)+) => { + $( + impl SwapBytes for $id { + #[inline] + fn swap_bytes(self) -> Self { +- unsafe { shuffle!(self, [1, 0]) } ++ shuffle!(self, [1, 0]) + } + } + )+ + }; + (v32: $($id:ident,)+) => { + $( + impl SwapBytes for $id { + #[inline] +diff --git a/third_party/rust/packed_simd/src/codegen/vPtr.rs b/third_party/rust/packed_simd/src/codegen/vPtr.rs +--- third_party/rust/packed_simd/src/codegen/vPtr.rs ++++ third_party/rust/packed_simd/src/codegen/vPtr.rs +@@ -1,16 +1,16 @@ + //! Pointer vector types + + macro_rules! impl_simd_ptr { + ([$ptr_ty:ty; $elem_count:expr]: $tuple_id:ident | $ty:ident + | $($tys:ty),*) => { + #[derive(Copy, Clone)] + #[repr(simd)] +- pub struct $tuple_id<$ty>($(crate $tys),*); ++ pub struct $tuple_id<$ty>($(pub(crate) $tys),*); + //^^^^^^^ leaked through SimdArray + + impl<$ty> crate::sealed::Seal for [$ptr_ty; $elem_count] {} + impl<$ty> crate::sealed::SimdArray for [$ptr_ty; $elem_count] { + type Tuple = $tuple_id<$ptr_ty>; + type T = $ptr_ty; + const N: usize = $elem_count; + type NT = [u32; $elem_count]; +diff --git a/third_party/rust/packed_simd/src/lib.rs b/third_party/rust/packed_simd/src/lib.rs +--- third_party/rust/packed_simd/src/lib.rs ++++ third_party/rust/packed_simd/src/lib.rs +@@ -206,14 +206,13 @@ + rustc_attrs, + platform_intrinsics, + stdsimd, +- aarch64_target_feature, + arm_target_feature, + link_llvm_intrinsics, + core_intrinsics, + stmt_expr_attributes, +- crate_visibility_modifier, + custom_inner_attributes + )] ++#![cfg_attr(aarch64_target_feature, feature(aarch64_target_feature))] + #![allow(non_camel_case_types, non_snake_case, + // FIXME: these types are unsound in C FFI already + // See https://github.com/rust-lang/rust/issues/53346 +@@ -334,6 +333,6 @@ pub use self::codegen::llvm::{ + __shuffle_vector4, __shuffle_vector64, __shuffle_vector8, + }; + +-crate mod llvm { +- crate use crate::codegen::llvm::*; ++pub(crate) mod llvm { ++ pub(crate) use crate::codegen::llvm::*; + } +diff --git a/third_party/rust/packed_simd/src/testing.rs b/third_party/rust/packed_simd/src/testing.rs +--- third_party/rust/packed_simd/src/testing.rs ++++ third_party/rust/packed_simd/src/testing.rs +@@ -1,8 +1,8 @@ + //! Testing macros and other utilities. + + #[macro_use] + mod macros; + + #[cfg(test)] + #[macro_use] +-crate mod utils; ++pub(crate) mod utils; -- 2.37.1 From 1312ccd2b2a001d226a21acc541db7447e410eac Mon Sep 17 00:00:00 2001 From: Mikael Urankar Date: Wed, 17 Aug 2022 19:36:27 +0200 Subject: [PATCH 5/5] mail/thunderbird: Fix build with rust 1.63.0 - Fix packed_simd with the relevant parts of https://hg.mozilla.org/releases/mozilla-beta/raw-rev/c37c77a20f96 --- mail/thunderbird/files/patch-rust-1.63 | 767 +++++++++++++++++++++++++ 1 file changed, 767 insertions(+) create mode 100644 mail/thunderbird/files/patch-rust-1.63 diff --git a/mail/thunderbird/files/patch-rust-1.63 b/mail/thunderbird/files/patch-rust-1.63 new file mode 100644 index 0000000000..15c50810ed --- /dev/null +++ b/mail/thunderbird/files/patch-rust-1.63 @@ -0,0 +1,767 @@ +Backport of https://hg.mozilla.org/releases/mozilla-beta/raw-rev/c37c77a20f96 +Only the rust code is present (not the .toml, .json and .lock files) + + +diff --git a/third_party/rust/packed_simd/build.rs b/third_party/rust/packed_simd/build.rs +--- third_party/rust/packed_simd/build.rs ++++ third_party/rust/packed_simd/build.rs +@@ -1,6 +1,11 @@ ++use rustc_version::{version, Version}; ++ + fn main() { + let target = std::env::var("TARGET").expect("TARGET environment variable not defined"); + if target.contains("neon") { + println!("cargo:rustc-cfg=libcore_neon"); + } ++ if version().unwrap() < Version::parse("1.61.0-alpha").unwrap() { ++ println!("cargo:rustc-cfg=aarch64_target_feature"); ++ } + } +diff --git a/third_party/rust/packed_simd/src/api.rs b/third_party/rust/packed_simd/src/api.rs +--- third_party/rust/packed_simd/src/api.rs ++++ third_party/rust/packed_simd/src/api.rs +@@ -1,13 +1,13 @@ + //! Implements the Simd<[T; N]> APIs + + #[macro_use] + mod bitmask; +-crate mod cast; ++pub(crate) mod cast; + #[macro_use] + mod cmp; + #[macro_use] + mod default; + #[macro_use] + mod fmt; + #[macro_use] + mod from; +@@ -32,17 +32,17 @@ mod shuffle1_dyn; + #[macro_use] + mod slice; + #[macro_use] + mod swap_bytes; + #[macro_use] + mod bit_manip; + + #[cfg(feature = "into_bits")] +-crate mod into_bits; ++pub(crate) mod into_bits; + + macro_rules! impl_i { + ([$elem_ty:ident; $elem_n:expr]: $tuple_id:ident, $mask_ty:ident + | $ielem_ty:ident, $ibitmask_ty:ident | $test_tt:tt | $($elem_ids:ident),* + | From: $($from_vec_ty:ident),* | $(#[$doc:meta])*) => { + impl_minimal_iuf!([$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt + | $($elem_ids),* | $(#[$doc])*); + impl_ops_vector_arithmetic!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +diff --git a/third_party/rust/packed_simd/src/codegen.rs b/third_party/rust/packed_simd/src/codegen.rs +--- third_party/rust/packed_simd/src/codegen.rs ++++ third_party/rust/packed_simd/src/codegen.rs +@@ -1,24 +1,24 @@ + //! Code-generation utilities + +-crate mod bit_manip; +-crate mod llvm; +-crate mod math; +-crate mod reductions; +-crate mod shuffle; +-crate mod shuffle1_dyn; +-crate mod swap_bytes; ++pub(crate) mod bit_manip; ++pub(crate) mod llvm; ++pub(crate) mod math; ++pub(crate) mod reductions; ++pub(crate) mod shuffle; ++pub(crate) mod shuffle1_dyn; ++pub(crate) mod swap_bytes; + + macro_rules! impl_simd_array { + ([$elem_ty:ident; $elem_count:expr]: + $tuple_id:ident | $($elem_tys:ident),*) => { + #[derive(Copy, Clone)] + #[repr(simd)] +- pub struct $tuple_id($(crate $elem_tys),*); ++ pub struct $tuple_id($(pub(crate) $elem_tys),*); + //^^^^^^^ leaked through SimdArray + + impl crate::sealed::Seal for [$elem_ty; $elem_count] {} + + impl crate::sealed::SimdArray for [$elem_ty; $elem_count] { + type Tuple = $tuple_id; + type T = $elem_ty; + const N: usize = $elem_count; +@@ -30,33 +30,33 @@ macro_rules! impl_simd_array { + type Element = $elem_ty; + const LANES: usize = $elem_count; + type LanesType = [u32; $elem_count]; + } + + } + } + +-crate mod pointer_sized_int; ++pub(crate) mod pointer_sized_int; + +-crate mod v16; +-crate use self::v16::*; ++pub(crate) mod v16; ++pub(crate) use self::v16::*; + +-crate mod v32; +-crate use self::v32::*; ++pub(crate) mod v32; ++pub(crate) use self::v32::*; + +-crate mod v64; +-crate use self::v64::*; ++pub(crate) mod v64; ++pub(crate) use self::v64::*; + +-crate mod v128; +-crate use self::v128::*; ++pub(crate) mod v128; ++pub(crate) use self::v128::*; + +-crate mod v256; +-crate use self::v256::*; ++pub(crate) mod v256; ++pub(crate) use self::v256::*; + +-crate mod v512; +-crate use self::v512::*; ++pub(crate) mod v512; ++pub(crate) use self::v512::*; + +-crate mod vSize; +-crate use self::vSize::*; ++pub(crate) mod vSize; ++pub(crate) use self::vSize::*; + +-crate mod vPtr; +-crate use self::vPtr::*; ++pub(crate) mod vPtr; ++pub(crate) use self::vPtr::*; +diff --git a/third_party/rust/packed_simd/src/codegen/bit_manip.rs b/third_party/rust/packed_simd/src/codegen/bit_manip.rs +--- third_party/rust/packed_simd/src/codegen/bit_manip.rs ++++ third_party/rust/packed_simd/src/codegen/bit_manip.rs +@@ -1,12 +1,12 @@ + //! LLVM bit manipulation intrinsics. + #[rustfmt::skip] + +-use crate::*; ++pub(crate) use crate::*; + + #[allow(improper_ctypes, dead_code)] + extern "C" { + #[link_name = "llvm.ctlz.v2i8"] + fn ctlz_u8x2(x: u8x2, is_zero_undef: bool) -> u8x2; + #[link_name = "llvm.ctlz.v4i8"] + fn ctlz_u8x4(x: u8x4, is_zero_undef: bool) -> u8x4; + #[link_name = "llvm.ctlz.v8i8"] +@@ -142,17 +142,17 @@ extern "C" { + #[link_name = "llvm.ctpop.v1i128"] + fn ctpop_u128x1(x: u128x1) -> u128x1; + #[link_name = "llvm.ctpop.v2i128"] + fn ctpop_u128x2(x: u128x2) -> u128x2; + #[link_name = "llvm.ctpop.v4i128"] + fn ctpop_u128x4(x: u128x4) -> u128x4; + } + +-crate trait BitManip { ++pub(crate) trait BitManip { + fn ctpop(self) -> Self; + fn ctlz(self) -> Self; + fn cttz(self) -> Self; + } + + macro_rules! impl_bit_manip { + (inner: $ty:ident, $scalar:ty, $uty:ident, + $ctpop:ident, $ctlz:ident, $cttz:ident) => { +diff --git a/third_party/rust/packed_simd/src/codegen/llvm.rs b/third_party/rust/packed_simd/src/codegen/llvm.rs +--- third_party/rust/packed_simd/src/codegen/llvm.rs ++++ third_party/rust/packed_simd/src/codegen/llvm.rs +@@ -71,58 +71,58 @@ pub unsafe fn __shuffle_vector64::Element: Shuffle<[u32; 64], Output = U>, + { + simd_shuffle64(x, y, IDX) + } + + extern "platform-intrinsic" { +- crate fn simd_eq(x: T, y: T) -> U; +- crate fn simd_ne(x: T, y: T) -> U; +- crate fn simd_lt(x: T, y: T) -> U; +- crate fn simd_le(x: T, y: T) -> U; +- crate fn simd_gt(x: T, y: T) -> U; +- crate fn simd_ge(x: T, y: T) -> U; ++ pub(crate) fn simd_eq(x: T, y: T) -> U; ++ pub(crate) fn simd_ne(x: T, y: T) -> U; ++ pub(crate) fn simd_lt(x: T, y: T) -> U; ++ pub(crate) fn simd_le(x: T, y: T) -> U; ++ pub(crate) fn simd_gt(x: T, y: T) -> U; ++ pub(crate) fn simd_ge(x: T, y: T) -> U; + +- crate fn simd_insert(x: T, idx: u32, val: U) -> T; +- crate fn simd_extract(x: T, idx: u32) -> U; ++ pub(crate) fn simd_insert(x: T, idx: u32, val: U) -> T; ++ pub(crate) fn simd_extract(x: T, idx: u32) -> U; + +- crate fn simd_cast(x: T) -> U; ++ pub(crate) fn simd_cast(x: T) -> U; + +- crate fn simd_add(x: T, y: T) -> T; +- crate fn simd_sub(x: T, y: T) -> T; +- crate fn simd_mul(x: T, y: T) -> T; +- crate fn simd_div(x: T, y: T) -> T; +- crate fn simd_rem(x: T, y: T) -> T; +- crate fn simd_shl(x: T, y: T) -> T; +- crate fn simd_shr(x: T, y: T) -> T; +- crate fn simd_and(x: T, y: T) -> T; +- crate fn simd_or(x: T, y: T) -> T; +- crate fn simd_xor(x: T, y: T) -> T; ++ pub(crate) fn simd_add(x: T, y: T) -> T; ++ pub(crate) fn simd_sub(x: T, y: T) -> T; ++ pub(crate) fn simd_mul(x: T, y: T) -> T; ++ pub(crate) fn simd_div(x: T, y: T) -> T; ++ pub(crate) fn simd_rem(x: T, y: T) -> T; ++ pub(crate) fn simd_shl(x: T, y: T) -> T; ++ pub(crate) fn simd_shr(x: T, y: T) -> T; ++ pub(crate) fn simd_and(x: T, y: T) -> T; ++ pub(crate) fn simd_or(x: T, y: T) -> T; ++ pub(crate) fn simd_xor(x: T, y: T) -> T; + +- crate fn simd_reduce_add_unordered(x: T) -> U; +- crate fn simd_reduce_mul_unordered(x: T) -> U; +- crate fn simd_reduce_add_ordered(x: T, acc: U) -> U; +- crate fn simd_reduce_mul_ordered(x: T, acc: U) -> U; +- crate fn simd_reduce_min(x: T) -> U; +- crate fn simd_reduce_max(x: T) -> U; +- crate fn simd_reduce_min_nanless(x: T) -> U; +- crate fn simd_reduce_max_nanless(x: T) -> U; +- crate fn simd_reduce_and(x: T) -> U; +- crate fn simd_reduce_or(x: T) -> U; +- crate fn simd_reduce_xor(x: T) -> U; +- crate fn simd_reduce_all(x: T) -> bool; +- crate fn simd_reduce_any(x: T) -> bool; ++ pub(crate) fn simd_reduce_add_unordered(x: T) -> U; ++ pub(crate) fn simd_reduce_mul_unordered(x: T) -> U; ++ pub(crate) fn simd_reduce_add_ordered(x: T, acc: U) -> U; ++ pub(crate) fn simd_reduce_mul_ordered(x: T, acc: U) -> U; ++ pub(crate) fn simd_reduce_min(x: T) -> U; ++ pub(crate) fn simd_reduce_max(x: T) -> U; ++ pub(crate) fn simd_reduce_min_nanless(x: T) -> U; ++ pub(crate) fn simd_reduce_max_nanless(x: T) -> U; ++ pub(crate) fn simd_reduce_and(x: T) -> U; ++ pub(crate) fn simd_reduce_or(x: T) -> U; ++ pub(crate) fn simd_reduce_xor(x: T) -> U; ++ pub(crate) fn simd_reduce_all(x: T) -> bool; ++ pub(crate) fn simd_reduce_any(x: T) -> bool; + +- crate fn simd_select(m: M, a: T, b: T) -> T; ++ pub(crate) fn simd_select(m: M, a: T, b: T) -> T; + +- crate fn simd_fmin(a: T, b: T) -> T; +- crate fn simd_fmax(a: T, b: T) -> T; ++ pub(crate) fn simd_fmin(a: T, b: T) -> T; ++ pub(crate) fn simd_fmax(a: T, b: T) -> T; + +- crate fn simd_fsqrt(a: T) -> T; +- crate fn simd_fma(a: T, b: T, c: T) -> T; ++ pub(crate) fn simd_fsqrt(a: T) -> T; ++ pub(crate) fn simd_fma(a: T, b: T, c: T) -> T; + +- crate fn simd_gather(value: T, pointers: P, mask: M) -> T; +- crate fn simd_scatter(value: T, pointers: P, mask: M); ++ pub(crate) fn simd_gather(value: T, pointers: P, mask: M) -> T; ++ pub(crate) fn simd_scatter(value: T, pointers: P, mask: M); + +- crate fn simd_bitmask(value: T) -> U; ++ pub(crate) fn simd_bitmask(value: T) -> U; + } +diff --git a/third_party/rust/packed_simd/src/codegen/math.rs b/third_party/rust/packed_simd/src/codegen/math.rs +--- third_party/rust/packed_simd/src/codegen/math.rs ++++ third_party/rust/packed_simd/src/codegen/math.rs +@@ -1,3 +1,3 @@ + //! Vertical math operations + +-crate mod float; ++pub(crate) mod float; +diff --git a/third_party/rust/packed_simd/src/codegen/math/float.rs b/third_party/rust/packed_simd/src/codegen/math/float.rs +--- third_party/rust/packed_simd/src/codegen/math/float.rs ++++ third_party/rust/packed_simd/src/codegen/math/float.rs +@@ -1,18 +1,18 @@ + //! Vertical floating-point math operations. + #![allow(clippy::useless_transmute)] + + #[macro_use] +-crate mod macros; +-crate mod abs; +-crate mod cos; +-crate mod cos_pi; +-crate mod exp; +-crate mod ln; +-crate mod mul_add; +-crate mod mul_adde; +-crate mod powf; +-crate mod sin; +-crate mod sin_cos_pi; +-crate mod sin_pi; +-crate mod sqrt; +-crate mod sqrte; ++pub(crate) mod macros; ++pub(crate) mod abs; ++pub(crate) mod cos; ++pub(crate) mod cos_pi; ++pub(crate) mod exp; ++pub(crate) mod ln; ++pub(crate) mod mul_add; ++pub(crate) mod mul_adde; ++pub(crate) mod powf; ++pub(crate) mod sin; ++pub(crate) mod sin_cos_pi; ++pub(crate) mod sin_pi; ++pub(crate) mod sqrt; ++pub(crate) mod sqrte; +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/abs.rs b/third_party/rust/packed_simd/src/codegen/math/float/abs.rs +--- third_party/rust/packed_simd/src/codegen/math/float/abs.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/abs.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `fabs` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors fabs + + use crate::*; + +-crate trait Abs { ++pub(crate) trait Abs { + fn abs(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.fabs.v2f32"] + fn fabs_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.fabs.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/cos.rs b/third_party/rust/packed_simd/src/codegen/math/float/cos.rs +--- third_party/rust/packed_simd/src/codegen/math/float/cos.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/cos.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `cos` + #![allow(unused)] + + // FIXME 64-bit 1 elem vector cos + + use crate::*; + +-crate trait Cos { ++pub(crate) trait Cos { + fn cos(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.cos.v2f32"] + fn cos_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.cos.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs b/third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs +--- third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `cos` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors cos_pi + + use crate::*; + +-crate trait CosPi { ++pub(crate) trait CosPi { + fn cos_pi(self) -> Self; + } + + gen_unary_impl_table!(CosPi, cos_pi); + + macro_rules! impl_def { + ($vid:ident, $PI:path) => { + impl CosPi for $vid { +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/exp.rs b/third_party/rust/packed_simd/src/codegen/math/float/exp.rs +--- third_party/rust/packed_simd/src/codegen/math/float/exp.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/exp.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `exp` + #![allow(unused)] + + // FIXME 64-bit expgle elem vectors misexpg + + use crate::*; + +-crate trait Exp { ++pub(crate) trait Exp { + fn exp(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.exp.v2f32"] + fn exp_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.exp.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/ln.rs b/third_party/rust/packed_simd/src/codegen/math/float/ln.rs +--- third_party/rust/packed_simd/src/codegen/math/float/ln.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/ln.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `ln` + #![allow(unused)] + + // FIXME 64-bit lngle elem vectors mislng + + use crate::*; + +-crate trait Ln { ++pub(crate) trait Ln { + fn ln(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.log.v2f32"] + fn ln_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.log.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs b/third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs +--- third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs +@@ -1,15 +1,15 @@ + //! Vertical floating-point `mul_add` + #![allow(unused)] + use crate::*; + + // FIXME: 64-bit 1 element mul_add + +-crate trait MulAdd { ++pub(crate) trait MulAdd { + fn mul_add(self, y: Self, z: Self) -> Self; + } + + #[cfg(not(target_arch = "s390x"))] + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.fma.v2f32"] + fn fma_v2f32(x: f32x2, y: f32x2, z: f32x2) -> f32x2; +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs b/third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs +--- third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs +@@ -1,14 +1,14 @@ + //! Approximation for floating-point `mul_add` + use crate::*; + + // FIXME: 64-bit 1 element mul_adde + +-crate trait MulAddE { ++pub(crate) trait MulAddE { + fn mul_adde(self, y: Self, z: Self) -> Self; + } + + #[cfg(not(target_arch = "s390x"))] + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.fmuladd.v2f32"] + fn fmuladd_v2f32(x: f32x2, y: f32x2, z: f32x2) -> f32x2; +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/powf.rs b/third_party/rust/packed_simd/src/codegen/math/float/powf.rs +--- third_party/rust/packed_simd/src/codegen/math/float/powf.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/powf.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `powf` + #![allow(unused)] + + // FIXME 64-bit powfgle elem vectors mispowfg + + use crate::*; + +-crate trait Powf { ++pub(crate) trait Powf { + fn powf(self, x: Self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.pow.v2f32"] + fn powf_v2f32(x: f32x2, y: f32x2) -> f32x2; + #[link_name = "llvm.pow.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sin.rs b/third_party/rust/packed_simd/src/codegen/math/float/sin.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sin.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sin.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `sin` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sin + + use crate::*; + +-crate trait Sin { ++pub(crate) trait Sin { + fn sin(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.sin.v2f32"] + fn sin_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.sin.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs b/third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `sin_cos` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sin_cos + + use crate::*; + +-crate trait SinCosPi: Sized { ++pub(crate) trait SinCosPi: Sized { + type Output; + fn sin_cos_pi(self) -> Self::Output; + } + + macro_rules! impl_def { + ($vid:ident, $PI:path) => { + impl SinCosPi for $vid { + type Output = (Self, Self); +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs b/third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `sin_pi` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sin_pi + + use crate::*; + +-crate trait SinPi { ++pub(crate) trait SinPi { + fn sin_pi(self) -> Self; + } + + gen_unary_impl_table!(SinPi, sin_pi); + + macro_rules! impl_def { + ($vid:ident, $PI:path) => { + impl SinPi for $vid { +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs b/third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs +@@ -1,16 +1,16 @@ + //! Vertical floating-point `sqrt` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sqrt + + use crate::*; + +-crate trait Sqrt { ++pub(crate) trait Sqrt { + fn sqrt(self) -> Self; + } + + #[allow(improper_ctypes)] + extern "C" { + #[link_name = "llvm.sqrt.v2f32"] + fn sqrt_v2f32(x: f32x2) -> f32x2; + #[link_name = "llvm.sqrt.v4f32"] +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs b/third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs +--- third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs ++++ third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs +@@ -1,17 +1,17 @@ + //! Vertical floating-point `sqrt` + #![allow(unused)] + + // FIXME 64-bit 1 elem vectors sqrte + + use crate::llvm::simd_fsqrt; + use crate::*; + +-crate trait Sqrte { ++pub(crate) trait Sqrte { + fn sqrte(self) -> Self; + } + + gen_unary_impl_table!(Sqrte, sqrte); + + cfg_if! { + if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { + use sleef_sys::*; +diff --git a/third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs b/third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs +--- third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs ++++ third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs +@@ -1,28 +1,28 @@ + //! Provides `isize` and `usize` + + use cfg_if::cfg_if; + + cfg_if! { + if #[cfg(target_pointer_width = "8")] { +- crate type isize_ = i8; +- crate type usize_ = u8; ++ pub(crate) type isize_ = i8; ++ pub(crate) type usize_ = u8; + } else if #[cfg(target_pointer_width = "16")] { +- crate type isize_ = i16; +- crate type usize_ = u16; ++ pub(crate) type isize_ = i16; ++ pub(crate) type usize_ = u16; + } else if #[cfg(target_pointer_width = "32")] { +- crate type isize_ = i32; +- crate type usize_ = u32; ++ pub(crate) type isize_ = i32; ++ pub(crate) type usize_ = u32; + + } else if #[cfg(target_pointer_width = "64")] { +- crate type isize_ = i64; +- crate type usize_ = u64; ++ pub(crate) type isize_ = i64; ++ pub(crate) type usize_ = u64; + } else if #[cfg(target_pointer_width = "64")] { +- crate type isize_ = i64; +- crate type usize_ = u64; ++ pub(crate) type isize_ = i64; ++ pub(crate) type usize_ = u64; + } else if #[cfg(target_pointer_width = "128")] { +- crate type isize_ = i128; +- crate type usize_ = u128; ++ pub(crate) type isize_ = i128; ++ pub(crate) type usize_ = u128; + } else { + compile_error!("unsupported target_pointer_width"); + } + } +diff --git a/third_party/rust/packed_simd/src/codegen/reductions.rs b/third_party/rust/packed_simd/src/codegen/reductions.rs +--- third_party/rust/packed_simd/src/codegen/reductions.rs ++++ third_party/rust/packed_simd/src/codegen/reductions.rs +@@ -1,1 +1,1 @@ +-crate mod mask; ++pub(crate) mod mask; +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask.rs +--- third_party/rust/packed_simd/src/codegen/reductions/mask.rs ++++ third_party/rust/packed_simd/src/codegen/reductions/mask.rs +@@ -2,21 +2,21 @@ + //! + //! Works around [LLVM bug 36702]. + //! + //! [LLVM bug 36702]: https://bugs.llvm.org/show_bug.cgi?id=36702 + #![allow(unused_macros)] + + use crate::*; + +-crate trait All: crate::marker::Sized { ++pub(crate) trait All: crate::marker::Sized { + unsafe fn all(self) -> bool; + } + +-crate trait Any: crate::marker::Sized { ++pub(crate) trait Any: crate::marker::Sized { + unsafe fn any(self) -> bool; + } + + #[macro_use] + mod fallback_impl; + + cfg_if! { + if #[cfg(any(target_arch = "x86", target_arch = "x86_64"))] { +diff --git a/third_party/rust/packed_simd/src/codegen/swap_bytes.rs b/third_party/rust/packed_simd/src/codegen/swap_bytes.rs +--- third_party/rust/packed_simd/src/codegen/swap_bytes.rs ++++ third_party/rust/packed_simd/src/codegen/swap_bytes.rs +@@ -1,26 +1,26 @@ + //! Horizontal swap bytes reductions. + + // FIXME: investigate using `llvm.bswap` + // https://github.com/rust-lang-nursery/packed_simd/issues/19 + + use crate::*; + +-crate trait SwapBytes { ++pub(crate) trait SwapBytes { + fn swap_bytes(self) -> Self; + } + + macro_rules! impl_swap_bytes { + (v16: $($id:ident,)+) => { + $( + impl SwapBytes for $id { + #[inline] + fn swap_bytes(self) -> Self { +- unsafe { shuffle!(self, [1, 0]) } ++ shuffle!(self, [1, 0]) + } + } + )+ + }; + (v32: $($id:ident,)+) => { + $( + impl SwapBytes for $id { + #[inline] +diff --git a/third_party/rust/packed_simd/src/codegen/vPtr.rs b/third_party/rust/packed_simd/src/codegen/vPtr.rs +--- third_party/rust/packed_simd/src/codegen/vPtr.rs ++++ third_party/rust/packed_simd/src/codegen/vPtr.rs +@@ -1,16 +1,16 @@ + //! Pointer vector types + + macro_rules! impl_simd_ptr { + ([$ptr_ty:ty; $elem_count:expr]: $tuple_id:ident | $ty:ident + | $($tys:ty),*) => { + #[derive(Copy, Clone)] + #[repr(simd)] +- pub struct $tuple_id<$ty>($(crate $tys),*); ++ pub struct $tuple_id<$ty>($(pub(crate) $tys),*); + //^^^^^^^ leaked through SimdArray + + impl<$ty> crate::sealed::Seal for [$ptr_ty; $elem_count] {} + impl<$ty> crate::sealed::SimdArray for [$ptr_ty; $elem_count] { + type Tuple = $tuple_id<$ptr_ty>; + type T = $ptr_ty; + const N: usize = $elem_count; + type NT = [u32; $elem_count]; +diff --git a/third_party/rust/packed_simd/src/lib.rs b/third_party/rust/packed_simd/src/lib.rs +--- third_party/rust/packed_simd/src/lib.rs ++++ third_party/rust/packed_simd/src/lib.rs +@@ -206,14 +206,13 @@ + rustc_attrs, + platform_intrinsics, + stdsimd, +- aarch64_target_feature, + arm_target_feature, + link_llvm_intrinsics, + core_intrinsics, + stmt_expr_attributes, +- crate_visibility_modifier, + custom_inner_attributes + )] ++#![cfg_attr(aarch64_target_feature, feature(aarch64_target_feature))] + #![allow(non_camel_case_types, non_snake_case, + // FIXME: these types are unsound in C FFI already + // See https://github.com/rust-lang/rust/issues/53346 +@@ -334,6 +333,6 @@ pub use self::codegen::llvm::{ + __shuffle_vector4, __shuffle_vector64, __shuffle_vector8, + }; + +-crate mod llvm { +- crate use crate::codegen::llvm::*; ++pub(crate) mod llvm { ++ pub(crate) use crate::codegen::llvm::*; + } +diff --git a/third_party/rust/packed_simd/src/testing.rs b/third_party/rust/packed_simd/src/testing.rs +--- third_party/rust/packed_simd/src/testing.rs ++++ third_party/rust/packed_simd/src/testing.rs +@@ -1,8 +1,8 @@ + //! Testing macros and other utilities. + + #[macro_use] + mod macros; + + #[cfg(test)] + #[macro_use] +-crate mod utils; ++pub(crate) mod utils; -- 2.37.1