pkgsrc-Changes archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
CVS commit: pkgsrc/www/seamonkey
Module Name: pkgsrc
Committed By: dholland
Date: Tue Nov 1 04:22:19 UTC 2022
Modified Files:
pkgsrc/www/seamonkey: Makefile distinfo
Added Files:
pkgsrc/www/seamonkey/patches: patch-fac963c3bc00
Log Message:
www/seamonkey: Add patch from upstream to make it build with current rust.
PKGREVISION -> 3 as a precaution.
To generate a diff of this commit:
cvs rdiff -u -r1.250 -r1.251 pkgsrc/www/seamonkey/Makefile
cvs rdiff -u -r1.176 -r1.177 pkgsrc/www/seamonkey/distinfo
cvs rdiff -u -r0 -r1.1 pkgsrc/www/seamonkey/patches/patch-fac963c3bc00
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: pkgsrc/www/seamonkey/Makefile
diff -u pkgsrc/www/seamonkey/Makefile:1.250 pkgsrc/www/seamonkey/Makefile:1.251
--- pkgsrc/www/seamonkey/Makefile:1.250 Tue Sep 27 20:58:28 2022
+++ pkgsrc/www/seamonkey/Makefile Tue Nov 1 04:22:19 2022
@@ -1,8 +1,8 @@
-# $NetBSD: Makefile,v 1.250 2022/09/27 20:58:28 wiz Exp $
+# $NetBSD: Makefile,v 1.251 2022/11/01 04:22:19 dholland Exp $
DISTNAME= seamonkey-${SM_VER}.source
PKGNAME= seamonkey-${SM_VER:S/b/beta/}
-PKGREVISION= 2
+PKGREVISION= 3
SM_VER= 2.53.13
CATEGORIES= www
MASTER_SITES= ${MASTER_SITE_MOZILLA:=seamonkey/releases/${SM_VER}/source/}
@@ -64,6 +64,87 @@ CKSUM_CRATES+= third_party/rust/libc
CKSUMS+= 4d9f7091af8e166943ac6f42ce85558909e5b6e61325039bff7adfbcf4b90212
CKSUMS+= 30c5211b393d9314f880f63e29833785c8b55369102eec21170a0fe0fd1c4a16
+# patch-fac963c3bc00
+CKSUM_CRATES+= third_party/rust/packed_simd
+# src/api.rs
+CKSUMS+= f6e92f056565e6fd93f98829a408aee9e790251e0cbd8a8bc30c8662b4d6fabb
+CKSUMS+= bb1795e9657a8298d37d2349b45443f08e9e455399ad4b727018600728478c10
+# src/codegen.rs
+CKSUMS+= a29d38fa0a85eaf787fb49989e625bf64effd5f39c126fbb2a24be206d2a3917
+CKSUMS+= db4f232fb9f5728db310b87dc8c4733be48afacab1053798c06106bef9a42b05
+# src/codegen/bit_manip.rs
+CKSUMS+= 17ecebcff1f080e712fea5eb51602a73f4201ed56a198220342c8eb55bb92692
+CKSUMS+= 6de2918225f6e2f67f9cb18c07f986d1580759e4fd0448cd0124b9d025a6721f
+# src/codegen/llvm.rs
+CKSUMS+= 5bc6751293f9f184cf23d5df448c7d58b58b799e41c7a91f8ca41a5ba56e64ec
+CKSUMS+= b4ccbc0bad90038f00fc3c158736462d01d0053df3afa00f9169e67d1a264444
+# src/codegen/math.rs
+CKSUMS+= 35f96e37a78fcf0cdb02146b7f27a45108fe06a37fc2a54d8851ce131a326178
+CKSUMS+= dfcf02ad34e2fdfe22c3f1cc2822001cc895e65031b4d06e585e5047839febb7
+# src/codegen/math/float.rs
+CKSUMS+= dd86c0449e576c83b719700962ac017c332987fac08d91f2b7a2b1b883598170
+CKSUMS+= 2c1cbce155bc527ce34d472c0fef6bc3dadb79cd7a357dd7aa5b1ebeb1d77a13
+# src/codegen/math/float/abs.rs
+CKSUMS+= f56e2b4b8055ea861c1f5cbc6b6e1d8e7e5af163b62c13574ddee4e09513bfbc
+CKSUMS+= d5aaadcf540bdb9b4264dca6471a255fd7bf509e763bef0239c0144a68466fea
+# src/codegen/math/float/cos.rs
+CKSUMS+= ef3b511a24d23045b310315e80348a9b7fedb576fc2de52d74290616a0abeb2a
+CKSUMS+= 17f28d2900c852dca221fa9c92a9cd5fe7fd2df8d427bbc60216c749b2be013d
+# src/codegen/math/float/cos_pi.rs
+CKSUMS+= 4e7631a5d73dac21531e09ef1802d1180f8997509c2c8fa9f67f322194263a97
+CKSUMS+= dbaf9f443f9846a491d4ec52210a7b5835dd593b03366e3135b05c37d70f9d6c
+# src/codegen/math/float/exp.rs
+CKSUMS+= 61b691598c41b5622f24e4320c1bdd08701e612a516438bdddcc728fc3405c8c
+CKSUMS+= d300058a4bcc7ae7976f216f81902cd73a9e603ad63880dff3bbc866c27a9f37
+# src/codegen/math/float/ln.rs
+CKSUMS+= 46b718b1ba8c9d99e1ad40f53d20dfde08a3063ca7bd2a9fdd6698e060da687e
+CKSUMS+= c851e211e43f8256093ba75b03ae0c307c9962ee66d94f09b4dd80068190cbdf
+# src/codegen/math/float/mul_add.rs
+CKSUMS+= a37bf764345d4b1714f97e83897b7cf0855fc2811704bcbc0012db91825339e1
+CKSUMS+= 041a5b69d5991d93ef795351b17560c10faf80b78fd26ad7df42a239b32cf9de
+# src/codegen/math/float/mul_adde.rs
+CKSUMS+= c75702bfcb361de45964a93caf959a695ef2376bd069227600b8c6872665c755
+CKSUMS+= 8eb4e1d2c10e890032d0ff976091ea89da16ea7c8234d608890c759e45d91e27
+# src/codegen/math/float/powf.rs
+CKSUMS+= 642346e982bc4c39203de0864d2149c4179cd7b21cf67a2951687932b4675872
+CKSUMS+= 9742c3877f1a5509ca5c9492a40884b6579ba6dd11c26b7112e63f70666b395d
+# src/codegen/math/float/sin.rs
+CKSUMS+= 9d68164c90cdca6a85155040cdac42e27342ebe0b925273ef1593df721af4258
+CKSUMS+= 0e9868d35531566509f3a01d85d5253045eb4afa8525d8407dcc1f5f33c56036
+# src/codegen/math/float/sin_cos_pi.rs
+CKSUMS+= 9be02ad48585a1e8d99129382fbffbaed47852f15459256a708850b6b7a75405
+CKSUMS+= 0c8981df6970db6f33f0adad16b1979c1d1be24f9622a200736c162c8de41bf7
+# src/codegen/math/float/sin_pi.rs
+CKSUMS+= 9890347905b4d4a3c7341c3eb06406e46e60582bcf6960688bd727e5dadc6c57
+CKSUMS+= bb6d39db8f921e03a301fc5206ac1a61a97def8a2cb83b87ccf189f3fc48d548
+# src/codegen/math/float/sqrt.rs
+CKSUMS+= e3c60dcfb0c6d2fc62adabcc931b2d4040b83cab294dea36443fb4b89eb79e34
+CKSUMS+= e6ebb0c5f428efad1f672b9a8fe4e58534dbf1ea5a8fe092ce5ce76b52fe89cb
+# src/codegen/math/float/sqrte.rs
+CKSUMS+= f0f4ef9eb475ae41bcc7ec6a95ad744ba6b36925faa8b2c2814004396d196b63
+CKSUMS+= 23acfaea38d0e081a6d9021c1094e813d0cfd12c58c1eca9662aade5e625d51c
+# src/codegen/pointer_sized_int.rs
+CKSUMS+= a70697169c28218b56fd2e8d5353f2e00671d1150d0c8cef77d613bdfacd84cb
+CKSUMS+= 6ca13c214b6cf7e0929dbe18e96a16fc0bb7d8799608df29c4c8115490f99e01
+# src/codegen/reductions.rs
+CKSUMS+= 645e2514746d01387ddd07f0aa4ffd8430cc9ab428d4fb13773ea319fa25dd95
+CKSUMS+= 8eb18ebac76985d2aa30262a2edd8cb004230b511a765d657525f677a585c12c
+# src/codegen/reductions/mask.rs
+CKSUMS+= 8f1afe6aabf096a3278e1fc3a30f736e04aa8b9ce96373cee22162d18cfe2702
+CKSUMS+= f3bf63d36d5e4612eae7899693e2bc5fd2efabe6dc81e2c62afaef488105b460
+# src/codegen/swap_bytes.rs
+CKSUMS+= 1d6cdc716eadddc92b4fd506b2445a821caa8dc00860447de09d7ebd69c2087f
+CKSUMS+= 0cd2c1ed297116e9d990259a99fcd633734105ce4bfb9fa7fda62e6aad3f3401
+# src/codegen/vPtr.rs
+CKSUMS+= 711c753a08d53a2879c4fb87a0762c46ce4e34c22f0ca88d2e4c557a0f679969
+CKSUMS+= f0753b405cdc865bdf8e82c6505f299ea1f96136239ebbaf7f9ce93d310764b8
+# src/lib.rs
+CKSUMS+= 41c2a5c5fb42225ce9c6a267653870fdb8af30f933b3b8534d57a15fb96ebb39
+CKSUMS+= 11055443120e525054c65d0b520cc023aa31d6e941ae75cb6321eeb531a16655
+# src/testing.rs
+CKSUMS+= 1d3a7862ef625e235a5734ad7204e68d350f902c0695182b1f08a0552432416e
+CKSUMS+= 896669c08d8c801448a4d2fadc9d633eda0fbe879d229997e2a182e31278e469
+
SUBST_CLASSES+= cksum
SUBST_STAGE.cksum= pre-configure
.for crate in ${CKSUM_CRATES}
Index: pkgsrc/www/seamonkey/distinfo
diff -u pkgsrc/www/seamonkey/distinfo:1.176 pkgsrc/www/seamonkey/distinfo:1.177
--- pkgsrc/www/seamonkey/distinfo:1.176 Thu Sep 8 20:27:32 2022
+++ pkgsrc/www/seamonkey/distinfo Tue Nov 1 04:22:19 2022
@@ -1,10 +1,11 @@
-$NetBSD: distinfo,v 1.176 2022/09/08 20:27:32 ryoon Exp $
+$NetBSD: distinfo,v 1.177 2022/11/01 04:22:19 dholland Exp $
BLAKE2s (seamonkey-2.53.13.source.tar.xz) = 20a58c1cf3a43955311d3a65bddba9c882c6ebfc0fff3173c1e83c517e198f26
SHA512 (seamonkey-2.53.13.source.tar.xz) = f95fcec1dd732c3ca8218e6359c51260d44c40c8c2f34ad11ee160166f4df7c2184dd5d7e02b4ee363700d189e8652fabe7aeec8d0917ea9589ec1baa714f7a2
Size (seamonkey-2.53.13.source.tar.xz) = 253664548 bytes
SHA1 (patch-build_moz.configure_rust.configure) = 38ba5e8a0e41352afc4e767c25388c3c772b0457
SHA1 (patch-dom_indexedDB_IDBTransaction.h) = 7882f1264889d5f17af0bafa68bfa5aff5b57634
+SHA1 (patch-fac963c3bc00) = 1c4e0289365840700960f42a46d9180dc25b8a29
SHA1 (patch-gfx_angle_checkout_src_compiler_translator_SymbolTable__ESSL__autogen.cpp) = 915fbe98d20ff405f031636add07d4bd610b5939
SHA1 (patch-gfx_angle_checkout_src_compiler_translator_SymbolTable__autogen.cpp) = c78ada128986334d04ae07ec98545ecf611a7dfc
SHA1 (patch-ldap_c-sdk_include_portable.h) = b742b070a45507678f592428110477e484c52659
Added files:
Index: pkgsrc/www/seamonkey/patches/patch-fac963c3bc00
diff -u /dev/null pkgsrc/www/seamonkey/patches/patch-fac963c3bc00:1.1
--- /dev/null Tue Nov 1 04:22:19 2022
+++ pkgsrc/www/seamonkey/patches/patch-fac963c3bc00 Tue Nov 1 04:22:19 2022
@@ -0,0 +1,762 @@
+$NetBSD: patch-fac963c3bc00,v 1.1 2022/11/01 04:22:19 dholland Exp $
+
+Upstream patch to build against current rust.
+
+From https://hg.mozilla.org/mozilla-central/rev/fac963c3bc00, with
+non-material bits that don't apply removed, and converted from -p1 to
+-p0.
+
+Note: this patch patches multiple files, but should go away with the
+next update.
+
+
+diff --git third_party/rust/packed_simd/src/api.rs 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 third_party/rust/packed_simd/src/codegen.rs 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 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
++++ 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 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
++++ third_party/rust/packed_simd/src/codegen/llvm.rs
+@@ -71,58 +71,58 @@ pub unsafe fn __shuffle_vector64<const I
+ where
+ T: Simd,
+ <T as Simd>::Element: Shuffle<[u32; 64], Output = U>,
+ {
+ simd_shuffle64(x, y, IDX)
+ }
+
+ extern "platform-intrinsic" {
+- crate fn simd_eq<T, U>(x: T, y: T) -> U;
+- crate fn simd_ne<T, U>(x: T, y: T) -> U;
+- crate fn simd_lt<T, U>(x: T, y: T) -> U;
+- crate fn simd_le<T, U>(x: T, y: T) -> U;
+- crate fn simd_gt<T, U>(x: T, y: T) -> U;
+- crate fn simd_ge<T, U>(x: T, y: T) -> U;
++ pub(crate) fn simd_eq<T, U>(x: T, y: T) -> U;
++ pub(crate) fn simd_ne<T, U>(x: T, y: T) -> U;
++ pub(crate) fn simd_lt<T, U>(x: T, y: T) -> U;
++ pub(crate) fn simd_le<T, U>(x: T, y: T) -> U;
++ pub(crate) fn simd_gt<T, U>(x: T, y: T) -> U;
++ pub(crate) fn simd_ge<T, U>(x: T, y: T) -> U;
+
+- crate fn simd_insert<T, U>(x: T, idx: u32, val: U) -> T;
+- crate fn simd_extract<T, U>(x: T, idx: u32) -> U;
++ pub(crate) fn simd_insert<T, U>(x: T, idx: u32, val: U) -> T;
++ pub(crate) fn simd_extract<T, U>(x: T, idx: u32) -> U;
+
+- crate fn simd_cast<T, U>(x: T) -> U;
++ pub(crate) fn simd_cast<T, U>(x: T) -> U;
+
+- crate fn simd_add<T>(x: T, y: T) -> T;
+- crate fn simd_sub<T>(x: T, y: T) -> T;
+- crate fn simd_mul<T>(x: T, y: T) -> T;
+- crate fn simd_div<T>(x: T, y: T) -> T;
+- crate fn simd_rem<T>(x: T, y: T) -> T;
+- crate fn simd_shl<T>(x: T, y: T) -> T;
+- crate fn simd_shr<T>(x: T, y: T) -> T;
+- crate fn simd_and<T>(x: T, y: T) -> T;
+- crate fn simd_or<T>(x: T, y: T) -> T;
+- crate fn simd_xor<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_add<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_sub<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_mul<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_div<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_rem<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_shl<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_shr<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_and<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_or<T>(x: T, y: T) -> T;
++ pub(crate) fn simd_xor<T>(x: T, y: T) -> T;
+
+- crate fn simd_reduce_add_unordered<T, U>(x: T) -> U;
+- crate fn simd_reduce_mul_unordered<T, U>(x: T) -> U;
+- crate fn simd_reduce_add_ordered<T, U>(x: T, acc: U) -> U;
+- crate fn simd_reduce_mul_ordered<T, U>(x: T, acc: U) -> U;
+- crate fn simd_reduce_min<T, U>(x: T) -> U;
+- crate fn simd_reduce_max<T, U>(x: T) -> U;
+- crate fn simd_reduce_min_nanless<T, U>(x: T) -> U;
+- crate fn simd_reduce_max_nanless<T, U>(x: T) -> U;
+- crate fn simd_reduce_and<T, U>(x: T) -> U;
+- crate fn simd_reduce_or<T, U>(x: T) -> U;
+- crate fn simd_reduce_xor<T, U>(x: T) -> U;
+- crate fn simd_reduce_all<T>(x: T) -> bool;
+- crate fn simd_reduce_any<T>(x: T) -> bool;
++ pub(crate) fn simd_reduce_add_unordered<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_mul_unordered<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_add_ordered<T, U>(x: T, acc: U) -> U;
++ pub(crate) fn simd_reduce_mul_ordered<T, U>(x: T, acc: U) -> U;
++ pub(crate) fn simd_reduce_min<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_max<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_min_nanless<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_max_nanless<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_and<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_or<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_xor<T, U>(x: T) -> U;
++ pub(crate) fn simd_reduce_all<T>(x: T) -> bool;
++ pub(crate) fn simd_reduce_any<T>(x: T) -> bool;
+
+- crate fn simd_select<M, T>(m: M, a: T, b: T) -> T;
++ pub(crate) fn simd_select<M, T>(m: M, a: T, b: T) -> T;
+
+- crate fn simd_fmin<T>(a: T, b: T) -> T;
+- crate fn simd_fmax<T>(a: T, b: T) -> T;
++ pub(crate) fn simd_fmin<T>(a: T, b: T) -> T;
++ pub(crate) fn simd_fmax<T>(a: T, b: T) -> T;
+
+- crate fn simd_fsqrt<T>(a: T) -> T;
+- crate fn simd_fma<T>(a: T, b: T, c: T) -> T;
++ pub(crate) fn simd_fsqrt<T>(a: T) -> T;
++ pub(crate) fn simd_fma<T>(a: T, b: T, c: T) -> T;
+
+- crate fn simd_gather<T, P, M>(value: T, pointers: P, mask: M) -> T;
+- crate fn simd_scatter<T, P, M>(value: T, pointers: P, mask: M);
++ pub(crate) fn simd_gather<T, P, M>(value: T, pointers: P, mask: M) -> T;
++ pub(crate) fn simd_scatter<T, P, M>(value: T, pointers: P, mask: M);
+
+- crate fn simd_bitmask<T, U>(value: T) -> U;
++ pub(crate) fn simd_bitmask<T, U>(value: T) -> U;
+ }
+diff --git 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ 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 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
++++ third_party/rust/packed_simd/src/codegen/reductions.rs
+@@ -1,1 +1,1 @@
+-crate mod mask;
++pub(crate) mod mask;
+diff --git 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
++++ third_party/rust/packed_simd/src/codegen/reductions/mask.rs
+@@ -2,21 +2,21 @@
+ //!
+ //! Works arround [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 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
++++ 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 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
++++ 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 third_party/rust/packed_simd/src/lib.rs 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,12 +206,10 @@
+ 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
+ )]
+ #![allow(non_camel_case_types, non_snake_case,
+@@ -339,11 +337,11 @@ pub use self::api::into_bits::*;
+
+ // Re-export the shuffle intrinsics required by the `shuffle!` macro.
+ #[doc(hidden)]
+ pub use self::codegen::llvm::{
+ __shuffle_vector16, __shuffle_vector2, __shuffle_vector32,
+ __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 third_party/rust/packed_simd/src/testing.rs 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;
Home |
Main Index |
Thread Index |
Old Index