From 1c7ffb263a7f0dec554d27da1c8057dc23d03f166f26e07cd74d667491237ca9 Mon Sep 17 00:00:00 2001 From: Tristan Miller Date: Thu, 5 Sep 2024 21:10:32 +0000 Subject: [PATCH] - update to SeaMonkey 2.53.19 * Cancel button in SeaMonkey bookmarking star ui not working bug 1872623. * Remove OfflineAppCacheHelper.jsm copy from SeaMonkey and use the one in toolkit bug 1896292. * Remove obsolete registerFactoryLocation calls from cZ bug 1870930. * Remove needless implements='nsIDOMEventListener' and QI bug 1611010. * Replace use of nsIStandardURL::Init bug 1864355. * Switch SeaMonkey website from hg.mozilla.org to heptapod. bug 1870934. * Allow view-image to open a data: URI by setting a flag on the loadinfo bug 1877001. * Save-link-as feature should use the loading principal and context menu using nsIContentPolicy.TYPE_SAVE_AS_DOWNLOAD bug 1879726. * Use punycode in SeaMonkey JS bug 1864287. * Font lists in preferences are no longer grouped by font type, port asynchronous handling like Bug 1399206 bug 1437393. * SeaMonkey broken tab after undo closed tab with invalid protocol bug 1885748. * SeaMonkey session restore is missing the checkboxes in the Classic theme bug 1896174. * Implement about:credits on seamonkey-project.org website bug 1898467. * Fix for the 0.0.0.0 day vulnerability oligo summary. * Link in update notification does not open Browser bug 1888364. * Update ReadExtensionPrefs in Preferences.cpp bug 1890196. * Add about:seamonkey page to SeaMonkey bug 1897801. * SeaMonkey 2.53.19 uses the same backend as Firefox and contains the relevant Firefox 60.8 security fixes. * SeaMonkey 2.53.19 shares most parts of the mail and news code with Thunderbird. Please read the Thunderbird 60.8.0 release notes for specific security fixes in this release. * Additional important security fixes up to Current Firefox 115.14 and Thunderbird 115.14 ESR plus many enhancements have been backported. We will continue to enhance SeaMonkey security in subsequent 2.53.x beta and release versions as fast as we are able to. - Adapt seamonkey-man-page.patch for SeaMonkey 2.53.19 - Adapt seamonkey-GNUmakefile to create mach environment - Build with GCC 13 on Tumbleweed due to build failures with GCC 14: https://bugzilla.mozilla.org/show_bug.cgi?id=1916827 OBS-URL: https://build.opensuse.org/package/show/mozilla:Factory/seamonkey?expand=0&rev=63 --- .gitattributes | 23 + .gitignore | 1 + _constraints | 23 + mozilla-bmo1862601.patch | 16 + mozilla-bmo1896958.patch | 24886 +++++++++++++++++++++++ mozilla-bmo531915.patch | 33 + mozilla-nongnome-proxies.patch | 25 + mozilla-ntlm-full-path.patch | 18 + mozilla.sh.in | 143 + reproducible.patch | 63 + seamonkey-2.53.18.2.source-l10n.tar.xz | 3 + seamonkey-2.53.18.2.source.tar.xz | 3 + seamonkey-2.53.19.source-l10n.tar.xz | 3 + seamonkey-2.53.19.source.tar.xz | 3 + seamonkey-GNUmakefile | 190 + seamonkey-appdata.tar.bz2 | 3 + seamonkey-desktop.tar.bz2 | 3 + seamonkey-lto.patch | 12 + seamonkey-man-page.patch | 23 + seamonkey-rpmlintrc | 1 + seamonkey.changes | 4873 +++++ seamonkey.spec | 498 + spellcheck.js | 1 + suse-default-prefs.js | 14 + 24 files changed, 30861 insertions(+) create mode 100644 .gitattributes create mode 100644 .gitignore create mode 100644 _constraints create mode 100644 mozilla-bmo1862601.patch create mode 100644 mozilla-bmo1896958.patch create mode 100644 mozilla-bmo531915.patch create mode 100644 mozilla-nongnome-proxies.patch create mode 100644 mozilla-ntlm-full-path.patch create mode 100644 mozilla.sh.in create mode 100644 reproducible.patch create mode 100644 seamonkey-2.53.18.2.source-l10n.tar.xz create mode 100644 seamonkey-2.53.18.2.source.tar.xz create mode 100644 seamonkey-2.53.19.source-l10n.tar.xz create mode 100644 seamonkey-2.53.19.source.tar.xz create mode 100644 seamonkey-GNUmakefile create mode 100644 seamonkey-appdata.tar.bz2 create mode 100644 seamonkey-desktop.tar.bz2 create mode 100644 seamonkey-lto.patch create mode 100644 seamonkey-man-page.patch create mode 100644 seamonkey-rpmlintrc create mode 100644 seamonkey.changes create mode 100644 seamonkey.spec create mode 100644 spellcheck.js create mode 100644 suse-default-prefs.js diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..9b03811 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,23 @@ +## Default LFS +*.7z filter=lfs diff=lfs merge=lfs -text +*.bsp filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.gem filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.jar filter=lfs diff=lfs merge=lfs -text +*.lz filter=lfs diff=lfs merge=lfs -text +*.lzma filter=lfs diff=lfs merge=lfs -text +*.obscpio filter=lfs diff=lfs merge=lfs -text +*.oxt filter=lfs diff=lfs merge=lfs -text +*.pdf filter=lfs diff=lfs merge=lfs -text +*.png filter=lfs diff=lfs merge=lfs -text +*.rpm filter=lfs diff=lfs merge=lfs -text +*.tbz filter=lfs diff=lfs merge=lfs -text +*.tbz2 filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.ttf filter=lfs diff=lfs merge=lfs -text +*.txz filter=lfs diff=lfs merge=lfs -text +*.whl filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57affb6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.osc diff --git a/_constraints b/_constraints new file mode 100644 index 0000000..9818d2d --- /dev/null +++ b/_constraints @@ -0,0 +1,23 @@ + + + + + 25 + + + 16 + + + + + armv6l + armv7l + ppc64le + + + + 5 + + + + diff --git a/mozilla-bmo1862601.patch b/mozilla-bmo1862601.patch new file mode 100644 index 0000000..f0906d3 --- /dev/null +++ b/mozilla-bmo1862601.patch @@ -0,0 +1,16 @@ +--- a/intl/lwbrk/LineBreaker.cpp ++++ b/intl/lwbrk/LineBreaker.cpp +@@ -559,7 +559,12 @@ + /* REGIONAL_INDICATOR = 39, [RI] */ CLASS_CHARACTER, + /* E_BASE = 40, [EB] */ CLASS_BREAKABLE, + /* E_MODIFIER = 41, [EM] */ CLASS_CHARACTER, +- /* ZWJ = 42, [ZWJ]*/ CLASS_CHARACTER ++ /* ZWJ = 42, [ZWJ]*/ CLASS_CHARACTER, ++ /* AKSARA = 43, [AK] */ CLASS_CHARACTER, ++ /* AKSARA_PREBASE = 44, [AP] */ CLASS_CHARACTER, ++ /* AKSARA_START = 45, [AS] */ CLASS_CHARACTER, ++ /* VIRAMA_FINAL = 46, [VF] */ CLASS_CHARACTER, ++ /* VIRAMA = 47, [VI] */ CLASS_CHARACTER, + }; + + static_assert(U_LB_COUNT == mozilla::ArrayLength(sUnicodeLineBreakToClass), diff --git a/mozilla-bmo1896958.patch b/mozilla-bmo1896958.patch new file mode 100644 index 0000000..95552f2 --- /dev/null +++ b/mozilla-bmo1896958.patch @@ -0,0 +1,24886 @@ +# HG changeset patch +# User Henri Sivonen +# Date 1714462184 0 +# Node ID 1db2ef126a6a8555dbf50345e16492c977b42e92 +# Parent aa27b7d58885afb6f52ba9eddc930bc3e218c975 +Bug 1882209 - Update encoding_rs to 0.8.34 to deal with rustc changes. r=glandium,supply-chain-reviewers + +Differential Revision: https://phabricator.services.mozilla.com/D207167 + +diff --git a/.cargo/config.in b/.cargo/config.in +--- a/.cargo/config.in ++++ b/.cargo/config.in +@@ -2,17 +2,17 @@ + registry = 'https://github.com/rust-lang/crates.io-index' + replace-with = 'vendored-sources' + + [source."https://github.com/servo/serde"] + git = "https://github.com/servo/serde" + branch = "deserialize_from_enums6" + replace-with = "vendored-sources" + +-[source."https://github.com/hsivonen/packed_simd"] +-git = "https://github.com/hsivonen/packed_simd" ++[source."git+https://github.com/hsivonen/any_all_workaround?rev=7fb1b7034c9f172aade21ee1c8554e8d8a48af80"] ++git = "https://github.com/hsivonen/any_all_workaround" ++rev = "7fb1b7034c9f172aade21ee1c8554e8d8a48af80" + replace-with = "vendored-sources" +-rev = "e588ceb568878e1a3156ea9ce551d5b63ef0cdc4" + + [source.vendored-sources] + directory = '@top_srcdir@/third_party/rust' + + @WIN64_CARGO_LINKER_CONFIG@ +diff --git a/Cargo.lock b/Cargo.lock +--- a/Cargo.lock ++++ b/Cargo.lock +@@ -22,16 +22,25 @@ dependencies = [ + + [[package]] + name = "ansi_term" + version = "0.10.2" + source = "registry+https://github.com/rust-lang/crates.io-index" + checksum = "6b3568b48b7cefa6b8ce125f9bb4989e52fbcc29ebea88df04cc7c5f12f70455" + + [[package]] ++name = "any_all_workaround" ++version = "0.1.0" ++source = "git+https://github.com/hsivonen/any_all_workaround?rev=7fb1b7034c9f172aade21ee1c8554e8d8a48af80#7fb1b7034c9f172aade21ee1c8554e8d8a48af80" ++dependencies = [ ++ "cfg-if 1.0.0", ++ "version_check", ++] ++ ++[[package]] + name = "app_units" + version = "0.6.0" + source = "registry+https://github.com/rust-lang/crates.io-index" + checksum = "29069a9b483f7780aebb55dafb360c6225eefdc1f98c8d336a65148fd10c37b1" + dependencies = [ + "num-traits 0.1.43", + "serde", + ] +@@ -645,22 +654,22 @@ version = "0.1.0" + dependencies = [ + "encoding_rs", + "nserror", + "nsstring", + ] + + [[package]] + name = "encoding_rs" +-version = "0.8.33" ++version = "0.8.34" + source = "registry+https://github.com/rust-lang/crates.io-index" +-checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1" ++checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59" + dependencies = [ ++ "any_all_workaround", + "cfg-if 1.0.0", +- "packed_simd", + ] + + [[package]] + name = "env_logger" + version = "0.5.6" + source = "registry+https://github.com/rust-lang/crates.io-index" + checksum = "0561146661ae44c579e993456bc76d11ce1e0c7d745e57b2fa7146b6e49fa2ad" + dependencies = [ +@@ -1340,25 +1349,16 @@ name = "owning_ref" + version = "0.3.3" + source = "registry+https://github.com/rust-lang/crates.io-index" + checksum = "cdf84f41639e037b484f93433aa3897863b561ed65c6e59c7073d7c561710f37" + dependencies = [ + "stable_deref_trait", + ] + + [[package]] +-name = "packed_simd" +-version = "0.3.9" +-source = "git+https://github.com/hsivonen/packed_simd?rev=e588ceb568878e1a3156ea9ce551d5b63ef0cdc4#e588ceb568878e1a3156ea9ce551d5b63ef0cdc4" +-dependencies = [ +- "cfg-if 1.0.0", +- "num-traits 0.2.15", +-] +- +-[[package]] + name = "parking_lot" + version = "0.4.4" + source = "registry+https://github.com/rust-lang/crates.io-index" + checksum = "37f364e2ce5efa24c7d0b6646d5bb61145551a0112f107ffd7499f1a3e322fbd" + dependencies = [ + "owning_ref", + "parking_lot_core", + "thread-id", +@@ -2249,16 +2249,22 @@ checksum = "025ce40a007e1907e58d5bc1a594 + + [[package]] + name = "vec_map" + version = "0.8.0" + source = "registry+https://github.com/rust-lang/crates.io-index" + checksum = "887b5b631c2ad01628bbbaa7dd4c869f80d3186688f8d0b6f58774fbe324988c" + + [[package]] ++name = "version_check" ++version = "0.9.4" ++source = "registry+https://github.com/rust-lang/crates.io-index" ++checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" ++ ++[[package]] + name = "void" + version = "1.0.2" + source = "registry+https://github.com/rust-lang/crates.io-index" + checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d" + + [[package]] + name = "walkdir" + version = "1.0.7" +diff --git a/Cargo.toml b/Cargo.toml +--- a/Cargo.toml ++++ b/Cargo.toml +@@ -50,9 +50,9 @@ opt-level = 2 + rpath = false + debug-assertions = false + panic = "abort" + codegen-units = 1 + + [patch.crates-io] + libudev-sys = { path = "dom/webauthn/libudev-sys" } + serde_derive = { git = "https://github.com/servo/serde", branch = "deserialize_from_enums6" } +-packed_simd = { git = "https://github.com/hsivonen/packed_simd", rev = "e588ceb568878e1a3156ea9ce551d5b63ef0cdc4" } ++any_all_workaround = { git = "https://github.com/hsivonen/any_all_workaround", rev = "7fb1b7034c9f172aade21ee1c8554e8d8a48af80" } +diff --git a/config/makefiles/rust.mk b/config/makefiles/rust.mk +--- a/config/makefiles/rust.mk ++++ b/config/makefiles/rust.mk +@@ -68,17 +68,17 @@ endif + endif + endif + + ifndef RUSTC_BOOTSTRAP + ifeq (,$(filter 1.47.% 1.48.% 1.49.%,$(RUSTC_VERSION))) + # RUSTC_BOOTSTRAP := gkrust_shared,qcms for later + RUSTC_BOOTSTRAP := gkrust_shared + ifdef MOZ_RUST_SIMD +-RUSTC_BOOTSTRAP := $(RUSTC_BOOTSTRAP),encoding_rs,packed_simd ++RUSTC_BOOTSTRAP := $(RUSTC_BOOTSTRAP),encoding_rs,any_all_workaround + endif + export RUSTC_BOOTSTRAP + endif + endif + + ifdef CARGO_INCREMENTAL + export CARGO_INCREMENTAL + endif +diff --git a/third_party/rust/any_all_workaround/.cargo-checksum.json b/third_party/rust/any_all_workaround/.cargo-checksum.json +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/any_all_workaround/.cargo-checksum.json +@@ -0,0 +1,1 @@ ++{"files":{"Cargo.toml":"f8c127449dc9432d404c21c99833e4617ab88a797445af249a7fe3c989985d6d","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","LICENSE-MIT-QCMS":"36d847ae882f6574ebc72f56a4f354e4f104fde4a584373496482e97d52d31bc","README.md":"4c617b8ced3a27b7edecf0e5e41ed451c04e88dab529e7a35fccc4e1551efbd7","build.rs":"56b29ab6da3e49075bfd0a7b690267c8016298bf0d332e2e68bbaf19decbbf71","src/lib.rs":"7118106690b9d25c5d0a3e2079feb83d76f1d434d0da36b9d0351806d27c850d"},"package":null} +\ No newline at end of file +diff --git a/third_party/rust/any_all_workaround/Cargo.toml b/third_party/rust/any_all_workaround/Cargo.toml +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/any_all_workaround/Cargo.toml +@@ -0,0 +1,28 @@ ++# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO ++# ++# When uploading crates to the registry Cargo will automatically ++# "normalize" Cargo.toml files for maximal compatibility ++# with all versions of Cargo and also rewrite `path` dependencies ++# to registry (e.g., crates.io) dependencies. ++# ++# If you are reading this file be aware that the original Cargo.toml ++# will likely look very different (and much more reasonable). ++# See Cargo.toml.orig for the original contents. ++ ++[package] ++edition = "2021" ++name = "any_all_workaround" ++version = "0.1.0" ++authors = ["Henri Sivonen "] ++description = "Workaround for bad LLVM codegen for boolean reductions on 32-bit ARM" ++homepage = "https://docs.rs/any_all_workaround/" ++documentation = "https://docs.rs/any_all_workaround/" ++readme = "README.md" ++license = "MIT OR Apache-2.0" ++repository = "https://github.com/hsivonen/any_all_workaround" ++ ++[dependencies] ++cfg-if = "1.0" ++ ++[build-dependencies] ++version_check = "0.9" +diff --git a/third_party/rust/packed_simd/LICENSE-APACHE b/third_party/rust/any_all_workaround/LICENSE-APACHE +rename from third_party/rust/packed_simd/LICENSE-APACHE +rename to third_party/rust/any_all_workaround/LICENSE-APACHE +diff --git a/third_party/rust/packed_simd/LICENSE-MIT b/third_party/rust/any_all_workaround/LICENSE-MIT +rename from third_party/rust/packed_simd/LICENSE-MIT +rename to third_party/rust/any_all_workaround/LICENSE-MIT +diff --git a/third_party/rust/any_all_workaround/LICENSE-MIT-QCMS b/third_party/rust/any_all_workaround/LICENSE-MIT-QCMS +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/any_all_workaround/LICENSE-MIT-QCMS +@@ -0,0 +1,21 @@ ++qcms ++Copyright (C) 2009-2024 Mozilla Corporation ++Copyright (C) 1998-2007 Marti Maria ++ ++Permission is hereby granted, free of charge, to any person obtaining ++a copy of this software and associated documentation files (the "Software"), ++to deal in the Software without restriction, including without limitation ++the rights to use, copy, modify, merge, publish, distribute, sublicense, ++and/or sell copies of the Software, and to permit persons to whom the Software ++is furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ++EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ++THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ++NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE ++LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION ++OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION ++WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +diff --git a/third_party/rust/any_all_workaround/README.md b/third_party/rust/any_all_workaround/README.md +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/any_all_workaround/README.md +@@ -0,0 +1,13 @@ ++# any_all_workaround ++ ++This is a workaround for bad codegen ([Rust bug](https://github.com/rust-lang/portable-simd/issues/146), [LLVM bug](https://github.com/llvm/llvm-project/issues/50466)) for the `any()` and `all()` reductions for NEON-backed SIMD vectors on 32-bit ARM. On other platforms these delegate to `any()` and `all()` in `core::simd`. ++ ++The plan is to abandon this crate once the LLVM bug is fixed or `core::simd` works around the LLVM bug. ++ ++The code is forked from the [`packed_simd` crate](https://raw.githubusercontent.com/hsivonen/packed_simd/d938e39bee9bc5c222f5f2f2a0df9e53b5ce36ae/src/codegen/reductions/mask/arm.rs). ++ ++This crate requires Nightly Rust as it depends on the `portable_simd` feature. ++ ++# License ++ ++`MIT OR Apache-2.0`, since that's how `packed_simd` is licensed. (The ARM intrinsics Rust version workaround is from qcms, see LICENSE-MIT-QCMS.) +diff --git a/third_party/rust/any_all_workaround/build.rs b/third_party/rust/any_all_workaround/build.rs +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/any_all_workaround/build.rs +@@ -0,0 +1,7 @@ ++extern crate version_check as rustc; ++ ++fn main() { ++ if rustc::is_min_version("1.78.0").unwrap_or(false) { ++ println!("cargo:rustc-cfg=stdsimd_split"); ++ } ++} +diff --git a/third_party/rust/any_all_workaround/src/lib.rs b/third_party/rust/any_all_workaround/src/lib.rs +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/any_all_workaround/src/lib.rs +@@ -0,0 +1,110 @@ ++// This code began as a fork of ++// https://raw.githubusercontent.com/rust-lang/packed_simd/d938e39bee9bc5c222f5f2f2a0df9e53b5ce36ae/src/codegen/reductions/mask/arm.rs ++// which didn't have a license header on the file, but Cargo.toml said "MIT OR Apache-2.0". ++// See LICENSE-MIT and LICENSE-APACHE. ++ ++#![no_std] ++#![feature(portable_simd)] ++#![cfg_attr( ++ all( ++ stdsimd_split, ++ target_arch = "arm", ++ target_endian = "little", ++ target_feature = "neon", ++ target_feature = "v7" ++ ), ++ feature(stdarch_arm_neon_intrinsics) ++)] ++#![cfg_attr( ++ all( ++ not(stdsimd_split), ++ target_arch = "arm", ++ target_endian = "little", ++ target_feature = "neon", ++ target_feature = "v7" ++ ), ++ feature(stdsimd) ++)] ++ ++use cfg_if::cfg_if; ++use core::simd::mask16x8; ++use core::simd::mask32x4; ++use core::simd::mask8x16; ++ ++cfg_if! { ++ if #[cfg(all(target_arch = "arm", target_endian = "little", target_feature = "neon", target_feature = "v7"))] { ++ use core::simd::mask8x8; ++ use core::simd::mask16x4; ++ use core::simd::mask32x2; ++ macro_rules! arm_128_v7_neon_impl { ++ ($all:ident, $any:ident, $id:ident, $half:ident, $vpmin:ident, $vpmax:ident) => { ++ #[inline] ++ pub fn $all(s: $id) -> bool { ++ use core::arch::arm::$vpmin; ++ use core::mem::transmute; ++ unsafe { ++ union U { ++ halves: ($half, $half), ++ vec: $id, ++ } ++ let halves = U { vec: s }.halves; ++ let h: $half = transmute($vpmin(transmute(halves.0), transmute(halves.1))); ++ h.all() ++ } ++ } ++ #[inline] ++ pub fn $any(s: $id) -> bool { ++ use core::arch::arm::$vpmax; ++ use core::mem::transmute; ++ unsafe { ++ union U { ++ halves: ($half, $half), ++ vec: $id, ++ } ++ let halves = U { vec: s }.halves; ++ let h: $half = transmute($vpmax(transmute(halves.0), transmute(halves.1))); ++ h.any() ++ } ++ } ++ } ++ } ++ } else { ++ macro_rules! arm_128_v7_neon_impl { ++ ($all:ident, $any:ident, $id:ident, $half:ident, $vpmin:ident, $vpmax:ident) => { ++ #[inline(always)] ++ pub fn $all(s: $id) -> bool { ++ s.all() ++ } ++ #[inline(always)] ++ pub fn $any(s: $id) -> bool { ++ s.any() ++ } ++ } ++ } ++ } ++} ++ ++arm_128_v7_neon_impl!( ++ all_mask8x16, ++ any_mask8x16, ++ mask8x16, ++ mask8x8, ++ vpmin_u8, ++ vpmax_u8 ++); ++arm_128_v7_neon_impl!( ++ all_mask16x8, ++ any_mask16x8, ++ mask16x8, ++ mask16x4, ++ vpmin_u16, ++ vpmax_u16 ++); ++arm_128_v7_neon_impl!( ++ all_mask32x4, ++ any_mask32x4, ++ mask32x4, ++ mask32x2, ++ vpmin_u32, ++ vpmax_u32 ++); +diff --git a/third_party/rust/encoding_rs/.cargo-checksum.json b/third_party/rust/encoding_rs/.cargo-checksum.json +--- a/third_party/rust/encoding_rs/.cargo-checksum.json ++++ b/third_party/rust/encoding_rs/.cargo-checksum.json +@@ -1,1 +1,1 @@ +-{"files":{"CONTRIBUTING.md":"ca1901f3e8532fb4cec894fd3664f0eaa898c0c4b961d1b992d1ed54eacf362a","COPYRIGHT":"11789f45bb180841cd362a5eee6789c68ddb573a11105e30768c308a6add0190","Cargo.toml":"42fa83322aa9fd6723b77d35d0cacb92cbb6e7f573ce11c55f5225292866f8f4","Ideas.md":"b7452893f500163868d8de52c09addaf91e1632454ed02e892c467ed7ec39dbd","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"3fa4ca83dcc9237839b1bdeb2e6d16bdfb5ec0c5ce42b24694d8bbf0dcbef72c","LICENSE-WHATWG":"838118388fe5c2e7f1dbbaeed13e1c7f3ebf88be91319c7c1d77c18e987d1a50","README.md":"d938e8ab0b9ab67e74a1a4f48f23fdce956d0ad3a3f6147ae7612a92763c88d5","ci/miri.sh":"43cb8d82f49e3bfe2d2274b6ccd6f0714a4188ccef0cecc040829883cfdbee25","doc/Big5.txt":"f73a2edc5cb6c2d140ba6e07f4542e1c4a234950378acde1df93480f0ca0be0b","doc/EUC-JP.txt":"ee2818b907d0137f40a9ab9fd525fc700a44dbdddb6cf0c157a656566bae4bf1","doc/EUC-KR.txt":"71d9e2ccf3b124e8bdfb433c8cf2773fd878077038d0cec3c7237a50f4a78a30","doc/GBK.txt":"c1b522b5a799884e5001da661f42c5a8f4d0acb9ef1d74b206f22b5f65365606","doc/IBM866.txt":"a5a433e804d0f83af785015179fbc1d9b0eaf1f7960efcd04093e136b51fbd0e","doc/ISO-2022-JP.txt":"af86684f5a8f0e2868d7b2c292860140c3d2e5527530ca091f1b28198e8e2fe6","doc/ISO-8859-10.txt":"6d3949ad7c81ca176895101ed81a1db7df1060d64e262880b94bd31bb344ab4d","doc/ISO-8859-13.txt":"3951dd89cf93f7729148091683cf8511f4529388b7dc8dcd0d62eaed55be93fa","doc/ISO-8859-14.txt":"3d330784a0374fd255a38b47949675cc7168c800530534b0a01cac6edc623adc","doc/ISO-8859-15.txt":"24b1084aab5127a85aab99153f86e24694d0a3615f53b5ce23683f97cf66c47a","doc/ISO-8859-16.txt":"ce0272559b92ba76d7a7e476f6424ae4a5cc72e75b183611b08392e44add4d25","doc/ISO-8859-2.txt":"18ceff88c13d1b5ba455a3919b1e3de489045c4c3d2dd7e8527c125c75d54aad","doc/ISO-8859-3.txt":"21798404c68f4f5db59223362f24999da96968c0628427321fccce7d2849a130","doc/ISO-8859-4.txt":"d27f6520c6c5bfbcc19176b71d081cdb3bccde1622bb3e420d5680e812632d53","doc/ISO-8859-5.txt":"a10ec8d6ea7a78ad15da7275f6cb1a3365118527e28f9af6d0d5830501303f3a","doc/ISO-8859-6.txt":"ccda8a2efc96115336bdd77776637b9712425e44fbcf745353b9057fbef144e7","doc/ISO-8859-7.txt":"17900fa1f27a445958f0a77d7d9056be375a6bd7ee4492aa680c7c1500bab85e","doc/ISO-8859-8-I.txt":"8357555646d54265a9b9ffa3e68b08d132312f1561c60108ff9b8b1167b6ecf2","doc/ISO-8859-8.txt":"72cd6f3afb7b4a9c16a66a362473315770b7755d72c86c870e52fc3eba86c8af","doc/KOI8-R.txt":"839cf19a38da994488004ed7814b1f6151640156a9a2af02bf2efca745fb5966","doc/KOI8-U.txt":"0cc76624ed1f024183e2298b7e019957da2c70c8ca06e0fc4e6f353f50a5054f","doc/Shift_JIS.txt":"34c49141818cb9ddbcf59cc858f78a79be8ad148d563f26415108ae1f148443f","doc/UTF-16BE.txt":"e2e280d8acbaa6d2a6b3569d60e17500a285f2baa0df3363dd85537cd5a1ef8f","doc/UTF-16LE.txt":"70bdc170e3fc5298ba68f10125fb5eeb8b077036cc96bb4416c4de396f6d76c1","doc/UTF-8.txt":"ea7bae742e613010ced002cf4b601a737d2203fad65e115611451bc4428f548a","doc/gb18030.txt":"dc71378a8f07a2d8659f69ee81fb8791fef56ba86f124b429978285237bb4a7b","doc/macintosh.txt":"57491e53866711b4672d9b9ff35380b9dac9e0d8e3d6c20bdd6140603687c023","doc/replacement.txt":"4b6c3bbd7999d9d4108a281594bd02d13607e334a95465afff8c2c08d395f0e4","doc/windows-1250.txt":"61296bb6a21cdab602300d32ecfba434cb82de5ac3bc88d58710d2f125e28d39","doc/windows-1251.txt":"7deea1c61dea1485c8ff02db2c7d578db7a9aab63ab1cfd02ec04b515864689e","doc/windows-1252.txt":"933ef3bdddfce5ee132b9f1a1aa8b47423d2587bbe475b19028d0a6d38e180b6","doc/windows-1253.txt":"1a38748b88e99071a5c7b3d5456ead4caedeabab50d50d658be105bc113714de","doc/windows-1254.txt":"f8372f86c6f8d642563cd6ddc025260553292a39423df1683a98670bd7bf2b47","doc/windows-1255.txt":"4e5852494730054e2da258a74e1b9d780abbcdd8ce22ebc218ca2efe9e90493d","doc/windows-1256.txt":"c0879c5172abedead302a406e8f60d9cd9598694a0ffa4fd288ffe4fef7b8ea1","doc/windows-1257.txt":"c28a0c9f964fcb2b46d21f537c402446501a2800670481d6abf9fd9e9018d523","doc/windows-1258.txt":"5019ae4d61805c79aacbf17c93793342dbb098d65a1837783bc3e2c6d6a23602","doc/windows-874.txt":"4ef0e4501c5feba8b17aee1818602ed44b36ca8475db771ce2fc16d392cabecc","doc/x-mac-cyrillic.txt":"58be154d8a888ca3d484b83b44f749823ef339ab27f14d90ca9a856f5050a8bd","doc/x-user-defined.txt":"f9cd07c4321bf5cfb0be4bdddd251072999b04a6cf7a6f5bc63709a84e2c1ffc","generate-encoding-data.py":"be989dd25c6b946e3e8745fdc8e8a80fcf24b3be99ad0b4b78153ba3f6ab6310","rustfmt.toml":"85c1a3b4382fd89e991cbb81b70fb52780472edc064c963943cdaaa56e0a2030","src/ascii.rs":"c44c002641adb5ebc4368707a8cc0a076d2f33e6a5c27b1b69988eb515f5653d","src/big5.rs":"ec6e2913011a38e9a3e825a1731f139a7ca1d5b264fefae51a3cc1a68a57cef9","src/data.rs":"8a617cc57032092d65850eb27e00de687c80aea3299e839a1f58b42d0b35abf3","src/euc_jp.rs":"32047f5b540188c4cb19c07165f846b9786a09f18e315ed3e9bda1293dae52aa","src/euc_kr.rs":"9b25afc72d9378700eecfac58d55ad1c5946d6cd0ccde2c29c08200ef2de6bb9","src/gb18030.rs":"808587168d73f0c80f8520f0ca9b161866ed2efeb17a05e85fdf3b8efe7ba28a","src/handles.rs":"cc83dc0754751d67f5688a65c5e0191cba02f6bacce81a0813a243cba55eef7a","src/iso_2022_jp.rs":"9bb485e82574f4b7d4b2364f0ff276acb6a0bc111758420a3b0ec5e04c196652","src/lib.rs":"1dc07b818e45846b16ddcaf0de46c8862dd7df8099123ec38b95c3f8ad9c91ec","src/macros.rs":"200997f8870de8bfd8cdc475e92115df42108c0df661e49d3d1cbc32056e1d99","src/mem.rs":"0bf34103e0ad1b842a13a082dee2b920b05cf4fb0f145c9ee7f608f4cb4a544f","src/replacement.rs":"7660b34a53f8c1ca2bdfa0e51e843ec28326950952ad8bc96569feb93ac62308","src/shift_jis.rs":"6951ae67e36b1a12fa3a30734957f444d8b1b4ae0e2bde52060b29bd0f16d9d9","src/simd_funcs.rs":"2612aba86e1d201096d7e47a859bc3444f85934cc82d8adc6d39a4304d9eecfc","src/single_byte.rs":"3c9e9c1f946ae622c725ba9421240c1faa9a05e95fa10dd4642a25cb276a1edc","src/test_data/big5_in.txt":"4c5a8691f8dc717311889c63894026d2fb62725a86c4208ca274a9cc8d42a503","src/test_data/big5_in_ref.txt":"99d399e17750cf9c7cf30bb253dbfe35b81c4fcbdead93cfa48b1429213473c7","src/test_data/big5_out.txt":"6193ca97c297aa20e09396038d18e938bb7ea331c26f0f2454097296723a0b13","src/test_data/big5_out_ref.txt":"36567691f557df144f6cc520015a87038dfa156f296fcf103b56ae9a718be1fc","src/test_data/euc_kr_in.txt":"c86a7224f3215fa0d04e685622a752fdc72763e8ae076230c7fd62de57ec4074","src/test_data/euc_kr_in_ref.txt":"1f419f4ca47d708b54c73c461545a022ae2e20498fdbf8005a483d752a204883","src/test_data/euc_kr_out.txt":"e7f32e026f70be1e1b58e0047baf7d3d2c520269c4f9b9992e158b4decb0a1a3","src/test_data/euc_kr_out_ref.txt":"c9907857980b20b8e9e3b584482ed6567a2be6185d72237b6322f0404944924e","src/test_data/gb18030_in.txt":"ab7231b2d3e9afacdbd7d7f3b9e5361a7ff9f7e1cfdb4f3bd905b9362b309e53","src/test_data/gb18030_in_ref.txt":"dc5069421adca2043c55f5012b55a76fdff651d22e6e699fd0978f8d5706815c","src/test_data/gb18030_out.txt":"f0208d527f5ca63de7d9a0323be8d5cf12d8a104b2943d92c2701f0c3364dac1","src/test_data/gb18030_out_ref.txt":"6819fe47627e4ea01027003fc514b9f21a1322e732d7f1fb92cc6c5455bc6c07","src/test_data/iso_2022_jp_in.txt":"cd24bbdcb1834e25db54646fbf4c41560a13dc7540f6be3dba4f5d97d44513af","src/test_data/iso_2022_jp_in_ref.txt":"3dc4e6a5e06471942d086b16c9440945e78415f6f3f47e43717e4bc2eac2cdf5","src/test_data/iso_2022_jp_out.txt":"9b6f015329dda6c3f9ee5ce6dbd6fa9c89acc21283e886836c78b8d833480c21","src/test_data/iso_2022_jp_out_ref.txt":"78cb260093a20116ad9a42f43b05d1848c5ab100b6b9a850749809e943884b35","src/test_data/jis0208_in.txt":"6df3030553ffb0a6615bb33dc8ea9dca6d9623a9028e2ffec754ce3c3da824cc","src/test_data/jis0208_in_ref.txt":"3dc4e6a5e06471942d086b16c9440945e78415f6f3f47e43717e4bc2eac2cdf5","src/test_data/jis0208_out.txt":"4ec24477e1675ce750733bdc3c5add1cd27b6bd4ce1f09289564646e9654e857","src/test_data/jis0208_out_ref.txt":"c3e1cef5032b2b1d93a406f31ff940c4e2dfe8859b8b17ca2761fee7a75a0e48","src/test_data/jis0212_in.txt":"c011f0dd72bd7c8cd922df9374ef8d2769a77190514c77f6c62b415852eeb9fe","src/test_data/jis0212_in_ref.txt":"7d9458b3d2f73e7092a7f505c08ce1d233dde18aa679fbcf9889256239cc9e06","src/test_data/shift_jis_in.txt":"02e389ccef0dd2122e63f503899402cb7f797912c2444cc80ab93131116c5524","src/test_data/shift_jis_in_ref.txt":"512f985950ca902e643c88682dba9708b7c38d3c5ec2925168ab00ac94ab19f9","src/test_data/shift_jis_out.txt":"5fbc44da7bf639bf6cfe0fa1fd3eba7102b88f81919c9ea991302712f69426fb","src/test_data/shift_jis_out_ref.txt":"466322c6fed8286c64582731755290c2296508efdd258826e6279686649b481f","src/test_labels_names.rs":"23a2e11b02b3b8d15fb5613a625e3edb2c61e70e3c581abfd638719a4088200d","src/testing.rs":"f59e671e95a98a56f6b573e8c6be4d71e670bf52f7e20eb1605d990aafa1894e","src/utf_16.rs":"c071a147fad38d750c2c247e141b76b929a48007b99f26b2922b9caecdaf2f25","src/utf_8.rs":"7b7d887b347f1aefa03246b028a36a72758a4ce76c28f3b45c19467851aa7839","src/variant.rs":"1fab5363588a1554a7169de8731ea9cded7ac63ea35caabdd1c27a8dde68c27b","src/x_user_defined.rs":"c9c010730dfb9f141d4fed19350c08a21af240913a54bb64f5ca89ff93b6b7d1"},"package":"7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"} +\ No newline at end of file ++{"files":{"CONTRIBUTING.md":"ca1901f3e8532fb4cec894fd3664f0eaa898c0c4b961d1b992d1ed54eacf362a","COPYRIGHT":"11789f45bb180841cd362a5eee6789c68ddb573a11105e30768c308a6add0190","Cargo.toml":"22a4d210c92dae9f32c6944ef340ee8fdd027f99c081577e8907123e2a93383e","Ideas.md":"b7452893f500163868d8de52c09addaf91e1632454ed02e892c467ed7ec39dbd","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"3fa4ca83dcc9237839b1bdeb2e6d16bdfb5ec0c5ce42b24694d8bbf0dcbef72c","LICENSE-WHATWG":"838118388fe5c2e7f1dbbaeed13e1c7f3ebf88be91319c7c1d77c18e987d1a50","README.md":"1d08aefcb92afa81b18154049c9abbcad4540a23f7172e9f9bbed5af33f1a087","ci/miri.sh":"43cb8d82f49e3bfe2d2274b6ccd6f0714a4188ccef0cecc040829883cfdbee25","doc/Big5.txt":"f73a2edc5cb6c2d140ba6e07f4542e1c4a234950378acde1df93480f0ca0be0b","doc/EUC-JP.txt":"ee2818b907d0137f40a9ab9fd525fc700a44dbdddb6cf0c157a656566bae4bf1","doc/EUC-KR.txt":"71d9e2ccf3b124e8bdfb433c8cf2773fd878077038d0cec3c7237a50f4a78a30","doc/GBK.txt":"c1b522b5a799884e5001da661f42c5a8f4d0acb9ef1d74b206f22b5f65365606","doc/IBM866.txt":"a5a433e804d0f83af785015179fbc1d9b0eaf1f7960efcd04093e136b51fbd0e","doc/ISO-2022-JP.txt":"af86684f5a8f0e2868d7b2c292860140c3d2e5527530ca091f1b28198e8e2fe6","doc/ISO-8859-10.txt":"6d3949ad7c81ca176895101ed81a1db7df1060d64e262880b94bd31bb344ab4d","doc/ISO-8859-13.txt":"3951dd89cf93f7729148091683cf8511f4529388b7dc8dcd0d62eaed55be93fa","doc/ISO-8859-14.txt":"3d330784a0374fd255a38b47949675cc7168c800530534b0a01cac6edc623adc","doc/ISO-8859-15.txt":"24b1084aab5127a85aab99153f86e24694d0a3615f53b5ce23683f97cf66c47a","doc/ISO-8859-16.txt":"ce0272559b92ba76d7a7e476f6424ae4a5cc72e75b183611b08392e44add4d25","doc/ISO-8859-2.txt":"18ceff88c13d1b5ba455a3919b1e3de489045c4c3d2dd7e8527c125c75d54aad","doc/ISO-8859-3.txt":"21798404c68f4f5db59223362f24999da96968c0628427321fccce7d2849a130","doc/ISO-8859-4.txt":"d27f6520c6c5bfbcc19176b71d081cdb3bccde1622bb3e420d5680e812632d53","doc/ISO-8859-5.txt":"a10ec8d6ea7a78ad15da7275f6cb1a3365118527e28f9af6d0d5830501303f3a","doc/ISO-8859-6.txt":"ccda8a2efc96115336bdd77776637b9712425e44fbcf745353b9057fbef144e7","doc/ISO-8859-7.txt":"17900fa1f27a445958f0a77d7d9056be375a6bd7ee4492aa680c7c1500bab85e","doc/ISO-8859-8-I.txt":"8357555646d54265a9b9ffa3e68b08d132312f1561c60108ff9b8b1167b6ecf2","doc/ISO-8859-8.txt":"72cd6f3afb7b4a9c16a66a362473315770b7755d72c86c870e52fc3eba86c8af","doc/KOI8-R.txt":"839cf19a38da994488004ed7814b1f6151640156a9a2af02bf2efca745fb5966","doc/KOI8-U.txt":"0cc76624ed1f024183e2298b7e019957da2c70c8ca06e0fc4e6f353f50a5054f","doc/Shift_JIS.txt":"34c49141818cb9ddbcf59cc858f78a79be8ad148d563f26415108ae1f148443f","doc/UTF-16BE.txt":"e2e280d8acbaa6d2a6b3569d60e17500a285f2baa0df3363dd85537cd5a1ef8f","doc/UTF-16LE.txt":"70bdc170e3fc5298ba68f10125fb5eeb8b077036cc96bb4416c4de396f6d76c1","doc/UTF-8.txt":"ea7bae742e613010ced002cf4b601a737d2203fad65e115611451bc4428f548a","doc/gb18030.txt":"dc71378a8f07a2d8659f69ee81fb8791fef56ba86f124b429978285237bb4a7b","doc/macintosh.txt":"57491e53866711b4672d9b9ff35380b9dac9e0d8e3d6c20bdd6140603687c023","doc/replacement.txt":"4b6c3bbd7999d9d4108a281594bd02d13607e334a95465afff8c2c08d395f0e4","doc/windows-1250.txt":"61296bb6a21cdab602300d32ecfba434cb82de5ac3bc88d58710d2f125e28d39","doc/windows-1251.txt":"7deea1c61dea1485c8ff02db2c7d578db7a9aab63ab1cfd02ec04b515864689e","doc/windows-1252.txt":"933ef3bdddfce5ee132b9f1a1aa8b47423d2587bbe475b19028d0a6d38e180b6","doc/windows-1253.txt":"1a38748b88e99071a5c7b3d5456ead4caedeabab50d50d658be105bc113714de","doc/windows-1254.txt":"f8372f86c6f8d642563cd6ddc025260553292a39423df1683a98670bd7bf2b47","doc/windows-1255.txt":"4e5852494730054e2da258a74e1b9d780abbcdd8ce22ebc218ca2efe9e90493d","doc/windows-1256.txt":"c0879c5172abedead302a406e8f60d9cd9598694a0ffa4fd288ffe4fef7b8ea1","doc/windows-1257.txt":"c28a0c9f964fcb2b46d21f537c402446501a2800670481d6abf9fd9e9018d523","doc/windows-1258.txt":"5019ae4d61805c79aacbf17c93793342dbb098d65a1837783bc3e2c6d6a23602","doc/windows-874.txt":"4ef0e4501c5feba8b17aee1818602ed44b36ca8475db771ce2fc16d392cabecc","doc/x-mac-cyrillic.txt":"58be154d8a888ca3d484b83b44f749823ef339ab27f14d90ca9a856f5050a8bd","doc/x-user-defined.txt":"f9cd07c4321bf5cfb0be4bdddd251072999b04a6cf7a6f5bc63709a84e2c1ffc","generate-encoding-data.py":"be989dd25c6b946e3e8745fdc8e8a80fcf24b3be99ad0b4b78153ba3f6ab6310","rustfmt.toml":"85c1a3b4382fd89e991cbb81b70fb52780472edc064c963943cdaaa56e0a2030","src/ascii.rs":"588e38b01e666d5e7462617ea7e90a108d608dec9e016f3d273ac0744af2e05d","src/big5.rs":"ec6e2913011a38e9a3e825a1731f139a7ca1d5b264fefae51a3cc1a68a57cef9","src/data.rs":"8a617cc57032092d65850eb27e00de687c80aea3299e839a1f58b42d0b35abf3","src/euc_jp.rs":"32047f5b540188c4cb19c07165f846b9786a09f18e315ed3e9bda1293dae52aa","src/euc_kr.rs":"9b25afc72d9378700eecfac58d55ad1c5946d6cd0ccde2c29c08200ef2de6bb9","src/gb18030.rs":"808587168d73f0c80f8520f0ca9b161866ed2efeb17a05e85fdf3b8efe7ba28a","src/handles.rs":"b08cef1f5785bb6a4822f2e844c6df1b046b737b7a075e4593eaa8c4208e9fe2","src/iso_2022_jp.rs":"9bb485e82574f4b7d4b2364f0ff276acb6a0bc111758420a3b0ec5e04c196652","src/lib.rs":"834f44b670ec48ee82c0e12223d1567313fdd9f88bca5f4b117c82c1828f559f","src/macros.rs":"200997f8870de8bfd8cdc475e92115df42108c0df661e49d3d1cbc32056e1d99","src/mem.rs":"948571137d3b151df8db4fb2c733e74ae595d055cdf0ad83abcab9341d6adabe","src/replacement.rs":"7660b34a53f8c1ca2bdfa0e51e843ec28326950952ad8bc96569feb93ac62308","src/shift_jis.rs":"6951ae67e36b1a12fa3a30734957f444d8b1b4ae0e2bde52060b29bd0f16d9d9","src/simd_funcs.rs":"05c6e77af74bfe73cd39a752067c11425d6b46e5da419910f54bf75a5c02a984","src/single_byte.rs":"3ad87116fb339434a4b58e8f2b15485f2b66b9f7814d708f16194ed08f6d6ccf","src/test_data/big5_in.txt":"4c5a8691f8dc717311889c63894026d2fb62725a86c4208ca274a9cc8d42a503","src/test_data/big5_in_ref.txt":"99d399e17750cf9c7cf30bb253dbfe35b81c4fcbdead93cfa48b1429213473c7","src/test_data/big5_out.txt":"6193ca97c297aa20e09396038d18e938bb7ea331c26f0f2454097296723a0b13","src/test_data/big5_out_ref.txt":"36567691f557df144f6cc520015a87038dfa156f296fcf103b56ae9a718be1fc","src/test_data/euc_kr_in.txt":"c86a7224f3215fa0d04e685622a752fdc72763e8ae076230c7fd62de57ec4074","src/test_data/euc_kr_in_ref.txt":"1f419f4ca47d708b54c73c461545a022ae2e20498fdbf8005a483d752a204883","src/test_data/euc_kr_out.txt":"e7f32e026f70be1e1b58e0047baf7d3d2c520269c4f9b9992e158b4decb0a1a3","src/test_data/euc_kr_out_ref.txt":"c9907857980b20b8e9e3b584482ed6567a2be6185d72237b6322f0404944924e","src/test_data/gb18030_in.txt":"ab7231b2d3e9afacdbd7d7f3b9e5361a7ff9f7e1cfdb4f3bd905b9362b309e53","src/test_data/gb18030_in_ref.txt":"dc5069421adca2043c55f5012b55a76fdff651d22e6e699fd0978f8d5706815c","src/test_data/gb18030_out.txt":"f0208d527f5ca63de7d9a0323be8d5cf12d8a104b2943d92c2701f0c3364dac1","src/test_data/gb18030_out_ref.txt":"6819fe47627e4ea01027003fc514b9f21a1322e732d7f1fb92cc6c5455bc6c07","src/test_data/iso_2022_jp_in.txt":"cd24bbdcb1834e25db54646fbf4c41560a13dc7540f6be3dba4f5d97d44513af","src/test_data/iso_2022_jp_in_ref.txt":"3dc4e6a5e06471942d086b16c9440945e78415f6f3f47e43717e4bc2eac2cdf5","src/test_data/iso_2022_jp_out.txt":"9b6f015329dda6c3f9ee5ce6dbd6fa9c89acc21283e886836c78b8d833480c21","src/test_data/iso_2022_jp_out_ref.txt":"78cb260093a20116ad9a42f43b05d1848c5ab100b6b9a850749809e943884b35","src/test_data/jis0208_in.txt":"6df3030553ffb0a6615bb33dc8ea9dca6d9623a9028e2ffec754ce3c3da824cc","src/test_data/jis0208_in_ref.txt":"3dc4e6a5e06471942d086b16c9440945e78415f6f3f47e43717e4bc2eac2cdf5","src/test_data/jis0208_out.txt":"4ec24477e1675ce750733bdc3c5add1cd27b6bd4ce1f09289564646e9654e857","src/test_data/jis0208_out_ref.txt":"c3e1cef5032b2b1d93a406f31ff940c4e2dfe8859b8b17ca2761fee7a75a0e48","src/test_data/jis0212_in.txt":"c011f0dd72bd7c8cd922df9374ef8d2769a77190514c77f6c62b415852eeb9fe","src/test_data/jis0212_in_ref.txt":"7d9458b3d2f73e7092a7f505c08ce1d233dde18aa679fbcf9889256239cc9e06","src/test_data/shift_jis_in.txt":"02e389ccef0dd2122e63f503899402cb7f797912c2444cc80ab93131116c5524","src/test_data/shift_jis_in_ref.txt":"512f985950ca902e643c88682dba9708b7c38d3c5ec2925168ab00ac94ab19f9","src/test_data/shift_jis_out.txt":"5fbc44da7bf639bf6cfe0fa1fd3eba7102b88f81919c9ea991302712f69426fb","src/test_data/shift_jis_out_ref.txt":"466322c6fed8286c64582731755290c2296508efdd258826e6279686649b481f","src/test_labels_names.rs":"23a2e11b02b3b8d15fb5613a625e3edb2c61e70e3c581abfd638719a4088200d","src/testing.rs":"f59e671e95a98a56f6b573e8c6be4d71e670bf52f7e20eb1605d990aafa1894e","src/utf_16.rs":"c071a147fad38d750c2c247e141b76b929a48007b99f26b2922b9caecdaf2f25","src/utf_8.rs":"7b7d887b347f1aefa03246b028a36a72758a4ce76c28f3b45c19467851aa7839","src/variant.rs":"1fab5363588a1554a7169de8731ea9cded7ac63ea35caabdd1c27a8dde68c27b","src/x_user_defined.rs":"9456ca46168ef86c98399a2536f577ef7be3cdde90c0c51392d8ac48519d3fae"},"package":"b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"} +\ No newline at end of file +diff --git a/third_party/rust/encoding_rs/Cargo.toml b/third_party/rust/encoding_rs/Cargo.toml +--- a/third_party/rust/encoding_rs/Cargo.toml ++++ b/third_party/rust/encoding_rs/Cargo.toml +@@ -6,18 +6,19 @@ + # to registry (e.g., crates.io) dependencies. + # + # If you are reading this file be aware that the original Cargo.toml + # will likely look very different (and much more reasonable). + # See Cargo.toml.orig for the original contents. + + [package] + edition = "2018" ++rust-version = "1.36" + name = "encoding_rs" +-version = "0.8.33" ++version = "0.8.34" + authors = ["Henri Sivonen "] + description = "A Gecko-oriented implementation of the Encoding Standard" + homepage = "https://docs.rs/encoding_rs/" + documentation = "https://docs.rs/encoding_rs/" + readme = "README.md" + keywords = [ + "encoding", + "web", +@@ -31,23 +32,23 @@ categories = [ + "internationalization", + ] + license = "(Apache-2.0 OR MIT) AND BSD-3-Clause" + repository = "https://github.com/hsivonen/encoding_rs" + + [profile.release] + lto = true + ++[dependencies.any_all_workaround] ++version = "0.1.0" ++optional = true ++ + [dependencies.cfg-if] + version = "1.0" + +-[dependencies.packed_simd] +-version = "0.3.9" +-optional = true +- + [dependencies.serde] + version = "1.0" + optional = true + + [dev-dependencies.bincode] + version = "1.0" + + [dev-dependencies.serde_derive] +@@ -69,15 +70,9 @@ fast-legacy-encode = [ + "fast-hanja-encode", + "fast-kanji-encode", + "fast-gb-hanzi-encode", + "fast-big5-hanzi-encode", + ] + less-slow-big5-hanzi-encode = [] + less-slow-gb-hanzi-encode = [] + less-slow-kanji-encode = [] +-simd-accel = [ +- "packed_simd", +- "packed_simd/into_bits", +-] +- +-[badges.travis-ci] +-repository = "hsivonen/encoding_rs" ++simd-accel = ["any_all_workaround"] +diff --git a/third_party/rust/encoding_rs/README.md b/third_party/rust/encoding_rs/README.md +--- a/third_party/rust/encoding_rs/README.md ++++ b/third_party/rust/encoding_rs/README.md +@@ -162,50 +162,36 @@ wrappers. + * [C++](https://github.com/hsivonen/recode_cpp) + + ## Optional features + + There are currently these optional cargo features: + + ### `simd-accel` + +-Enables SIMD acceleration using the nightly-dependent `packed_simd` crate. ++Enables SIMD acceleration using the nightly-dependent `portable_simd` standard ++library feature. + + This is an opt-in feature, because enabling this feature _opts out_ of Rust's + guarantees of future compilers compiling old code (aka. "stability story"). + + Currently, this has not been tested to be an improvement except for these +-targets: ++targets and enabling the `simd-accel` feature is expected to break the build ++on other targets: + + * x86_64 + * i686 + * aarch64 + * thumbv7neon + + If you use nightly Rust, you use targets whose first component is one of the + above, and you are prepared _to have to revise your configuration when updating + Rust_, you should enable this feature. Otherwise, please _do not_ enable this + feature. + +-_Note!_ If you are compiling for a target that does not have 128-bit SIMD +-enabled as part of the target definition and you are enabling 128-bit SIMD +-using `-C target_feature`, you need to enable the `core_arch` Cargo feature +-for `packed_simd` to compile a crates.io snapshot of `core_arch` instead of +-using the standard-library copy of `core::arch`, because the `core::arch` +-module of the pre-compiled standard library has been compiled with the +-assumption that the CPU doesn't have 128-bit SIMD. At present this applies +-mainly to 32-bit ARM targets whose first component does not include the +-substring `neon`. +- +-The encoding_rs side of things has not been properly set up for POWER, +-PowerPC, MIPS, etc., SIMD at this time, so even if you were to follow +-the advice from the previous paragraph, you probably shouldn't use +-the `simd-accel` option on the less mainstream architectures at this +-time. +- + Used by Firefox. + + ### `serde` + + Enables support for serializing and deserializing `&'static Encoding`-typed + struct fields using [Serde][1]. + + [1]: https://serde.rs/ +@@ -376,18 +362,19 @@ It is a goal to support the latest stabl + the version of Rust that's used for Firefox Nightly. + + At this time, there is no firm commitment to support a version older than + what's required by Firefox, and there is no commitment to treat MSRV changes + as semver-breaking, because this crate depends on `cfg-if`, which doesn't + appear to treat MSRV changes as semver-breaking, so it would be useless for + this crate to treat MSRV changes as semver-breaking. + +-As of 2021-02-04, MSRV appears to be Rust 1.36.0 for using the crate and ++As of 2024-04-04, MSRV appears to be Rust 1.36.0 for using the crate and + 1.42.0 for doc tests to pass without errors about the global allocator. ++With the `simd-accel` feature, the MSRV is even higher. + + ## Compatibility with rust-encoding + + A compatibility layer that implements the rust-encoding API on top of + encoding_rs is + [provided as a separate crate](https://github.com/hsivonen/encoding_rs_compat) + (cannot be uploaded to crates.io). The compatibility layer was originally + written with the assuption that Firefox would need it, but it is not currently +@@ -441,20 +428,27 @@ To regenerate the generated code: + - [x] Implement the rust-encoding API in terms of encoding_rs. + - [x] Add SIMD acceleration for Aarch64. + - [x] Investigate the use of NEON on 32-bit ARM. + - [ ] ~Investigate Björn Höhrmann's lookup table acceleration for UTF-8 as + adapted to Rust in rust-encoding.~ + - [x] Add actually fast CJK encode options. + - [ ] ~Investigate [Bob Steagall's lookup table acceleration for UTF-8](https://github.com/BobSteagall/CppNow2018/blob/master/FastConversionFromUTF-8/Fast%20Conversion%20From%20UTF-8%20with%20C%2B%2B%2C%20DFAs%2C%20and%20SSE%20Intrinsics%20-%20Bob%20Steagall%20-%20C%2B%2BNow%202018.pdf).~ + - [x] Provide a build mode that works without `alloc` (with lesser API surface). +-- [ ] Migrate to `std::simd` once it is stable and declare 1.0. ++- [x] Migrate to `std::simd` ~once it is stable and declare 1.0.~ ++- [ ] Migrate `unsafe` slice access by larger types than `u8`/`u16` to `align_to`. + + ## Release Notes + ++### 0.8.34 ++ ++* Use the `portable_simd` nightly feature of the standard library instead of the `packed_simd` crate. Only affects the `simd-accel` optional nightly feature. ++* Internal documentation improvements and minor code improvements around `unsafe`. ++* Added `rust-version` to `Cargo.toml`. ++ + ### 0.8.33 + + * Use `packed_simd` instead of `packed_simd_2` again now that updates are back under the `packed_simd` name. Only affects the `simd-accel` optional nightly feature. + + ### 0.8.32 + + * Removed `build.rs`. (This removal should resolve false positives reported by some antivirus products. This may break some build configurations that have opted out of Rust's guarantees against future build breakage.) + * Internal change to what API is used for reinterpreting the lane configuration of SIMD vectors. +diff --git a/third_party/rust/encoding_rs/src/ascii.rs b/third_party/rust/encoding_rs/src/ascii.rs +--- a/third_party/rust/encoding_rs/src/ascii.rs ++++ b/third_party/rust/encoding_rs/src/ascii.rs +@@ -46,71 +46,87 @@ cfg_if! { + #[allow(dead_code)] + #[inline(always)] + fn likely(b: bool) -> bool { + b + } + } + } + ++// Safety invariants for masks: data & mask = 0 for valid ASCII or basic latin utf-16 ++ + // `as` truncates, so works on 32-bit, too. + #[allow(dead_code)] + pub const ASCII_MASK: usize = 0x8080_8080_8080_8080u64 as usize; + + // `as` truncates, so works on 32-bit, too. + #[allow(dead_code)] + pub const BASIC_LATIN_MASK: usize = 0xFF80_FF80_FF80_FF80u64 as usize; + + #[allow(unused_macros)] + macro_rules! ascii_naive { + ($name:ident, $src_unit:ty, $dst_unit:ty) => { ++ /// Safety: src and dst must have len_unit elements and be aligned ++ /// Safety-usable invariant: will return Some() when it fails ++ /// to convert. The first value will be a u8 that is > 127. + #[inline(always)] + pub unsafe fn $name( + src: *const $src_unit, + dst: *mut $dst_unit, + len: usize, + ) -> Option<($src_unit, usize)> { + // Yes, manually omitting the bound check here matters + // a lot for perf. + for i in 0..len { ++ // Safety: len invariant used here + let code_unit = *(src.add(i)); ++ // Safety: Upholds safety-usable invariant here + if code_unit > 127 { + return Some((code_unit, i)); + } ++ // Safety: len invariant used here + *(dst.add(i)) = code_unit as $dst_unit; + } + return None; + } + }; + } + + #[allow(unused_macros)] + macro_rules! ascii_alu { + ($name:ident, ++ // safety invariant: src/dst MUST be u8 + $src_unit:ty, + $dst_unit:ty, ++ // Safety invariant: stride_fn must consume and produce two usizes, and return the index of the first non-ascii when it fails + $stride_fn:ident) => { ++ /// Safety: src and dst must have len elements, src is valid for read, dst is valid for ++ /// write ++ /// Safety-usable invariant: will return Some() when it fails ++ /// to convert. The first value will be a u8 that is > 127. + #[cfg_attr(feature = "cargo-clippy", allow(never_loop, cast_ptr_alignment))] + #[inline(always)] + pub unsafe fn $name( + src: *const $src_unit, + dst: *mut $dst_unit, + len: usize, + ) -> Option<($src_unit, usize)> { + let mut offset = 0usize; + // This loop is only broken out of as a `goto` forward + loop { ++ // Safety: until_alignment becomes the number of bytes we need to munch until we are aligned to usize + let mut until_alignment = { + // Check if the other unit aligns if we move the narrower unit + // to alignment. + // if ::core::mem::size_of::<$src_unit>() == ::core::mem::size_of::<$dst_unit>() { + // ascii_to_ascii + let src_alignment = (src as usize) & ALU_ALIGNMENT_MASK; + let dst_alignment = (dst as usize) & ALU_ALIGNMENT_MASK; + if src_alignment != dst_alignment { ++ // Safety: bails early and ends up in the naïve branch where usize-alignment doesn't matter + break; + } + (ALU_ALIGNMENT - src_alignment) & ALU_ALIGNMENT_MASK + // } else if ::core::mem::size_of::<$src_unit>() < ::core::mem::size_of::<$dst_unit>() { + // ascii_to_basic_latin + // let src_until_alignment = (ALIGNMENT - ((src as usize) & ALIGNMENT_MASK)) & ALIGNMENT_MASK; + // if (dst.add(src_until_alignment) as usize) & ALIGNMENT_MASK != 0 { + // break; +@@ -129,74 +145,104 @@ macro_rules! ascii_alu { + // Moving pointers to alignment seems to be a pessimization on + // x86_64 for operations that have UTF-16 as the internal + // Unicode representation. However, since it seems to be a win + // on ARM (tested ARMv7 code running on ARMv8 [rpi3]), except + // mixed results when encoding from UTF-16 and since x86 and + // x86_64 should be using SSE2 in due course, keeping the move + // to alignment here. It would be good to test on more ARM CPUs + // and on real MIPS and POWER hardware. ++ // ++ // Safety: This is the naïve code once again, for `until_alignment` bytes + while until_alignment != 0 { + let code_unit = *(src.add(offset)); + if code_unit > 127 { ++ // Safety: Upholds safety-usable invariant here + return Some((code_unit, offset)); + } + *(dst.add(offset)) = code_unit as $dst_unit; ++ // Safety: offset is the number of bytes copied so far + offset += 1; + until_alignment -= 1; + } + let len_minus_stride = len - ALU_STRIDE_SIZE; + loop { ++ // Safety: num_ascii is known to be a byte index of a non-ascii byte due to stride_fn's invariant + if let Some(num_ascii) = $stride_fn( ++ // Safety: These are known to be valid and aligned since we have at ++ // least ALU_STRIDE_SIZE data in these buffers, and offset is the ++ // number of elements copied so far, which according to the ++ // until_alignment calculation above will cause both src and dst to be ++ // aligned to usize after this add + src.add(offset) as *const usize, + dst.add(offset) as *mut usize, + ) { + offset += num_ascii; ++ // Safety: Upholds safety-usable invariant here by indexing into non-ascii byte + return Some((*(src.add(offset)), offset)); + } ++ // Safety: offset continues to be the number of bytes copied so far, and ++ // maintains usize alignment for the next loop iteration + offset += ALU_STRIDE_SIZE; ++ // Safety: This is `offset > len - stride. This loop will continue as long as ++ // `offset <= len - stride`, which means there are `stride` bytes to still be read. + if offset > len_minus_stride { + break; + } + } + } + break; + } ++ ++ // Safety: This is the naïve code, same as ascii_naive, and has no requirements ++ // other than src/dst being valid for the the right lens + while offset < len { ++ // Safety: len invariant used here + let code_unit = *(src.add(offset)); + if code_unit > 127 { ++ // Safety: Upholds safety-usable invariant here + return Some((code_unit, offset)); + } ++ // Safety: len invariant used here + *(dst.add(offset)) = code_unit as $dst_unit; + offset += 1; + } + None + } + }; + } + + #[allow(unused_macros)] + macro_rules! basic_latin_alu { + ($name:ident, ++ // safety invariant: use u8 for src/dest for ascii, and u16 for basic_latin + $src_unit:ty, + $dst_unit:ty, ++ // safety invariant: stride function must munch ALU_STRIDE_SIZE*size(src_unit) bytes off of src and ++ // write ALU_STRIDE_SIZE*size(dst_unit) bytes to dst + $stride_fn:ident) => { ++ /// Safety: src and dst must have len elements, src is valid for read, dst is valid for ++ /// write ++ /// Safety-usable invariant: will return Some() when it fails ++ /// to convert. The first value will be a u8 that is > 127. + #[cfg_attr( + feature = "cargo-clippy", + allow(never_loop, cast_ptr_alignment, cast_lossless) + )] + #[inline(always)] + pub unsafe fn $name( + src: *const $src_unit, + dst: *mut $dst_unit, + len: usize, + ) -> Option<($src_unit, usize)> { + let mut offset = 0usize; + // This loop is only broken out of as a `goto` forward + loop { ++ // Safety: until_alignment becomes the number of bytes we need to munch from src/dest until we are aligned to usize ++ // We ensure basic-latin has the same alignment as ascii, starting with ascii since it is smaller. + let mut until_alignment = { + // Check if the other unit aligns if we move the narrower unit + // to alignment. + // if ::core::mem::size_of::<$src_unit>() == ::core::mem::size_of::<$dst_unit>() { + // ascii_to_ascii + // let src_alignment = (src as usize) & ALIGNMENT_MASK; + // let dst_alignment = (dst as usize) & ALIGNMENT_MASK; + // if src_alignment != dst_alignment { +@@ -232,66 +278,89 @@ macro_rules! basic_latin_alu { + // Moving pointers to alignment seems to be a pessimization on + // x86_64 for operations that have UTF-16 as the internal + // Unicode representation. However, since it seems to be a win + // on ARM (tested ARMv7 code running on ARMv8 [rpi3]), except + // mixed results when encoding from UTF-16 and since x86 and + // x86_64 should be using SSE2 in due course, keeping the move + // to alignment here. It would be good to test on more ARM CPUs + // and on real MIPS and POWER hardware. ++ // ++ // Safety: This is the naïve code once again, for `until_alignment` bytes + while until_alignment != 0 { + let code_unit = *(src.add(offset)); + if code_unit > 127 { ++ // Safety: Upholds safety-usable invariant here + return Some((code_unit, offset)); + } + *(dst.add(offset)) = code_unit as $dst_unit; ++ // Safety: offset is the number of bytes copied so far + offset += 1; + until_alignment -= 1; + } + let len_minus_stride = len - ALU_STRIDE_SIZE; + loop { + if !$stride_fn( ++ // Safety: These are known to be valid and aligned since we have at ++ // least ALU_STRIDE_SIZE data in these buffers, and offset is the ++ // number of elements copied so far, which according to the ++ // until_alignment calculation above will cause both src and dst to be ++ // aligned to usize after this add + src.add(offset) as *const usize, + dst.add(offset) as *mut usize, + ) { + break; + } ++ // Safety: offset continues to be the number of bytes copied so far, and ++ // maintains usize alignment for the next loop iteration + offset += ALU_STRIDE_SIZE; ++ // Safety: This is `offset > len - stride. This loop will continue as long as ++ // `offset <= len - stride`, which means there are `stride` bytes to still be read. + if offset > len_minus_stride { + break; + } + } + } + break; + } ++ // Safety: This is the naïve code once again, for leftover bytes + while offset < len { ++ // Safety: len invariant used here + let code_unit = *(src.add(offset)); + if code_unit > 127 { ++ // Safety: Upholds safety-usable invariant here + return Some((code_unit, offset)); + } ++ // Safety: len invariant used here + *(dst.add(offset)) = code_unit as $dst_unit; + offset += 1; + } + None + } + }; + } + + #[allow(unused_macros)] + macro_rules! latin1_alu { ++ // safety invariant: stride function must munch ALU_STRIDE_SIZE*size(src_unit) bytes off of src and ++ // write ALU_STRIDE_SIZE*size(dst_unit) bytes to dst + ($name:ident, $src_unit:ty, $dst_unit:ty, $stride_fn:ident) => { ++ /// Safety: src and dst must have len elements, src is valid for read, dst is valid for ++ /// write + #[cfg_attr( + feature = "cargo-clippy", + allow(never_loop, cast_ptr_alignment, cast_lossless) + )] + #[inline(always)] + pub unsafe fn $name(src: *const $src_unit, dst: *mut $dst_unit, len: usize) { + let mut offset = 0usize; + // This loop is only broken out of as a `goto` forward + loop { ++ // Safety: until_alignment becomes the number of bytes we need to munch from src/dest until we are aligned to usize ++ // We ensure the UTF-16 side has the same alignment as the Latin-1 side, starting with Latin-1 since it is smaller. + let mut until_alignment = { + if ::core::mem::size_of::<$src_unit>() < ::core::mem::size_of::<$dst_unit>() { + // unpack + let src_until_alignment = (ALU_ALIGNMENT + - ((src as usize) & ALU_ALIGNMENT_MASK)) + & ALU_ALIGNMENT_MASK; + if (dst.wrapping_add(src_until_alignment) as usize) & ALU_ALIGNMENT_MASK + != 0 +@@ -308,373 +377,485 @@ macro_rules! latin1_alu { + != 0 + { + break; + } + dst_until_alignment + } + }; + if until_alignment + ALU_STRIDE_SIZE <= len { ++ // Safety: This is the naïve code once again, for `until_alignment` bytes + while until_alignment != 0 { + let code_unit = *(src.add(offset)); + *(dst.add(offset)) = code_unit as $dst_unit; ++ // Safety: offset is the number of bytes copied so far + offset += 1; + until_alignment -= 1; + } + let len_minus_stride = len - ALU_STRIDE_SIZE; + loop { + $stride_fn( ++ // Safety: These are known to be valid and aligned since we have at ++ // least ALU_STRIDE_SIZE data in these buffers, and offset is the ++ // number of elements copied so far, which according to the ++ // until_alignment calculation above will cause both src and dst to be ++ // aligned to usize after this add + src.add(offset) as *const usize, + dst.add(offset) as *mut usize, + ); ++ // Safety: offset continues to be the number of bytes copied so far, and ++ // maintains usize alignment for the next loop iteration + offset += ALU_STRIDE_SIZE; ++ // Safety: This is `offset > len - stride. This loop will continue as long as ++ // `offset <= len - stride`, which means there are `stride` bytes to still be read. + if offset > len_minus_stride { + break; + } + } + } + break; + } ++ // Safety: This is the naïve code once again, for leftover bytes + while offset < len { ++ // Safety: len invariant used here + let code_unit = *(src.add(offset)); + *(dst.add(offset)) = code_unit as $dst_unit; + offset += 1; + } + } + }; + } + + #[allow(unused_macros)] + macro_rules! ascii_simd_check_align { + ( + $name:ident, + $src_unit:ty, + $dst_unit:ty, ++ // Safety: This function must require aligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_both_aligned:ident, ++ // Safety: This function must require aligned/unaligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_src_aligned:ident, ++ // Safety: This function must require unaligned/aligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_dst_aligned:ident, ++ // Safety: This function must require unaligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_neither_aligned:ident + ) => { ++ /// Safety: src/dst must be valid for reads/writes of `len` elements of their units. ++ /// ++ /// Safety-usable invariant: will return Some() when it encounters non-ASCII, with the first element in the Some being ++ /// guaranteed to be non-ASCII (> 127), and the second being the offset where it is found + #[inline(always)] + pub unsafe fn $name( + src: *const $src_unit, + dst: *mut $dst_unit, + len: usize, + ) -> Option<($src_unit, usize)> { + let mut offset = 0usize; ++ // Safety: if this check succeeds we're valid for reading/writing at least `SIMD_STRIDE_SIZE` elements. + if SIMD_STRIDE_SIZE <= len { + let len_minus_stride = len - SIMD_STRIDE_SIZE; + // XXX Should we first process one stride unconditionally as unaligned to + // avoid the cost of the branchiness below if the first stride fails anyway? + // XXX Should we just use unaligned SSE2 access unconditionally? It seems that + // on Haswell, it would make sense to just use unaligned and not bother + // checking. Need to benchmark older architectures before deciding. + let dst_masked = (dst as usize) & SIMD_ALIGNMENT_MASK; ++ // Safety: checking whether src is aligned + if ((src as usize) & SIMD_ALIGNMENT_MASK) == 0 { ++ // Safety: Checking whether dst is aligned + if dst_masked == 0 { + loop { ++ // Safety: We're valid to read/write SIMD_STRIDE_SIZE elements and have the appropriate alignments + if !$stride_both_aligned(src.add(offset), dst.add(offset)) { + break; + } + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE` which means we always have at least `SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride { + break; + } + } + } else { + loop { ++ // Safety: We're valid to read/write SIMD_STRIDE_SIZE elements and have the appropriate alignments + if !$stride_src_aligned(src.add(offset), dst.add(offset)) { + break; + } + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE` which means we always have at least `SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride { + break; + } + } + } + } else { + if dst_masked == 0 { + loop { ++ // Safety: We're valid to read/write SIMD_STRIDE_SIZE elements and have the appropriate alignments + if !$stride_dst_aligned(src.add(offset), dst.add(offset)) { + break; + } + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE` which means we always have at least `SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride { + break; + } + } + } else { + loop { ++ // Safety: We're valid to read/write SIMD_STRIDE_SIZE elements and have the appropriate alignments + if !$stride_neither_aligned(src.add(offset), dst.add(offset)) { + break; + } + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE` which means we always have at least `SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride { + break; + } + } + } + } + } + while offset < len { ++ // Safety: uses len invariant here and below + let code_unit = *(src.add(offset)); + if code_unit > 127 { ++ // Safety: upholds safety-usable invariant + return Some((code_unit, offset)); + } + *(dst.add(offset)) = code_unit as $dst_unit; + offset += 1; + } + None + } + }; + } + + #[allow(unused_macros)] + macro_rules! ascii_simd_check_align_unrolled { + ( + $name:ident, + $src_unit:ty, + $dst_unit:ty, ++ // Safety: This function must require aligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_both_aligned:ident, ++ // Safety: This function must require aligned/unaligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_src_aligned:ident, ++ // Safety: This function must require unaligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_neither_aligned:ident, ++ // Safety: This function must require aligned src/dest that are valid for reading/writing 2*SIMD_STRIDE_SIZE src_unit/dst_unit + $double_stride_both_aligned:ident, ++ // Safety: This function must require aligned/unaligned src/dest that are valid for reading/writing 2*SIMD_STRIDE_SIZE src_unit/dst_unit + $double_stride_src_aligned:ident + ) => { +- #[inline(always)] ++ /// Safety: src/dst must be valid for reads/writes of `len` elements of their units. ++ /// ++ /// Safety-usable invariant: will return Some() when it encounters non-ASCII, with the first element in the Some being ++ /// guaranteed to be non-ASCII (> 127), and the second being the offset where it is found #[inline(always)] + pub unsafe fn $name( + src: *const $src_unit, + dst: *mut $dst_unit, + len: usize, + ) -> Option<($src_unit, usize)> { + let unit_size = ::core::mem::size_of::<$src_unit>(); + let mut offset = 0usize; + // This loop is only broken out of as a goto forward without + // actually looping + 'outer: loop { ++ // Safety: if this check succeeds we're valid for reading/writing at least `SIMD_STRIDE_SIZE` elements. + if SIMD_STRIDE_SIZE <= len { + // First, process one unaligned ++ // Safety: this is safe to call since we're valid for this read/write + if !$stride_neither_aligned(src, dst) { + break 'outer; + } + offset = SIMD_STRIDE_SIZE; + + // We have now seen 16 ASCII bytes. Let's guess that + // there will be enough more to justify more expense + // in the case of non-ASCII. + // Use aligned reads for the sake of old microachitectures. ++ // ++ // Safety: this correctly calculates the number of src_units that need to be read before the remaining list is aligned. ++ // This is less that SIMD_ALIGNMENT, which is also SIMD_STRIDE_SIZE (as documented) + let until_alignment = ((SIMD_ALIGNMENT + - ((src.add(offset) as usize) & SIMD_ALIGNMENT_MASK)) + & SIMD_ALIGNMENT_MASK) + / unit_size; +- // This addition won't overflow, because even in the 32-bit PAE case the ++ // Safety: This addition won't overflow, because even in the 32-bit PAE case the + // address space holds enough code that the slice length can't be that + // close to address space size. + // offset now equals SIMD_STRIDE_SIZE, hence times 3 below. ++ // ++ // Safety: if this check succeeds we're valid for reading/writing at least `2 * SIMD_STRIDE_SIZE` elements plus `until_alignment`. ++ // The extra SIMD_STRIDE_SIZE in the condition is because `offset` is already `SIMD_STRIDE_SIZE`. + if until_alignment + (SIMD_STRIDE_SIZE * 3) <= len { + if until_alignment != 0 { ++ // Safety: this is safe to call since we're valid for this read/write (and more), and don't care about alignment ++ // This will copy over bytes that get decoded twice since it's not incrementing `offset` by SIMD_STRIDE_SIZE. This is fine. + if !$stride_neither_aligned(src.add(offset), dst.add(offset)) { + break; + } + offset += until_alignment; + } ++ // Safety: At this point we're valid for reading/writing 2*SIMD_STRIDE_SIZE elements ++ // Safety: Now `offset` is aligned for `src` + let len_minus_stride_times_two = len - (SIMD_STRIDE_SIZE * 2); ++ // Safety: This is whether dst is aligned + let dst_masked = (dst.add(offset) as usize) & SIMD_ALIGNMENT_MASK; + if dst_masked == 0 { + loop { ++ // Safety: both are aligned, we can call the aligned function. We're valid for reading/writing double stride from the initial condition ++ // and the loop break condition below + if let Some(advance) = + $double_stride_both_aligned(src.add(offset), dst.add(offset)) + { + offset += advance; + let code_unit = *(src.add(offset)); ++ // Safety: uses safety-usable invariant on ascii_to_ascii_simd_double_stride to return ++ // guaranteed non-ascii + return Some((code_unit, offset)); + } + offset += SIMD_STRIDE_SIZE * 2; ++ // Safety: This is `offset > len - 2 * SIMD_STRIDE_SIZE` which means we always have at least `2 * SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride_times_two { + break; + } + } ++ // Safety: We're valid for reading/writing one more, and can still assume alignment + if offset + SIMD_STRIDE_SIZE <= len { + if !$stride_both_aligned(src.add(offset), dst.add(offset)) { + break 'outer; + } + offset += SIMD_STRIDE_SIZE; + } + } else { + loop { ++ // Safety: only src is aligned here. We're valid for reading/writing double stride from the initial condition ++ // and the loop break condition below + if let Some(advance) = + $double_stride_src_aligned(src.add(offset), dst.add(offset)) + { + offset += advance; + let code_unit = *(src.add(offset)); ++ // Safety: uses safety-usable invariant on ascii_to_ascii_simd_double_stride to return ++ // guaranteed non-ascii + return Some((code_unit, offset)); + } + offset += SIMD_STRIDE_SIZE * 2; ++ // Safety: This is `offset > len - 2 * SIMD_STRIDE_SIZE` which means we always have at least `2 * SIMD_STRIDE_SIZE` elements to munch next time. ++ + if offset > len_minus_stride_times_two { + break; + } + } ++ // Safety: We're valid for reading/writing one more, and can still assume alignment + if offset + SIMD_STRIDE_SIZE <= len { + if !$stride_src_aligned(src.add(offset), dst.add(offset)) { + break 'outer; + } + offset += SIMD_STRIDE_SIZE; + } + } + } else { + // At most two iterations, so unroll + if offset + SIMD_STRIDE_SIZE <= len { ++ // Safety: The check above ensures we're allowed to read/write this, and we don't use alignment + if !$stride_neither_aligned(src.add(offset), dst.add(offset)) { + break; + } + offset += SIMD_STRIDE_SIZE; + if offset + SIMD_STRIDE_SIZE <= len { ++ // Safety: The check above ensures we're allowed to read/write this, and we don't use alignment + if !$stride_neither_aligned(src.add(offset), dst.add(offset)) { + break; + } + offset += SIMD_STRIDE_SIZE; + } + } + } + } + break 'outer; + } + while offset < len { ++ // Safety: relies straightforwardly on the `len` invariant + let code_unit = *(src.add(offset)); + if code_unit > 127 { ++ // Safety-usable invariant upheld here + return Some((code_unit, offset)); + } + *(dst.add(offset)) = code_unit as $dst_unit; + offset += 1; + } + None + } + }; + } + + #[allow(unused_macros)] + macro_rules! latin1_simd_check_align { + ( + $name:ident, + $src_unit:ty, + $dst_unit:ty, ++ // Safety: This function must require aligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_both_aligned:ident, ++ // Safety: This function must require aligned/unaligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_src_aligned:ident, ++ // Safety: This function must require unaligned/aligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_dst_aligned:ident, ++ // Safety: This function must require unaligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_neither_aligned:ident ++ + ) => { ++ /// Safety: src/dst must be valid for reads/writes of `len` elements of their units. + #[inline(always)] + pub unsafe fn $name(src: *const $src_unit, dst: *mut $dst_unit, len: usize) { + let mut offset = 0usize; ++ // Safety: if this check succeeds we're valid for reading/writing at least `SIMD_STRIDE_SIZE` elements. + if SIMD_STRIDE_SIZE <= len { + let len_minus_stride = len - SIMD_STRIDE_SIZE; ++ // Whether dst is aligned + let dst_masked = (dst as usize) & SIMD_ALIGNMENT_MASK; ++ // Whether src is aligned + if ((src as usize) & SIMD_ALIGNMENT_MASK) == 0 { + if dst_masked == 0 { + loop { ++ // Safety: Both were aligned, we can use the aligned function + $stride_both_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE`, which means in the next iteration we're valid for ++ // reading/writing at least SIMD_STRIDE_SIZE elements. + if offset > len_minus_stride { + break; + } + } + } else { + loop { ++ // Safety: src was aligned, dst was not + $stride_src_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE`, which means in the next iteration we're valid for ++ // reading/writing at least SIMD_STRIDE_SIZE elements. + if offset > len_minus_stride { + break; + } + } + } + } else { + if dst_masked == 0 { + loop { ++ // Safety: src was aligned, dst was not + $stride_dst_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE`, which means in the next iteration we're valid for ++ // reading/writing at least SIMD_STRIDE_SIZE elements. + if offset > len_minus_stride { + break; + } + } + } else { + loop { ++ // Safety: Neither were aligned + $stride_neither_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE`, which means in the next iteration we're valid for ++ // reading/writing at least SIMD_STRIDE_SIZE elements. + if offset > len_minus_stride { + break; + } + } + } + } + } + while offset < len { ++ // Safety: relies straightforwardly on the `len` invariant + let code_unit = *(src.add(offset)); + *(dst.add(offset)) = code_unit as $dst_unit; + offset += 1; + } + } + }; + } + + #[allow(unused_macros)] + macro_rules! latin1_simd_check_align_unrolled { + ( + $name:ident, + $src_unit:ty, + $dst_unit:ty, ++ // Safety: This function must require aligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_both_aligned:ident, ++ // Safety: This function must require aligned/unaligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_src_aligned:ident, ++ // Safety: This function must require unaligned/aligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_dst_aligned:ident, ++ // Safety: This function must require unaligned src/dest that are valid for reading/writing SIMD_STRIDE_SIZE src_unit/dst_unit + $stride_neither_aligned:ident + ) => { ++ /// Safety: src/dst must be valid for reads/writes of `len` elements of their units. + #[inline(always)] + pub unsafe fn $name(src: *const $src_unit, dst: *mut $dst_unit, len: usize) { + let unit_size = ::core::mem::size_of::<$src_unit>(); + let mut offset = 0usize; ++ // Safety: if this check succeeds we're valid for reading/writing at least `SIMD_STRIDE_SIZE` elements. + if SIMD_STRIDE_SIZE <= len { ++ // Safety: this correctly calculates the number of src_units that need to be read before the remaining list is aligned. ++ // This is by definition less than SIMD_STRIDE_SIZE. + let mut until_alignment = ((SIMD_STRIDE_SIZE + - ((src as usize) & SIMD_ALIGNMENT_MASK)) + & SIMD_ALIGNMENT_MASK) + / unit_size; + while until_alignment != 0 { ++ // Safety: This is a straightforward copy, since until_alignment is < SIMD_STRIDE_SIZE < len, this is in-bounds + *(dst.add(offset)) = *(src.add(offset)) as $dst_unit; + offset += 1; + until_alignment -= 1; + } ++ // Safety: here offset will be `until_alignment`, i.e. enough to align `src`. + let len_minus_stride = len - SIMD_STRIDE_SIZE; ++ // Safety: if this check succeeds we're valid for reading/writing at least `2 * SIMD_STRIDE_SIZE` elements. + if offset + SIMD_STRIDE_SIZE * 2 <= len { + let len_minus_stride_times_two = len_minus_stride - SIMD_STRIDE_SIZE; ++ // Safety: at this point src is known to be aligned at offset, dst is not. + if (dst.add(offset) as usize) & SIMD_ALIGNMENT_MASK == 0 { + loop { ++ // Safety: We checked alignment of dst above, we can use the alignment functions. We're allowed to read/write 2*SIMD_STRIDE_SIZE elements, which we do. + $stride_both_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; + $stride_both_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - 2 * SIMD_STRIDE_SIZE` which means we always have at least `2 * SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride_times_two { + break; + } + } + } else { + loop { ++ // Safety: we ensured alignment of src already. + $stride_src_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; + $stride_src_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - 2 * SIMD_STRIDE_SIZE` which means we always have at least `2 * SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride_times_two { + break; + } + } + } + } ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE` which means we are valid to munch SIMD_STRIDE_SIZE more elements, which we do + if offset < len_minus_stride { + $stride_src_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; + } + } + while offset < len { ++ // Safety: uses len invariant here and below + let code_unit = *(src.add(offset)); + // On x86_64, this loop autovectorizes but in the pack + // case there are instructions whose purpose is to make sure + // each u16 in the vector is truncated before packing. However, + // since we don't care about saturating behavior of SSE2 packing + // when the input isn't Latin1, those instructions are useless. + // Unfortunately, using the `assume` intrinsic to lie to the + // optimizer doesn't make LLVM omit the trunctation that we +@@ -688,138 +869,180 @@ macro_rules! latin1_simd_check_align_unr + offset += 1; + } + } + }; + } + + #[allow(unused_macros)] + macro_rules! ascii_simd_unalign { ++ // Safety: stride_neither_aligned must be a function that requires src/dest be valid for unaligned reads/writes for SIMD_STRIDE_SIZE elements of type src_unit/dest_unit + ($name:ident, $src_unit:ty, $dst_unit:ty, $stride_neither_aligned:ident) => { ++ /// Safety: src and dst must be valid for reads/writes of len elements of type src_unit/dst_unit ++ /// ++ /// Safety-usable invariant: will return Some() when it encounters non-ASCII, with the first element in the Some being ++ /// guaranteed to be non-ASCII (> 127), and the second being the offset where it is found + #[inline(always)] + pub unsafe fn $name( + src: *const $src_unit, + dst: *mut $dst_unit, + len: usize, + ) -> Option<($src_unit, usize)> { + let mut offset = 0usize; ++ // Safety: if this check succeeds we're valid for reading/writing at least `stride` elements. + if SIMD_STRIDE_SIZE <= len { + let len_minus_stride = len - SIMD_STRIDE_SIZE; + loop { ++ // Safety: We know we're valid for `stride` reads/writes, so we can call this function. We don't need alignment. + if !$stride_neither_aligned(src.add(offset), dst.add(offset)) { + break; + } + offset += SIMD_STRIDE_SIZE; ++ // This is `offset > len - stride` which means we always have at least `stride` elements to munch next time. + if offset > len_minus_stride { + break; + } + } + } + while offset < len { ++ // Safety: Uses len invariant here and below + let code_unit = *(src.add(offset)); + if code_unit > 127 { ++ // Safety-usable invariant upheld here + return Some((code_unit, offset)); + } + *(dst.add(offset)) = code_unit as $dst_unit; + offset += 1; + } + None + } + }; + } + + #[allow(unused_macros)] + macro_rules! latin1_simd_unalign { ++ // Safety: stride_neither_aligned must be a function that requires src/dest be valid for unaligned reads/writes for SIMD_STRIDE_SIZE elements of type src_unit/dest_unit + ($name:ident, $src_unit:ty, $dst_unit:ty, $stride_neither_aligned:ident) => { ++ /// Safety: src and dst must be valid for unaligned reads/writes of len elements of type src_unit/dst_unit + #[inline(always)] + pub unsafe fn $name(src: *const $src_unit, dst: *mut $dst_unit, len: usize) { + let mut offset = 0usize; ++ // Safety: if this check succeeds we're valid for reading/writing at least `stride` elements. + if SIMD_STRIDE_SIZE <= len { + let len_minus_stride = len - SIMD_STRIDE_SIZE; + loop { ++ // Safety: We know we're valid for `stride` reads/writes, so we can call this function. We don't need alignment. + $stride_neither_aligned(src.add(offset), dst.add(offset)); + offset += SIMD_STRIDE_SIZE; ++ // This is `offset > len - stride` which means we always have at least `stride` elements to munch next time. + if offset > len_minus_stride { + break; + } + } + } + while offset < len { ++ // Safety: Uses len invariant here + let code_unit = *(src.add(offset)); + *(dst.add(offset)) = code_unit as $dst_unit; + offset += 1; + } + } + }; + } + + #[allow(unused_macros)] + macro_rules! ascii_to_ascii_simd_stride { ++ // Safety: load/store must be valid for 16 bytes of read/write, which may be unaligned. (candidates: `(load|store)(16|8)_(unaligned|aligned)` functions) + ($name:ident, $load:ident, $store:ident) => { ++ /// Safety: src and dst must be valid for 16 bytes of read/write according to ++ /// the $load/$store fn, which may allow for unaligned reads/writes or require ++ /// alignment to either 16x8 or u8x16. + #[inline(always)] + pub unsafe fn $name(src: *const u8, dst: *mut u8) -> bool { + let simd = $load(src); + if !simd_is_ascii(simd) { + return false; + } + $store(dst, simd); + true + } + }; + } + + #[allow(unused_macros)] + macro_rules! ascii_to_ascii_simd_double_stride { ++ // Safety: store must be valid for 32 bytes of write, which may be unaligned (candidates: `store(8|16)_(aligned|unaligned)`) + ($name:ident, $store:ident) => { ++ /// Safety: src must be valid for 32 bytes of aligned u8x16 read ++ /// dst must be valid for 32 bytes of unaligned write according to ++ /// the $store fn, which may allow for unaligned writes or require ++ /// alignment to either 16x8 or u8x16. ++ /// ++ /// Safety-usable invariant: Returns Some(index) if the element at `index` is invalid ASCII + #[inline(always)] + pub unsafe fn $name(src: *const u8, dst: *mut u8) -> Option { + let first = load16_aligned(src); + let second = load16_aligned(src.add(SIMD_STRIDE_SIZE)); + $store(dst, first); + if unlikely(!simd_is_ascii(first | second)) { ++ // Safety: mask_ascii produces a mask of all the high bits. + let mask_first = mask_ascii(first); + if mask_first != 0 { ++ // Safety: on little endian systems this will be the number of ascii bytes ++ // before the first non-ascii, i.e. valid for indexing src ++ // TODO SAFETY: What about big-endian systems? + return Some(mask_first.trailing_zeros() as usize); + } + $store(dst.add(SIMD_STRIDE_SIZE), second); + let mask_second = mask_ascii(second); ++ // Safety: on little endian systems this will be the number of ascii bytes ++ // before the first non-ascii, i.e. valid for indexing src + return Some(SIMD_STRIDE_SIZE + mask_second.trailing_zeros() as usize); + } + $store(dst.add(SIMD_STRIDE_SIZE), second); + None + } + }; + } + + #[allow(unused_macros)] + macro_rules! ascii_to_basic_latin_simd_stride { ++ // Safety: load/store must be valid for 16 bytes of read/write, which may be unaligned. (candidates: `(load|store)(16|8)_(unaligned|aligned)` functions) + ($name:ident, $load:ident, $store:ident) => { ++ /// Safety: src and dst must be valid for 16/32 bytes of read/write according to ++ /// the $load/$store fn, which may allow for unaligned reads/writes or require ++ /// alignment to either 16x8 or u8x16. + #[inline(always)] + pub unsafe fn $name(src: *const u8, dst: *mut u16) -> bool { + let simd = $load(src); + if !simd_is_ascii(simd) { + return false; + } + let (first, second) = simd_unpack(simd); + $store(dst, first); + $store(dst.add(8), second); + true + } + }; + } + + #[allow(unused_macros)] + macro_rules! ascii_to_basic_latin_simd_double_stride { ++ // Safety: store must be valid for 16 bytes of write, which may be unaligned + ($name:ident, $store:ident) => { ++ /// Safety: src must be valid for 2*SIMD_STRIDE_SIZE bytes of aligned reads, ++ /// aligned to either 16x8 or u8x16. ++ /// dst must be valid for 2*SIMD_STRIDE_SIZE bytes of aligned or unaligned reads + #[inline(always)] + pub unsafe fn $name(src: *const u8, dst: *mut u16) -> Option { + let first = load16_aligned(src); + let second = load16_aligned(src.add(SIMD_STRIDE_SIZE)); + let (a, b) = simd_unpack(first); + $store(dst, a); ++ // Safety: divide by 2 since it's a u16 pointer + $store(dst.add(SIMD_STRIDE_SIZE / 2), b); + if unlikely(!simd_is_ascii(first | second)) { + let mask_first = mask_ascii(first); + if mask_first != 0 { + return Some(mask_first.trailing_zeros() as usize); + } + let (c, d) = simd_unpack(second); + $store(dst.add(SIMD_STRIDE_SIZE), c); +@@ -832,47 +1055,59 @@ macro_rules! ascii_to_basic_latin_simd_d + $store(dst.add(SIMD_STRIDE_SIZE + (SIMD_STRIDE_SIZE / 2)), d); + None + } + }; + } + + #[allow(unused_macros)] + macro_rules! unpack_simd_stride { ++ // Safety: load/store must be valid for 16 bytes of read/write, which may be unaligned. (candidates: `(load|store)(16|8)_(unaligned|aligned)` functions) + ($name:ident, $load:ident, $store:ident) => { ++ /// Safety: src and dst must be valid for 16 bytes of read/write according to ++ /// the $load/$store fn, which may allow for unaligned reads/writes or require ++ /// alignment to either 16x8 or u8x16. + #[inline(always)] + pub unsafe fn $name(src: *const u8, dst: *mut u16) { + let simd = $load(src); + let (first, second) = simd_unpack(simd); + $store(dst, first); + $store(dst.add(8), second); + } + }; + } + + #[allow(unused_macros)] + macro_rules! basic_latin_to_ascii_simd_stride { ++ // Safety: load/store must be valid for 16 bytes of read/write, which may be unaligned. (candidates: `(load|store)(16|8)_(unaligned|aligned)` functions) + ($name:ident, $load:ident, $store:ident) => { ++ /// Safety: src and dst must be valid for 32/16 bytes of read/write according to ++ /// the $load/$store fn, which may allow for unaligned reads/writes or require ++ /// alignment to either 16x8 or u8x16. + #[inline(always)] + pub unsafe fn $name(src: *const u16, dst: *mut u8) -> bool { + let first = $load(src); + let second = $load(src.add(8)); + if simd_is_basic_latin(first | second) { + $store(dst, simd_pack(first, second)); + true + } else { + false + } + } + }; + } + + #[allow(unused_macros)] + macro_rules! pack_simd_stride { ++ // Safety: load/store must be valid for 16 bytes of read/write, which may be unaligned. (candidates: `(load|store)(16|8)_(unaligned|aligned)` functions) + ($name:ident, $load:ident, $store:ident) => { ++ /// Safety: src and dst must be valid for 32/16 bytes of read/write according to ++ /// the $load/$store fn, which may allow for unaligned reads/writes or require ++ /// alignment to either 16x8 or u8x16. + #[inline(always)] + pub unsafe fn $name(src: *const u16, dst: *mut u8) { + let first = $load(src); + let second = $load(src.add(8)); + $store(dst, simd_pack(first, second)); + } + }; + } +@@ -888,24 +1123,28 @@ cfg_if! { + // pub const ALIGNMENT: usize = 8; + + pub const ALU_STRIDE_SIZE: usize = 16; + + pub const ALU_ALIGNMENT: usize = 8; + + pub const ALU_ALIGNMENT_MASK: usize = 7; + ++ // Safety for stride macros: We stick to the load8_aligned/etc family of functions. We consistently produce ++ // neither_unaligned variants using only unaligned inputs. + ascii_to_ascii_simd_stride!(ascii_to_ascii_stride_neither_aligned, load16_unaligned, store16_unaligned); + + ascii_to_basic_latin_simd_stride!(ascii_to_basic_latin_stride_neither_aligned, load16_unaligned, store8_unaligned); + unpack_simd_stride!(unpack_stride_neither_aligned, load16_unaligned, store8_unaligned); + + basic_latin_to_ascii_simd_stride!(basic_latin_to_ascii_stride_neither_aligned, load8_unaligned, store16_unaligned); + pack_simd_stride!(pack_stride_neither_aligned, load8_unaligned, store16_unaligned); + ++ // Safety for conversion macros: We use the unalign macro with unalign functions above. All stride functions were produced ++ // by stride macros that universally munch a single SIMD_STRIDE_SIZE worth of elements. + ascii_simd_unalign!(ascii_to_ascii, u8, u8, ascii_to_ascii_stride_neither_aligned); + ascii_simd_unalign!(ascii_to_basic_latin, u8, u16, ascii_to_basic_latin_stride_neither_aligned); + ascii_simd_unalign!(basic_latin_to_ascii, u16, u8, basic_latin_to_ascii_stride_neither_aligned); + latin1_simd_unalign!(unpack_latin1, u8, u16, unpack_stride_neither_aligned); + latin1_simd_unalign!(pack_latin1, u16, u8, pack_stride_neither_aligned); + } else if #[cfg(all(feature = "simd-accel", target_endian = "little", target_feature = "neon"))] { + // SIMD with different instructions for aligned and unaligned loads and stores. + // +@@ -914,16 +1153,19 @@ cfg_if! { + // but the benchmark results I see don't agree. + + pub const SIMD_STRIDE_SIZE: usize = 16; + + pub const MAX_STRIDE_SIZE: usize = 16; + + pub const SIMD_ALIGNMENT_MASK: usize = 15; + ++ // Safety for stride macros: We stick to the load8_aligned/etc family of functions. We consistently name ++ // aligned/unaligned functions according to src/dst being aligned/unaligned ++ + ascii_to_ascii_simd_stride!(ascii_to_ascii_stride_both_aligned, load16_aligned, store16_aligned); + ascii_to_ascii_simd_stride!(ascii_to_ascii_stride_src_aligned, load16_aligned, store16_unaligned); + ascii_to_ascii_simd_stride!(ascii_to_ascii_stride_dst_aligned, load16_unaligned, store16_aligned); + ascii_to_ascii_simd_stride!(ascii_to_ascii_stride_neither_aligned, load16_unaligned, store16_unaligned); + + ascii_to_basic_latin_simd_stride!(ascii_to_basic_latin_stride_both_aligned, load16_aligned, store8_aligned); + ascii_to_basic_latin_simd_stride!(ascii_to_basic_latin_stride_src_aligned, load16_aligned, store8_unaligned); + ascii_to_basic_latin_simd_stride!(ascii_to_basic_latin_stride_dst_aligned, load16_unaligned, store8_aligned); +@@ -939,36 +1181,43 @@ cfg_if! { + basic_latin_to_ascii_simd_stride!(basic_latin_to_ascii_stride_dst_aligned, load8_unaligned, store16_aligned); + basic_latin_to_ascii_simd_stride!(basic_latin_to_ascii_stride_neither_aligned, load8_unaligned, store16_unaligned); + + pack_simd_stride!(pack_stride_both_aligned, load8_aligned, store16_aligned); + pack_simd_stride!(pack_stride_src_aligned, load8_aligned, store16_unaligned); + pack_simd_stride!(pack_stride_dst_aligned, load8_unaligned, store16_aligned); + pack_simd_stride!(pack_stride_neither_aligned, load8_unaligned, store16_unaligned); + ++ // Safety for conversion macros: We use the correct pattern of both/src/dst/neither here. All stride functions were produced ++ // by stride macros that universally munch a single SIMD_STRIDE_SIZE worth of elements. ++ + ascii_simd_check_align!(ascii_to_ascii, u8, u8, ascii_to_ascii_stride_both_aligned, ascii_to_ascii_stride_src_aligned, ascii_to_ascii_stride_dst_aligned, ascii_to_ascii_stride_neither_aligned); + ascii_simd_check_align!(ascii_to_basic_latin, u8, u16, ascii_to_basic_latin_stride_both_aligned, ascii_to_basic_latin_stride_src_aligned, ascii_to_basic_latin_stride_dst_aligned, ascii_to_basic_latin_stride_neither_aligned); + ascii_simd_check_align!(basic_latin_to_ascii, u16, u8, basic_latin_to_ascii_stride_both_aligned, basic_latin_to_ascii_stride_src_aligned, basic_latin_to_ascii_stride_dst_aligned, basic_latin_to_ascii_stride_neither_aligned); + latin1_simd_check_align!(unpack_latin1, u8, u16, unpack_stride_both_aligned, unpack_stride_src_aligned, unpack_stride_dst_aligned, unpack_stride_neither_aligned); + latin1_simd_check_align!(pack_latin1, u16, u8, pack_stride_both_aligned, pack_stride_src_aligned, pack_stride_dst_aligned, pack_stride_neither_aligned); + } else if #[cfg(all(feature = "simd-accel", target_feature = "sse2"))] { + // SIMD with different instructions for aligned and unaligned loads and stores. + // + // Newer microarchitectures are not supposed to have a performance difference between + // aligned and unaligned SSE2 loads and stores when the address is actually aligned, + // but the benchmark results I see don't agree. + + pub const SIMD_STRIDE_SIZE: usize = 16; + ++ /// Safety-usable invariant: This should be identical to SIMD_STRIDE_SIZE (used by ascii_simd_check_align_unrolled) + pub const SIMD_ALIGNMENT: usize = 16; + + pub const MAX_STRIDE_SIZE: usize = 16; + + pub const SIMD_ALIGNMENT_MASK: usize = 15; + ++ // Safety for stride macros: We stick to the load8_aligned/etc family of functions. We consistently name ++ // aligned/unaligned functions according to src/dst being aligned/unaligned ++ + ascii_to_ascii_simd_double_stride!(ascii_to_ascii_simd_double_stride_both_aligned, store16_aligned); + ascii_to_ascii_simd_double_stride!(ascii_to_ascii_simd_double_stride_src_aligned, store16_unaligned); + + ascii_to_basic_latin_simd_double_stride!(ascii_to_basic_latin_simd_double_stride_both_aligned, store8_aligned); + ascii_to_basic_latin_simd_double_stride!(ascii_to_basic_latin_simd_double_stride_src_aligned, store8_unaligned); + + ascii_to_ascii_simd_stride!(ascii_to_ascii_stride_both_aligned, load16_aligned, store16_aligned); + ascii_to_ascii_simd_stride!(ascii_to_ascii_stride_src_aligned, load16_aligned, store16_unaligned); +@@ -984,33 +1233,43 @@ cfg_if! { + basic_latin_to_ascii_simd_stride!(basic_latin_to_ascii_stride_both_aligned, load8_aligned, store16_aligned); + basic_latin_to_ascii_simd_stride!(basic_latin_to_ascii_stride_src_aligned, load8_aligned, store16_unaligned); + basic_latin_to_ascii_simd_stride!(basic_latin_to_ascii_stride_dst_aligned, load8_unaligned, store16_aligned); + basic_latin_to_ascii_simd_stride!(basic_latin_to_ascii_stride_neither_aligned, load8_unaligned, store16_unaligned); + + pack_simd_stride!(pack_stride_both_aligned, load8_aligned, store16_aligned); + pack_simd_stride!(pack_stride_src_aligned, load8_aligned, store16_unaligned); + ++ // Safety for conversion macros: We use the correct pattern of both/src/dst/neither/double_both/double_src here. All stride functions were produced ++ // by stride macros that universally munch a single SIMD_STRIDE_SIZE worth of elements. ++ + ascii_simd_check_align_unrolled!(ascii_to_ascii, u8, u8, ascii_to_ascii_stride_both_aligned, ascii_to_ascii_stride_src_aligned, ascii_to_ascii_stride_neither_aligned, ascii_to_ascii_simd_double_stride_both_aligned, ascii_to_ascii_simd_double_stride_src_aligned); + ascii_simd_check_align_unrolled!(ascii_to_basic_latin, u8, u16, ascii_to_basic_latin_stride_both_aligned, ascii_to_basic_latin_stride_src_aligned, ascii_to_basic_latin_stride_neither_aligned, ascii_to_basic_latin_simd_double_stride_both_aligned, ascii_to_basic_latin_simd_double_stride_src_aligned); + + ascii_simd_check_align!(basic_latin_to_ascii, u16, u8, basic_latin_to_ascii_stride_both_aligned, basic_latin_to_ascii_stride_src_aligned, basic_latin_to_ascii_stride_dst_aligned, basic_latin_to_ascii_stride_neither_aligned); + latin1_simd_check_align_unrolled!(unpack_latin1, u8, u16, unpack_stride_both_aligned, unpack_stride_src_aligned, unpack_stride_dst_aligned, unpack_stride_neither_aligned); + latin1_simd_check_align_unrolled!(pack_latin1, u16, u8, pack_stride_both_aligned, pack_stride_src_aligned, pack_stride_dst_aligned, pack_stride_neither_aligned); + } else if #[cfg(all(target_endian = "little", target_pointer_width = "64"))] { + // Aligned ALU word, little-endian, 64-bit + ++ /// Safety invariant: this is the amount of bytes consumed by ++ /// unpack_alu. This will be twice the pointer width, as it consumes two usizes. ++ /// This is also the number of bytes produced by pack_alu. ++ /// This is also the number of u16 code units produced/consumed by unpack_alu/pack_alu respectively. + pub const ALU_STRIDE_SIZE: usize = 16; + + pub const MAX_STRIDE_SIZE: usize = 16; + ++ // Safety invariant: this is the pointer width in bytes + pub const ALU_ALIGNMENT: usize = 8; + ++ // Safety invariant: this is a mask for getting the bits of a pointer not aligned to ALU_ALIGNMENT + pub const ALU_ALIGNMENT_MASK: usize = 7; + ++ /// Safety: dst must point to valid space for writing four `usize`s + #[inline(always)] + unsafe fn unpack_alu(word: usize, second_word: usize, dst: *mut usize) { + let first = ((0x0000_0000_FF00_0000usize & word) << 24) | + ((0x0000_0000_00FF_0000usize & word) << 16) | + ((0x0000_0000_0000_FF00usize & word) << 8) | + (0x0000_0000_0000_00FFusize & word); + let second = ((0xFF00_0000_0000_0000usize & word) >> 8) | + ((0x00FF_0000_0000_0000usize & word) >> 16) | +@@ -1019,22 +1278,24 @@ cfg_if! { + let third = ((0x0000_0000_FF00_0000usize & second_word) << 24) | + ((0x0000_0000_00FF_0000usize & second_word) << 16) | + ((0x0000_0000_0000_FF00usize & second_word) << 8) | + (0x0000_0000_0000_00FFusize & second_word); + let fourth = ((0xFF00_0000_0000_0000usize & second_word) >> 8) | + ((0x00FF_0000_0000_0000usize & second_word) >> 16) | + ((0x0000_FF00_0000_0000usize & second_word) >> 24) | + ((0x0000_00FF_0000_0000usize & second_word) >> 32); ++ // Safety: fn invariant used here + *dst = first; + *(dst.add(1)) = second; + *(dst.add(2)) = third; + *(dst.add(3)) = fourth; + } + ++ /// Safety: dst must point to valid space for writing two `usize`s + #[inline(always)] + unsafe fn pack_alu(first: usize, second: usize, third: usize, fourth: usize, dst: *mut usize) { + let word = ((0x00FF_0000_0000_0000usize & second) << 8) | + ((0x0000_00FF_0000_0000usize & second) << 16) | + ((0x0000_0000_00FF_0000usize & second) << 24) | + ((0x0000_0000_0000_00FFusize & second) << 32) | + ((0x00FF_0000_0000_0000usize & first) >> 24) | + ((0x0000_00FF_0000_0000usize & first) >> 16) | +@@ -1043,70 +1304,88 @@ cfg_if! { + let second_word = ((0x00FF_0000_0000_0000usize & fourth) << 8) | + ((0x0000_00FF_0000_0000usize & fourth) << 16) | + ((0x0000_0000_00FF_0000usize & fourth) << 24) | + ((0x0000_0000_0000_00FFusize & fourth) << 32) | + ((0x00FF_0000_0000_0000usize & third) >> 24) | + ((0x0000_00FF_0000_0000usize & third) >> 16) | + ((0x0000_0000_00FF_0000usize & third) >> 8) | + (0x0000_0000_0000_00FFusize & third); ++ // Safety: fn invariant used here + *dst = word; + *(dst.add(1)) = second_word; + } + } else if #[cfg(all(target_endian = "little", target_pointer_width = "32"))] { + // Aligned ALU word, little-endian, 32-bit + ++ /// Safety invariant: this is the amount of bytes consumed by ++ /// unpack_alu. This will be twice the pointer width, as it consumes two usizes. ++ /// This is also the number of bytes produced by pack_alu. ++ /// This is also the number of u16 code units produced/consumed by unpack_alu/pack_alu respectively. + pub const ALU_STRIDE_SIZE: usize = 8; + + pub const MAX_STRIDE_SIZE: usize = 8; + ++ // Safety invariant: this is the pointer width in bytes + pub const ALU_ALIGNMENT: usize = 4; + ++ // Safety invariant: this is a mask for getting the bits of a pointer not aligned to ALU_ALIGNMENT + pub const ALU_ALIGNMENT_MASK: usize = 3; + ++ /// Safety: dst must point to valid space for writing four `usize`s + #[inline(always)] + unsafe fn unpack_alu(word: usize, second_word: usize, dst: *mut usize) { + let first = ((0x0000_FF00usize & word) << 8) | + (0x0000_00FFusize & word); + let second = ((0xFF00_0000usize & word) >> 8) | + ((0x00FF_0000usize & word) >> 16); + let third = ((0x0000_FF00usize & second_word) << 8) | + (0x0000_00FFusize & second_word); + let fourth = ((0xFF00_0000usize & second_word) >> 8) | + ((0x00FF_0000usize & second_word) >> 16); ++ // Safety: fn invariant used here + *dst = first; + *(dst.add(1)) = second; + *(dst.add(2)) = third; + *(dst.add(3)) = fourth; + } + ++ /// Safety: dst must point to valid space for writing two `usize`s + #[inline(always)] + unsafe fn pack_alu(first: usize, second: usize, third: usize, fourth: usize, dst: *mut usize) { + let word = ((0x00FF_0000usize & second) << 8) | + ((0x0000_00FFusize & second) << 16) | + ((0x00FF_0000usize & first) >> 8) | + (0x0000_00FFusize & first); + let second_word = ((0x00FF_0000usize & fourth) << 8) | + ((0x0000_00FFusize & fourth) << 16) | + ((0x00FF_0000usize & third) >> 8) | + (0x0000_00FFusize & third); ++ // Safety: fn invariant used here + *dst = word; + *(dst.add(1)) = second_word; + } + } else if #[cfg(all(target_endian = "big", target_pointer_width = "64"))] { + // Aligned ALU word, big-endian, 64-bit + ++ /// Safety invariant: this is the amount of bytes consumed by ++ /// unpack_alu. This will be twice the pointer width, as it consumes two usizes. ++ /// This is also the number of bytes produced by pack_alu. ++ /// This is also the number of u16 code units produced/consumed by unpack_alu/pack_alu respectively. + pub const ALU_STRIDE_SIZE: usize = 16; + + pub const MAX_STRIDE_SIZE: usize = 16; + ++ // Safety invariant: this is the pointer width in bytes + pub const ALU_ALIGNMENT: usize = 8; + ++ // Safety invariant: this is a mask for getting the bits of a pointer not aligned to ALU_ALIGNMENT + pub const ALU_ALIGNMENT_MASK: usize = 7; + ++ /// Safety: dst must point to valid space for writing four `usize`s + #[inline(always)] + unsafe fn unpack_alu(word: usize, second_word: usize, dst: *mut usize) { + let first = ((0xFF00_0000_0000_0000usize & word) >> 8) | + ((0x00FF_0000_0000_0000usize & word) >> 16) | + ((0x0000_FF00_0000_0000usize & word) >> 24) | + ((0x0000_00FF_0000_0000usize & word) >> 32); + let second = ((0x0000_0000_FF00_0000usize & word) << 24) | + ((0x0000_0000_00FF_0000usize & word) << 16) | +@@ -1115,22 +1394,24 @@ cfg_if! { + let third = ((0xFF00_0000_0000_0000usize & second_word) >> 8) | + ((0x00FF_0000_0000_0000usize & second_word) >> 16) | + ((0x0000_FF00_0000_0000usize & second_word) >> 24) | + ((0x0000_00FF_0000_0000usize & second_word) >> 32); + let fourth = ((0x0000_0000_FF00_0000usize & second_word) << 24) | + ((0x0000_0000_00FF_0000usize & second_word) << 16) | + ((0x0000_0000_0000_FF00usize & second_word) << 8) | + (0x0000_0000_0000_00FFusize & second_word); ++ // Safety: fn invariant used here + *dst = first; + *(dst.add(1)) = second; + *(dst.add(2)) = third; + *(dst.add(3)) = fourth; + } + ++ /// Safety: dst must point to valid space for writing two `usize`s + #[inline(always)] + unsafe fn pack_alu(first: usize, second: usize, third: usize, fourth: usize, dst: *mut usize) { + let word = ((0x00FF0000_00000000usize & first) << 8) | + ((0x000000FF_00000000usize & first) << 16) | + ((0x00000000_00FF0000usize & first) << 24) | + ((0x00000000_000000FFusize & first) << 32) | + ((0x00FF0000_00000000usize & second) >> 24) | + ((0x000000FF_00000000usize & second) >> 16) | +@@ -1139,67 +1420,80 @@ cfg_if! { + let second_word = ((0x00FF0000_00000000usize & third) << 8) | + ((0x000000FF_00000000usize & third) << 16) | + ((0x00000000_00FF0000usize & third) << 24) | + ((0x00000000_000000FFusize & third) << 32) | + ((0x00FF0000_00000000usize & fourth) >> 24) | + ((0x000000FF_00000000usize & fourth) >> 16) | + ((0x00000000_00FF0000usize & fourth) >> 8) | + (0x00000000_000000FFusize & fourth); ++ // Safety: fn invariant used here + *dst = word; + *(dst.add(1)) = second_word; + } + } else if #[cfg(all(target_endian = "big", target_pointer_width = "32"))] { + // Aligned ALU word, big-endian, 32-bit + ++ /// Safety invariant: this is the amount of bytes consumed by ++ /// unpack_alu. This will be twice the pointer width, as it consumes two usizes. ++ /// This is also the number of bytes produced by pack_alu. ++ /// This is also the number of u16 code units produced/consumed by unpack_alu/pack_alu respectively. + pub const ALU_STRIDE_SIZE: usize = 8; + + pub const MAX_STRIDE_SIZE: usize = 8; + ++ // Safety invariant: this is the pointer width in bytes + pub const ALU_ALIGNMENT: usize = 4; + ++ // Safety invariant: this is a mask for getting the bits of a pointer not aligned to ALU_ALIGNMENT + pub const ALU_ALIGNMENT_MASK: usize = 3; + ++ /// Safety: dst must point to valid space for writing four `usize`s + #[inline(always)] + unsafe fn unpack_alu(word: usize, second_word: usize, dst: *mut usize) { + let first = ((0xFF00_0000usize & word) >> 8) | + ((0x00FF_0000usize & word) >> 16); + let second = ((0x0000_FF00usize & word) << 8) | + (0x0000_00FFusize & word); + let third = ((0xFF00_0000usize & second_word) >> 8) | + ((0x00FF_0000usize & second_word) >> 16); + let fourth = ((0x0000_FF00usize & second_word) << 8) | + (0x0000_00FFusize & second_word); ++ // Safety: fn invariant used here + *dst = first; + *(dst.add(1)) = second; + *(dst.add(2)) = third; + *(dst.add(3)) = fourth; + } + ++ /// Safety: dst must point to valid space for writing two `usize`s + #[inline(always)] + unsafe fn pack_alu(first: usize, second: usize, third: usize, fourth: usize, dst: *mut usize) { + let word = ((0x00FF_0000usize & first) << 8) | + ((0x0000_00FFusize & first) << 16) | + ((0x00FF_0000usize & second) >> 8) | + (0x0000_00FFusize & second); + let second_word = ((0x00FF_0000usize & third) << 8) | + ((0x0000_00FFusize & third) << 16) | + ((0x00FF_0000usize & fourth) >> 8) | + (0x0000_00FFusize & fourth); ++ // Safety: fn invariant used here + *dst = word; + *(dst.add(1)) = second_word; + } + } else { + ascii_naive!(ascii_to_ascii, u8, u8); + ascii_naive!(ascii_to_basic_latin, u8, u16); + ascii_naive!(basic_latin_to_ascii, u16, u8); + } + } + + cfg_if! { ++ // Safety-usable invariant: this counts the zeroes from the "first byte" of utf-8 data packed into a usize ++ // with the target endianness + if #[cfg(target_endian = "little")] { + #[allow(dead_code)] + #[inline(always)] + fn count_zeros(word: usize) -> u32 { + word.trailing_zeros() + } + } else { + #[allow(dead_code)] +@@ -1207,208 +1501,272 @@ cfg_if! { + fn count_zeros(word: usize) -> u32 { + word.leading_zeros() + } + } + } + + cfg_if! { + if #[cfg(all(feature = "simd-accel", target_endian = "little", target_arch = "disabled"))] { ++ /// Safety-usable invariant: Will return the value and position of the first non-ASCII byte in the slice in a Some if found. ++ /// In other words, the first element of the Some is always `> 127` + #[inline(always)] + pub fn validate_ascii(slice: &[u8]) -> Option<(u8, usize)> { + let src = slice.as_ptr(); + let len = slice.len(); + let mut offset = 0usize; ++ // Safety: if this check succeeds we're valid for reading/writing at least `stride` elements. + if SIMD_STRIDE_SIZE <= len { + let len_minus_stride = len - SIMD_STRIDE_SIZE; + loop { ++ // Safety: src at offset is valid for a `SIMD_STRIDE_SIZE` read + let simd = unsafe { load16_unaligned(src.add(offset)) }; + if !simd_is_ascii(simd) { + break; + } + offset += SIMD_STRIDE_SIZE; ++ // This is `offset > len - SIMD_STRIDE_SIZE` which means we always have at least `SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride { + break; + } + } + } + while offset < len { + let code_unit = slice[offset]; + if code_unit > 127 { ++ // Safety: Safety-usable invariant upheld here + return Some((code_unit, offset)); + } + offset += 1; + } + None + } + } else if #[cfg(all(feature = "simd-accel", target_feature = "sse2"))] { ++ /// Safety-usable invariant: will return Some() when it encounters non-ASCII, with the first element in the Some being ++ /// guaranteed to be non-ASCII (> 127), and the second being the offset where it is found + #[inline(always)] + pub fn validate_ascii(slice: &[u8]) -> Option<(u8, usize)> { + let src = slice.as_ptr(); + let len = slice.len(); + let mut offset = 0usize; ++ // Safety: if this check succeeds we're valid for reading at least `stride` elements. + if SIMD_STRIDE_SIZE <= len { + // First, process one unaligned vector ++ // Safety: src is valid for a `SIMD_STRIDE_SIZE` read + let simd = unsafe { load16_unaligned(src) }; + let mask = mask_ascii(simd); + if mask != 0 { + offset = mask.trailing_zeros() as usize; + let non_ascii = unsafe { *src.add(offset) }; + return Some((non_ascii, offset)); + } + offset = SIMD_STRIDE_SIZE; ++ // Safety: Now that offset has changed we don't yet know how much it is valid for + + // We have now seen 16 ASCII bytes. Let's guess that + // there will be enough more to justify more expense + // in the case of non-ASCII. + // Use aligned reads for the sake of old microachitectures. ++ // Safety: this correctly calculates the number of src_units that need to be read before the remaining list is aligned. ++ // This is by definition less than SIMD_ALIGNMENT, which is defined to be equal to SIMD_STRIDE_SIZE. + let until_alignment = unsafe { (SIMD_ALIGNMENT - ((src.add(offset) as usize) & SIMD_ALIGNMENT_MASK)) & SIMD_ALIGNMENT_MASK }; + // This addition won't overflow, because even in the 32-bit PAE case the + // address space holds enough code that the slice length can't be that + // close to address space size. + // offset now equals SIMD_STRIDE_SIZE, hence times 3 below. ++ // ++ // Safety: if this check succeeds we're valid for reading at least `2 * SIMD_STRIDE_SIZE` elements plus `until_alignment`. ++ // The extra SIMD_STRIDE_SIZE in the condition is because `offset` is already `SIMD_STRIDE_SIZE`. + if until_alignment + (SIMD_STRIDE_SIZE * 3) <= len { + if until_alignment != 0 { ++ // Safety: this is safe to call since we're valid for this read (and more), and don't care about alignment ++ // This will copy over bytes that get decoded twice since it's not incrementing `offset` by SIMD_STRIDE_SIZE. This is fine. + let simd = unsafe { load16_unaligned(src.add(offset)) }; + let mask = mask_ascii(simd); + if mask != 0 { + offset += mask.trailing_zeros() as usize; + let non_ascii = unsafe { *src.add(offset) }; + return Some((non_ascii, offset)); + } + offset += until_alignment; + } ++ // Safety: At this point we're valid for reading 2*SIMD_STRIDE_SIZE elements ++ // Safety: Now `offset` is aligned for `src` + let len_minus_stride_times_two = len - (SIMD_STRIDE_SIZE * 2); + loop { ++ // Safety: We were valid for this read, and were aligned. + let first = unsafe { load16_aligned(src.add(offset)) }; + let second = unsafe { load16_aligned(src.add(offset + SIMD_STRIDE_SIZE)) }; + if !simd_is_ascii(first | second) { ++ // Safety: mask_ascii produces a mask of all the high bits. + let mask_first = mask_ascii(first); + if mask_first != 0 { ++ // Safety: on little endian systems this will be the number of ascii bytes ++ // before the first non-ascii, i.e. valid for indexing src ++ // TODO SAFETY: What about big-endian systems? + offset += mask_first.trailing_zeros() as usize; + } else { + let mask_second = mask_ascii(second); ++ // Safety: on little endian systems this will be the number of ascii bytes ++ // before the first non-ascii, i.e. valid for indexing src + offset += SIMD_STRIDE_SIZE + mask_second.trailing_zeros() as usize; + } ++ // Safety: We know this is non-ASCII, and can uphold the safety-usable invariant here + let non_ascii = unsafe { *src.add(offset) }; ++ + return Some((non_ascii, offset)); + } + offset += SIMD_STRIDE_SIZE * 2; ++ // Safety: This is `offset > len - 2 * SIMD_STRIDE_SIZE` which means we always have at least `2 * SIMD_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride_times_two { + break; + } + } ++ // Safety: if this check succeeds we're valid for reading at least `SIMD_STRIDE_SIZE` + if offset + SIMD_STRIDE_SIZE <= len { +- let simd = unsafe { load16_aligned(src.add(offset)) }; +- let mask = mask_ascii(simd); ++ // Safety: We were valid for this read, and were aligned. ++ let simd = unsafe { load16_aligned(src.add(offset)) }; ++ // Safety: mask_ascii produces a mask of all the high bits. ++ let mask = mask_ascii(simd); + if mask != 0 { ++ // Safety: on little endian systems this will be the number of ascii bytes ++ // before the first non-ascii, i.e. valid for indexing src + offset += mask.trailing_zeros() as usize; + let non_ascii = unsafe { *src.add(offset) }; ++ // Safety: We know this is non-ASCII, and can uphold the safety-usable invariant here + return Some((non_ascii, offset)); + } + offset += SIMD_STRIDE_SIZE; + } + } else { ++ // Safety: this is the unaligned branch + // At most two iterations, so unroll ++ // Safety: if this check succeeds we're valid for reading at least `SIMD_STRIDE_SIZE` + if offset + SIMD_STRIDE_SIZE <= len { ++ // Safety: We're valid for this read but must use an unaligned read + let simd = unsafe { load16_unaligned(src.add(offset)) }; + let mask = mask_ascii(simd); + if mask != 0 { + offset += mask.trailing_zeros() as usize; + let non_ascii = unsafe { *src.add(offset) }; ++ // Safety-usable invariant upheld here (same as above) + return Some((non_ascii, offset)); + } + offset += SIMD_STRIDE_SIZE; ++ // Safety: if this check succeeds we're valid for reading at least `SIMD_STRIDE_SIZE` + if offset + SIMD_STRIDE_SIZE <= len { ++ // Safety: We're valid for this read but must use an unaligned read + let simd = unsafe { load16_unaligned(src.add(offset)) }; + let mask = mask_ascii(simd); + if mask != 0 { + offset += mask.trailing_zeros() as usize; + let non_ascii = unsafe { *src.add(offset) }; ++ // Safety-usable invariant upheld here (same as above) + return Some((non_ascii, offset)); + } + offset += SIMD_STRIDE_SIZE; + } + } + } + } + while offset < len { ++ // Safety: relies straightforwardly on the `len` invariant + let code_unit = unsafe { *(src.add(offset)) }; + if code_unit > 127 { ++ // Safety-usable invariant upheld here + return Some((code_unit, offset)); + } + offset += 1; + } + None + } + } else { ++ // Safety-usable invariant: returns byte index of first non-ascii byte + #[inline(always)] + fn find_non_ascii(word: usize, second_word: usize) -> Option { + let word_masked = word & ASCII_MASK; + let second_masked = second_word & ASCII_MASK; + if (word_masked | second_masked) == 0 { ++ // Both are ascii, invariant upheld + return None; + } + if word_masked != 0 { + let zeros = count_zeros(word_masked); +- // `zeros` now contains 7 (for the seven bits of non-ASCII) ++ // `zeros` now contains 0 to 7 (for the seven bits of masked ASCII in little endian, ++ // or up to 7 bits of non-ASCII in big endian if the first byte is non-ASCII) + // plus 8 times the number of ASCII in text order before the + // non-ASCII byte in the little-endian case or 8 times the number of ASCII in + // text order before the non-ASCII byte in the big-endian case. + let num_ascii = (zeros >> 3) as usize; ++ // Safety-usable invariant upheld here + return Some(num_ascii); + } + let zeros = count_zeros(second_masked); +- // `zeros` now contains 7 (for the seven bits of non-ASCII) ++ // `zeros` now contains 0 to 7 (for the seven bits of masked ASCII in little endian, ++ // or up to 7 bits of non-ASCII in big endian if the first byte is non-ASCII) + // plus 8 times the number of ASCII in text order before the + // non-ASCII byte in the little-endian case or 8 times the number of ASCII in + // text order before the non-ASCII byte in the big-endian case. + let num_ascii = (zeros >> 3) as usize; ++ // Safety-usable invariant upheld here + Some(ALU_ALIGNMENT + num_ascii) + } + ++ /// Safety: `src` must be valid for the reads of two `usize`s ++ /// ++ /// Safety-usable invariant: will return byte index of first non-ascii byte + #[inline(always)] + unsafe fn validate_ascii_stride(src: *const usize) -> Option { + let word = *src; + let second_word = *(src.add(1)); + find_non_ascii(word, second_word) + } + ++ /// Safety-usable invariant: will return Some() when it encounters non-ASCII, with the first element in the Some being ++ /// guaranteed to be non-ASCII (> 127), and the second being the offset where it is found + #[cfg_attr(feature = "cargo-clippy", allow(cast_ptr_alignment))] + #[inline(always)] + pub fn validate_ascii(slice: &[u8]) -> Option<(u8, usize)> { + let src = slice.as_ptr(); + let len = slice.len(); + let mut offset = 0usize; + let mut until_alignment = (ALU_ALIGNMENT - ((src as usize) & ALU_ALIGNMENT_MASK)) & ALU_ALIGNMENT_MASK; ++ // Safety: If this check fails we're valid to read `until_alignment + ALU_STRIDE_SIZE` elements + if until_alignment + ALU_STRIDE_SIZE <= len { + while until_alignment != 0 { + let code_unit = slice[offset]; + if code_unit > 127 { ++ // Safety-usable invairant upheld here + return Some((code_unit, offset)); + } + offset += 1; + until_alignment -= 1; + } ++ // Safety: At this point we have read until_alignment elements and ++ // are valid for `ALU_STRIDE_SIZE` more. + let len_minus_stride = len - ALU_STRIDE_SIZE; + loop { ++ // Safety: we were valid for this read + let ptr = unsafe { src.add(offset) as *const usize }; + if let Some(num_ascii) = unsafe { validate_ascii_stride(ptr) } { + offset += num_ascii; ++ // Safety-usable invairant upheld here using the invariant from validate_ascii_stride() + return Some((unsafe { *(src.add(offset)) }, offset)); + } + offset += ALU_STRIDE_SIZE; ++ // Safety: This is `offset > ALU_STRIDE_SIZE` which means we always have at least `2 * ALU_STRIDE_SIZE` elements to munch next time. + if offset > len_minus_stride { + break; + } + } + } + while offset < len { + let code_unit = slice[offset]; + if code_unit > 127 { ++ // Safety-usable invairant upheld here + return Some((code_unit, offset)); + } + offset += 1; + } + None + } + + } +@@ -1423,70 +1781,88 @@ cfg_if! { + // vector reads without vector writes. + + pub const ALU_STRIDE_SIZE: usize = 8; + + pub const ALU_ALIGNMENT: usize = 4; + + pub const ALU_ALIGNMENT_MASK: usize = 3; + } else { ++ // Safety: src points to two valid `usize`s, dst points to four valid `usize`s + #[inline(always)] + unsafe fn unpack_latin1_stride_alu(src: *const usize, dst: *mut usize) { ++ // Safety: src safety invariant used here + let word = *src; + let second_word = *(src.add(1)); ++ // Safety: dst safety invariant passed down + unpack_alu(word, second_word, dst); + } + ++ // Safety: src points to four valid `usize`s, dst points to two valid `usize`s + #[inline(always)] + unsafe fn pack_latin1_stride_alu(src: *const usize, dst: *mut usize) { ++ // Safety: src safety invariant used here + let first = *src; + let second = *(src.add(1)); + let third = *(src.add(2)); + let fourth = *(src.add(3)); ++ // Safety: dst safety invariant passed down + pack_alu(first, second, third, fourth, dst); + } + ++ // Safety: src points to two valid `usize`s, dst points to four valid `usize`s + #[inline(always)] + unsafe fn ascii_to_basic_latin_stride_alu(src: *const usize, dst: *mut usize) -> bool { ++ // Safety: src safety invariant used here + let word = *src; + let second_word = *(src.add(1)); + // Check if the words contains non-ASCII + if (word & ASCII_MASK) | (second_word & ASCII_MASK) != 0 { + return false; + } ++ // Safety: dst safety invariant passed down + unpack_alu(word, second_word, dst); + true + } + ++ // Safety: src points four valid `usize`s, dst points to two valid `usize`s + #[inline(always)] + unsafe fn basic_latin_to_ascii_stride_alu(src: *const usize, dst: *mut usize) -> bool { ++ // Safety: src safety invariant used here + let first = *src; + let second = *(src.add(1)); + let third = *(src.add(2)); + let fourth = *(src.add(3)); + if (first & BASIC_LATIN_MASK) | (second & BASIC_LATIN_MASK) | (third & BASIC_LATIN_MASK) | (fourth & BASIC_LATIN_MASK) != 0 { + return false; + } ++ // Safety: dst safety invariant passed down + pack_alu(first, second, third, fourth, dst); + true + } + ++ // Safety: src, dst both point to two valid `usize`s each ++ // Safety-usable invariant: Will return byte index of first non-ascii byte. + #[inline(always)] + unsafe fn ascii_to_ascii_stride(src: *const usize, dst: *mut usize) -> Option { ++ // Safety: src safety invariant used here + let word = *src; + let second_word = *(src.add(1)); ++ // Safety: src safety invariant used here + *dst = word; + *(dst.add(1)) = second_word; ++ // Relies on safety-usable invariant here + find_non_ascii(word, second_word) + } + + basic_latin_alu!(ascii_to_basic_latin, u8, u16, ascii_to_basic_latin_stride_alu); + basic_latin_alu!(basic_latin_to_ascii, u16, u8, basic_latin_to_ascii_stride_alu); + latin1_alu!(unpack_latin1, u8, u16, unpack_latin1_stride_alu); + latin1_alu!(pack_latin1, u16, u8, pack_latin1_stride_alu); ++ // Safety invariant upheld: ascii_to_ascii_stride will return byte index of first non-ascii if found + ascii_alu!(ascii_to_ascii, u8, u8, ascii_to_ascii_stride); + } + } + + pub fn ascii_valid_up_to(bytes: &[u8]) -> usize { + match validate_ascii(bytes) { + None => bytes.len(), + Some((_, num_valid)) => num_valid, +diff --git a/third_party/rust/encoding_rs/src/handles.rs b/third_party/rust/encoding_rs/src/handles.rs +--- a/third_party/rust/encoding_rs/src/handles.rs ++++ b/third_party/rust/encoding_rs/src/handles.rs +@@ -29,17 +29,17 @@ use crate::simd_funcs::*; + #[cfg(all( + feature = "simd-accel", + any( + target_feature = "sse2", + all(target_endian = "little", target_arch = "aarch64"), + all(target_endian = "little", target_feature = "neon") + ) + ))] +-use packed_simd::u16x8; ++use core::simd::u16x8; + + use super::DecoderResult; + use super::EncoderResult; + use crate::ascii::*; + use crate::utf_8::convert_utf8_to_utf16_up_to_invalid; + use crate::utf_8::utf8_valid_up_to; + + pub enum Space { +@@ -85,84 +85,100 @@ impl Endian for LittleEndian { + const OPPOSITE_ENDIAN: bool = false; + + #[cfg(target_endian = "big")] + const OPPOSITE_ENDIAN: bool = true; + } + + #[derive(Debug, Copy, Clone)] + struct UnalignedU16Slice { ++ // Safety invariant: ptr must be valid for reading 2*len bytes + ptr: *const u8, + len: usize, + } + + impl UnalignedU16Slice { ++ /// Safety: ptr must be valid for reading 2*len bytes + #[inline(always)] + pub unsafe fn new(ptr: *const u8, len: usize) -> UnalignedU16Slice { ++ // Safety: field invariant passed up to caller here + UnalignedU16Slice { ptr, len } + } + + #[inline(always)] + pub fn trim_last(&mut self) { + assert!(self.len > 0); ++ // Safety: invariant upheld here: a slice is still valid with a shorter len + self.len -= 1; + } + + #[inline(always)] + pub fn at(&self, i: usize) -> u16 { + use core::mem::MaybeUninit; + + assert!(i < self.len); + unsafe { + let mut u: MaybeUninit = MaybeUninit::uninit(); ++ // Safety: i is at most len - 1, which works here + ::core::ptr::copy_nonoverlapping(self.ptr.add(i * 2), u.as_mut_ptr() as *mut u8, 2); ++ // Safety: valid read above lets us do this + u.assume_init() + } + } + + #[cfg(feature = "simd-accel")] + #[inline(always)] + pub fn simd_at(&self, i: usize) -> u16x8 { ++ // Safety: i/len are on the scale of u16s, each one corresponds to 2 u8s + assert!(i + SIMD_STRIDE_SIZE / 2 <= self.len); + let byte_index = i * 2; ++ // Safety: load16_unaligned needs SIMD_STRIDE_SIZE=16 u8 elements to read, ++ // or 16/2 = 8 u16 elements to read. ++ // We have checked that we have at least that many above. ++ + unsafe { to_u16_lanes(load16_unaligned(self.ptr.add(byte_index))) } + } + + #[inline(always)] + pub fn len(&self) -> usize { + self.len + } + + #[inline(always)] + pub fn tail(&self, from: usize) -> UnalignedU16Slice { + // XXX the return value should be restricted not to + // outlive self. + assert!(from <= self.len); ++ // Safety: This upholds the same invariant: `from` is in bounds and we're returning a shorter slice + unsafe { UnalignedU16Slice::new(self.ptr.add(from * 2), self.len - from) } + } + + #[cfg(feature = "simd-accel")] + #[inline(always)] + pub fn copy_bmp_to(&self, other: &mut [u16]) -> Option<(u16, usize)> { + assert!(self.len <= other.len()); + let mut offset = 0; ++ // Safety: SIMD_STRIDE_SIZE is measured in bytes, whereas len is in u16s. We check we can ++ // munch SIMD_STRIDE_SIZE / 2 u16s which means we can write SIMD_STRIDE_SIZE u8s + if SIMD_STRIDE_SIZE / 2 <= self.len { + let len_minus_stride = self.len - SIMD_STRIDE_SIZE / 2; + loop { + let mut simd = self.simd_at(offset); + if E::OPPOSITE_ENDIAN { + simd = simd_byte_swap(simd); + } ++ // Safety: we have enough space on the other side to write this + unsafe { + store8_unaligned(other.as_mut_ptr().add(offset), simd); + } + if contains_surrogates(simd) { + break; + } + offset += SIMD_STRIDE_SIZE / 2; ++ // Safety: This ensures we still have space for writing SIMD_STRIDE_SIZE u8s + if offset > len_minus_stride { + break; + } + } + } + while offset < self.len { + let unit = swap_if_opposite_endian::(self.at(offset)); + other[offset] = unit; +@@ -231,33 +247,37 @@ fn copy_unaligned_basic_latin_to_ascii( + src: UnalignedU16Slice, + dst: &mut [u8], + ) -> CopyAsciiResult { + let len = ::core::cmp::min(src.len(), dst.len()); + let mut offset = 0; ++ // Safety: This check ensures we are able to read/write at least SIMD_STRIDE_SIZE elements + if SIMD_STRIDE_SIZE <= len { + let len_minus_stride = len - SIMD_STRIDE_SIZE; + loop { + let mut first = src.simd_at(offset); + let mut second = src.simd_at(offset + (SIMD_STRIDE_SIZE / 2)); + if E::OPPOSITE_ENDIAN { + first = simd_byte_swap(first); + second = simd_byte_swap(second); + } + if !simd_is_basic_latin(first | second) { + break; + } + let packed = simd_pack(first, second); ++ // Safety: We are able to write SIMD_STRIDE_SIZE elements in this iteration + unsafe { + store16_unaligned(dst.as_mut_ptr().add(offset), packed); + } + offset += SIMD_STRIDE_SIZE; ++ // Safety: This is `offset > len - SIMD_STRIDE_SIZE`, which ensures that we can write at least SIMD_STRIDE_SIZE elements ++ // in the next iteration + if offset > len_minus_stride { + break; + } + } + } + copy_unaligned_basic_latin_to_ascii_alu::(src.tail(offset), &mut dst[offset..], offset) + } + +@@ -632,94 +652,106 @@ impl<'a> Utf16Destination<'a> { + #[inline(always)] + fn write_astral(&mut self, astral: u32) { + debug_assert!(astral > 0xFFFF); + debug_assert!(astral <= 0x10_FFFF); + self.write_code_unit((0xD7C0 + (astral >> 10)) as u16); + self.write_code_unit((0xDC00 + (astral & 0x3FF)) as u16); + } + #[inline(always)] +- pub fn write_surrogate_pair(&mut self, high: u16, low: u16) { ++ fn write_surrogate_pair(&mut self, high: u16, low: u16) { + self.write_code_unit(high); + self.write_code_unit(low); + } + #[inline(always)] + fn write_big5_combination(&mut self, combined: u16, combining: u16) { + self.write_bmp_excl_ascii(combined); + self.write_bmp_excl_ascii(combining); + } ++ // Safety-usable invariant: CopyAsciiResult::GoOn will only contain bytes >=0x80 + #[inline(always)] + pub fn copy_ascii_from_check_space_bmp<'b>( + &'b mut self, + source: &mut ByteSource, + ) -> CopyAsciiResult<(DecoderResult, usize, usize), (u8, Utf16BmpHandle<'b, 'a>)> { + let non_ascii_ret = { + let src_remaining = &source.slice[source.pos..]; + let dst_remaining = &mut self.slice[self.pos..]; + let (pending, length) = if dst_remaining.len() < src_remaining.len() { + (DecoderResult::OutputFull, dst_remaining.len()) + } else { + (DecoderResult::InputEmpty, src_remaining.len()) + }; ++ // Safety: This function is documented as needing valid pointers for src/dest and len, which ++ // is true since we've passed the minumum length of the two + match unsafe { + ascii_to_basic_latin(src_remaining.as_ptr(), dst_remaining.as_mut_ptr(), length) + } { + None => { + source.pos += length; + self.pos += length; + return CopyAsciiResult::Stop((pending, source.pos, self.pos)); + } ++ // Safety: the function is documented as returning bytes >=0x80 in the Some + Some((non_ascii, consumed)) => { + source.pos += consumed; + self.pos += consumed; + source.pos += 1; // +1 for non_ascii ++ // Safety: non-ascii bubbled out here + non_ascii + } + } + }; ++ // Safety: non-ascii returned here + CopyAsciiResult::GoOn((non_ascii_ret, Utf16BmpHandle::new(self))) + } ++ // Safety-usable invariant: CopyAsciiResult::GoOn will only contain bytes >=0x80 + #[inline(always)] + pub fn copy_ascii_from_check_space_astral<'b>( + &'b mut self, + source: &mut ByteSource, + ) -> CopyAsciiResult<(DecoderResult, usize, usize), (u8, Utf16AstralHandle<'b, 'a>)> { + let non_ascii_ret = { + let dst_len = self.slice.len(); + let src_remaining = &source.slice[source.pos..]; + let dst_remaining = &mut self.slice[self.pos..]; + let (pending, length) = if dst_remaining.len() < src_remaining.len() { + (DecoderResult::OutputFull, dst_remaining.len()) + } else { + (DecoderResult::InputEmpty, src_remaining.len()) + }; ++ // Safety: This function is documented as needing valid pointers for src/dest and len, which ++ // is true since we've passed the minumum length of the two + match unsafe { + ascii_to_basic_latin(src_remaining.as_ptr(), dst_remaining.as_mut_ptr(), length) + } { + None => { + source.pos += length; + self.pos += length; + return CopyAsciiResult::Stop((pending, source.pos, self.pos)); + } ++ // Safety: the function is documented as returning bytes >=0x80 in the Some + Some((non_ascii, consumed)) => { + source.pos += consumed; + self.pos += consumed; + if self.pos + 1 < dst_len { + source.pos += 1; // +1 for non_ascii ++ // Safety: non-ascii bubbled out here + non_ascii + } else { + return CopyAsciiResult::Stop(( + DecoderResult::OutputFull, + source.pos, + self.pos, + )); + } + } + } + }; ++ // Safety: non-ascii returned here + CopyAsciiResult::GoOn((non_ascii_ret, Utf16AstralHandle::new(self))) + } + #[inline(always)] + pub fn copy_utf8_up_to_invalid_from(&mut self, source: &mut ByteSource) { + let src_remaining = &source.slice[source.pos..]; + let dst_remaining = &mut self.slice[self.pos..]; + let (read, written) = convert_utf8_to_utf16_up_to_invalid(src_remaining, dst_remaining); + source.pos += read; +diff --git a/third_party/rust/encoding_rs/src/lib.rs b/third_party/rust/encoding_rs/src/lib.rs +--- a/third_party/rust/encoding_rs/src/lib.rs ++++ b/third_party/rust/encoding_rs/src/lib.rs +@@ -684,37 +684,26 @@ + //! TIS-620windows-874 + //! + //! + //! + //! See the section [_UTF-16LE, UTF-16BE and Unicode Encoding Schemes_](#utf-16le-utf-16be-and-unicode-encoding-schemes) + //! for discussion about the UTF-16 family. + + #![no_std] +-#![cfg_attr(feature = "simd-accel", feature(core_intrinsics))] ++#![cfg_attr(feature = "simd-accel", feature(core_intrinsics, portable_simd))] + + #[cfg(feature = "alloc")] + #[cfg_attr(test, macro_use)] + extern crate alloc; + + extern crate core; + #[macro_use] + extern crate cfg_if; + +-#[cfg(all( +- feature = "simd-accel", +- any( +- target_feature = "sse2", +- all(target_endian = "little", target_arch = "aarch64"), +- all(target_endian = "little", target_feature = "neon") +- ) +-))] +-#[macro_use(shuffle)] +-extern crate packed_simd; +- + #[cfg(feature = "serde")] + extern crate serde; + + #[cfg(all(test, feature = "serde"))] + extern crate bincode; + #[cfg(all(test, feature = "serde"))] + #[macro_use] + extern crate serde_derive; +diff --git a/third_party/rust/encoding_rs/src/mem.rs b/third_party/rust/encoding_rs/src/mem.rs +--- a/third_party/rust/encoding_rs/src/mem.rs ++++ b/third_party/rust/encoding_rs/src/mem.rs +@@ -111,16 +111,21 @@ macro_rules! by_unit_check_alu { + until_alignment -= 1; + } + if accu >= $bound { + return false; + } + } + let len_minus_stride = len - ALU_ALIGNMENT / unit_size; + if offset + (4 * (ALU_ALIGNMENT / unit_size)) <= len { ++ // Safety: the above check lets us perform 4 consecutive reads of ++ // length ALU_ALIGNMENT / unit_size. ALU_ALIGNMENT is the size of usize, and unit_size ++ // is the size of the `src` pointer, so this is equal to performing four usize reads. ++ // ++ // This invariant is upheld on all loop iterations + let len_minus_unroll = len - (4 * (ALU_ALIGNMENT / unit_size)); + loop { + let unroll_accu = unsafe { *(src.add(offset) as *const usize) } + | unsafe { + *(src.add(offset + (ALU_ALIGNMENT / unit_size)) as *const usize) + } + | unsafe { + *(src.add(offset + (2 * (ALU_ALIGNMENT / unit_size))) +@@ -129,22 +134,24 @@ macro_rules! by_unit_check_alu { + | unsafe { + *(src.add(offset + (3 * (ALU_ALIGNMENT / unit_size))) + as *const usize) + }; + if unroll_accu & $mask != 0 { + return false; + } + offset += 4 * (ALU_ALIGNMENT / unit_size); ++ // Safety: this check lets us continue to perform the 4 reads earlier + if offset > len_minus_unroll { + break; + } + } + } + while offset <= len_minus_stride { ++ // Safety: the above check lets us perform one usize read. + accu |= unsafe { *(src.add(offset) as *const usize) }; + offset += ALU_ALIGNMENT / unit_size; + } + } + } + for &unit in &buffer[offset..] { + accu |= unit as usize; + } +@@ -184,16 +191,21 @@ macro_rules! by_unit_check_simd { + until_alignment -= 1; + } + if accu >= $bound { + return false; + } + } + let len_minus_stride = len - SIMD_STRIDE_SIZE / unit_size; + if offset + (4 * (SIMD_STRIDE_SIZE / unit_size)) <= len { ++ // Safety: the above check lets us perform 4 consecutive reads of ++ // length SIMD_STRIDE_SIZE / unit_size. SIMD_STRIDE_SIZE is the size of $simd_ty, and unit_size ++ // is the size of the `src` pointer, so this is equal to performing four $simd_ty reads. ++ // ++ // This invariant is upheld on all loop iterations + let len_minus_unroll = len - (4 * (SIMD_STRIDE_SIZE / unit_size)); + loop { + let unroll_accu = unsafe { *(src.add(offset) as *const $simd_ty) } + | unsafe { + *(src.add(offset + (SIMD_STRIDE_SIZE / unit_size)) + as *const $simd_ty) + } + | unsafe { +@@ -203,23 +215,25 @@ macro_rules! by_unit_check_simd { + | unsafe { + *(src.add(offset + (3 * (SIMD_STRIDE_SIZE / unit_size))) + as *const $simd_ty) + }; + if !$func(unroll_accu) { + return false; + } + offset += 4 * (SIMD_STRIDE_SIZE / unit_size); ++ // Safety: this check lets us continue to perform the 4 reads earlier + if offset > len_minus_unroll { + break; + } + } + } + let mut simd_accu = $splat; + while offset <= len_minus_stride { ++ // Safety: the above check lets us perform one $simd_ty read. + simd_accu = simd_accu | unsafe { *(src.add(offset) as *const $simd_ty) }; + offset += SIMD_STRIDE_SIZE / unit_size; + } + if !$func(simd_accu) { + return false; + } + } + } +@@ -229,18 +243,18 @@ macro_rules! by_unit_check_simd { + accu < $bound + } + }; + } + + cfg_if! { + if #[cfg(all(feature = "simd-accel", any(target_feature = "sse2", all(target_endian = "little", target_arch = "aarch64"), all(target_endian = "little", target_feature = "neon"))))] { + use crate::simd_funcs::*; +- use packed_simd::u8x16; +- use packed_simd::u16x8; ++ use core::simd::u8x16; ++ use core::simd::u16x8; + + const SIMD_ALIGNMENT: usize = 16; + + const SIMD_ALIGNMENT_MASK: usize = 15; + + by_unit_check_simd!(is_ascii_impl, u8, u8x16::splat(0), u8x16, 0x80, simd_is_ascii); + by_unit_check_simd!(is_basic_latin_impl, u16, u16x8::splat(0), u16x8, 0x80, simd_is_basic_latin); + by_unit_check_simd!(is_utf16_latin1_impl, u16, u16x8::splat(0), u16x8, 0x100, simd_is_latin1); +diff --git a/third_party/rust/encoding_rs/src/simd_funcs.rs b/third_party/rust/encoding_rs/src/simd_funcs.rs +--- a/third_party/rust/encoding_rs/src/simd_funcs.rs ++++ b/third_party/rust/encoding_rs/src/simd_funcs.rs +@@ -2,65 +2,84 @@ + // file at the top-level directory of this distribution. + // + // Licensed under the Apache License, Version 2.0 or the MIT license + // , at your + // option. This file may not be copied, modified, or distributed + // except according to those terms. + +-use packed_simd::u16x8; +-use packed_simd::u8x16; +-use packed_simd::IntoBits; ++use any_all_workaround::all_mask16x8; ++use any_all_workaround::all_mask8x16; ++use any_all_workaround::any_mask16x8; ++use any_all_workaround::any_mask8x16; ++use core::simd::cmp::SimdPartialEq; ++use core::simd::cmp::SimdPartialOrd; ++use core::simd::mask16x8; ++use core::simd::mask8x16; ++use core::simd::simd_swizzle; ++use core::simd::u16x8; ++use core::simd::u8x16; ++use core::simd::ToBytes; + + // TODO: Migrate unaligned access to stdlib code if/when the RFC + // https://github.com/rust-lang/rfcs/pull/1725 is implemented. + ++/// Safety invariant: ptr must be valid for an unaligned read of 16 bytes + #[inline(always)] + pub unsafe fn load16_unaligned(ptr: *const u8) -> u8x16 { +- let mut simd = ::core::mem::uninitialized(); +- ::core::ptr::copy_nonoverlapping(ptr, &mut simd as *mut u8x16 as *mut u8, 16); +- simd ++ let mut simd = ::core::mem::MaybeUninit::::uninit(); ++ ::core::ptr::copy_nonoverlapping(ptr, simd.as_mut_ptr() as *mut u8, 16); ++ // Safety: copied 16 bytes of initialized memory into this, it is now initialized ++ simd.assume_init() + } + ++/// Safety invariant: ptr must be valid for an aligned-for-u8x16 read of 16 bytes + #[allow(dead_code)] + #[inline(always)] + pub unsafe fn load16_aligned(ptr: *const u8) -> u8x16 { + *(ptr as *const u8x16) + } + ++/// Safety invariant: ptr must be valid for an unaligned store of 16 bytes + #[inline(always)] + pub unsafe fn store16_unaligned(ptr: *mut u8, s: u8x16) { + ::core::ptr::copy_nonoverlapping(&s as *const u8x16 as *const u8, ptr, 16); + } + ++/// Safety invariant: ptr must be valid for an aligned-for-u8x16 store of 16 bytes + #[allow(dead_code)] + #[inline(always)] + pub unsafe fn store16_aligned(ptr: *mut u8, s: u8x16) { + *(ptr as *mut u8x16) = s; + } + ++/// Safety invariant: ptr must be valid for an unaligned read of 16 bytes + #[inline(always)] + pub unsafe fn load8_unaligned(ptr: *const u16) -> u16x8 { +- let mut simd = ::core::mem::uninitialized(); +- ::core::ptr::copy_nonoverlapping(ptr as *const u8, &mut simd as *mut u16x8 as *mut u8, 16); +- simd ++ let mut simd = ::core::mem::MaybeUninit::::uninit(); ++ ::core::ptr::copy_nonoverlapping(ptr as *const u8, simd.as_mut_ptr() as *mut u8, 16); ++ // Safety: copied 16 bytes of initialized memory into this, it is now initialized ++ simd.assume_init() + } + ++/// Safety invariant: ptr must be valid for an aligned-for-u16x8 read of 16 bytes + #[allow(dead_code)] + #[inline(always)] + pub unsafe fn load8_aligned(ptr: *const u16) -> u16x8 { + *(ptr as *const u16x8) + } + ++/// Safety invariant: ptr must be valid for an unaligned store of 16 bytes + #[inline(always)] + pub unsafe fn store8_unaligned(ptr: *mut u16, s: u16x8) { + ::core::ptr::copy_nonoverlapping(&s as *const u16x8 as *const u8, ptr as *mut u8, 16); + } + ++/// Safety invariant: ptr must be valid for an aligned-for-u16x8 store of 16 bytes + #[allow(dead_code)] + #[inline(always)] + pub unsafe fn store8_aligned(ptr: *mut u16, s: u16x8) { + *(ptr as *mut u16x8) = s; + } + + cfg_if! { + if #[cfg(all(target_feature = "sse2", target_arch = "x86_64"))] { +@@ -95,234 +114,241 @@ cfg_if! { + pub fn simd_byte_swap(s: u16x8) -> u16x8 { + let left = s << 8; + let right = s >> 8; + left | right + } + + #[inline(always)] + pub fn to_u16_lanes(s: u8x16) -> u16x8 { +- s.into_bits() ++ u16x8::from_ne_bytes(s) + } + + cfg_if! { + if #[cfg(target_feature = "sse2")] { + + // Expose low-level mask instead of higher-level conclusion, + // because the non-ASCII case would perform less well otherwise. ++ // Safety-usable invariant: This returned value is whether each high bit is set + #[inline(always)] + pub fn mask_ascii(s: u8x16) -> i32 { + unsafe { +- _mm_movemask_epi8(s.into_bits()) ++ _mm_movemask_epi8(s.into()) + } + } + + } else { + + } + } + + cfg_if! { + if #[cfg(target_feature = "sse2")] { + #[inline(always)] + pub fn simd_is_ascii(s: u8x16) -> bool { + unsafe { +- _mm_movemask_epi8(s.into_bits()) == 0 ++ // Safety: We have cfg()d the correct platform ++ _mm_movemask_epi8(s.into()) == 0 + } + } + } else if #[cfg(target_arch = "aarch64")]{ + #[inline(always)] + pub fn simd_is_ascii(s: u8x16) -> bool { + unsafe { +- vmaxvq_u8(s.into_bits()) < 0x80 ++ // Safety: We have cfg()d the correct platform ++ vmaxvq_u8(s.into()) < 0x80 + } + } + } else { + #[inline(always)] + pub fn simd_is_ascii(s: u8x16) -> bool { + // This optimizes better on ARM than + // the lt formulation. + let highest_ascii = u8x16::splat(0x7F); +- !s.gt(highest_ascii).any() ++ !any_mask8x16(s.simd_gt(highest_ascii)) + } + } + } + + cfg_if! { + if #[cfg(target_feature = "sse2")] { + #[inline(always)] + pub fn simd_is_str_latin1(s: u8x16) -> bool { + if simd_is_ascii(s) { + return true; + } + let above_str_latin1 = u8x16::splat(0xC4); +- s.lt(above_str_latin1).all() ++ s.simd_lt(above_str_latin1).all() + } + } else if #[cfg(target_arch = "aarch64")]{ + #[inline(always)] + pub fn simd_is_str_latin1(s: u8x16) -> bool { + unsafe { +- vmaxvq_u8(s.into_bits()) < 0xC4 ++ // Safety: We have cfg()d the correct platform ++ vmaxvq_u8(s.into()) < 0xC4 + } + } + } else { + #[inline(always)] + pub fn simd_is_str_latin1(s: u8x16) -> bool { + let above_str_latin1 = u8x16::splat(0xC4); +- s.lt(above_str_latin1).all() ++ all_mask8x16(s.simd_lt(above_str_latin1)) + } + } + } + + cfg_if! { + if #[cfg(target_arch = "aarch64")]{ + #[inline(always)] + pub fn simd_is_basic_latin(s: u16x8) -> bool { + unsafe { +- vmaxvq_u16(s.into_bits()) < 0x80 ++ // Safety: We have cfg()d the correct platform ++ vmaxvq_u16(s.into()) < 0x80 + } + } + + #[inline(always)] + pub fn simd_is_latin1(s: u16x8) -> bool { + unsafe { +- vmaxvq_u16(s.into_bits()) < 0x100 ++ // Safety: We have cfg()d the correct platform ++ vmaxvq_u16(s.into()) < 0x100 + } + } + } else { + #[inline(always)] + pub fn simd_is_basic_latin(s: u16x8) -> bool { + let above_ascii = u16x8::splat(0x80); +- s.lt(above_ascii).all() ++ all_mask16x8(s.simd_lt(above_ascii)) + } + + #[inline(always)] + pub fn simd_is_latin1(s: u16x8) -> bool { + // For some reason, on SSE2 this formulation + // seems faster in this case while the above + // function is better the other way round... + let highest_latin1 = u16x8::splat(0xFF); +- !s.gt(highest_latin1).any() ++ !any_mask16x8(s.simd_gt(highest_latin1)) + } + } + } + + #[inline(always)] + pub fn contains_surrogates(s: u16x8) -> bool { + let mask = u16x8::splat(0xF800); + let surrogate_bits = u16x8::splat(0xD800); +- (s & mask).eq(surrogate_bits).any() ++ any_mask16x8((s & mask).simd_eq(surrogate_bits)) + } + + cfg_if! { + if #[cfg(target_arch = "aarch64")]{ + macro_rules! aarch64_return_false_if_below_hebrew { + ($s:ident) => ({ + unsafe { +- if vmaxvq_u16($s.into_bits()) < 0x0590 { ++ // Safety: We have cfg()d the correct platform ++ if vmaxvq_u16($s.into()) < 0x0590 { + return false; + } + } + }) + } + + macro_rules! non_aarch64_return_false_if_all { + ($s:ident) => () + } + } else { + macro_rules! aarch64_return_false_if_below_hebrew { + ($s:ident) => () + } + + macro_rules! non_aarch64_return_false_if_all { + ($s:ident) => ({ +- if $s.all() { ++ if all_mask16x8($s) { + return false; + } + }) + } + } + } + + macro_rules! in_range16x8 { + ($s:ident, $start:expr, $end:expr) => {{ + // SIMD sub is wrapping +- ($s - u16x8::splat($start)).lt(u16x8::splat($end - $start)) ++ ($s - u16x8::splat($start)).simd_lt(u16x8::splat($end - $start)) + }}; + } + + #[inline(always)] + pub fn is_u16x8_bidi(s: u16x8) -> bool { + // We try to first quickly refute the RTLness of the vector. If that + // fails, we do the real RTL check, so in that case we end up wasting + // the work for the up-front quick checks. Even the quick-check is + // two-fold in order to return `false` ASAP if everything is below + // Hebrew. + + aarch64_return_false_if_below_hebrew!(s); + +- let below_hebrew = s.lt(u16x8::splat(0x0590)); ++ let below_hebrew = s.simd_lt(u16x8::splat(0x0590)); + + non_aarch64_return_false_if_all!(below_hebrew); + +- if (below_hebrew | in_range16x8!(s, 0x0900, 0x200F) | in_range16x8!(s, 0x2068, 0xD802)).all() { ++ if all_mask16x8( ++ below_hebrew | in_range16x8!(s, 0x0900, 0x200F) | in_range16x8!(s, 0x2068, 0xD802), ++ ) { + return false; + } + + // Quick refutation failed. Let's do the full check. + +- (in_range16x8!(s, 0x0590, 0x0900) +- | in_range16x8!(s, 0xFB1D, 0xFE00) +- | in_range16x8!(s, 0xFE70, 0xFEFF) +- | in_range16x8!(s, 0xD802, 0xD804) +- | in_range16x8!(s, 0xD83A, 0xD83C) +- | s.eq(u16x8::splat(0x200F)) +- | s.eq(u16x8::splat(0x202B)) +- | s.eq(u16x8::splat(0x202E)) +- | s.eq(u16x8::splat(0x2067))) +- .any() ++ any_mask16x8( ++ (in_range16x8!(s, 0x0590, 0x0900) ++ | in_range16x8!(s, 0xFB1D, 0xFE00) ++ | in_range16x8!(s, 0xFE70, 0xFEFF) ++ | in_range16x8!(s, 0xD802, 0xD804) ++ | in_range16x8!(s, 0xD83A, 0xD83C) ++ | s.simd_eq(u16x8::splat(0x200F)) ++ | s.simd_eq(u16x8::splat(0x202B)) ++ | s.simd_eq(u16x8::splat(0x202E)) ++ | s.simd_eq(u16x8::splat(0x2067))), ++ ) + } + + #[inline(always)] + pub fn simd_unpack(s: u8x16) -> (u16x8, u16x8) { +- unsafe { +- let first: u8x16 = shuffle!( +- s, +- u8x16::splat(0), +- [0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23] +- ); +- let second: u8x16 = shuffle!( +- s, +- u8x16::splat(0), +- [8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31] +- ); +- (first.into_bits(), second.into_bits()) +- } ++ let first: u8x16 = simd_swizzle!( ++ s, ++ u8x16::splat(0), ++ [0, 16, 1, 17, 2, 18, 3, 19, 4, 20, 5, 21, 6, 22, 7, 23] ++ ); ++ let second: u8x16 = simd_swizzle!( ++ s, ++ u8x16::splat(0), ++ [8, 24, 9, 25, 10, 26, 11, 27, 12, 28, 13, 29, 14, 30, 15, 31] ++ ); ++ (u16x8::from_ne_bytes(first), u16x8::from_ne_bytes(second)) + } + + cfg_if! { + if #[cfg(target_feature = "sse2")] { + #[inline(always)] + pub fn simd_pack(a: u16x8, b: u16x8) -> u8x16 { + unsafe { +- _mm_packus_epi16(a.into_bits(), b.into_bits()).into_bits() ++ // Safety: We have cfg()d the correct platform ++ _mm_packus_epi16(a.into(), b.into()).into() + } + } + } else { + #[inline(always)] + pub fn simd_pack(a: u16x8, b: u16x8) -> u8x16 { +- unsafe { +- let first: u8x16 = a.into_bits(); +- let second: u8x16 = b.into_bits(); +- shuffle!( +- first, +- second, +- [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30] +- ) +- } ++ let first: u8x16 = a.to_ne_bytes(); ++ let second: u8x16 = b.to_ne_bytes(); ++ simd_swizzle!( ++ first, ++ second, ++ [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30] ++ ) + } + } + } + + #[cfg(test)] + mod tests { + use super::*; + use alloc::vec::Vec; +diff --git a/third_party/rust/encoding_rs/src/single_byte.rs b/third_party/rust/encoding_rs/src/single_byte.rs +--- a/third_party/rust/encoding_rs/src/single_byte.rs ++++ b/third_party/rust/encoding_rs/src/single_byte.rs +@@ -48,16 +48,19 @@ impl SingleByteDecoder { + CopyAsciiResult::GoOn((mut non_ascii, mut handle)) => 'middle: loop { + // Start non-boilerplate + // + // Since the non-ASCIIness of `non_ascii` is hidden from + // the optimizer, it can't figure out that it's OK to + // statically omit the bound check when accessing + // `[u16; 128]` with an index + // `non_ascii as usize - 0x80usize`. ++ // ++ // Safety: `non_ascii` is a u8 byte >=0x80, from the invariants ++ // on Utf8Destination::copy_ascii_from_check_space_bmp() + let mapped = + unsafe { *(self.table.get_unchecked(non_ascii as usize - 0x80usize)) }; + // let mapped = self.table[non_ascii as usize - 0x80usize]; + if mapped == 0u16 { + return ( + DecoderResult::Malformed(1, 0), + source.consumed(), + handle.written(), +@@ -146,82 +149,103 @@ impl SingleByteDecoder { + dst: &mut [u16], + _last: bool, + ) -> (DecoderResult, usize, usize) { + let (pending, length) = if dst.len() < src.len() { + (DecoderResult::OutputFull, dst.len()) + } else { + (DecoderResult::InputEmpty, src.len()) + }; ++ // Safety invariant: converted <= length. Quite often we have `converted < length` ++ // which will be separately marked. + let mut converted = 0usize; + 'outermost: loop { + match unsafe { ++ // Safety: length is the minimum length, `src/dst + x` will always be valid for reads/writes of `len - x` + ascii_to_basic_latin( + src.as_ptr().add(converted), + dst.as_mut_ptr().add(converted), + length - converted, + ) + } { + None => { + return (pending, length, length); + } + Some((mut non_ascii, consumed)) => { ++ // Safety invariant: `converted <= length` upheld, since this can only consume ++ // up to `length - converted` bytes. ++ // ++ // Furthermore, in this context, ++ // we can assume `converted < length` since this branch is only ever hit when ++ // ascii_to_basic_latin fails to consume the entire slice + converted += consumed; + 'middle: loop { + // `converted` doesn't count the reading of `non_ascii` yet. + // Since the non-ASCIIness of `non_ascii` is hidden from + // the optimizer, it can't figure out that it's OK to + // statically omit the bound check when accessing + // `[u16; 128]` with an index + // `non_ascii as usize - 0x80usize`. ++ // ++ // Safety: We can rely on `non_ascii` being between `0x80` and `0xFF` due to ++ // the invariants of `ascii_to_basic_latin()`, and our table has enough space for that. + let mapped = + unsafe { *(self.table.get_unchecked(non_ascii as usize - 0x80usize)) }; + // let mapped = self.table[non_ascii as usize - 0x80usize]; + if mapped == 0u16 { + return ( + DecoderResult::Malformed(1, 0), + converted + 1, // +1 `for non_ascii` + converted, + ); + } + unsafe { +- // The bound check has already been performed ++ // Safety: As mentioned above, `converted < length` + *(dst.get_unchecked_mut(converted)) = mapped; + } ++ // Safety: `converted <= length` upheld, since `converted < length` before this + converted += 1; + // Next, handle ASCII punctuation and non-ASCII without + // going back to ASCII acceleration. Non-ASCII scripts + // use ASCII punctuation, so this avoid going to + // acceleration just for punctuation/space and then + // failing. This is a significant boost to non-ASCII + // scripts. + // TODO: Split out Latin converters without this part + // this stuff makes Latin script-conversion slower. + if converted == length { + return (pending, length, length); + } ++ // Safety: We are back to `converted < length` because of the == above ++ // and can perform this check. + let mut b = unsafe { *(src.get_unchecked(converted)) }; ++ // Safety: `converted < length` is upheld for this loop + 'innermost: loop { + if b > 127 { + non_ascii = b; + continue 'middle; + } + // Testing on Haswell says that we should write the + // byte unconditionally instead of trying to unread it + // to make it part of the next SIMD stride. + unsafe { ++ // Safety: `converted < length` is true for this loop + *(dst.get_unchecked_mut(converted)) = u16::from(b); + } ++ // Safety: We are now at `converted <= length`. We should *not* `continue` ++ // the loop without reverifying + converted += 1; + if b < 60 { + // We've got punctuation + if converted == length { + return (pending, length, length); + } ++ // Safety: we're back to `converted <= length` because of the == above + b = unsafe { *(src.get_unchecked(converted)) }; ++ // Safety: The loop continues as `converted < length` + continue 'innermost; + } + // We've got markup or ASCII text + continue 'outermost; + } + } + } + } +@@ -229,16 +253,18 @@ impl SingleByteDecoder { + } + + pub fn latin1_byte_compatible_up_to(&self, buffer: &[u8]) -> usize { + let mut bytes = buffer; + let mut total = 0; + loop { + if let Some((non_ascii, offset)) = validate_ascii(bytes) { + total += offset; ++ // Safety: We can rely on `non_ascii` being between `0x80` and `0xFF` due to ++ // the invariants of `ascii_to_basic_latin()`, and our table has enough space for that. + let mapped = unsafe { *(self.table.get_unchecked(non_ascii as usize - 0x80usize)) }; + if mapped != u16::from(non_ascii) { + return total; + } + total += 1; + bytes = &bytes[offset + 1..]; + } else { + return total; +@@ -379,64 +405,89 @@ impl SingleByteEncoder { + dst: &mut [u8], + _last: bool, + ) -> (EncoderResult, usize, usize) { + let (pending, length) = if dst.len() < src.len() { + (EncoderResult::OutputFull, dst.len()) + } else { + (EncoderResult::InputEmpty, src.len()) + }; ++ // Safety invariant: converted <= length. Quite often we have `converted < length` ++ // which will be separately marked. + let mut converted = 0usize; + 'outermost: loop { + match unsafe { ++ // Safety: length is the minimum length, `src/dst + x` will always be valid for reads/writes of `len - x` + basic_latin_to_ascii( + src.as_ptr().add(converted), + dst.as_mut_ptr().add(converted), + length - converted, + ) + } { + None => { + return (pending, length, length); + } + Some((mut non_ascii, consumed)) => { ++ // Safety invariant: `converted <= length` upheld, since this can only consume ++ // up to `length - converted` bytes. ++ // ++ // Furthermore, in this context, ++ // we can assume `converted < length` since this branch is only ever hit when ++ // ascii_to_basic_latin fails to consume the entire slice + converted += consumed; + 'middle: loop { + // `converted` doesn't count the reading of `non_ascii` yet. + match self.encode_u16(non_ascii) { + Some(byte) => { + unsafe { ++ // Safety: we're allowed this access since `converted < length` + *(dst.get_unchecked_mut(converted)) = byte; + } + converted += 1; ++ // `converted <= length` now + } + None => { + // At this point, we need to know if we + // have a surrogate. + let high_bits = non_ascii & 0xFC00u16; + if high_bits == 0xD800u16 { + // high surrogate + if converted + 1 == length { + // End of buffer. This surrogate is unpaired. + return ( + EncoderResult::Unmappable('\u{FFFD}'), + converted + 1, // +1 `for non_ascii` + converted, + ); + } ++ // Safety: convered < length from outside the match, and `converted + 1 != length`, ++ // So `converted + 1 < length` as well. We're in bounds + let second = + u32::from(unsafe { *src.get_unchecked(converted + 1) }); + if second & 0xFC00u32 != 0xDC00u32 { + return ( + EncoderResult::Unmappable('\u{FFFD}'), + converted + 1, // +1 `for non_ascii` + converted, + ); + } + // The next code unit is a low surrogate. + let astral: char = unsafe { ++ // Safety: We can rely on non_ascii being 0xD800-0xDBFF since the high bits are 0xD800 ++ // Then, (non_ascii << 10 - 0xD800 << 10) becomes between (0 to 0x3FF) << 10, which is between ++ // 0x400 to 0xffc00. Adding the 0x10000 gives a range of 0x10400 to 0x10fc00. Subtracting the 0xDC00 ++ // gives 0x2800 to 0x102000 ++ // The second term is between 0xDC00 and 0xDFFF from the check above. This gives a maximum ++ // possible range of (0x10400 + 0xDC00) to (0x102000 + 0xDFFF) which is 0x1E000 to 0x10ffff. ++ // This is in range. ++ // ++ // From a Unicode principles perspective this can also be verified as we have checked that `non_ascii` is a high surrogate ++ // (0xD800..=0xDBFF), and that `second` is a low surrogate (`0xDC00..=0xDFFF`), and we are applying reverse of the UTC16 transformation ++ // algorithm , by applying the high surrogate - 0xD800 to the ++ // high ten bits, and the low surrogate - 0xDc00 to the low ten bits, and then adding 0x10000 + ::core::char::from_u32_unchecked( + (u32::from(non_ascii) << 10) + second + - (((0xD800u32 << 10) - 0x1_0000u32) + 0xDC00u32), + ) + }; + return ( + EncoderResult::Unmappable(astral), + converted + 2, // +2 `for non_ascii` and `second` +@@ -451,52 +502,63 @@ impl SingleByteEncoder { + converted, + ); + } + return ( + EncoderResult::unmappable_from_bmp(non_ascii), + converted + 1, // +1 `for non_ascii` + converted, + ); ++ // Safety: This branch diverges, so no need to uphold invariants on `converted` + } + } + // Next, handle ASCII punctuation and non-ASCII without + // going back to ASCII acceleration. Non-ASCII scripts + // use ASCII punctuation, so this avoid going to + // acceleration just for punctuation/space and then + // failing. This is a significant boost to non-ASCII + // scripts. + // TODO: Split out Latin converters without this part + // this stuff makes Latin script-conversion slower. + if converted == length { + return (pending, length, length); + } ++ // Safety: we're back to `converted < length` due to the == above and can perform ++ // the unchecked read + let mut unit = unsafe { *(src.get_unchecked(converted)) }; + 'innermost: loop { ++ // Safety: This loop always begins with `converted < length`, see ++ // the invariant outside and the comment on the continue below + if unit > 127 { + non_ascii = unit; + continue 'middle; + } + // Testing on Haswell says that we should write the + // byte unconditionally instead of trying to unread it + // to make it part of the next SIMD stride. + unsafe { ++ // Safety: Can rely on converted < length + *(dst.get_unchecked_mut(converted)) = unit as u8; + } + converted += 1; ++ // `converted <= length` here + if unit < 60 { + // We've got punctuation + if converted == length { + return (pending, length, length); + } ++ // Safety: `converted < length` due to the == above. The read is safe. + unit = unsafe { *(src.get_unchecked(converted)) }; ++ // Safety: This only happens if `converted < length`, maintaining it + continue 'innermost; + } + // We've got markup or ASCII text + continue 'outermost; ++ // Safety: All other routes to here diverge so the continue is the only ++ // way to run the innermost loop. + } + } + } + } + } + } + } + +diff --git a/third_party/rust/encoding_rs/src/x_user_defined.rs b/third_party/rust/encoding_rs/src/x_user_defined.rs +--- a/third_party/rust/encoding_rs/src/x_user_defined.rs ++++ b/third_party/rust/encoding_rs/src/x_user_defined.rs +@@ -9,22 +9,23 @@ + + use super::*; + use crate::handles::*; + use crate::variant::*; + + cfg_if! { + if #[cfg(feature = "simd-accel")] { + use simd_funcs::*; +- use packed_simd::u16x8; ++ use core::simd::u16x8; ++ use core::simd::cmp::SimdPartialOrd; + + #[inline(always)] + fn shift_upper(unpacked: u16x8) -> u16x8 { + let highest_ascii = u16x8::splat(0x7F); +- unpacked + unpacked.gt(highest_ascii).select(u16x8::splat(0xF700), u16x8::splat(0)) } ++ unpacked + unpacked.simd_gt(highest_ascii).select(u16x8::splat(0xF700), u16x8::splat(0)) } + } else { + } + } + + pub struct UserDefinedDecoder; + + impl UserDefinedDecoder { + pub fn new() -> VariantDecoder { +@@ -111,20 +112,25 @@ impl UserDefinedDecoder { + } else { + (DecoderResult::InputEmpty, src.len()) + }; + // Not bothering with alignment + let tail_start = length & !0xF; + let simd_iterations = length >> 4; + let src_ptr = src.as_ptr(); + let dst_ptr = dst.as_mut_ptr(); ++ // Safety: This is `for i in 0..length / 16` + for i in 0..simd_iterations { ++ // Safety: This is in bounds: length is the minumum valid length for both src/dst ++ // and i ranges to length/16, so multiplying by 16 will always be `< length` and can do ++ // a 16 byte read + let input = unsafe { load16_unaligned(src_ptr.add(i * 16)) }; + let (first, second) = simd_unpack(input); + unsafe { ++ // Safety: same as above, but this is two consecutive 8-byte reads + store8_unaligned(dst_ptr.add(i * 16), shift_upper(first)); + store8_unaligned(dst_ptr.add((i * 16) + 8), shift_upper(second)); + } + } + let src_tail = &src[tail_start..length]; + let dst_tail = &mut dst[tail_start..length]; + src_tail + .iter() +diff --git a/third_party/rust/packed_simd/.appveyor.yml b/third_party/rust/packed_simd/.appveyor.yml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/.appveyor.yml ++++ /dev/null +@@ -1,59 +0,0 @@ +-matrix: +- allow_failures: +- # FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/72 +- - TARGET: i686-pc-windows-msvc +- - TARGET: i686-pc-windows-gnu +- - TARGET: x86_64-pc-windows-gnu +- fast_finish: true +- +-environment: +- matrix: +- - TARGET: x86_64-pc-windows-msvc +- MSYSTEM: MINGW64 +- NOVERIFY: "1" +- - TARGET: x86_64-pc-windows-msvc +- MSYSTEM: MINGW64 +- RUSTFLAGS: "-C target-feature=+sse4.2" +- NOVERIFY: "1" +- - TARGET: x86_64-pc-windows-msvc +- MSYSTEM: MINGW64 +- RUSTFLAGS: "-C target-feature=+avx" +- NOVERIFY: "1" +- - TARGET: x86_64-pc-windows-msvc +- MSYSTEM: MINGW64 +- RUSTFLAGS: "-C target-feature=+avx2" +- NOVERIFY: "1" +- +- - TARGET: i686-pc-windows-msvc +- MSYSTEM: MINGW32 +- NOVERIFY: "1" +- - TARGET: i686-pc-windows-msvc +- MSYSTEM: MINGW32 +- RUSTFLAGS: "-C target-feature=+sse4.2" +- NOVERIFY: "1" +- - TARGET: i686-pc-windows-msvc +- MSYSTEM: MINGW32 +- RUSTFLAGS: "-C target-feature=+avx" +- NOVERIFY: "1" +- - TARGET: i686-pc-windows-msvc +- MSYSTEM: MINGW32 +- RUSTFLAGS: "-C target-feature=+avx2" +- NOVERIFY: "1" +- +- - TARGET: x86_64-pc-windows-gnu +- MSYSTEM: MINGW64 +- +- - TARGET: i686-pc-windows-gnu +- MSYSTEM: MINGW32 +- - TARGET: x86_64-pc-windows-gnu +- MSYSTEM: MINGW64 +-install: +- - ps: if (ls -r . -fi "*.rs" | sls "`t") { throw "Found tab character" } +- - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe" -FileName "rust-install.exe" +- - ps: .\rust-install.exe /VERYSILENT /NORESTART /DIR="C:\rust" | Out-Null +- - ps: $env:PATH="$env:PATH;C:\rust\bin" +- - set PATH=c:\msys64\%MSYSTEM%\bin;c:\msys64\usr\bin;%PATH% +- - rustc -vV +- - cargo -vV +-build: false +-test_script: bash -c "ci/run.sh" +diff --git a/third_party/rust/packed_simd/.cargo-checksum.json b/third_party/rust/packed_simd/.cargo-checksum.json +deleted file mode 100644 +--- a/third_party/rust/packed_simd/.cargo-checksum.json ++++ /dev/null +@@ -1,1 +0,0 @@ +-{"files":{".appveyor.yml":"f1ed01850e0d725f9498f52a1a63ddf40702ad6e0bf5b2d7c4c04d76e96794a3",".github/workflows/benchmarks.yml":"d049f016dc53830a3fcc735833eca168df2e491f33b6b44ce7e4d5d1dd453854",".github/workflows/ci.yml":"170a2074add57ddc8f88b780149e4930162c6ee4718add4369dca8e3fd6c022a",".github/workflows/docs.yml":"86f7eb652c900624e4deb76320cd92175db1fa7295a76f28f30336ff0fad1604",".github/workflows/run-ci-script.yml":"d847be293f9ec17038e450652b1eb7bdc20b805c18c5dbab34d1d9ff7a9c8940",".travis.yml":"30a61a5ec53355fc1f3585e1690280308c2b7961701abc11e8389b235b647178","Cargo.toml":"2298b95db733423c8dfe684e28086fc50ef48cac43d0c5192abd876495eacfba","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"c4ac7027a9ab7d7858aa8957d7454dbfcdbb81e605b6a171f05310cc3cad3762","bors.toml":"dee881dc69b9b7834e4eba5d95c3ed5a416d4628815a167d6a22d4cb4fb064b8","build.rs":"019ed29c43989782d8eec3a961654cfc172d7a7898da4eca8f654700af7e1988","ci/all.sh":"2ae6b2445b4db83833e40b37efd0016c6b9879ee988b9b3ef94db5439a3e1606","ci/android-install-ndk.sh":"bdcf93ba9043ac1184e2c504a3d40c47c6c1601d882e0f0a27a8eb56fbabcb5f","ci/android-install-sdk.sh":"3490432022c5c8f5a115c084f7a9aca1626f96c0c87ffb62019228c4346b47e4","ci/android-sysimage.sh":"ebf4e5daa1f0fe1b2092b79f0f3f161c4c4275cb744e52352c4d81ab451e4c5a","ci/benchmark.sh":"b61d19ef6b90deba8fb79dee74c8b062d94844676293da346da87bb78a9a49a4","ci/deploy_and_run_on_ios_simulator.rs":"ec8ecf82d92072676aa47f0d1a3d021b60a7ae3531153ef12d2ff4541fc294dc","ci/docker/aarch64-linux-android/Dockerfile":"ace2e7d33c87bc0f6d3962a4a3408c04557646f7f51ab99cfbf574906796b016","ci/docker/aarch64-unknown-linux-gnu/Dockerfile":"da88c0d50f16dc08448c7fdf1fa5ed2cbe576acf9e7dd85b5b818621b2a8c702","ci/docker/arm-unknown-linux-gnueabi/Dockerfile":"bb5f8ae890707c128652290ffc544447643bf12037ddd73c6ad6989f848cb380","ci/docker/arm-unknown-linux-gnueabihf/Dockerfile":"1afaefcbc05b740859acd4e067bc92439be6bcbe8f2e9678474fb434bcd398d9","ci/docker/armv7-linux-androideabi/Dockerfile":"370e55d3330a413a3ccf677b3afb3e0ef9018a5fab263faa97ae8ac017fc2286","ci/docker/armv7-unknown-linux-gnueabihf/Dockerfile":"8282ea707a94109beed47a57574755e2d58401735904a03f85fb64c578c53b4f","ci/docker/i586-unknown-linux-gnu/Dockerfile":"49792922269f371bd29da4727e9085101b27be67a6b97755d0196c63317f7abb","ci/docker/i686-unknown-linux-gnu/Dockerfile":"49792922269f371bd29da4727e9085101b27be67a6b97755d0196c63317f7abb","ci/docker/mips-unknown-linux-gnu/Dockerfile":"b2ebc25797612c4f8395fe9d407725156044955bfbcf442036b7f55b43a5f9da","ci/docker/mips64-unknown-linux-gnuabi64/Dockerfile":"b0c1692ac65bc56dd30494b1993d8e929c48cc9c4b92029b7c7592af6d4f9220","ci/docker/mips64el-unknown-linux-gnuabi64/Dockerfile":"4e9249c179300138141d0b2b7401b11897f64aed69f541f078c1db4594df2827","ci/docker/mipsel-unknown-linux-musl/Dockerfile":"3164c52b0dcbb01afa78292b15b5c43503ccf0491cf6eb801ec2bf22ae274e52","ci/docker/powerpc-unknown-linux-gnu/Dockerfile":"ae8274309928620a5dd232a46264e05399bb746288ebee3843a71c4162208cc3","ci/docker/powerpc64-unknown-linux-gnu/Dockerfile":"ba5fbc4bf3bb91cd50b407248da31225681efc8f2be7618f4a0ab1219b389508","ci/docker/powerpc64le-unknown-linux-gnu/Dockerfile":"53f97f8b9b5aca7534b9bf9ea48f35175052cd2a560a107e01ad270731c032fc","ci/docker/s390x-unknown-linux-gnu/Dockerfile":"89f5421cf06d817ae94092987e914472ef384ad2d1fff2735be3d8786ba11214","ci/docker/sparc64-unknown-linux-gnu/Dockerfile":"83eba19576486f9d10d7c037d669d72b31a65565a479f30b22aab36aaa2ff8dc","ci/docker/thumbv7neon-linux-androideabi/Dockerfile":"c2decd5591bd7a09378901bef629cd944acf052eb55e4f35b79eb9cb4d62246a","ci/docker/thumbv7neon-unknown-linux-gnueabihf/Dockerfile":"51955a8bf3c4d440f47382af6f5426ebff94ab01a04da36175babda9a057740f","ci/docker/wasm32-unknown-unknown/Dockerfile":"b982b421c70db476900df5b60e19ef8815e6c7dae22687225002780cab7b0a76","ci/docker/x86_64-linux-android/Dockerfile":"a17ebdb186ce2dd6b62100b5a439e05a1ab9adab113e2508843e121aaea52992","ci/docker/x86_64-unknown-linux-gnu-emulated/Dockerfile":"44b6203d9290bfdc53d81219f0937e1110847a23dd982ec8c4de388354f01536","ci/docker/x86_64-unknown-linux-gnu/Dockerfile":"7f4e3ca5fa288ea70edb4d1f75309708cd30b192e2e4444e61c4d5b3b58f89cf","ci/dox.sh":"434e9611c52e389312d2b03564adf09429f10cc76fe66a8644adb104903b87b7","ci/linux-s390x.sh":"d6b732d7795b4ba131326aff893bca6228a7d2eb0e9402f135705413dbbe0dce","ci/linux-sparc64.sh":"c92966838b1ab7ad3b7a344833ee726aba6b647cf5952e56f0ad1ba420b13325","ci/lld-shim.rs":"3d7f71ec23a49e2b67f694a0168786f9a954dda15f5a138815d966643fd3fcc3","ci/max_line_width.sh":"0a1518bba4c9ecaa55694cb2e9930d0e19c265baabf73143f17f9cf285aaa5bb","ci/run-docker.sh":"92e036390ad9b0d16f109579df1b5ced2e72e9afea40c7d011400ebd3a2a90de","ci/run.sh":"9afabc961e0ee83b87201f3fd554c19e5b0c36f3a95d013595e276c9882dd0a4","ci/run_examples.sh":"d1a23c6c35374a0678ba5114b9b8fefd8be0a79e774872a8bf0898d1baca18d0","ci/runtest-android.rs":"145a8e9799a5223975061fe7e586ade5669ee4877a7d7a4cf6b4ab48e8e36c7c","ci/setup_benchmarks.sh":"fae3960023f6f3d1388cd2ad22fdbab4b075f1f29dd4292d7994a20783beb6cf","ci/test-runner-linux":"c8aa6025cff5306f4f31d0c61dc5f9d4dd5a1d189ab613ef8d4c367c694d9ccd","contributing.md":"2d2629310ad4d464c482bdbb5819f0d6ce223c576aeef2cdce6a1f6857085ea5","perf-guide/.gitignore":"fe82c7da551079d832cf74200b0b359b4df9828cb4a0416fa7384f07a2ae6a13","perf-guide/book.toml":"115a98284126c6b180178b44713314cc494f08a71662ee2ce15cf67f17a51064","perf-guide/src/SUMMARY.md":"3e03bffc991fdc2050f3d51842d72d9d21ea6abab56a3baf3b2d5973a78b89e1","perf-guide/src/ascii.css":"29afb08833b2fe2250f0412e1fa1161a2432a0820a14953c87124407417c741a","perf-guide/src/bound_checks.md":"5e4991ff58a183ef0cd9fdc1feb4cd12d083b44bdf87393bbb0927808ef3ce7d","perf-guide/src/float-math/approx.md":"8c09032fa2d795a0c5db1775826c850d28eb2627846d0965c60ee72de63735ad","perf-guide/src/float-math/fma.md":"311076ba4b741d604a82e74b83a8d7e8c318fcbd7f64c4392d1cf5af95c60243","perf-guide/src/float-math/fp.md":"04153e775ab6e4f0d7837bcc515230d327b04edfa34c84ce9c9e10ebaeef2be8","perf-guide/src/float-math/svml.md":"0798873b8eedaeda5fed62dc91645b57c20775a02d3cd74d8bd06958f1516506","perf-guide/src/introduction.md":"9f5a19e9e6751f25d2daad39891a0cc600974527ec4c8305843f9618910671bd","perf-guide/src/prof/linux.md":"447731eb5de7d69166728fdbc5ecb0c0c9db678ea493b45a592d67dd002184c0","perf-guide/src/prof/mca.md":"f56d54f3d20e7aa4d32052186e8237b03d65971eb5d112802b442570ff11d344","perf-guide/src/prof/profiling.md":"8a650c0fd6ede0964789bb6577557eeef1d8226a896788602ce61528e260e43c","perf-guide/src/target-feature/attribute.md":"615f88dca0a707b6c416fa605435dd6e1fb5361cc639429cbf68cd87624bd78b","perf-guide/src/target-feature/features.md":"17077760ff24c006b606dd21889c53d87228f4311f3ba3a574f9afdeacd86165","perf-guide/src/target-feature/inlining.md":"7ed1d7068d8173a00d84c16cfe5871cd68b9f04f8d0cca2d01ebc84957ebf2f6","perf-guide/src/target-feature/practice.md":"c4b371842e0086df178488fec97f20def8f0c62ee588bcd25fd948b9b1fa227e","perf-guide/src/target-feature/runtime.md":"835425f5ee597fb3e51d36e725a81ebee29f4561231d19563cd4da81dbb1cfcb","perf-guide/src/target-feature/rustflags.md":"01197acf6f0adec8db32b8591811f69cecb6555a2b05dc5d5ec27d0e3f7b065e","perf-guide/src/vert-hor-ops.md":"c6211c0ee91e60552ec592d89d9d957eedc21dee3cbd89e1ad6765ea06a27471","rustfmt.toml":"d99a43f3f8ef9e425cf01c333fba9f0051f888f5d87ab4e8f63c2f7d0fe6620f","src/api.rs":"bb1795e9657a8298d37d2349b45443f08e9e455399ad4b727018600728478c10","src/api/bit_manip.rs":"27f3097fc0a11e3c4107049d9779e680dcd67407a066704008a6b9c4fd529e05","src/api/bitmask.rs":"058ebc38a2e0363f07a441d3e9a4775aaec57ccb170a0e5d5efa5dc4743ab07b","src/api/cast.rs":"03b94a3d316ac7b7be7068810044911e965e889a0ace7bae762749ca74a92747","src/api/cast/macros.rs":"b0a14d0c83ad2ebb7a275180f6d9e3f2bc312ba57a7d3d6c39fad4e0f20f9408","src/api/cast/v128.rs":"edd0994efac4379dff26e178423a52dbb3ffeb38b1fc97cae975d744c00b4fb6","src/api/cast/v16.rs":"96bd98c2d21b0663abe6c0ab33005b1fa693f3db7ee6795351391343863484da","src/api/cast/v256.rs":"8c31fe91f5e78ef737dfba6979cc1240210cb094a89d284fe459bf8a991ca24b","src/api/cast/v32.rs":"a99a79dd84d2a5e6adf9db98705675915bd03fd1287d489c7fe38e84d7e4a086","src/api/cast/v512.rs":"c0dd526f41ed7b8a71c3743d91267554ec0a0c75834ccc2e3ecb0ef3004af642","src/api/cast/v64.rs":"6572fdba2a1241a6cd666d3f0cce3306cd2cb7e5e236172e59d5d4351c8a88af","src/api/cmp.rs":"357c3a2a09c6d4611c32dd7fa95be2fae933d513e229026ec9b44451a77b884e","src/api/cmp/eq.rs":"60f70f355bae4cb5b17db53204cacc3890f70670611c17df638d4c04f7cc8075","src/api/cmp/ord.rs":"589f7234761c294fa5df8f525bc4acd5a47cdb602207d524a0d4e19804cd9695","src/api/cmp/partial_eq.rs":"902ccb8aa01fd5738b30ba0b712669c21d4801958907e03bad23432c7dba0198","src/api/cmp/partial_ord.rs":"9db0c37d7434cdfc62d8d66912e972fa3d8c115ab2af051a6f45e414bd3e4f1c","src/api/cmp/vertical.rs":"de3d62f38eba817299aa16f1e1939954c9a447e316509397465c2830852ba053","src/api/default.rs":"67bf21c134127d12a7028c8b88a57f0ceee8ccbd74976da8ca74eb9f16a174d5","src/api/fmt.rs":"67fb804bb86b6cd77cf8cd492b5733ce437071b66fe3297278b8a6552c325dda","src/api/fmt/binary.rs":"02b2b287f7404f8a983813cf70c87108c8da3835578b63ab303116885f609413","src/api/fmt/debug.rs":"56e1c3bdc092747344fffaafff9da7163ee7827857f6fb7cb1c9923eca4f6fa0","src/api/fmt/lower_hex.rs":"558fd592f7f485712fb051509cecc7174a21e6bf62e5ce64766e75afc97bb8e1","src/api/fmt/octal.rs":"3b2e70877a4f368c7704f8e254236c014c365c74d93371c1feb5f030e6c66422","src/api/fmt/upper_hex.rs":"2a442f666bc80e22d41f903f881238fe114dd49344c3ed69849250e853cafc5d","src/api/from.rs":"2e599d8329cb05eaf06224cc441355c4b7b51254fc19256619333be8c149d444","src/api/from/from_array.rs":"5d2cc700568376bf6ee1fe5e406da3bc2d488ff155644bf73d06a1349b73fc53","src/api/from/from_vector.rs":"9764371aa9e6005aace74dea14f59e5611a095b7cf42707940924749282c52f0","src/api/hash.rs":"5076ece87969592c876486f5b1ea8affbeaec379d1a14a30859e0aa5592019de","src/api/into_bits.rs":"8f8011627250e23e66b5c0ca641afb079d8232674bb1354140b536bdbea63e55","src/api/into_bits/arch_specific.rs":"e7445021f3908326bfee758835e5fc5ad56aa1baa77fc1c58abe4350c66c670a","src/api/into_bits/macros.rs":"bb4fe99be2af6a21d805efab44c8e4e61a7b2adb42a65504a0cf26d13efdadcd","src/api/into_bits/v128.rs":"145a44922b09a5ca5b62d88a461d327d399a997a15db4b11d7b17e554a9fa4c0","src/api/into_bits/v16.rs":"f4f4f61ba88aa51b158ec56ca3dce234349aea0daf2b3029a14ab5125d1e41e5","src/api/into_bits/v256.rs":"8cea9c5d9809f11323cb7cdc53b83df593fd17caf926251e412ae9777bed547f","src/api/into_bits/v32.rs":"905ba683d342fa32f4202b80bb46530807bd0a5b588f6c2e8c9f475223c47775","src/api/into_bits/v512.rs":"e25afa1fbf088a5d58e7d75d197b6cd4c56637ea28542ba18e46a451f29d04e7","src/api/into_bits/v64.rs":"d6238022ccff7b92e55b3f6017fc269acb6f36330a6d7e8fb389853a0f1b6478","src/api/math.rs":"8b2a2fc651917a850539f993aa0b9e5bf4da67b11685285b8de8cdca311719ec","src/api/math/float.rs":"61d2794d68262a1090ae473bd30793b5f65cf732f32a6694a3af2ce5d9225616","src/api/math/float/abs.rs":"5b6b2701e2e11135b7ce58a05052ea8120e10e4702c95d046b9d21b827b26bf8","src/api/math/float/consts.rs":"6302c9261da4291d144d5bb53493cdd073498feb40955fb6860ea3c4d06c978a","src/api/math/float/cos.rs":"4c2dd7173728ef189314f1576c9486e03be21b7da98843b2f9011282a7979e31","src/api/math/float/exp.rs":"7c6d5f1e304f498a01cfa23b92380c815d7da0ad94eae3483783bc377d287eef","src/api/math/float/ln.rs":"54c7583f3df793b39ff57534fade27b41bb992439e5dc178252f5ca3190a3e54","src/api/math/float/mul_add.rs":"62cac77660d20159276d4c9ef066eb90c81cbddb808e8e157182c607625ad2eb","src/api/math/float/mul_adde.rs":"bae056ee9f3a70df39ec3c3b2f6437c65303888a7b843ef1a5bcf1f5aca0e602","src/api/math/float/powf.rs":"9ddb938984b36d39d82a82f862f80df8f7fb013f1d222d45698d41d88472f568","src/api/math/float/recpre.rs":"589225794ff1dbf31158dff660e6d4509ecc8befbb57c633900dea5ac0b840d6","src/api/math/float/rsqrte.rs":"a32abdcc318d7ccc8448231f54d75b884b7cbeb03a7d595713ab6243036f4dbf","src/api/math/float/sin.rs":"cbd3622b7df74f19691743001c8cf747a201f8977ad90542fee915f37dcd1e49","src/api/math/float/sqrt.rs":"0c66d5d63fb08e4d99c6b82a8828e41173aff1ac9fa1a2764a11fac217ccf2ac","src/api/math/float/sqrte.rs":"731e1c9f321b662accdd27dacb3aac2e8043b7aecb2f2161dde733bd9f025362","src/api/minimal.rs":"1f22bcc528555444e76de569ec0ae2029b9ae9d04805efeafa93369c8098036b","src/api/minimal/iuf.rs":"819cff26d3e196f807645bcc1d79eb27d9f175edb89910f2274d52a1e913cd11","src/api/minimal/mask.rs":"0cae10ae1fc65f5070e686c0c79bfba27b86b33d6c399367bd4848fb367dcec4","src/api/minimal/ptr.rs":"f74d7a4925d7209faebc26ea8315259cb2c08ec65789a70869e595649a9bc39a","src/api/ops.rs":"3e273b277a0f3019d42c3c59ca94a5afd4885d5ae6d2182e5089bbeec9de42ee","src/api/ops/scalar_arithmetic.rs":"d2d5ad897a59dd0787544f927e0e7ca4072c3e58b0f4a2324083312b0d5a21d7","src/api/ops/scalar_bitwise.rs":"482204e459ca6be79568e1c9f70adbe2d2151412ddf122fb2161be8ebb51c40c","src/api/ops/scalar_mask_bitwise.rs":"c250f52042e37b22d57256c80d4604104cfd2fbe2a2e127c676267270ca5d350","src/api/ops/scalar_shifts.rs":"c4773d435c3f9da4454327e6fbb2b5b41a1c0ebb1cca7372e69dc7a344a1b6e4","src/api/ops/vector_arithmetic.rs":"ddca15d09ddeef502c2ed66117a62300ca65d87e959e8b622d767bdf1c307910","src/api/ops/vector_bitwise.rs":"b3968f7005b649edcc22a54e2379b14d5ee19045f2e784029805781ae043b5ee","src/api/ops/vector_float_min_max.rs":"76bf8cb607e2c442923c1da1061a6b80d742d607408033c2a3761161114cf2a0","src/api/ops/vector_int_min_max.rs":"a378789c6ff9b32a51fbd0a97ffd36ed102cd1fe6a067d2b02017c1df342def6","src/api/ops/vector_mask_bitwise.rs":"5052d18517d765415d40327e6e8e55a312daaca0a5e2aec959bfa54b1675f9c8","src/api/ops/vector_neg.rs":"5c62f6b0221983cdbd23cd0a3af3672e6ba1255f0dfe8b19aae6fbd6503e231b","src/api/ops/vector_rotates.rs":"6c3f761d9d551f6365a8a95539ceace4b1a02e0b12d144f34ed68db94e88cff4","src/api/ops/vector_shifts.rs":"e510be14127c0ffd58a2573a39701da3557d66bedec09837ac8bbd44d579da00","src/api/ptr.rs":"8a793251bed6130dcfb2f1519ceaa18b751bbb15875928d0fb6deb5a5e07523a","src/api/ptr/gather_scatter.rs":"3d614f9d5b4ca201a9f7e46af4405e1d2c28ecee1620297c23b52e37b92cc0ea","src/api/reductions.rs":"ae5baca81352ecd44526d6c30c0a1feeda475ec73ddd3c3ec6b14e944e5448ee","src/api/reductions/bitwise.rs":"8bf910ae226188bd15fc7e125f058cd2566b6186fcd0cd8fd020f352c39ce139","src/api/reductions/float_arithmetic.rs":"47a5679896db2cbb56c31372fe42143da015b6beae7db5d2f3a0309ddf427ae1","src/api/reductions/integer_arithmetic.rs":"c2df3cf7493cca4174f2c65aea422a3d20d8a23af03f8d57cef72c19fee8f20d","src/api/reductions/mask.rs":"db83327a950e33a317f37fd33ca4e20c347fb415975ec024f3e23da8509425af","src/api/reductions/min_max.rs":"6af8c9aa45c69961b1b6fc205395f4767d4421869fb105fb3d563c5605fc13cd","src/api/select.rs":"6b07e7e8026df561f7307221a896f0fbb272536f41b9109040ac094c24c69331","src/api/shuffle.rs":"be7faff9b59654926df12897b2f98a4baa7d6acf2af1aaf93d388ba6e96f83ec","src/api/shuffle1_dyn.rs":"bfea5a91905b31444e9ef7ca6eddb7a9606b7e22d3f71bb842eb2795a0346620","src/api/slice.rs":"ee87484e8af329547b9a5d4f2a69e8bed6ea10bbd96270d706083843d4eea2ac","src/api/slice/from_slice.rs":"3735363000737104a8fc5f394ad8c31ec14e885952bd57647dd2a84001aee0a6","src/api/slice/write_to_slice.rs":"79d09c64d00724783c77c42e4583eeec97b18db94cf2ae146b564c3f85cfefd6","src/api/swap_bytes.rs":"05b4262eaade2f63e6cd3b780c19a03aecd2459d4cc4360051fc088887179a6e","src/codegen.rs":"db4f232fb9f5728db310b87dc8c4733be48afacab1053798c06106bef9a42b05","src/codegen/bit_manip.rs":"525ea6ff7ad1e043b6f6136992166f1803ed5563b7f6fc292c1c40257d20e264","src/codegen/llvm.rs":"12e748b4928c3be6cc12b4165c3041a3d0efccf6195338ecd3d88b8fdb0bbcc7","src/codegen/math.rs":"dfcf02ad34e2fdfe22c3f1cc2822001cc895e65031b4d06e585e5047839febb7","src/codegen/math/float.rs":"2c1cbce155bc527ce34d472c0fef6bc3dadb79cd7a357dd7aa5b1ebeb1d77a13","src/codegen/math/float/abs.rs":"d5aaadcf540bdb9b4264dca6471a255fd7bf509e763bef0239c0144a68466fea","src/codegen/math/float/cos.rs":"17f28d2900c852dca221fa9c92a9cd5fe7fd2df8d427bbc60216c749b2be013d","src/codegen/math/float/cos_pi.rs":"dbaf9f443f9846a491d4ec52210a7b5835dd593b03366e3135b05c37d70f9d6c","src/codegen/math/float/exp.rs":"d300058a4bcc7ae7976f216f81902cd73a9e603ad63880dff3bbc866c27a9f37","src/codegen/math/float/ln.rs":"c851e211e43f8256093ba75b03ae0c307c9962ee66d94f09b4dd80068190cbdf","src/codegen/math/float/macros.rs":"fc9924869ed85e4795983af228cacf23158f4f35919adce16c920ad4a3f0a009","src/codegen/math/float/mul_add.rs":"041a5b69d5991d93ef795351b17560c10faf80b78fd26ad7df42a239b32cf9de","src/codegen/math/float/mul_adde.rs":"d71d5f0f3333b62a7439b823cb7adf5340ea1555ce820fb4a3f4cb922f73f5f5","src/codegen/math/float/powf.rs":"9742c3877f1a5509ca5c9492a40884b6579ba6dd11c26b7112e63f70666b395d","src/codegen/math/float/sin.rs":"0e9868d35531566509f3a01d85d5253045eb4afa8525d8407dcc1f5f33c56036","src/codegen/math/float/sin_cos_pi.rs":"8e6b6142d7dd240cdb36669722e82ab9810a2261e86e659f7d97a942ad8b1258","src/codegen/math/float/sin_pi.rs":"bb6d39db8f921e03a301fc5206ac1a61a97def8a2cb83b87ccf189f3fc48d548","src/codegen/math/float/sqrt.rs":"e6ebb0c5f428efad1f672b9a8fe4e58534dbf1ea5a8fe092ce5ce76b52fe89cb","src/codegen/math/float/sqrte.rs":"23acfaea38d0e081a6d9021c1094e813d0cfd12c58c1eca9662aade5e625d51c","src/codegen/pointer_sized_int.rs":"6ca13c214b6cf7e0929dbe18e96a16fc0bb7d8799608df29c4c8115490f99e01","src/codegen/reductions.rs":"8eb18ebac76985d2aa30262a2edd8cb004230b511a765d657525f677a585c12c","src/codegen/reductions/mask.rs":"e67f35a1f4d156a4894a2d6ea5a935b4d898cf70eefb2715f5c1cc165e776c11","src/codegen/reductions/mask/aarch64.rs":"84b101c17cad1ede4eb6d38cada0ac7da239dba8cea3badd3829b967e558431f","src/codegen/reductions/mask/arm.rs":"aaa07129bd078ae7e677cf8b8e67ec9f30536606a0c7ed1baaa18fd1793bb218","src/codegen/reductions/mask/fallback.rs":"3eb9319d2c7cf19216b607b8459612c4e027b643cf11b036937d36896bf76786","src/codegen/reductions/mask/fallback_impl.rs":"76547f396e55ef403327c77c314cf8db8c7a5c9b9819bfb925abeacf130249e5","src/codegen/reductions/mask/x86.rs":"36dcd8af4ab99730a078ed113d3955f74eb1a2876e2e6d9f224e0ff462c216d1","src/codegen/reductions/mask/x86/avx.rs":"3a40868b38c86e35aefb96d7578de6322efe89d8135e0366359b54ddd06f861a","src/codegen/reductions/mask/x86/avx2.rs":"677aed3f056285285daa3adff8bc65e739630b4424defa6d9665e160f027507e","src/codegen/reductions/mask/x86/sse.rs":"8522f6ed03f6c32dd577d4298df477c08aeaaa38563706f29096e1911ed731f2","src/codegen/reductions/mask/x86/sse2.rs":"54ec56e49b0c6841eccb719e4f310d65fe767c04136b2ec20bd8b9d7d9897b9e","src/codegen/shuffle.rs":"1ec2930f4e1acc43ac30b518af298d466a79e9e75734a51c380b7810efd1a27f","src/codegen/shuffle1_dyn.rs":"3f13ca1597378758d05106bf5ff3715eee531f3cb6d88f48b9182bd6c9386b51","src/codegen/swap_bytes.rs":"c67c86e91ca3fc77539e0efcea081a3c62548cccf503963ae408f2e86f4e6a21","src/codegen/v128.rs":"94226b31ec403d18d9d2fe06713f147c9c79e9b5f9105089088266313f843185","src/codegen/v16.rs":"ddec4ffb66b6f7aaffb9a1780c5ddba82557abd74f45073d335047e04cf74924","src/codegen/v256.rs":"6b63917f0444118d6b1595bff2045e59b97c4d24012bd575f69f1f0efc5a0241","src/codegen/v32.rs":"3477b3c5540aed86e61e2f5807dd31db947413cec9181c587d93ed6ec74f0eba","src/codegen/v512.rs":"5854f99d3aabc4cd42b28a20d9ce447756dc2ba024a409a69b6a8ae1f1842fc5","src/codegen/v64.rs":"e9e89caebfe63d10c0cbca61e4dfdba3b7e02ee0989170f80beed23237ddd950","src/codegen/vPtr.rs":"f0753b405cdc865bdf8e82c6505f299ea1f96136239ebbaf7f9ce93d310764b8","src/codegen/vSize.rs":"c89f5fdeb28ac4c8272ed1816fce03d9d95308cc32bb2533bd8b20cd5ac102ac","src/lib.rs":"05048c6a85ec65cf902d9dd8f757a3f76392b703a6794ea71f0d41500a89f78f","src/masks.rs":"70fc0abe4c2907ce2a491c574e1cfb9f3423385da2e1a923a48c9c13f8ba6ed8","src/sealed.rs":"ae7fdeaf5d84cd7710ed730ca72ca7eaba93df6cb0acb183e5c0a7327acf197f","src/testing.rs":"896669c08d8c801448a4d2fadc9d633eda0fbe879d229997e2a182e31278e469","src/testing/macros.rs":"403bbc5ecb7c786fe36156df302d0c07a8122408dbb15f7474d7682224ba1106","src/testing/utils.rs":"41912a92266dfe884647fc035e4242fd746100df8e839808ae0397af3759a3c8","src/v128.rs":"16cf9a8e7156b899ee9b9cd3f2dba9d13ec63289bea8c3ee9ae2e43ad9510288","src/v16.rs":"cb6465cf1e00bf530183af1819b9fe3d7eec978f8765d5e85d9b58a39a4b4045","src/v256.rs":"fe235017da18c7f3c361831c60e3173ad304d8ea1e95d64ebebc79da2d708511","src/v32.rs":"145d347855bac59b2de6508f9e594654e6c330423af9edc0e2ac8f4d1abdf45e","src/v512.rs":"f372f277f3e62eb5c945bb1c460333fdb17b6974fcc876633788ff53bded9599","src/v64.rs":"0b8079881b71575e3414be0b7f8f7eaba65281ba6732f2b2f61f73e95b6f48f7","src/vPtr.rs":"8b3e433d487180bb4304ff71245ecad90f0010f43e139a72027b672abe58facc","src/vSize.rs":"eda5aa020706cbf94d15bada41a0c2a35fc8f3f37cb7c2cd6f34d201399a495e","tests/endianness.rs":"5147f86d224c4c540b772033da2f994cad9bc9c035f38ec21e23bc4e55f8a759"},"package":null} +\ No newline at end of file +diff --git a/third_party/rust/packed_simd/.github/workflows/benchmarks.yml b/third_party/rust/packed_simd/.github/workflows/benchmarks.yml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/.github/workflows/benchmarks.yml ++++ /dev/null +@@ -1,31 +0,0 @@ +-name: benchmarks +- +-on: +- push: +- branches: +- - master +- pull_request: +- workflow_dispatch: +- +-jobs: +- x86_64-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- with: +- target: x86_64-unknown-linux-gnu +- setup_script: ci/setup_benchmarks.sh +- script: ci/benchmark.sh +- norun: 1 +- verify: 1 +- # FIXME: figure out how to add downloaded ispc to PATH +- # features: ispc +- x86_64-apple-darwin: +- uses: ./.github/workflows/run-ci-script.yml +- with: +- target: x86_64-apple-darwin +- runner: macos-latest +- setup_script: ci/setup_benchmarks.sh +- script: ci/benchmark.sh +- norun: 1 +- verify: 1 +- # FIXME: figure out how to add downloaded ispc to PATH +- # features: ispc +diff --git a/third_party/rust/packed_simd/.github/workflows/ci.yml b/third_party/rust/packed_simd/.github/workflows/ci.yml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/.github/workflows/ci.yml ++++ /dev/null +@@ -1,218 +0,0 @@ +-name: ci +- +-# trigger for all PRs and changes to master +-on: +- push: +- branches: +- - master +- pull_request: +- +-jobs: +- rustfmt: +- uses: ./.github/workflows/run-ci-script.yml +- with: +- script: ci/all.sh check_fmt || true +- x86_64-unknown-linux-android: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: x86_64-linux-android +- armv7-linux-androideabi: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: armv7-linux-androideabi +- aarch64-unknown-linux-android-NEON: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: aarch64-linux-android +- rustflags: -Ctarget-feature=+neon +- thumbv7neon-linux-androideabi: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: thumbv7neon-linux-androideabi +- i586-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: i586-unknown-linux-gnu +- rustflags: -Crelocation-model=static +- i586-unknown-linux-gnu-SSE: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: i586-unknown-linux-gnu +- rustflags: -Crelocation-model=static -Ctarget-feature=+sse +- i586-unknown-linux-gnu-SSE2: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: i586-unknown-linux-gnu +- rustflags: -Crelocation-model=static -Ctarget-feature=+sse2 +- i686-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: i686-unknown-linux-gnu +- rustflags: -Crelocation-model=static +- i686-unknown-linux-gnu-SSE4_2: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: i686-unknown-linux-gnu +- rustflags: -Crelocation-model=static -Ctarget-feature=+sse4.2 +- i686-unknown-linux-gnu-AVX2: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: i686-unknown-linux-gnu +- rustflags: -Crelocation-model=static -Ctarget-feature=+avx2 +- x86_64-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: x86_64-unknown-linux-gnu +- x86_64-unknown-linux-gnu-SSE4_2: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: x86_64-unknown-linux-gnu +- rustflags: -Ctarget-feature=+sse4.2 +- x86_64-unknown-linux-gnu-AVX2: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: x86_64-unknown-linux-gnu +- rustflags: -Ctarget-feature=+avx2 +- arm-unknown-linux-gnueabihf: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: arm-unknown-linux-gnueabihf +- armv7-unknown-linux-gnueabihf: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: armv7-unknown-linux-gnueabihf +- armv7-unknown-linux-gnueabihf-NEON: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: armv7-unknown-linux-gnueabihf +- rustflags: -Ctarget-feature=+neon +- thumbv7neon-unknown-linux-gnueabihf: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: thumbv7neon-unknown-linux-gnueabihf +- aarch64-unknown-linux-gnu-NEON: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: aarch64-unknown-linux-gnu +- rustflags: -Ctarget-feature=+neon +- powerpc-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: powerpc-unknown-linux-gnu +- powerpc64-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: powerpc64-unknown-linux-gnu +- powerpc64le-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: powerpc64le-unknown-linux-gnu +- powerpc64le-unknown-linux-gnu-ALTIVEC: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: powerpc64le-unknown-linux-gnu +- rustflags: -Ctarget-feature=+altivec +- powerpc64le-unknown-linux-gnu-VSX: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- target: powerpc64le-unknown-linux-gnu +- rustflags: -Ctarget-feature=+vsx +- s390x-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: s390x-unknown-linux-gnu +- sparc64-unknown-linux-gnu: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: sparc64-unknown-linux-gnu +- wasm32-unknown-unknown: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: false +- with: +- target: wasm32-unknown-unknown +- x86_64-apple-darwin-SSE4_2: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- runner: macos-latest +- script: ci/run.sh +- target: x86_64-apple-darwin +- rustflags: -Ctarget-feature=+sse4.2 +- x86_64-apple-darwin-AVX: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- runner: macos-latest +- script: ci/run.sh +- target: x86_64-apple-darwin +- rustflags: -Ctarget-feature=+avx +- x86_64-apple-ios: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- runner: macos-latest +- script: ci/run.sh +- target: x86_64-apple-ios +- aarch64-apple-ios: +- uses: ./.github/workflows/run-ci-script.yml +- strategy: +- fail-fast: true +- with: +- runner: macos-latest +- script: ci/run.sh +- target: aarch64-apple-ios +- rustflags: -Ctarget-feature=+neon +diff --git a/third_party/rust/packed_simd/.github/workflows/docs.yml b/third_party/rust/packed_simd/.github/workflows/docs.yml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/.github/workflows/docs.yml ++++ /dev/null +@@ -1,13 +0,0 @@ +-name: docs +- +-on: +- push: +- branches: +- - master +- +-jobs: +- docs: +- uses: ./.github/workflows/run-ci-script.yml +- with: +- setup_script: cargo install mdbook +- script: ci/dox.sh +diff --git a/third_party/rust/packed_simd/.github/workflows/run-ci-script.yml b/third_party/rust/packed_simd/.github/workflows/run-ci-script.yml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/.github/workflows/run-ci-script.yml ++++ /dev/null +@@ -1,86 +0,0 @@ +-name: run-ci-script +- +-on: +- workflow_call: +- inputs: +- runner: +- required: false +- type: string +- default: ubuntu-latest +- target: +- required: false +- type: string +- default: '' +- rustflags: +- required: false +- type: string +- default: '' +- script: +- required: false +- type: string +- default: ci/run-docker.sh +- setup_script: +- required: false +- type: string +- norun: +- required: false +- type: string +- default: '' +- verify: +- required: false +- type: string +- default: '' +- features: +- required: false +- type: string +- default: '' +- +-jobs: +- run-ci-script: +- runs-on: ${{ inputs.runner }} +- steps: +- - name: Checkout +- uses: actions/checkout@v2 +- - name: Init Rustup Cache +- uses: actions/cache@v2 +- with: +- path: | +- ~/.rustup/toolchains +- key: ${{ runner.os }}-cargo-${{ hashFiles('**/rust-toolchain') }} +- - name: Install Toolchain +- uses: dtolnay/rust-toolchain@nightly +- with: +- # FIXME: change to nightly once https://github.com/rust-lang/packed_simd/pull/350 is merged +- # needs to be kept in sync with the toolchain files +- targets: ${{ inputs.target }} +- components: rustfmt +- - name: Generate Lockfile +- run: cargo generate-lockfile +- - name: Init Cargo Cache +- uses: actions/cache@v2 +- with: +- path: | +- ~/.cargo/bin/ +- ~/.cargo/registry/index/ +- ~/.cargo/registry/cache/ +- ~/.cargo/git/db/ +- target/ +- key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }} +- - name: Setup +- if: ${{ inputs.setup_script != '' }} +- run: ${{ inputs.setup_script }} +- env: +- TARGET: ${{ inputs.target }} +- RUSTFLAGS: ${{ inputs.rustflags }} +- NORUN: ${{ inputs.norun }} +- VERIFY: ${{ inputs.verify }} +- FEATURES: ${{ inputs.features }} +- - name: Run CI Script +- timeout-minutes: 30 +- run: ${{ inputs.script }} +- env: +- TARGET: ${{ inputs.target }} +- RUSTFLAGS: ${{ inputs.rustflags }} +- NORUN: ${{ inputs.norun }} +- VERIFY: ${{ inputs.verify }} +- FEATURES: ${{ inputs.features }} +diff --git a/third_party/rust/packed_simd/.travis.yml b/third_party/rust/packed_simd/.travis.yml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/.travis.yml ++++ /dev/null +@@ -1,212 +0,0 @@ +-language: rust +-rust: nightly +-os: linux +-dist: focal +- +-stages: +- - tools +- - build-test-verify # Passes full test suite, permit no regressions (unless it's rustup :/) +- - 32bit-tier1 +- - 64bit-tier2 +- - 32bit-tier2 +- +-jobs: +- fast_finish: true +- include: +- # Android: +- - env: TARGET=x86_64-linux-android +- name: "x86_64-unknown-linux-android + SSE2" +- stage: build-test-verify +- - env: TARGET=arm-linux-androideabi +- name: "arm-linux-androideabi" +- stage: build-test-verify +- - name: "aarch64-unknown-linux-android + NEON" +- env: TARGET=aarch64-linux-android RUSTFLAGS="-C target-feature=+neon" +- stage: build-test-verify +- - env: TARGET="thumbv7neon-linux-androideabi" +- name: "thumbv7neon-linux-androideabi" +- stage: 32bit-tier2 +- # Linux: +- - env: TARGET=i586-unknown-linux-gnu +- name: "i586-unknown-linux-gnu" +- stage: 32bit-tier2 +- - env: TARGET=i586-unknown-linux-gnu RUSTFLAGS="-C target-feature=+sse" +- name: "i586-unknown-linux-gnu + SSE" +- stage: 32bit-tier2 +- - env: TARGET=i586-unknown-linux-gnu RUSTFLAGS="-C target-feature=+sse2" +- name: "i586-unknown-linux-gnu + SSE2" +- stage: 32bit-tier2 +- - env: TARGET=i686-unknown-linux-gnu +- name: "i686-unknown-linux-gnu + SSE2" +- stage: 32bit-tier1 +- - env: TARGET=i686-unknown-linux-gnu RUSTFLAGS="-C target-feature=+sse4.2" +- name: "i686-unknown-linux-gnu + SSE4.2" +- stage: 32bit-tier1 +- - env: TARGET=i686-unknown-linux-gnu RUSTFLAGS="-C target-feature=+avx2" +- name: "i686-unknown-linux-gnu + AVX2" +- stage: 32bit-tier1 +- - env: TARGET=x86_64-unknown-linux-gnu RUSTFLAGS="-C target-feature=+sse4.2" +- name: "x86_64-unknown-linux-gnu + SSE4.2" +- stage: build-test-verify +- - env: TARGET=x86_64-unknown-linux-gnu RUSTFLAGS="-C target-feature=+avx2" +- name: "x86_64-unknown-linux-gnu + AVX2" +- stage: build-test-verify +- - env: TARGET=arm-unknown-linux-gnueabihf +- name: "arm-unknown-linux-gnueabihf" +- stage: build-test-verify +- - env: TARGET=armv7-unknown-linux-gnueabihf +- name: "armv7-unknown-linux-gnueabihf" +- stage: build-test-verify +- - env: TARGET=armv7-unknown-linux-gnueabihf RUSTFLAGS="-C target-feature=+neon" +- name: "armv7-unknown-linux-gnueabihf + NEON" +- stage: build-test-verify +- - env: TARGET="thumbv7neon-unknown-linux-gnueabihf" +- name: "thumbv7neon-unknown-linux-gnueabihf" +- stage: 32bit-tier2 +- - name: "aarch64-unknown-linux-gnu + NEON" +- env: TARGET=aarch64-unknown-linux-gnu RUSTFLAGS="-C target-feature=+neon" +- stage: build-test-verify +- - env: TARGET=mips-unknown-linux-gnu +- name: "mips-unknown-linux-gnu" +- stage: 32bit-tier2 +- - env: TARGET=mipsel-unknown-linux-musl +- name: "mipsel-unknown-linux-musl" +- stage: 32bit-tier2 +- - env: TARGET=mips64-unknown-linux-gnuabi64 +- name: "mips64-unknown-linux-gnuabi64" +- stage: 64bit-tier2 +- - env: TARGET=mips64el-unknown-linux-gnuabi64 +- name: "mips64el-unknown-linux-gnuabi64" +- stage: 64bit-tier2 +- # FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/18 +- # env: TARGET=mips64el-unknown-linux-gnuabi64 RUSTFLAGS="-C target-feature=+msa -C target-cpu=mips64r6" +- - env: TARGET=powerpc-unknown-linux-gnu +- name: "powerpc-unknown-linux-gnu" +- stage: 32bit-tier2 +- - env: TARGET=powerpc64-unknown-linux-gnu +- name: "powerpc64-unknown-linux-gnu" +- stage: 64bit-tier2 +- - name: "powerpc64le-unknown-linux-gnu" +- env: TARGET=powerpc64le-unknown-linux-gnu +- stage: build-test-verify +- - name: "powerpc64le-unknown-linux-gnu + ALTIVEC" +- env: TARGET=powerpc64le-unknown-linux-gnu RUSTFLAGS="-C target-feature=+altivec" +- stage: build-test-verify +- - name: "powerpc64le-unknown-linux-gnu + VSX" +- env: TARGET=powerpc64le-unknown-linux-gnu RUSTFLAGS="-C target-feature=+vsx" +- stage: build-test-verify +- - name: "s390x-unknown-linux-gnu" +- env: TARGET=s390x-unknown-linux-gnu +- stage: 64bit-tier2 +- - env: TARGET=sparc64-unknown-linux-gnu +- name: "sparc64-unknown-linux-gnu" +- stage: 64bit-tier2 +- # WebAssembly: +- - env: TARGET=wasm32-unknown-unknown +- name: "wasm32-unknown-unknown" +- stage: 32bit-tier2 +- # MacOSX: +- - os: osx +- env: TARGET=x86_64-apple-darwin RUSTFLAGS="-C target-feature=+sse4.2" +- name: "x86_64-apple-darwin + SSE4.2" +- install: true +- script: ci/run.sh +- osx_image: xcode10 +- stage: build-test-verify +- # Travis-CI OSX build bots do not support AVX2: +- - os: osx +- env: TARGET=x86_64-apple-darwin RUSTFLAGS="-C target-feature=+avx" +- name: "x86_64-apple-darwin + AVX" +- install: true +- script: ci/run.sh +- osx_image: xcode10 +- stage: build-test-verify +- # *BSDs: +- #- env: TARGET=i686-unknown-freebsd NORUN=1 +- # script: ci/run.sh +- #- env: TARGET=x86_64-unknown-freebsd NORUN=1 +- # script: ci/run.sh +- #- env: TARGET=x86_64-unknown-netbsd NORUN=1 +- # script: ci/run.sh +- # Solaris: +- #- env: TARGET=x86_64-sun-solaris NORUN=1 +- # script: ci/run.sh +- # iOS: +- - os: osx +- env: TARGET=x86_64-apple-ios +- name: "x86_64-apple-ios + SSE2" +- script: ci/run.sh +- osx_image: xcode9.4 +- stage: 64bit-tier2 +- - name: "aarch64-apple-ios + NEON" +- env: TARGET=aarch64-apple-ios RUSTFLAGS="-C target-feature=+neon" +- os: osx +- osx_image: xcode9.4 +- script: ci/run.sh +- stage: 64bit-tier2 +- # BENCHMARKS: +- - name: "Benchmarks - x86_64-unknown-linux-gnu" +- install: TARGET=x86_64-unknown-linux-gnu ./ci/setup_benchmarks.sh +- # FIXME: Use `core_arch,sleef-sys` features once they works again +- script: PATH=$(pwd):$PATH NORUN=1 VERIFY=1 FEATURES=ispc ci/benchmark.sh +- stage: tools +- - name: "Benchmarks - x86_64-apple-darwin" +- install: TARGET=x86_64-apple-darwin ./ci/setup_benchmarks.sh +- # FIXME: Use `core_arch,sleef-sys` features once they works again +- script: PATH=$(pwd):$PATH NORUN=1 VERIFY=1 FEATURES=ispc ci/benchmark.sh +- os: osx +- osx_image: xcode9.4 +- stage: tools +- # TOOLS: +- - name: "Documentation" +- before_install: +- - sudo add-apt-repository -y ppa:deadsnakes/ppa +- - sudo apt-get update -y +- - sudo apt-get install -y python3.9 +- install: +- - cargo install mdbook +- script: ci/dox.sh +- stage: tools +- - name: "rustfmt" +- install: true +- script: | +- rustup toolchain install nightly -c rustfmt --allow-downgrade +- ci/all.sh check_fmt || true +- stage: tools +- +- allow_failures: +- # FIXME: ISPC cannot be found? +- - name: "Benchmarks - x86_64-apple-darwin" +- # FIXME: i686 fails in inlining, apparently +- - stage: 32bit-tier1 +- #- env: TARGET=i686-unknown-freebsd NORUN=1 +- #- env: TARGET=x86_64-unknown-freebsd NORUN=1 +- #- env: TARGET=x86_64-unknown-netbsd NORUN=1 +- #- env: TARGET=x86_64-sun-solaris NORUN=1 +- +- # FIXME: TBD +- - stage: 64bit-tier2 +- - stage: 32bit-tier2 +- +- # FIXME: iOS +- # https://github.com/rust-lang-nursery/packed_simd/issues/26 +- - env: TARGET=x86_64-apple-ios +- # Is this related to the above? Mysterious test failure +- - name: "aarch64-apple-ios + NEON" +- +-install: travis_retry rustup target add $TARGET +-before_script: cargo generate-lockfile +-script: travis_wait 50 ci/run-docker.sh +-after_script: sleep 5 +- +-env: +- global: +- secure: "lPHv7s6+AxQYNaFncycVFQt++Y1asQmMhOikQU1ztlP8CK7+hn2m98cg/euOJyzIOb2iJ3ZX4cGZkzw4lc59MQBByb1GtDbazQoUOzVDbVfe9BDD2f8JVoIFh1CMfjPKQ7Gg/rJqWlwrUlSd5GNxPCutKjY7qZhJuR6SQbJjlWaGN2Vd4fVCzKXz8fHRXgMEZS+d+CR4Nsrkb83J3Z4s5kSdJmhYxJ61AWjuzJVwUh4l3/HEYlSL5XXpuh5R2i7W16h1PlNdaTUgkZli1lHzO8+6Q8LzX9+XiLIEVX9lw3A2NdIKGz8E/+7Qs5oYOkwYhjROsDQxIK7xkSM30bQuN7cwMBybAVIyOPJkqXQ1dQyp83KSdsOj7JMyDDRvcEDLI6ehRlm5EcdH7YrReuboN81iUo0Sa7VsuUmgj5hjERCt9r30f9aWuitABai7vKRtjglg7Sp5CrEVPA4PQs6PqKCCRogoggbXJ/Z5Dyw/RZaXPeNR9+qIKN1Vjm9Gew1sRN2JK/3+vXTKtyJXH/uBxgJt4jQlbuShOJuF+BSfTF88sMe67a/357SSOIb4JkaCyd0flDCWYE8576kaHPlVVMT2peXee0LeRXm1e13nG3Na0t3LS/orJLPHOShNQGoDj7qAP5aEKggRya896JGwtvlaBHHTmSQh65G7cyNErZo=" +-branches: +- only: +- - staging # bors r+ +- - trying # bors try +- - master +-notifications: +- email: +- on_success: never +diff --git a/third_party/rust/packed_simd/Cargo.toml b/third_party/rust/packed_simd/Cargo.toml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/Cargo.toml ++++ /dev/null +@@ -1,46 +0,0 @@ +-[package] +-name = "packed_simd" +-version = "0.3.9" +-description = "Portable Packed SIMD vectors" +-documentation = "https://docs.rs/crate/packed_simd/" +-homepage = "https://github.com/rust-lang/packed_simd" +-repository = "https://github.com/rust-lang/packed_simd" +-keywords = ["simd", "vector", "portability"] +-categories = ["hardware-support", "concurrency", "no-std", "data-structures"] +-license = "MIT OR Apache-2.0" +-build = "build.rs" +-edition = "2018" +- +-[package.metadata.docs.rs] +-features = ["into_bits"] +-rustdoc-args = ["--cfg", "doc_cfg"] +-# To build locally: +-# RUSTDOCFLAGS="--cfg doc_cfg" cargo +nightly doc --features into_bits --no-deps --open +- +-[badges] +-is-it-maintained-issue-resolution = { repository = "rust-lang/packed_simd" } +-is-it-maintained-open-issues = { repository = "rust-lang/packed_simd" } +-maintenance = { status = "experimental" } +- +-[dependencies] +-cfg-if = "1.0.0" +-core_arch = { version = "0.1.5", optional = true } +-num-traits = { version = "0.2.14", default-features = false } +- +-[features] +-default = [] +-into_bits = [] +-libcore_neon = [] +- +-[dev-dependencies] +-paste = "^1" +-arrayvec = { version = "^0.5", default-features = false } +- +-[target.'cfg(target_arch = "x86_64")'.dependencies.sleef-sys] +-version = "0.1.2" +-optional = true +- +-[target.wasm32-unknown-unknown.dev-dependencies] +-# Keep in sync with the version on Dockerfile. +-wasm-bindgen = "=0.2.87" +-wasm-bindgen-test = "=0.3.37" +-diff --git a/third_party/rust/packed_simd/README.md b/third_party/rust/packed_simd/README.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/README.md ++++ /dev/null +@@ -1,144 +0,0 @@ +-# `Simd<[T; N]>` +- +-## Implementation of [Rust RFC #2366: `std::simd`][rfc2366] +- +-[![Latest Version]][crates.io] [![docs]][master_docs] +- +-**WARNING**: this crate only supports the most recent nightly Rust toolchain +-and will be superseded by [`#![feature(portable_simd)]`](https://github.com/rust-lang/portable-simd). +- +-## Documentation +- +-* [API docs (`master` branch)][master_docs] +-* [Performance guide][perf_guide] +-* [API docs (`docs.rs`)][docs.rs] +-* [RFC2366 `std::simd`][rfc2366]: - contains motivation, design rationale, +- discussion, etc. +- +-## Examples +- +-Most of the examples come with both a scalar and a vectorized implementation. +- +-* [`aobench`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/aobench) +-* [`fannkuch_redux`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/fannkuch_redux) +-* [`matrix inverse`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/matrix_inverse) +-* [`mandelbrot`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/mandelbrot) +-* [`n-body`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/nbody) +-* [`options_pricing`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/options_pricing) +-* [`spectral_norm`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/spectral_norm) +-* [`triangle transform`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/triangle_xform) +-* [`stencil`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/stencil) +-* [`vector dot product`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/dot_product) +- +-## Cargo features +- +-* `into_bits` (default: disabled): enables `FromBits`/`IntoBits` trait +- implementations for the vector types. These allow reinterpreting the bits of a +- vector type as those of another vector type safely by just using the +- `.into_bits()` method. +- +-## Performance +- +-The following [ISPC] examples are also part of `packed_simd`'s +-[`examples/`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples/) +-directory, where `packed_simd`+[`rayon`][rayon] are used to emulate [ISPC]'s +-Single-Program-Multiple-Data (SPMD) programming model. The performance results +-on different hardware is shown in the `readme.md` of each example. The following +-table summarizes the performance ranges, where `+` means speed-up and `-` +-slowdown: +- +-* `aobench`: `[-1.02x, +1.53x]`, +-* `stencil`: `[+1.06x, +1.72x]`, +-* `mandelbrot`: `[-1.74x, +1.2x]`, +-* `options_pricing`: +- * `black_scholes`: `+1.0x` +- * `binomial_put`: `+1.4x` +- +- While SPMD is not the intended use case for `packed_simd`, it is possible to +- combine the library with [`rayon`][rayon] to poorly emulate [ISPC]'s SPMD programming +- model in Rust. Writing performant code is not as straightforward as with +- [ISPC], but with some care (e.g. see the [Performance Guide][perf_guide]) one +- can easily match and often out-perform [ISPC]'s "default performance". +- +-## Platform support +- +-The following table describes the supported platforms: `build` shows whether +-the library compiles without issues for a given target, while `run` shows +-whether the test suite passes for a given target. +- +-| **Linux** | **build** | **run** | +-|---------------------------------------|-----------|---------| +-| `i586-unknown-linux-gnu` | ✓ | ✗ | +-| `i686-unknown-linux-gnu` | ✓ | ✗ | +-| `x86_64-unknown-linux-gnu` | ✓ | ✓ | +-| `arm-unknown-linux-gnueabihf` | ✓ | ✓ | +-| `armv7-unknown-linux-gnueabi` | ✓ | ✓ | +-| `aarch64-unknown-linux-gnu` | ✓ | ✓ | +-| `powerpc-unknown-linux-gnu` | ✓ | ✗ | +-| `powerpc64-unknown-linux-gnu` | ✓ | ✗ | +-| `powerpc64le-unknown-linux-gnu` | ✓ | ✓ | +-| `s390x-unknown-linux-gnu` | ✓ | ✗ | +-| `sparc64-unknown-linux-gnu` | ✓ | ✗ | +-| `thumbv7neon-unknown-linux-gnueabihf` | ✓ | ✓ | +-| **MacOSX** | **build** | **run** | +-| `x86_64-apple-darwin` | ✓ | ✓ | +-| **Android** | **build** | **run** | +-| `x86_64-linux-android` | ✓ | ✓ | +-| `armv7-linux-androideabi` | ✓ | ✗ | +-| `aarch64-linux-android` | ✓ | ✗ | +-| `thumbv7neon-linux-androideabi` | ✓ | ✗ | +-| **iOS** | **build** | **run** | +-| `x86_64-apple-ios` | ✗ | ✗ | +-| `aarch64-apple-ios` | ✗ | ✗ | +- +- +-## Machine code verification +- +-The +-[`verify/`](https://github.com/rust-lang-nursery/packed_simd/tree/master/verify) +-crate tests disassembles the portable packed vector APIs at run-time and +-compares the generated machine code against the desired one to make sure that +-this crate remains efficient. +- +-## License +- +-This project is licensed under either of +- +-* [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0) +- ([LICENSE-APACHE](LICENSE-APACHE)) +- +-* [MIT License](http://opensource.org/licenses/MIT) +- ([LICENSE-MIT](LICENSE-MIT)) +- +-at your option. +- +-## Contributing +- +-We welcome all people who want to contribute. +-Please see the [contributing instructions] for more information. +- +-Contributions in any form (issues, pull requests, etc.) to this project +-must adhere to Rust's [Code of Conduct]. +- +-Unless you explicitly state otherwise, any contribution intentionally submitted +-for inclusion in `packed_simd` by you, as defined in the Apache-2.0 license, shall be +-dual licensed as above, without any additional terms or conditions. +- +-[travis]: https://travis-ci.com/rust-lang/packed_simd +-[Travis-CI Status]: https://travis-ci.com/rust-lang/packed_simd.svg?branch=master +-[appveyor]: https://ci.appveyor.com/project/gnzlbg/packed-simd +-[Appveyor Status]: https://ci.appveyor.com/api/projects/status/hd7v9dvr442hgdix?svg=true +-[Latest Version]: https://img.shields.io/crates/v/packed_simd.svg +-[crates.io]: https://crates.io/crates/packed_simd +-[docs]: https://docs.rs/packed_simd/badge.svg +-[docs.rs]: https://docs.rs/packed_simd +-[master_docs]: https://rust-lang-nursery.github.io/packed_simd/packed_simd/ +-[perf_guide]: https://rust-lang-nursery.github.io/packed_simd/perf-guide/ +-[rfc2366]: https://github.com/rust-lang/rfcs/pull/2366 +-[ISPC]: https://ispc.github.io/ +-[rayon]: https://crates.io/crates/rayon +-[boost_license]: https://www.boost.org/LICENSE_1_0.txt +-[SLEEF]: https://sleef.org/ +-[sleef_sys]: https://crates.io/crates/sleef-sys +-[contributing instructions]: contributing.md +-[Code of Conduct]: https://www.rust-lang.org/en-US/conduct.html +diff --git a/third_party/rust/packed_simd/bors.toml b/third_party/rust/packed_simd/bors.toml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/bors.toml ++++ /dev/null +@@ -1,3 +0,0 @@ +-status = [ +- "continuous-integration/travis-ci/push" +-] +\ No newline at end of file +diff --git a/third_party/rust/packed_simd/build.rs b/third_party/rust/packed_simd/build.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/build.rs ++++ /dev/null +@@ -1,6 +0,0 @@ +-fn main() { +- let target = std::env::var("TARGET").expect("TARGET environment variable not defined"); +- if target.contains("neon") { +- println!("cargo:rustc-cfg=libcore_neon"); +- } +-} +diff --git a/third_party/rust/packed_simd/ci/all.sh b/third_party/rust/packed_simd/ci/all.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/all.sh ++++ /dev/null +@@ -1,71 +0,0 @@ +-#!/usr/bin/env bash +-# +-# Performs an operation on all targets +- +-set -ex +- +-: "${1?The all.sh script requires one argument.}" +- +-op=$1 +- +-cargo_clean() { +- cargo clean +-} +- +-cargo_check_fmt() { +- cargo fmt --all -- --check +-} +- +-cargo_fmt() { +- cargo fmt --all +-} +- +-cargo_clippy() { +- cargo clippy --all -- -D clippy::perf +-} +- +-CMD="-1" +- +-case $op in +- clean*) +- CMD=cargo_clean +- ;; +- check_fmt*) +- CMD=cargo_check_fmt +- ;; +- fmt*) +- CMD=cargo_fmt +- ;; +- clippy) +- CMD=cargo_clippy +- ;; +- *) +- echo "Unknown operation: \"${op}\"" +- exit 1 +- ;; +-esac +- +-echo "Operation is: ${CMD}" +- +-# On src/ +-$CMD +- +-# Check examples/ +-for dir in examples/*/ +-do +- dir=${dir%*/} +- ( +- cd "${dir%*/}" +- $CMD +- ) +-done +- +-( +- cd verify/verify +- $CMD +-) +- +-( +- cd micro_benchmarks +- $CMD +-) +diff --git a/third_party/rust/packed_simd/ci/android-install-ndk.sh b/third_party/rust/packed_simd/ci/android-install-ndk.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/android-install-ndk.sh ++++ /dev/null +@@ -1,21 +0,0 @@ +-#!/usr/bin/env sh +-# Copyright 2016 The Rust Project Developers. See the COPYRIGHT +-# file at the top-level directory of this distribution and at +-# http://rust-lang.org/COPYRIGHT. +-# +-# Licensed under the Apache License, Version 2.0 or the MIT license +-# , at your +-# option. This file may not be copied, modified, or distributed +-# except according to those terms. +- +-set -ex +- +-ANDROID_NDK_URL=https://dl.google.com/android/repository +-ANDROID_NDK_ARCHIVE=android-ndk-r25b-linux.zip +- +-curl -fO "$ANDROID_NDK_URL/$ANDROID_NDK_ARCHIVE" +-unzip -q $ANDROID_NDK_ARCHIVE +-rm $ANDROID_NDK_ARCHIVE +-mv android-ndk-* ndk +-rm -rf android-ndk-* +diff --git a/third_party/rust/packed_simd/ci/android-install-sdk.sh b/third_party/rust/packed_simd/ci/android-install-sdk.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/android-install-sdk.sh ++++ /dev/null +@@ -1,60 +0,0 @@ +-#!/usr/bin/env sh +-# Copyright 2016 The Rust Project Developers. See the COPYRIGHT +-# file at the top-level directory of this distribution and at +-# http://rust-lang.org/COPYRIGHT. +-# +-# Licensed under the Apache License, Version 2.0 or the MIT license +-# , at your +-# option. This file may not be copied, modified, or distributed +-# except according to those terms. +- +-set -ex +- +-# Prep the SDK and emulator +-# +-# Note that the update process requires that we accept a bunch of licenses, and +-# we can't just pipe `yes` into it for some reason, so we take the same strategy +-# located in https://github.com/appunite/docker by just wrapping it in a script +-# which apparently magically accepts the licenses. +- +-mkdir sdk +-curl --retry 5 https://dl.google.com/android/repository/sdk-tools-linux-3859397.zip -O +-unzip -d sdk sdk-tools-linux-3859397.zip +- +-case "$1" in +- arm | armv7) +- abi=armeabi-v7a +- ;; +- +- aarch64) +- abi=arm64-v8a +- ;; +- +- i686) +- abi=x86 +- ;; +- +- x86_64) +- abi=x86_64 +- ;; +- +- *) +- echo "invalid arch: $1" +- exit 1 +- ;; +-esac; +- +-# --no_https avoids +- # javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: No trusted certificate found +-yes | ./sdk/tools/bin/sdkmanager --licenses --no_https +-yes | ./sdk/tools/bin/sdkmanager --no_https \ +- "emulator" \ +- "platform-tools" \ +- "platforms;android-24" \ +- "system-images;android-24;default;$abi" +- +-echo "no" | +- ./sdk/tools/bin/avdmanager create avd \ +- --name "${1}" \ +- --package "system-images;android-24;default;$abi" +diff --git a/third_party/rust/packed_simd/ci/android-sysimage.sh b/third_party/rust/packed_simd/ci/android-sysimage.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/android-sysimage.sh ++++ /dev/null +@@ -1,56 +0,0 @@ +-#!/usr/bin/env bash +- +-# Copyright 2017 The Rust Project Developers. See the COPYRIGHT +-# file at the top-level directory of this distribution and at +-# http://rust-lang.org/COPYRIGHT. +-# +-# Licensed under the Apache License, Version 2.0 or the MIT license +-# , at your +-# option. This file may not be copied, modified, or distributed +-# except according to those terms. +- +-set -ex +- +-URL=https://dl.google.com/android/repository/sys-img/android +- +-main() { +- local arch="${1}" +- local name="${2}" +- local dest=/system +- local td +- td="$(mktemp -d)" +- +- apt-get install --no-install-recommends e2tools +- +- pushd "${td}" +- curl --retry 5 -O "${URL}/${name}" +- unzip -q "${name}" +- +- local system +- system="$(find . -name system.img)" +- mkdir -p ${dest}/{bin,lib,lib64} +- +- # Extract android linker and libraries to /system +- # This allows android executables to be run directly (or with qemu) +- if [ "${arch}" = "x86_64" ] || [ "${arch}" = "arm64" ]; then +- e2cp -p "${system}:/bin/linker64" "${dest}/bin/" +- e2cp -p "${system}:/lib64/libdl.so" "${dest}/lib64/" +- e2cp -p "${system}:/lib64/libc.so" "${dest}/lib64/" +- e2cp -p "${system}:/lib64/libm.so" "${dest}/lib64/" +- else +- e2cp -p "${system}:/bin/linker" "${dest}/bin/" +- e2cp -p "${system}:/lib/libdl.so" "${dest}/lib/" +- e2cp -p "${system}:/lib/libc.so" "${dest}/lib/" +- e2cp -p "${system}:/lib/libm.so" "${dest}/lib/" +- fi +- +- # clean up +- apt-get purge --auto-remove -y e2tools +- +- popd +- +- rm -rf "${td}" +-} +- +-main "${@}" +diff --git a/third_party/rust/packed_simd/ci/benchmark.sh b/third_party/rust/packed_simd/ci/benchmark.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/benchmark.sh ++++ /dev/null +@@ -1,32 +0,0 @@ +-#!/usr/bin/env bash +-# +-# Runs all benchmarks. Controlled by the following environment variables: +-# +-# FEATURES={} - cargo features to pass to all benchmarks (e.g. core_arch,sleef-sys,ispc) +-# NORUN={1} - only builds the benchmarks +- +-set -ex +- +-if [[ ${NORUN} != 1 ]]; then +- # Most benchmarks require hyperfine; require it upfront. +- hash hyperfine 2>/dev/null || { echo >&2 "hyperfine is not in PATH."; exit 1; } +-fi +- +- +-# If the ispc benchmark feature is enabled, ispc must be in the path of the +-# benchmarks. +-if echo "$FEATURES" | grep -q "ispc"; then +- hash ispc 2>/dev/null || { echo >&2 "ispc is not in PATH."; exit 1; } +-fi +- +-# An example with a benchmark.sh is a benchmark: +-for dir in examples/*/ +-do +- dir=${dir%*/} +- cd ${dir%*/} +- if [ -f "benchmark.sh" ]; then +- ./benchmark.sh +- fi +- cd - +-done +- +diff --git a/third_party/rust/packed_simd/ci/deploy_and_run_on_ios_simulator.rs b/third_party/rust/packed_simd/ci/deploy_and_run_on_ios_simulator.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/deploy_and_run_on_ios_simulator.rs ++++ /dev/null +@@ -1,176 +0,0 @@ +-// Copyright 2017 The Rust Project Developers. See the COPYRIGHT +-// file at the top-level directory of this distribution and at +-// http://rust-lang.org/COPYRIGHT. +-// +-// Licensed under the Apache License, Version 2.0 or the MIT license +-// , at your +-// option. This file may not be copied, modified, or distributed +-// except according to those terms. +- +-// This is a script to deploy and execute a binary on an iOS simulator. +-// The primary use of this is to be able to run unit tests on the simulator and +-// retrieve the results. +-// +-// To do this through Cargo instead, use Dinghy +-// (https://github.com/snipsco/dinghy): cargo dinghy install, then cargo dinghy +-// test. +- +-use std::env; +-use std::fs::{self, File}; +-use std::io::Write; +-use std::path::Path; +-use std::process; +-use std::process::Command; +- +-macro_rules! t { +- ($e:expr) => (match $e { +- Ok(e) => e, +- Err(e) => panic!("{} failed with: {}", stringify!($e), e), +- }) +-} +- +-// Step one: Wrap as an app +-fn package_as_simulator_app(crate_name: &str, test_binary_path: &Path) { +- println!("Packaging simulator app"); +- drop(fs::remove_dir_all("ios_simulator_app")); +- t!(fs::create_dir("ios_simulator_app")); +- t!(fs::copy(test_binary_path, +- Path::new("ios_simulator_app").join(crate_name))); +- +- let mut f = t!(File::create("ios_simulator_app/Info.plist")); +- t!(f.write_all(format!(r#" +- +- +- +- +- CFBundleExecutable +- {} +- CFBundleIdentifier +- com.rust.unittests +- +- +- "#, crate_name).as_bytes())); +-} +- +-// Step two: Start the iOS simulator +-fn start_simulator() { +- println!("Looking for iOS simulator"); +- let output = t!(Command::new("xcrun").arg("simctl").arg("list").output()); +- assert!(output.status.success()); +- let mut simulator_exists = false; +- let mut simulator_booted = false; +- let mut found_rust_sim = false; +- let stdout = t!(String::from_utf8(output.stdout)); +- for line in stdout.lines() { +- if line.contains("rust_ios") { +- if found_rust_sim { +- panic!("Duplicate rust_ios simulators found. Please \ +- double-check xcrun simctl list."); +- } +- simulator_exists = true; +- simulator_booted = line.contains("(Booted)"); +- found_rust_sim = true; +- } +- } +- +- if simulator_exists == false { +- println!("Creating iOS simulator"); +- Command::new("xcrun") +- .arg("simctl") +- .arg("create") +- .arg("rust_ios") +- .arg("com.apple.CoreSimulator.SimDeviceType.iPhone-SE") +- .arg("com.apple.CoreSimulator.SimRuntime.iOS-10-2") +- .check_status(); +- } else if simulator_booted == true { +- println!("Shutting down already-booted simulator"); +- Command::new("xcrun") +- .arg("simctl") +- .arg("shutdown") +- .arg("rust_ios") +- .check_status(); +- } +- +- println!("Starting iOS simulator"); +- // We can't uninstall the app (if present) as that will hang if the +- // simulator isn't completely booted; just erase the simulator instead. +- Command::new("xcrun").arg("simctl").arg("erase").arg("rust_ios").check_status(); +- Command::new("xcrun").arg("simctl").arg("boot").arg("rust_ios").check_status(); +-} +- +-// Step three: Install the app +-fn install_app_to_simulator() { +- println!("Installing app to simulator"); +- Command::new("xcrun") +- .arg("simctl") +- .arg("install") +- .arg("booted") +- .arg("ios_simulator_app/") +- .check_status(); +-} +- +-// Step four: Run the app +-fn run_app_on_simulator() { +- println!("Running app"); +- let output = t!(Command::new("xcrun") +- .arg("simctl") +- .arg("launch") +- .arg("--console") +- .arg("booted") +- .arg("com.rust.unittests") +- .output()); +- +- println!("stdout --\n{}\n", String::from_utf8_lossy(&output.stdout)); +- println!("stderr --\n{}\n", String::from_utf8_lossy(&output.stderr)); +- +- let stdout = String::from_utf8_lossy(&output.stdout); +- let failed = stdout.lines() +- .find(|l| l.contains("FAILED")) +- .map(|l| l.contains("FAILED")) +- .unwrap_or(false); +- +- let passed = stdout.lines() +- .find(|l| l.contains("test result: ok")) +- .map(|l| l.contains("test result: ok")) +- .unwrap_or(false); +- +- println!("Shutting down simulator"); +- Command::new("xcrun") +- .arg("simctl") +- .arg("shutdown") +- .arg("rust_ios") +- .check_status(); +- if !(passed && !failed) { +- panic!("tests didn't pass"); +- } +-} +- +-trait CheckStatus { +- fn check_status(&mut self); +-} +- +-impl CheckStatus for Command { +- fn check_status(&mut self) { +- println!("\trunning: {:?}", self); +- assert!(t!(self.status()).success()); +- } +-} +- +-fn main() { +- let args: Vec = env::args().collect(); +- if args.len() != 2 { +- println!("Usage: {} ", args[0]); +- process::exit(-1); +- } +- +- let test_binary_path = Path::new(&args[1]); +- let crate_name = test_binary_path.file_name().unwrap(); +- +- package_as_simulator_app(crate_name.to_str().unwrap(), test_binary_path); +- start_simulator(); +- install_app_to_simulator(); +- run_app_on_simulator(); +-} +diff --git a/third_party/rust/packed_simd/ci/docker/aarch64-linux-android/Dockerfile b/third_party/rust/packed_simd/ci/docker/aarch64-linux-android/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/aarch64-linux-android/Dockerfile ++++ /dev/null +@@ -1,47 +0,0 @@ +-FROM ubuntu:16.04 +- +-RUN dpkg --add-architecture i386 && \ +- apt-get update && \ +- apt-get install -y --no-install-recommends \ +- file \ +- make \ +- curl \ +- ca-certificates \ +- python \ +- unzip \ +- expect \ +- openjdk-9-jre \ +- libstdc++6:i386 \ +- libpulse0 \ +- gcc \ +- libc6-dev +- +-WORKDIR /android/ +-COPY android* /android/ +- +-ENV ANDROID_ARCH=aarch64 +-ENV PATH=$PATH:/android/ndk-$ANDROID_ARCH/bin:/android/sdk/tools:/android/sdk/platform-tools +- +-RUN sh /android/android-install-ndk.sh $ANDROID_ARCH +-RUN sh /android/android-install-sdk.sh $ANDROID_ARCH +-RUN mv /root/.android /tmp +-RUN chmod 777 -R /tmp/.android +-RUN chmod 755 /android/sdk/tools/* /android/sdk/emulator/qemu/linux-x86_64/* +- +-ENV PATH=$PATH:/rust/bin \ +- CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER=aarch64-linux-android-gcc \ +- CARGO_TARGET_AARCH64_LINUX_ANDROID_RUNNER=/tmp/runtest \ +- OBJDUMP=aarch64-linux-android-objdump \ +- HOME=/tmp +- +-ADD runtest-android.rs /tmp/runtest.rs +-ENTRYPOINT [ \ +- "bash", \ +- "-c", \ +- # set SHELL so android can detect a 64bits system, see +- # http://stackoverflow.com/a/41789144 +- "SHELL=/bin/dash /android/sdk/emulator/emulator @aarch64 -no-window & \ +- rustc /tmp/runtest.rs -o /tmp/runtest && \ +- exec \"$@\"", \ +- "--" \ +-] +diff --git a/third_party/rust/packed_simd/ci/docker/aarch64-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/aarch64-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/aarch64-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,14 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc \ +- ca-certificates \ +- libc6-dev \ +- gcc-aarch64-linux-gnu \ +- libc6-dev-arm64-cross \ +- qemu-user \ +- make \ +- file +- +-ENV CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER=aarch64-linux-gnu-gcc \ +- CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_RUNNER="qemu-aarch64 -L /usr/aarch64-linux-gnu" \ +- OBJDUMP=aarch64-linux-gnu-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/arm-unknown-linux-gnueabi/Dockerfile b/third_party/rust/packed_simd/ci/docker/arm-unknown-linux-gnueabi/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/arm-unknown-linux-gnueabi/Dockerfile ++++ /dev/null +@@ -1,15 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc \ +- ca-certificates \ +- libc6-dev \ +- libc6-armel-cross \ +- libc6-dev-armel-cross \ +- binutils-arm-linux-gnueabi \ +- gcc-arm-linux-gnueabi \ +- qemu-user \ +- make \ +- file +-ENV CARGO_TARGET_ARM_UNKNOWN_LINUX_GNUEABI_LINKER=arm-linux-gnueabi-gcc \ +- CARGO_TARGET_ARM_UNKNOWN_LINUX_GNUEABI_RUNNER="qemu-arm -L /usr/arm-linux-gnueabi" \ +- OBJDUMP=arm-linux-gnueabi-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/arm-unknown-linux-gnueabihf/Dockerfile b/third_party/rust/packed_simd/ci/docker/arm-unknown-linux-gnueabihf/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/arm-unknown-linux-gnueabihf/Dockerfile ++++ /dev/null +@@ -1,13 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc \ +- ca-certificates \ +- libc6-dev \ +- gcc-arm-linux-gnueabihf \ +- libc6-dev-armhf-cross \ +- qemu-user \ +- make \ +- file +-ENV CARGO_TARGET_ARM_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc \ +- CARGO_TARGET_ARM_UNKNOWN_LINUX_GNUEABIHF_RUNNER="qemu-arm -L /usr/arm-linux-gnueabihf" \ +- OBJDUMP=arm-linux-gnueabihf-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/armv7-linux-androideabi/Dockerfile b/third_party/rust/packed_simd/ci/docker/armv7-linux-androideabi/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/armv7-linux-androideabi/Dockerfile ++++ /dev/null +@@ -1,47 +0,0 @@ +-FROM ubuntu:16.04 +- +-RUN dpkg --add-architecture i386 && \ +- apt-get update && \ +- apt-get install -y --no-install-recommends \ +- file \ +- make \ +- curl \ +- ca-certificates \ +- python \ +- unzip \ +- expect \ +- openjdk-9-jre \ +- libstdc++6:i386 \ +- libpulse0 \ +- gcc \ +- libc6-dev +- +-WORKDIR /android/ +-COPY android* /android/ +- +-ENV ANDROID_ARCH=arm +-ENV PATH=$PATH:/android/ndk-$ANDROID_ARCH/bin:/android/sdk/tools:/android/sdk/platform-tools +- +-RUN sh /android/android-install-ndk.sh $ANDROID_ARCH +-RUN sh /android/android-install-sdk.sh $ANDROID_ARCH +-RUN mv /root/.android /tmp +-RUN chmod 777 -R /tmp/.android +-RUN chmod 755 /android/sdk/tools/* /android/sdk/emulator/qemu/linux-x86_64/* +- +-ENV PATH=$PATH:/rust/bin \ +- CARGO_TARGET_ARM_LINUX_ANDROIDEABI_LINKER=arm-linux-androideabi-gcc \ +- CARGO_TARGET_ARM_LINUX_ANDROIDEABI_RUNNER=/tmp/runtest \ +- OBJDUMP=arm-linux-androideabi-objdump \ +- HOME=/tmp +- +-ADD runtest-android.rs /tmp/runtest.rs +-ENTRYPOINT [ \ +- "bash", \ +- "-c", \ +- # set SHELL so android can detect a 64bits system, see +- # http://stackoverflow.com/a/41789144 +- "SHELL=/bin/dash /android/sdk/emulator/emulator @arm -no-window & \ +- rustc /tmp/runtest.rs -o /tmp/runtest && \ +- exec \"$@\"", \ +- "--" \ +-] +diff --git a/third_party/rust/packed_simd/ci/docker/armv7-unknown-linux-gnueabihf/Dockerfile b/third_party/rust/packed_simd/ci/docker/armv7-unknown-linux-gnueabihf/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/armv7-unknown-linux-gnueabihf/Dockerfile ++++ /dev/null +@@ -1,13 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc \ +- ca-certificates \ +- libc6-dev \ +- gcc-arm-linux-gnueabihf \ +- libc6-dev-armhf-cross \ +- qemu-user \ +- make \ +- file +-ENV CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc \ +- CARGO_TARGET_ARMV7_UNKNOWN_LINUX_GNUEABIHF_RUNNER="qemu-arm -L /usr/arm-linux-gnueabihf" \ +- OBJDUMP=arm-linux-gnueabihf-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/i586-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/i586-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/i586-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,7 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc-multilib \ +- libc6-dev \ +- file \ +- make \ +- ca-certificates +diff --git a/third_party/rust/packed_simd/ci/docker/i686-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/i686-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/i686-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,7 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc-multilib \ +- libc6-dev \ +- file \ +- make \ +- ca-certificates +diff --git a/third_party/rust/packed_simd/ci/docker/mips-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/mips-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/mips-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,13 +0,0 @@ +-FROM ubuntu:18.04 +- +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc libc6-dev qemu-user ca-certificates \ +- gcc-mips-linux-gnu libc6-dev-mips-cross \ +- qemu-system-mips \ +- qemu-user \ +- make \ +- file +- +-ENV CARGO_TARGET_MIPS_UNKNOWN_LINUX_GNU_LINKER=mips-linux-gnu-gcc \ +- CARGO_TARGET_MIPS_UNKNOWN_LINUX_GNU_RUNNER="qemu-mips -L /usr/mips-linux-gnu" \ +- OBJDUMP=mips-linux-gnu-objdump +\ No newline at end of file +diff --git a/third_party/rust/packed_simd/ci/docker/mips64-unknown-linux-gnuabi64/Dockerfile b/third_party/rust/packed_simd/ci/docker/mips64-unknown-linux-gnuabi64/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/mips64-unknown-linux-gnuabi64/Dockerfile ++++ /dev/null +@@ -1,10 +0,0 @@ +-FROM ubuntu:18.04 +- +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc libc6-dev qemu-user ca-certificates \ +- gcc-mips64-linux-gnuabi64 libc6-dev-mips64-cross \ +- qemu-system-mips64 qemu-user +- +-ENV CARGO_TARGET_MIPS64_UNKNOWN_LINUX_GNUABI64_LINKER=mips64-linux-gnuabi64-gcc \ +- CARGO_TARGET_MIPS64_UNKNOWN_LINUX_GNUABI64_RUNNER="qemu-mips64 -L /usr/mips64-linux-gnuabi64" \ +- OBJDUMP=mips64-linux-gnuabi64-objdump +\ No newline at end of file +diff --git a/third_party/rust/packed_simd/ci/docker/mips64el-unknown-linux-gnuabi64/Dockerfile b/third_party/rust/packed_simd/ci/docker/mips64el-unknown-linux-gnuabi64/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/mips64el-unknown-linux-gnuabi64/Dockerfile ++++ /dev/null +@@ -1,10 +0,0 @@ +-FROM ubuntu:18.04 +- +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc libc6-dev qemu-user ca-certificates \ +- gcc-mips64el-linux-gnuabi64 libc6-dev-mips64el-cross \ +- qemu-system-mips64el +- +-ENV CARGO_TARGET_MIPS64EL_UNKNOWN_LINUX_GNUABI64_LINKER=mips64el-linux-gnuabi64-gcc \ +- CARGO_TARGET_MIPS64EL_UNKNOWN_LINUX_GNUABI64_RUNNER="qemu-mips64el -L /usr/mips64el-linux-gnuabi64" \ +- OBJDUMP=mips64el-linux-gnuabi64-objdump +\ No newline at end of file +diff --git a/third_party/rust/packed_simd/ci/docker/mipsel-unknown-linux-musl/Dockerfile b/third_party/rust/packed_simd/ci/docker/mipsel-unknown-linux-musl/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/mipsel-unknown-linux-musl/Dockerfile ++++ /dev/null +@@ -1,25 +0,0 @@ +-FROM ubuntu:18.10 +- +-RUN apt-get update && \ +- apt-get install -y --no-install-recommends \ +- ca-certificates \ +- gcc \ +- libc6-dev \ +- make \ +- qemu-user \ +- qemu-system-mips \ +- bzip2 \ +- curl \ +- file +- +-RUN mkdir /toolchain +- +-# Note that this originally came from: +-# https://downloads.openwrt.org/snapshots/trunk/malta/generic/OpenWrt-Toolchain-malta-le_gcc-5.3.0_musl-1.1.15.Linux-x86_64.tar.bz2 +-RUN curl -L https://ci-mirrors.rust-lang.org/libc/OpenWrt-Toolchain-malta-le_gcc-5.3.0_musl-1.1.15.Linux-x86_64.tar.bz2 | \ +- tar xjf - -C /toolchain --strip-components=2 +- +-ENV PATH=$PATH:/rust/bin:/toolchain/bin \ +- CC_mipsel_unknown_linux_musl=mipsel-openwrt-linux-gcc \ +- CARGO_TARGET_MIPSEL_UNKNOWN_LINUX_MUSL_LINKER=mipsel-openwrt-linux-gcc \ +- CARGO_TARGET_MIPSEL_UNKNOWN_LINUX_MUSL_RUNNER="qemu-mipsel -L /toolchain" +diff --git a/third_party/rust/packed_simd/ci/docker/powerpc-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/powerpc-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/powerpc-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,13 +0,0 @@ +-FROM ubuntu:22.04 +- +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc libc6-dev qemu-user ca-certificates \ +- gcc-powerpc-linux-gnu libc6-dev-powerpc-cross \ +- qemu-system-ppc \ +- make \ +- file +- +-ENV CARGO_TARGET_POWERPC_UNKNOWN_LINUX_GNU_LINKER=powerpc-linux-gnu-gcc \ +- CARGO_TARGET_POWERPC_UNKNOWN_LINUX_GNU_RUNNER="qemu-ppc -cpu Vger -L /usr/powerpc-linux-gnu" \ +- CC=powerpc-linux-gnu-gcc \ +- OBJDUMP=powerpc-linux-gnu-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/powerpc64-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/powerpc64-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/powerpc64-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,17 +0,0 @@ +-FROM ubuntu:22.04 +- +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc \ +- ca-certificates \ +- libc6-dev \ +- gcc-powerpc64-linux-gnu \ +- libc6-dev-ppc64-cross \ +- qemu-user \ +- qemu-system-ppc \ +- make \ +- file +- +-ENV CARGO_TARGET_POWERPC64_UNKNOWN_LINUX_GNU_LINKER=powerpc64-linux-gnu-gcc \ +- CARGO_TARGET_POWERPC64_UNKNOWN_LINUX_GNU_RUNNER="qemu-ppc64 -L /usr/powerpc64-linux-gnu" \ +- CC=powerpc64-linux-gnu-gcc \ +- OBJDUMP=powerpc64-linux-gnu-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/powerpc64le-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/powerpc64le-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/powerpc64le-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,11 +0,0 @@ +-FROM ubuntu:22.04 +- +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc libc6-dev qemu-user ca-certificates \ +- gcc-powerpc64le-linux-gnu libc6-dev-ppc64el-cross \ +- qemu-system-ppc file make +- +-ENV CARGO_TARGET_POWERPC64LE_UNKNOWN_LINUX_GNU_LINKER=powerpc64le-linux-gnu-gcc \ +- CARGO_TARGET_POWERPC64LE_UNKNOWN_LINUX_GNU_RUNNER="qemu-ppc64le -L /usr/powerpc64le-linux-gnu" \ +- CC=powerpc64le-linux-gnu-gcc \ +- OBJDUMP=powerpc64le-linux-gnu-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/s390x-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/s390x-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/s390x-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,20 +0,0 @@ +-FROM ubuntu:22.04 +- +-RUN apt-get update && \ +- apt-get install -y --no-install-recommends \ +- ca-certificates \ +- curl \ +- cmake \ +- gcc \ +- libc6-dev \ +- g++-s390x-linux-gnu \ +- libc6-dev-s390x-cross \ +- qemu-user \ +- make \ +- file +- +-ENV CARGO_TARGET_S390X_UNKNOWN_LINUX_GNU_LINKER=s390x-linux-gnu-gcc \ +- CARGO_TARGET_S390X_UNKNOWN_LINUX_GNU_RUNNER="qemu-s390x -L /usr/s390x-linux-gnu" \ +- CC_s390x_unknown_linux_gnu=s390x-linux-gnu-gcc \ +- CXX_s390x_unknown_linux_gnu=s390x-linux-gnu-g++ \ +- OBJDUMP=s390x-linux-gnu-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/sparc64-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/sparc64-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/sparc64-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,18 +0,0 @@ +-FROM debian:bookworm +- +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- curl ca-certificates \ +- gcc libc6-dev \ +- gcc-sparc64-linux-gnu libc6-dev-sparc64-cross \ +- qemu-system-sparc64 openbios-sparc seabios ipxe-qemu \ +- p7zip-full cpio +- +-COPY linux-sparc64.sh / +-RUN bash /linux-sparc64.sh +- +-COPY test-runner-linux / +- +-ENV CARGO_TARGET_SPARC64_UNKNOWN_LINUX_GNU_LINKER=sparc64-linux-gnu-gcc \ +- CARGO_TARGET_SPARC64_UNKNOWN_LINUX_GNU_RUNNER="/test-runner-linux sparc64" \ +- CC_sparc64_unknown_linux_gnu=sparc64-linux-gnu-gcc \ +- PATH=$PATH:/rust/bin +diff --git a/third_party/rust/packed_simd/ci/docker/thumbv7neon-linux-androideabi/Dockerfile b/third_party/rust/packed_simd/ci/docker/thumbv7neon-linux-androideabi/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/thumbv7neon-linux-androideabi/Dockerfile ++++ /dev/null +@@ -1,47 +0,0 @@ +-FROM ubuntu:16.04 +- +-RUN dpkg --add-architecture i386 && \ +- apt-get update && \ +- apt-get install -y --no-install-recommends \ +- file \ +- make \ +- curl \ +- ca-certificates \ +- python \ +- unzip \ +- expect \ +- openjdk-9-jre \ +- libstdc++6:i386 \ +- libpulse0 \ +- gcc \ +- libc6-dev +- +-WORKDIR /android/ +-COPY android* /android/ +- +-ENV ANDROID_ARCH=arm +-ENV PATH=$PATH:/android/ndk-$ANDROID_ARCH/bin:/android/sdk/tools:/android/sdk/platform-tools +- +-RUN sh /android/android-install-ndk.sh $ANDROID_ARCH +-RUN sh /android/android-install-sdk.sh $ANDROID_ARCH +-RUN mv /root/.android /tmp +-RUN chmod 777 -R /tmp/.android +-RUN chmod 755 /android/sdk/tools/* /android/sdk/emulator/qemu/linux-x86_64/* +- +-ENV PATH=$PATH:/rust/bin \ +- CARGO_TARGET_THUMBV7NEON_LINUX_ANDROIDEABI_LINKER=arm-linux-androideabi-gcc \ +- CARGO_TARGET_THUMBV7NEON_LINUX_ANDROIDEABI_RUNNER=/tmp/runtest \ +- OBJDUMP=arm-linux-androideabi-objdump \ +- HOME=/tmp +- +-ADD runtest-android.rs /tmp/runtest.rs +-ENTRYPOINT [ \ +- "bash", \ +- "-c", \ +- # set SHELL so android can detect a 64bits system, see +- # http://stackoverflow.com/a/41789144 +- "SHELL=/bin/dash /android/sdk/emulator/emulator @arm -no-window & \ +- rustc /tmp/runtest.rs -o /tmp/runtest && \ +- exec \"$@\"", \ +- "--" \ +-] +diff --git a/third_party/rust/packed_simd/ci/docker/thumbv7neon-unknown-linux-gnueabihf/Dockerfile b/third_party/rust/packed_simd/ci/docker/thumbv7neon-unknown-linux-gnueabihf/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/thumbv7neon-unknown-linux-gnueabihf/Dockerfile ++++ /dev/null +@@ -1,13 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc \ +- ca-certificates \ +- libc6-dev \ +- gcc-arm-linux-gnueabihf \ +- libc6-dev-armhf-cross \ +- qemu-user \ +- make \ +- file +-ENV CARGO_TARGET_THUMBV7NEON_UNKNOWN_LINUX_GNUEABIHF_LINKER=arm-linux-gnueabihf-gcc \ +- CARGO_TARGET_THUMBV7NEON_UNKNOWN_LINUX_GNUEABIHF_RUNNER="qemu-arm -L /usr/arm-linux-gnueabihf" \ +- OBJDUMP=arm-linux-gnueabihf-objdump +diff --git a/third_party/rust/packed_simd/ci/docker/wasm32-unknown-unknown/Dockerfile b/third_party/rust/packed_simd/ci/docker/wasm32-unknown-unknown/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/wasm32-unknown-unknown/Dockerfile ++++ /dev/null +@@ -1,39 +0,0 @@ +-FROM ubuntu:22.04 +- +-RUN apt-get update -y && apt-get install -y --no-install-recommends \ +- ca-certificates \ +- clang \ +- cmake \ +- curl \ +- git \ +- libc6-dev \ +- make \ +- ninja-build \ +- python-is-python3 \ +- xz-utils +- +-# Install `wasm2wat` +-RUN git clone --recursive https://github.com/WebAssembly/wabt +-RUN make -C wabt -j$(nproc) +-ENV PATH=$PATH:/wabt/bin +- +-# Install `wasm-bindgen-test-runner` +-RUN curl -L https://github.com/rustwasm/wasm-bindgen/releases/download/0.2.87/wasm-bindgen-0.2.87-x86_64-unknown-linux-musl.tar.gz \ +- | tar xzf - +-# Keep in sync with the version on Cargo.toml. +-ENV PATH=$PATH:/wasm-bindgen-0.2.87-x86_64-unknown-linux-musl +-ENV CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUNNER=wasm-bindgen-test-runner +- +-# Install `node` +-RUN curl https://nodejs.org/dist/v14.16.0/node-v14.16.0-linux-x64.tar.xz | tar xJf - +-ENV PATH=$PATH:/node-v14.16.0-linux-x64/bin +- +-# We use a shim linker that removes `--strip-debug` when passed to LLD. While +-# this typically results in invalid debug information in release mode it doesn't +-# result in an invalid names section which is what we're interested in. +-COPY lld-shim.rs / +-ENV CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_LINKER=/tmp/lld-shim +- +-# Rustc isn't available until this container starts, so defer compilation of the +-# shim. +-ENTRYPOINT /rust/bin/rustc /lld-shim.rs -o /tmp/lld-shim && exec bash "$@" +diff --git a/third_party/rust/packed_simd/ci/docker/x86_64-linux-android/Dockerfile b/third_party/rust/packed_simd/ci/docker/x86_64-linux-android/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/x86_64-linux-android/Dockerfile ++++ /dev/null +@@ -1,31 +0,0 @@ +-FROM ubuntu:20.04 +- +-RUN apt-get update && \ +- apt-get install -y --no-install-recommends \ +- ca-certificates \ +- curl \ +- gcc \ +- libc-dev \ +- python \ +- unzip \ +- file \ +- make +- +-WORKDIR /android/ +-ENV ANDROID_ARCH=x86_64 +-COPY android-install-ndk.sh /android/ +-RUN sh /android/android-install-ndk.sh +- +-ENV STDARCH_ASSERT_INSTR_LIMIT=30 +- +-# We do not run x86_64-linux-android tests on an android emulator. +-# See ci/android-sysimage.sh for informations about how tests are run. +-COPY android-sysimage.sh /android/ +-RUN bash /android/android-sysimage.sh x86_64 x86_64-24_r07.zip +- +-ENV PATH=$PATH:/rust/bin:/android/ndk/toolchains/llvm/prebuilt/linux-x86_64/bin \ +- CARGO_TARGET_X86_64_LINUX_ANDROID_LINKER=x86_64-linux-android21-clang \ +- CC_x86_64_linux_android=x86_64-linux-android21-clang \ +- CXX_x86_64_linux_android=x86_64-linux-android21-clang++ \ +- OBJDUMP=llvm-objdump \ +- HOME=/tmp +diff --git a/third_party/rust/packed_simd/ci/docker/x86_64-unknown-linux-gnu-emulated/Dockerfile b/third_party/rust/packed_simd/ci/docker/x86_64-unknown-linux-gnu-emulated/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/x86_64-unknown-linux-gnu-emulated/Dockerfile ++++ /dev/null +@@ -1,16 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc \ +- libc6-dev \ +- file \ +- make \ +- ca-certificates \ +- wget \ +- bzip2 \ +- cmake \ +- libclang-dev \ +- clang +- +-RUN wget https://github.com/gnzlbg/intel_sde/raw/master/sde-external-8.16.0-2018-01-30-lin.tar.bz2 +-RUN tar -xjf sde-external-8.16.0-2018-01-30-lin.tar.bz2 +-ENV CARGO_TARGET_X86_64_UNKNOWN_LINUX_GNU_RUNNER="/sde-external-8.16.0-2018-01-30-lin/sde64 --" +diff --git a/third_party/rust/packed_simd/ci/docker/x86_64-unknown-linux-gnu/Dockerfile b/third_party/rust/packed_simd/ci/docker/x86_64-unknown-linux-gnu/Dockerfile +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/docker/x86_64-unknown-linux-gnu/Dockerfile ++++ /dev/null +@@ -1,10 +0,0 @@ +-FROM ubuntu:18.04 +-RUN apt-get update && apt-get install -y --no-install-recommends \ +- gcc \ +- libc6-dev \ +- file \ +- make \ +- ca-certificates \ +- cmake \ +- libclang-dev \ +- clang +diff --git a/third_party/rust/packed_simd/ci/dox.sh b/third_party/rust/packed_simd/ci/dox.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/dox.sh ++++ /dev/null +@@ -1,27 +0,0 @@ +-#!/bin/sh +- +-set -ex +- +-rm -rf target/doc +-mkdir -p target/doc +- +-# Build API documentation +-cargo doc --features=into_bits +- +-# Build Performance Guide +-# FIXME: https://github.com/rust-lang-nursery/mdBook/issues/780 +-# mdbook build perf-guide -d target/doc/perf-guide +-cd perf-guide +-mdbook build +-cd - +-cp -r perf-guide/book target/doc/perf-guide +- +-# If we're on travis, not a PR, and on the right branch, publish! +-if [ "$TRAVIS_PULL_REQUEST" = "false" ] && [ "$TRAVIS_BRANCH" = "master" ]; then +- python3 -vV +- pip -vV +- python3.9 -vV +- pip install ghp_import --user +- ghp-import -n target/doc +- git push -qf https://${GH_PAGES}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages +-fi +diff --git a/third_party/rust/packed_simd/ci/linux-s390x.sh b/third_party/rust/packed_simd/ci/linux-s390x.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/linux-s390x.sh ++++ /dev/null +@@ -1,18 +0,0 @@ +-set -ex +- +-mkdir -m 777 /qemu +-cd /qemu +- +-curl -LO https://github.com/qemu/qemu/raw/master/pc-bios/s390-ccw.img +-curl -LO http://ftp.debian.org/debian/dists/testing/main/installer-s390x/20170828/images/generic/kernel.debian +-curl -LO http://ftp.debian.org/debian/dists/testing/main/installer-s390x/20170828/images/generic/initrd.debian +- +-mv kernel.debian kernel +-mv initrd.debian initrd.gz +- +-mkdir init +-cd init +-gunzip -c ../initrd.gz | cpio -id +-rm ../initrd.gz +-cp /usr/s390x-linux-gnu/lib/libgcc_s.so.1 usr/lib/ +-chmod a+w . +diff --git a/third_party/rust/packed_simd/ci/linux-sparc64.sh b/third_party/rust/packed_simd/ci/linux-sparc64.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/linux-sparc64.sh ++++ /dev/null +@@ -1,17 +0,0 @@ +-set -ex +- +-mkdir -m 777 /qemu +-cd /qemu +- +-curl -LO https://cdimage.debian.org/cdimage/ports/9.0/sparc64/iso-cd/debian-9.0-sparc64-NETINST-1.iso +-7z e debian-9.0-sparc64-NETINST-1.iso boot/initrd.gz +-7z e debian-9.0-sparc64-NETINST-1.iso boot/sparc64 +-mv sparc64 kernel +-rm debian-9.0-sparc64-NETINST-1.iso +- +-mkdir init +-cd init +-gunzip -c ../initrd.gz | cpio -id +-rm ../initrd.gz +-cp /usr/sparc64-linux-gnu/lib/libgcc_s.so.1 usr/lib/ +-chmod a+w . +diff --git a/third_party/rust/packed_simd/ci/lld-shim.rs b/third_party/rust/packed_simd/ci/lld-shim.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/lld-shim.rs ++++ /dev/null +@@ -1,11 +0,0 @@ +-use std::os::unix::prelude::*; +-use std::process::Command; +-use std::env; +- +-fn main() { +- let args = env::args() +- .skip(1) +- .filter(|s| s != "--strip-debug") +- .collect::>(); +- panic!("failed to exec: {}", Command::new("rust-lld").args(&args).exec()); +-} +diff --git a/third_party/rust/packed_simd/ci/max_line_width.sh b/third_party/rust/packed_simd/ci/max_line_width.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/max_line_width.sh ++++ /dev/null +@@ -1,17 +0,0 @@ +-#!/usr/bin/env sh +- +-set -x +- +-export success=true +- +-find . -iname '*.rs' | while read -r file; do +- result=$(grep '.\{79\}' "${file}" | grep --invert 'http') +- if [ "${result}" = "" ] +- then +- : +- else +- echo "file \"${file}\": $result" +- exit 1 +- fi +-done +- +diff --git a/third_party/rust/packed_simd/ci/run-docker.sh b/third_party/rust/packed_simd/ci/run-docker.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/run-docker.sh ++++ /dev/null +@@ -1,38 +0,0 @@ +-# Small script to run tests for a target (or all targets) inside all the +-# respective docker images. +- +-set -ex +- +-run() { +- echo "Building docker container for TARGET=${TARGET} RUSTFLAGS=${RUSTFLAGS}" +- docker build -t packed_simd -f ci/docker/${TARGET}/Dockerfile ci/ +- mkdir -p target +- target=$(echo "${TARGET}" | sed 's/-emulated//') +- echo "Running docker" +- docker run \ +- --user `id -u`:`id -g` \ +- --rm \ +- --init \ +- --volume $HOME/.cargo:/cargo \ +- --env CARGO_HOME=/cargo \ +- --volume `rustc --print sysroot`:/rust:ro \ +- --env TARGET=$target \ +- --env NORUN \ +- --env NOVERIFY \ +- --env RUSTFLAGS \ +- --volume `pwd`:/checkout:ro \ +- --volume `pwd`/target:/checkout/target \ +- --workdir /checkout \ +- --privileged \ +- packed_simd \ +- bash \ +- -c 'PATH=$PATH:/rust/bin exec ci/run.sh' +-} +- +-if [ -z "${TARGET}" ]; then +- for d in `ls ci/docker/`; do +- run $d +- done +-else +- run ${TARGET} +-fi +diff --git a/third_party/rust/packed_simd/ci/run.sh b/third_party/rust/packed_simd/ci/run.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/run.sh ++++ /dev/null +@@ -1,99 +0,0 @@ +-#!/usr/bin/env bash +- +-set -ex +- +-: ${TARGET?"The TARGET environment variable must be set."} +- +-# Tests are all super fast anyway, and they fault often enough on travis that +-# having only one thread increases debuggability to be worth it. +-#export RUST_TEST_THREADS=1 +-#export RUST_BACKTRACE=full +-#export RUST_TEST_NOCAPTURE=1 +- +-# Some appveyor builds run out-of-memory; this attempts to mitigate that: +-# https://github.com/rust-lang-nursery/packed_simd/issues/39 +-# export RUSTFLAGS="${RUSTFLAGS} -C codegen-units=1" +-# export CARGO_BUILD_JOBS=1 +- +-export CARGO_SUBCMD=test +-if [[ "${NORUN}" == "1" ]]; then +- export CARGO_SUBCMD=build +-fi +- +-if [[ ${TARGET} == "x86_64-apple-ios" ]] || [[ ${TARGET} == "i386-apple-ios" ]]; then +- export RUSTFLAGS="${RUSTFLAGS} -Clink-arg=-mios-simulator-version-min=7.0" +- rustc ./ci/deploy_and_run_on_ios_simulator.rs -o $HOME/runtest +- export CARGO_TARGET_X86_64_APPLE_IOS_RUNNER=$HOME/runtest +- export CARGO_TARGET_I386_APPLE_IOS_RUNNER=$HOME/runtest +-fi +- +-# The source directory is read-only. Need to copy internal crates to the target +-# directory for their Cargo.lock to be properly written. +-mkdir target || true +- +-rustc --version +-cargo --version +-echo "TARGET=${TARGET}" +-echo "HOST=${HOST}" +-echo "RUSTFLAGS=${RUSTFLAGS}" +-echo "NORUN=${NORUN}" +-echo "NOVERIFY=${NOVERIFY}" +-echo "CARGO_SUBCMD=${CARGO_SUBCMD}" +-echo "CARGO_BUILD_JOBS=${CARGO_BUILD_JOBS}" +-echo "CARGO_INCREMENTAL=${CARGO_INCREMENTAL}" +-echo "RUST_TEST_THREADS=${RUST_TEST_THREADS}" +-echo "RUST_BACKTRACE=${RUST_BACKTRACE}" +-echo "RUST_TEST_NOCAPTURE=${RUST_TEST_NOCAPTURE}" +- +-cargo_test() { +- cmd="cargo ${CARGO_SUBCMD} --verbose --target=${TARGET} ${@}" +- if [ "${NORUN}" != "1" ] +- then +- if [ "$TARGET" != "wasm32-unknown-unknown" ] +- then +- cmd="$cmd -- --quiet" +- fi +- fi +- mkdir target || true +- ${cmd} 2>&1 | tee > target/output +- if [[ ${PIPESTATUS[0]} != 0 ]]; then +- cat target/output +- return 1 +- fi +-} +- +-cargo_test_impl() { +- ORIGINAL_RUSTFLAGS=${RUSTFLAGS} +- RUSTFLAGS="${ORIGINAL_RUSTFLAGS} --cfg test_v16 --cfg test_v32 --cfg test_v64" cargo_test ${@} +- RUSTFLAGS="${ORIGINAL_RUSTFLAGS} --cfg test_v128 --cfg test_v256" cargo_test ${@} +- RUSTFLAGS="${ORIGINAL_RUSTFLAGS} --cfg test_v512" cargo_test ${@} +- RUSTFLAGS=${ORIGINAL_RUSTFLAGS} +-} +- +-# Debug run: +-if [[ "${TARGET}" != "wasm32-unknown-unknown" ]]; then +- # Run wasm32-unknown-unknown in release mode only +- cargo_test_impl +-fi +- +-if [[ "${TARGET}" == "x86_64-unknown-linux-gnu" ]] || [[ "${TARGET}" == "x86_64-pc-windows-msvc" ]]; then +- # use sleef on linux and windows x86_64 builds +- # FIXME: Use `core_arch,sleef-sys` features once they works again +- cargo_test_impl --release --features=into_bits +-else +- # FIXME: Use `core_arch` feature once it works again +- cargo_test_impl --release --features=into_bits +-fi +- +-# Verify code generation +-if [[ "${NOVERIFY}" != "1" ]]; then +- cp -r verify/verify target/verify +- export STDSIMD_ASSERT_INSTR_LIMIT=30 +- if [[ "${TARGET}" == "i586-unknown-linux-gnu" ]]; then +- export STDSIMD_ASSERT_INSTR_LIMIT=50 +- fi +- cargo_test --release --manifest-path=target/verify/Cargo.toml +-fi +- +-# FIXME: Figure out which examples take too long to run and ignore or adjust those +-#. ci/run_examples.sh +diff --git a/third_party/rust/packed_simd/ci/run_examples.sh b/third_party/rust/packed_simd/ci/run_examples.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/run_examples.sh ++++ /dev/null +@@ -1,51 +0,0 @@ +-# Runs all examples. +- +-# FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/55 +-# All examples fail to build for `armv7-apple-ios`. +-if [[ ${TARGET} == "armv7-apple-ios" ]]; then +- exit 0 +-fi +- +-# FIXME: travis exceeds 50 minutes on these targets +-# Skipping the examples is an attempt at preventing travis from timing-out +-if [[ ${TARGET} == "arm-linux-androidabi" ]] || [[ ${TARGET} == "aarch64-linux-androidabi" ]] \ +- || [[ ${TARGET} == "sparc64-unknown-linux-gnu" ]]; then +- exit 0 +-fi +- +-if [[ ${TARGET} == "wasm32-unknown-unknown" ]]; then +- exit 0 +-fi +- +-cp -r examples/aobench target/aobench +-cargo_test --manifest-path=target/aobench/Cargo.toml --release --no-default-features +-cargo_test --manifest-path=target/aobench/Cargo.toml --release --features=256bit +- +-cp -r examples/dot_product target/dot_product +-cargo_test --manifest-path=target/dot_product/Cargo.toml --release +- +-cp -r examples/fannkuch_redux target/fannkuch_redux +-cargo_test --manifest-path=target/fannkuch_redux/Cargo.toml --release +- +-# FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/56 +-if [[ ${TARGET} != "i586-unknown-linux-gnu" ]]; then +- cp -r examples/mandelbrot target/mandelbrot +- cargo_test --manifest-path=target/mandelbrot/Cargo.toml --release +-fi +- +-cp -r examples/matrix_inverse target/matrix_inverse +-cargo_test --manifest-path=target/matrix_inverse/Cargo.toml --release +- +-cp -r examples/nbody target/nbody +-cargo_test --manifest-path=target/nbody/Cargo.toml --release +- +-cp -r examples/spectral_norm target/spectral_norm +-cargo_test --manifest-path=target/spectral_norm/Cargo.toml --release +- +-if [[ ${TARGET} != "i586-unknown-linux-gnu" ]]; then +- cp -r examples/stencil target/stencil +- cargo_test --manifest-path=target/stencil/Cargo.toml --release +-fi +- +-cp -r examples/triangle_xform target/triangle_xform +-cargo_test --manifest-path=target/triangle_xform/Cargo.toml --release +diff --git a/third_party/rust/packed_simd/ci/runtest-android.rs b/third_party/rust/packed_simd/ci/runtest-android.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/runtest-android.rs ++++ /dev/null +@@ -1,45 +0,0 @@ +-use std::env; +-use std::process::Command; +-use std::path::{Path, PathBuf}; +- +-fn main() { +- let args = env::args_os() +- .skip(1) +- .filter(|arg| arg != "--quiet") +- .collect::>(); +- assert_eq!(args.len(), 1); +- let test = PathBuf::from(&args[0]); +- let dst = Path::new("/data/local/tmp").join(test.file_name().unwrap()); +- +- let status = Command::new("adb") +- .arg("wait-for-device") +- .status() +- .expect("failed to run: adb wait-for-device"); +- assert!(status.success()); +- +- let status = Command::new("adb") +- .arg("push") +- .arg(&test) +- .arg(&dst) +- .status() +- .expect("failed to run: adb pushr"); +- assert!(status.success()); +- +- let output = Command::new("adb") +- .arg("shell") +- .arg(&dst) +- .output() +- .expect("failed to run: adb shell"); +- assert!(status.success()); +- +- println!("status: {}\nstdout ---\n{}\nstderr ---\n{}", +- output.status, +- String::from_utf8_lossy(&output.stdout), +- String::from_utf8_lossy(&output.stderr)); +- +- let stdout = String::from_utf8_lossy(&output.stdout); +- let mut lines = stdout.lines().filter(|l| l.starts_with("test result")); +- if !lines.all(|l| l.contains("test result: ok") && l.contains("0 failed")) { +- panic!("failed to find successful test run"); +- } +-} +diff --git a/third_party/rust/packed_simd/ci/setup_benchmarks.sh b/third_party/rust/packed_simd/ci/setup_benchmarks.sh +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/setup_benchmarks.sh ++++ /dev/null +@@ -1,7 +0,0 @@ +-#!/usr/bin/env bash +- +-set -ex +- +-# Get latest ISPC binary for the target and put it in the path +-git clone https://github.com/gnzlbg/ispc-binaries +-cp ispc-binaries/ispc-${TARGET} ispc +diff --git a/third_party/rust/packed_simd/ci/test-runner-linux b/third_party/rust/packed_simd/ci/test-runner-linux +deleted file mode 100644 +--- a/third_party/rust/packed_simd/ci/test-runner-linux ++++ /dev/null +@@ -1,24 +0,0 @@ +-#!/bin/sh +- +-set -e +- +-arch=$1 +-prog=$2 +- +-cd /qemu/init +-cp -f $2 prog +-find . | cpio --create --format='newc' --quiet | gzip > ../initrd.gz +-cd .. +- +-timeout 30s qemu-system-$arch \ +- -m 1024 \ +- -nographic \ +- -kernel kernel \ +- -initrd initrd.gz \ +- -append init=/prog > output || true +- +-# remove kernel messages +-tr -d '\r' < output | egrep -v '^\[' +- +-# if the output contains a failure, return error +-! grep FAILED output > /dev/null +diff --git a/third_party/rust/packed_simd/contributing.md b/third_party/rust/packed_simd/contributing.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/contributing.md ++++ /dev/null +@@ -1,67 +0,0 @@ +-# Contributing to `packed_simd` +- +-Welcome! If you are reading this document, it means you are interested in contributing +-to the `packed_simd` crate. +- +-## Reporting issues +- +-All issues with this crate are tracked using GitHub's [Issue Tracker]. +- +-You can use issues to bring bugs to the attention of the maintainers, to discuss +-certain problems encountered with the crate, or to request new features (although +-feature requests should be limited to things mentioned in the [RFC]). +- +-One thing to keep in mind is to always use the **latest** nightly toolchain when +-working on this crate. Due to the nature of this project, we use a lot of unstable +-features, meaning breakage happens often. +- +-[Issue Tracker]: https://github.com/rust-lang-nursery/packed_simd/issues +-[RFC]: https://github.com/rust-lang/rfcs/pull/2366 +- +-### LLVM issues +- +-The Rust compiler relies on [LLVM](https://llvm.org/) for machine code generation, +-and quite a few LLVM bugs have been discovered during the development of this project. +- +-If you encounter issues with incorrect/suboptimal codegen, which you do not encounter +-when using the [SIMD vendor intrinsics](https://doc.rust-lang.org/nightly/std/arch/), +-it is likely the issue is with LLVM, or this crate's interaction with it. +- +-You should first open an issue **in this repo** to help us track the problem, and we +-will help determine what is the exact cause of the problem. +-If LLVM is indeed the cause, the issue will be reported upstream to the +-[LLVM bugtracker](https://bugs.llvm.org/). +- +-## Submitting Pull Requests +- +-New code is submitted to the crate using GitHub's [pull request] mechanism. +-You should first fork this repository, make your changes (preferably in a new +-branch), then use GitHub's web UI to create a new PR. +- +-[pull request]: https://help.github.com/articles/about-pull-requests/ +- +-### Examples +- +-The `examples` directory contains code showcasing SIMD code written with this crate, +-usually in comparison to scalar or ISPC code. If you have a project / idea which +-uses SIMD, we'd love to add it to the examples list. +- +-Every example should include a small `README`, describing the example code's purpose. +-If your example could potentially work as a benchmark, then add a `benchmark.sh` +-script to allow running the example benchmark code in CI. See an existing example's +-[`benchmark.sh`](examples/aobench/benchmark.sh) for a sample. +- +-Don't forget to update the crate's top-level `README` with a link to your example. +- +-### Perf guide +- +-The objective of the [performance guide][perf-guide] is to be a comprehensive +-resource detailing the process of optimizing Rust code with SIMD support. +- +-If you believe a certain section could be reworded, or if you have any tips & tricks +-related to SIMD which you'd like to share, please open a PR. +- +-[mdBook] is used to manage the formatting of the guide as a book. +- +-[perf-guide]: https://rust-lang-nursery.github.io/packed_simd/perf-guide/ +-[mdBook]: https://github.com/rust-lang-nursery/mdBook +diff --git a/third_party/rust/packed_simd/perf-guide/.gitignore b/third_party/rust/packed_simd/perf-guide/.gitignore +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/.gitignore ++++ /dev/null +@@ -1,1 +0,0 @@ +-/book +diff --git a/third_party/rust/packed_simd/perf-guide/book.toml b/third_party/rust/packed_simd/perf-guide/book.toml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/book.toml ++++ /dev/null +@@ -1,12 +0,0 @@ +-[book] +-authors = ["Gonzalo Brito Gadeschi", "Gabriel Majeri"] +-multilingual = false +-src = "src" +-title = "Rust SIMD Performance Guide" +-description = "This book describes how to write performant SIMD code in Rust." +- +-[build] +-create-missing = false +- +-[output.html] +-additional-css = ["./src/ascii.css"] +diff --git a/third_party/rust/packed_simd/perf-guide/src/SUMMARY.md b/third_party/rust/packed_simd/perf-guide/src/SUMMARY.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/SUMMARY.md ++++ /dev/null +@@ -1,21 +0,0 @@ +-# Summary +- +-[Introduction](./introduction.md) +- +-- [Floating-point Math](./float-math/fp.md) +- - [Short-vector Math Library](./float-math/svml.md) +- - [Approximate functions](./float-math/approx.md) +- - [Fused multiply-accumulate](./float-math/fma.md) +- +-- [Target features](./target-feature/features.md) +- - [Using `RUSTFLAGS`](./target-feature/rustflags.md) +- - [Using the `target_feature` attribute](./target-feature/attribute.md) +- - [Interaction with inlining](./target-feature/inlining.md) +- - [Detecting features at runtime](./target-feature/runtime.md) +- +-- [Bounds checking](./bound_checks.md) +-- [Vertical and horizontal operations](./vert-hor-ops.md) +- +-- [Performance profiling](./prof/profiling.md) +- - [Profiling on Linux](./prof/linux.md) +- - [Using machine code analyzers](./prof/mca.md) +diff --git a/third_party/rust/packed_simd/perf-guide/src/ascii.css b/third_party/rust/packed_simd/perf-guide/src/ascii.css +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/ascii.css ++++ /dev/null +@@ -1,4 +0,0 @@ +-code { +- /* "Source Code Pro" breaks ASCII art */ +- font-family: Consolas, "Ubuntu Mono", Menlo, "DejaVu Sans Mono", monospace; +-} +diff --git a/third_party/rust/packed_simd/perf-guide/src/bound_checks.md b/third_party/rust/packed_simd/perf-guide/src/bound_checks.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/bound_checks.md ++++ /dev/null +@@ -1,22 +0,0 @@ +-# Bounds checking +- +-Reading and writing packed vectors to/from slices is checked by default. +-Independently of the configuration options used, the safe functions: +- +-* `Simd<[T; N]>::from_slice_aligned(& s[..])` +-* `Simd<[T; N]>::write_to_slice_aligned(&mut s[..])` +- +-always check that: +- +-* the slice is big enough to hold the vector +-* the slice is suitably aligned to perform an aligned load/store for a `Simd<[T; +- N]>` (this alignment is often much larger than that of `T`). +- +-There are `_unaligned` versions that use unaligned load and stores, as well as +-`unsafe` `_unchecked` that do not perform any checks iff `debug-assertions = +-false` / `debug = false`. That is, the `_unchecked` methods do still assert size +-and alignment in debug builds and could also do so in release builds depending +-on the configuration options. +- +-These assertions do often significantly impact performance and you should be +-aware of them. +diff --git a/third_party/rust/packed_simd/perf-guide/src/float-math/approx.md b/third_party/rust/packed_simd/perf-guide/src/float-math/approx.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/float-math/approx.md ++++ /dev/null +@@ -1,8 +0,0 @@ +-# Approximate functions +- +- +diff --git a/third_party/rust/packed_simd/perf-guide/src/float-math/fma.md b/third_party/rust/packed_simd/perf-guide/src/float-math/fma.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/float-math/fma.md ++++ /dev/null +@@ -1,6 +0,0 @@ +-# Fused Multiply Add +- +- +diff --git a/third_party/rust/packed_simd/perf-guide/src/float-math/fp.md b/third_party/rust/packed_simd/perf-guide/src/float-math/fp.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/float-math/fp.md ++++ /dev/null +@@ -1,3 +0,0 @@ +-# Floating-point math +- +-This chapter contains information pertaining to working with floating-point numbers. +diff --git a/third_party/rust/packed_simd/perf-guide/src/float-math/svml.md b/third_party/rust/packed_simd/perf-guide/src/float-math/svml.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/float-math/svml.md ++++ /dev/null +@@ -1,7 +0,0 @@ +-# Short Vector Math Library +- +- +diff --git a/third_party/rust/packed_simd/perf-guide/src/introduction.md b/third_party/rust/packed_simd/perf-guide/src/introduction.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/introduction.md ++++ /dev/null +@@ -1,26 +0,0 @@ +-# Introduction +- +-## What is SIMD +- +- +- +-## History of SIMD in Rust +- +- +- +-## Discover packed_simd +- +- +- +-Writing fast and portable SIMD algorithms using `packed_simd` is, unfortunately, +-not trivial. There are many pitfals that one should be aware of, and some idioms +-that help avoid those pitfalls. +- +-This book attempts to document these best practices and provides practical examples +-on how to apply the tips to _your_ code. +diff --git a/third_party/rust/packed_simd/perf-guide/src/prof/linux.md b/third_party/rust/packed_simd/perf-guide/src/prof/linux.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/prof/linux.md ++++ /dev/null +@@ -1,107 +0,0 @@ +-# Performance profiling on Linux +- +-## Using `perf` +- +-[perf](https://perf.wiki.kernel.org/) is the most powerful performance profiler +-for Linux, featuring support for various hardware Performance Monitoring Units, +-as well as integration with the kernel's performance events framework. +- +-We will only look at how can the `perf` command can be used to profile SIMD code. +-Full system profiling is outside of the scope of this book. +- +-### Recording +- +-The first step is to record a program's execution during an average workload. +-It helps if you can isolate the parts of your program which have performance +-issues, and set up a benchmark which can be easily (re)run. +- +-Build the benchmark binary in release mode, after having enabled debug info: +- +-```sh +-$ cargo build --release +-Finished release [optimized + debuginfo] target(s) in 0.02s +-``` +- +-Then use the `perf record` subcommand: +- +-```sh +-$ perf record --call-graph=dwarf ./target/release/my-program +-[ perf record: Woken up 10 times to write data ] +-[ perf record: Captured and wrote 2,356 MB perf.data (292 samples) ] +-``` +- +-Instead of using `--call-graph=dwarf`, which can become pretty slow, you can use +-`--call-graph=lbr` if you have a processor with support for Last Branch Record +-(i.e. Intel Haswell and newer). +- +-`perf` will, by default, record the count of CPU cycles it takes to execute +-various parts of your program. You can use the `-e` command line option +-to enable other performance events, such as `cache-misses`. Use `perf list` +-to get a list of all hardware counters supported by your CPU. +- +-### Viewing the report +- +-The next step is getting a bird's eye view of the program's execution. +-`perf` provides a `ncurses`-based interface which will get you started. +- +-Use `perf report` to open a visualization of your program's performance: +- +-```sh +-perf report --hierarchy -M intel +-``` +- +-`--hierarchy` will display a tree-like structure of where your program spent +-most of its time. `-M intel` enables disassembly output with Intel syntax, which +-is subjectively more readable than the default AT&T syntax. +- +-Here is the output from profiling the `nbody` benchmark: +- +-``` +-- 100,00% nbody +- - 94,18% nbody +- + 93,48% [.] nbody_lib::simd::advance +- + 0,70% [.] nbody_lib::run +- + 5,06% libc-2.28.so +-``` +- +-If you move with the arrow keys to any node in the tree, you can the press `a` +-to have `perf` _annotate_ that node. This means it will: +- +-- disassemble the function +- +-- associate every instruction with the percentage of time which was spent executing it +- +-- interleaves the disassembly with the source code, +- assuming it found the debug symbols +- (you can use `s` to toggle this behaviour) +- +-`perf` will, by default, open the instruction which it identified as being the +-hottest spot in the function: +- +-``` +-0,76 │ movapd xmm2,xmm0 +-0,38 │ movhlps xmm2,xmm0 +- │ addpd xmm2,xmm0 +- │ unpcklpd xmm1,xmm2 +-12,50 │ sqrtpd xmm0,xmm1 +-1,52 │ mulpd xmm0,xmm1 +-``` +- +-In this case, `sqrtpd` will be highlighted in red, since that's the instruction +-which the CPU spends most of its time executing. +- +-## Using Valgrind +- +-Valgrind is a set of tools which initially helped C/C++ programmers find unsafe +-memory accesses in their code. Nowadays the project also has +- +-- a heap profiler called `massif` +- +-- a cache utilization profiler called `cachegrind` +- +-- a call-graph performance profiler called `callgrind` +- +- +diff --git a/third_party/rust/packed_simd/perf-guide/src/prof/mca.md b/third_party/rust/packed_simd/perf-guide/src/prof/mca.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/prof/mca.md ++++ /dev/null +@@ -1,100 +0,0 @@ +-# Machine code analysis tools +- +-## The microarchitecture of modern CPUs +- +-While you might have heard of Instruction Set Architectures, such as `x86` or +-`arm` or `mips`, the term _microarchitecture_ (also written here as _µ-arch_), +-refers to the internal details of an actual family of CPUs, such as Intel's +-_Haswell_ or AMD's _Jaguar_. +- +-Replacing scalar code with SIMD code will improve performance on all CPUs +-supporting the required vector extensions. +-However, due to microarchitectural differences, the actual speed-up at +-runtime might vary. +- +-**Example**: a simple example arises when optimizing for AMD K8 CPUs. +-The assembly generated for an empty function should look like this: +- +-```asm +-nop +-ret +-``` +- +-The `nop` is used to align the `ret` instruction for better performance. +-However, the compiler will actually generated the following code: +- +-```asm +-repz ret +-``` +- +-The `repz` instruction will repeat the following instruction until a certain +-condition. Of course, in this situation, the function will simply immediately +-return, and the `ret` instruction is still aligned. +-However, AMD K8's branch predictor performs better with the latter code. +- +-For those looking to absolutely maximize performance for a certain target µ-arch, +-you will have to read some CPU manuals, or ask the compiler to do it for you +-with `-C target-cpu`. +- +-### Summary of CPU internals +- +-Modern processors are able to execute instructions out-of-order for better performance, +-by utilizing tricks such as [branch prediction], [instruction pipelining], +-or [superscalar execution]. +- +-[branch prediction]: https://en.wikipedia.org/wiki/Branch_predictor +-[instruction pipelining]: https://en.wikipedia.org/wiki/Instruction_pipelining +-[superscalar execution]: https://en.wikipedia.org/wiki/Superscalar_processor +- +-SIMD instructions are also subject to these optimizations, meaning it can get pretty +-difficult to determine where the slowdown happens. +-For example, if the profiler reports a store operation is slow, one of two things +-could be happening: +- +-- the store is limited by the CPU's memory bandwidth, which is actually an ideal +- scenario, all things considered; +- +-- memory bandwidth is nowhere near its peak, but the value to be stored is at the +- end of a long chain of operations, and this store is where the profiler +- encountered the pipeline stall; +- +-Since most profilers are simple tools which don't understand the subtleties of +-instruction scheduling, you +- +-## Analyzing the machine code +- +-Certain tools have knowledge of internal CPU microarchitecture, i.e. they know +- +-- how many physical [register files] a CPU actually has +- +-- what is the latency / throughtput of an instruction +- +-- what [µ-ops] are generated for a set of instructions +- +-and many other architectural details. +- +-[register files]: https://en.wikipedia.org/wiki/Register_file +-[µ-ops]: https://en.wikipedia.org/wiki/Micro-operation +- +-These tools are therefore able to provide accurate information as to why some +-instructions are inefficient, and where the bottleneck is. +- +-The disadvantage is that the output of these tools requires advanced knowledge +-of the target architecture to understand, i.e. they **cannot** point out what +-the cause of the issue is explicitly. +- +-## Intel's Architecture Code Analyzer (IACA) +- +-[IACA] is a free tool offered by Intel for analyzing the performance of various +-computational kernels. +- +-Being a proprietary, closed source tool, it _only_ supports Intel's µ-arches. +- +-[IACA]: https://software.intel.com/en-us/articles/intel-architecture-code-analyzer +- +-## llvm-mca +- +- +diff --git a/third_party/rust/packed_simd/perf-guide/src/prof/profiling.md b/third_party/rust/packed_simd/perf-guide/src/prof/profiling.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/prof/profiling.md ++++ /dev/null +@@ -1,14 +0,0 @@ +-# Performance profiling +- +-While the rest of the book provides practical advice on how to improve the performance +-of SIMD code, this chapter is dedicated to [**performance profiling**][profiling]. +-Profiling consists of recording a program's execution in order to identify program +-hotspots. +- +-**Important**: most profilers require debug information in order to accurately +-link the program hotspots back to the corresponding source code lines. Rust will +-disable debug info generation by default for optimized builds, but you can change +-that [in your `Cargo.toml`][cargo-ref]. +- +-[profiling]: https://en.wikipedia.org/wiki/Profiling_(computer_programming) +-[cargo-ref]: https://doc.rust-lang.org/cargo/reference/manifest.html#the-profile-sections +diff --git a/third_party/rust/packed_simd/perf-guide/src/target-feature/attribute.md b/third_party/rust/packed_simd/perf-guide/src/target-feature/attribute.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/target-feature/attribute.md ++++ /dev/null +@@ -1,5 +0,0 @@ +-# The `target_feature` attribute +- +- +diff --git a/third_party/rust/packed_simd/perf-guide/src/target-feature/features.md b/third_party/rust/packed_simd/perf-guide/src/target-feature/features.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/target-feature/features.md ++++ /dev/null +@@ -1,13 +0,0 @@ +-# Enabling target features +- +-Not all processors of a certain architecture will have SIMD processing units, +-and using a SIMD instruction which is not supported will trigger undefined behavior. +- +-To allow building safe, portable programs, the Rust compiler will **not**, by default, +-generate any sort of vector instructions, unless it can statically determine +-they are supported. For example, on AMD64, SSE2 support is architecturally guaranteed. +-The `x86_64-apple-darwin` target enables up to SSSE3. The get a defintive list of +-which features are enabled by default on various platforms, refer to the target +-specifications [in the compiler's source code][targets]. +- +-[targets]: https://github.com/rust-lang/rust/tree/master/src/librustc_target/spec +diff --git a/third_party/rust/packed_simd/perf-guide/src/target-feature/inlining.md b/third_party/rust/packed_simd/perf-guide/src/target-feature/inlining.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/target-feature/inlining.md ++++ /dev/null +@@ -1,5 +0,0 @@ +-# Inlining +- +- +diff --git a/third_party/rust/packed_simd/perf-guide/src/target-feature/practice.md b/third_party/rust/packed_simd/perf-guide/src/target-feature/practice.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/target-feature/practice.md ++++ /dev/null +@@ -1,31 +0,0 @@ +-# Target features in practice +- +-Using `RUSTFLAGS` will allow the crate being compiled, as well as all its +-transitive dependencies to use certain target features. +- +-A tehnique used to avoid undefined behavior at runtime is to compile and +-ship multiple binaries, each compiled with a certain set of features. +-This might not be feasible in some cases, and can quickly get out of hand +-as more and more vector extensions are added to an architecture. +- +-Rust can be more flexible: you can build a single binary/library which automatically +-picks the best supported vector instructions depending on the host machine. +-The trick consists of monomorphizing parts of the code during building, and then +-using run-time feature detection to select the right code path when running. +- +- +- +-**NOTE** (x86 specific): because the AVX (256-bit) registers extend the existing +-SSE (128-bit) registers, mixing SSE and AVX instructions in a program can cause +-performance issues. +- +-The solution is to compile all code, even the code written with 128-bit vectors, +-with the AVX target feature enabled. This will cause the compiler to prefix the +-generated instructions with the [VEX] prefix. +- +-[VEX]: https://en.wikipedia.org/wiki/VEX_prefix +diff --git a/third_party/rust/packed_simd/perf-guide/src/target-feature/runtime.md b/third_party/rust/packed_simd/perf-guide/src/target-feature/runtime.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/target-feature/runtime.md ++++ /dev/null +@@ -1,5 +0,0 @@ +-# Detecting host features at runtime +- +- +diff --git a/third_party/rust/packed_simd/perf-guide/src/target-feature/rustflags.md b/third_party/rust/packed_simd/perf-guide/src/target-feature/rustflags.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/target-feature/rustflags.md ++++ /dev/null +@@ -1,77 +0,0 @@ +-# Using RUSTFLAGS +- +-One of the easiest ways to benefit from SIMD is to allow the compiler +-to generate code using certain vector instruction extensions. +- +-The environment variable `RUSTFLAGS` can be used to pass options for code +-generation to the Rust compiler. These flags will affect **all** compiled crates. +- +-There are two flags which can be used to enable specific vector extensions: +- +-## target-feature +- +-- Syntax: `-C target-feature=` +- +-- Provides the compiler with a comma-separated set of instruction extensions +- to enable. +- +- **Example**: Use `-C target-feature=+sse3,+avx` to enable generating instructions +- for [Streaming SIMD Extensions 3](https://en.wikipedia.org/wiki/SSE3) and +- [Advanced Vector Extensions](https://en.wikipedia.org/wiki/Advanced_Vector_Extensions). +- +-- To list target triples for all targets supported by Rust, use: +- +- ```sh +- rustc --print target-list +- ``` +- +-- To list all support target features for a certain target triple, use: +- +- ```sh +- rustc --target=${TRIPLE} --print target-features +- ``` +- +-- Note that all CPU features are independent, and will have to be enabled individually. +- +- **Example**: Setting `-C target-feature=+avx2` will _not_ enable `fma`, even though +- all CPUs which support AVX2 also support FMA. To enable both, one has to use +- `-C target-feature=+avx2,+fma` +- +-- Some features also depend on other features, which need to be enabled for the +- target instructions to be generated. +- +- **Example**: Unless `v7` is specified as the target CPU (see below), to enable +- NEON on ARM it is necessary to use `-C target-feature=+v7,+neon`. +- +-## target-cpu +- +-- Syntax: `-C target-cpu=` +- +-- Sets the identifier of a CPU family / model for which to build and optimize the code. +- +- **Example**: `RUSTFLAGS='-C target-cpu=cortex-a75'` +- +-- To list all supported target CPUs for a certain target triple, use: +- +- ```sh +- rustc --target=${TRIPLE} --print target-cpus +- ``` +- +- **Example**: +- +- ```sh +- rustc --target=i686-pc-windows-msvc --print target-cpus +- ``` +- +-- The compiler will translate this into a list of target features. Therefore, +- individual feature checks (`#[cfg(target_feature = "...")]`) will still +- work properly. +- +-- It will cause the code generator to optimize the generated code for that +- specific CPU model. +- +-- Using `native` as the CPU model will cause Rust to generate and optimize code +- for the CPU running the compiler. It is useful when building programs which you +- plan to only use locally. This should never be used when the generated programs +- are meant to be run on other computers, such as when packaging for distribution +- or cross-compiling. +diff --git a/third_party/rust/packed_simd/perf-guide/src/vert-hor-ops.md b/third_party/rust/packed_simd/perf-guide/src/vert-hor-ops.md +deleted file mode 100644 +--- a/third_party/rust/packed_simd/perf-guide/src/vert-hor-ops.md ++++ /dev/null +@@ -1,76 +0,0 @@ +-# Vertical and horizontal operations +- +-In SIMD terminology, each vector has a certain "width" (number of lanes). +-A vector processor is able to perform two kinds of operations on a vector: +- +-- Vertical operations: +- operate on two vectors of the same width, result has same width +- +-**Example**: vertical addition of two `f32x4` vectors +- +- %0 == | 2 | -3.5 | 0 | 7 | +- + + + + +- %1 == | 4 | 1.5 | -1 | 0 | +- = = = = +- %0 + %1 == | 6 | -2 | -1 | 7 | +- +-- Horizontal operations: +- reduce the elements of two vectors in some way, +- the result's elements combine information from the two original ones +- +-**Example**: horizontal addition of two `u64x2` vectors +- +- %0 == | 1 | 3 | +- └─+───┘ +- └───────┐ +- │ +- %1 == | 4 | -1 | │ +- └─+──┘ │ +- └───┐ │ +- │ │ +- ┌─────│───┘ +- ▼ ▼ +- %0 + %1 == | 4 | 3 | +- +-## Performance consideration of horizontal operations +- +-The result of vertical operations, like vector negation: `-a`, for a given lane, +-does not depend on the result of the operation for the other lanes. The result +-of horizontal operations, like the vector `sum` reduction: `a.sum()`, depends on +-the value of all vector lanes. +- +-In virtually all architectures vertical operations are fast, while horizontal +-operations are, by comparison, very slow. +- +-Consider the following two functions for computing the sum of all `f32` values +-in a slice: +- +-```rust +-fn fast_sum(x: &[f32]) -> f32 { +- assert!(x.len() % 4 == 0); +- let mut sum = f32x4::splat(0.); // [0., 0., 0., 0.] +- for i in (0..x.len()).step_by(4) { +- sum += f32x4::from_slice_unaligned(&x[i..]); +- } +- sum.sum() +-} +- +-fn slow_sum(x: &[f32]) -> f32 { +- assert!(x.len() % 4 == 0); +- let mut sum: f32 = 0.; +- for i in (0..x.len()).step_by(4) { +- sum += f32x4::from_slice_unaligned(&x[i..]).sum(); +- } +- sum +-} +-``` +- +-The inner loop over the slice is where the bulk of the work actually happens. +-There, the `fast_sum` function perform vertical operations into a vector, doing +-a single horizontal reduction at the end, while the `slow_sum` function performs +-horizontal vector operations inside of the loop. +- +-On all widely-used architectures, `fast_sum` is a large constant factor faster +-than `slow_sum`. You can run the [slice_sum]() example and see for yourself. On +-the particular machine tested there the algorithm using the horizontal vector +-addition is 2.7x slower than the one using vertical vector operations! +diff --git a/third_party/rust/packed_simd/rustfmt.toml b/third_party/rust/packed_simd/rustfmt.toml +deleted file mode 100644 +--- a/third_party/rust/packed_simd/rustfmt.toml ++++ /dev/null +@@ -1,5 +0,0 @@ +-max_width = 110 +-use_small_heuristics = "Max" +-wrap_comments = true +-edition = "2018" +-error_on_line_overflow = true +\ No newline at end of file +diff --git a/third_party/rust/packed_simd/src/api.rs b/third_party/rust/packed_simd/src/api.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api.rs ++++ /dev/null +@@ -1,308 +0,0 @@ +-//! Implements the Simd<[T; N]> APIs +- +-#[macro_use] +-mod bitmask; +-pub(crate) mod cast; +-#[macro_use] +-mod cmp; +-#[macro_use] +-mod default; +-#[macro_use] +-mod fmt; +-#[macro_use] +-mod from; +-#[macro_use] +-mod hash; +-#[macro_use] +-mod math; +-#[macro_use] +-mod minimal; +-#[macro_use] +-mod ops; +-#[macro_use] +-mod ptr; +-#[macro_use] +-mod reductions; +-#[macro_use] +-mod select; +-#[macro_use] +-mod shuffle; +-#[macro_use] +-mod shuffle1_dyn; +-#[macro_use] +-mod slice; +-#[macro_use] +-mod swap_bytes; +-#[macro_use] +-mod bit_manip; +- +-#[cfg(feature = "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); +- impl_ops_scalar_arithmetic!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_bitwise!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (!(0 as $elem_ty), 0) +- ); +- impl_ops_scalar_bitwise!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (!(0 as $elem_ty), 0) +- ); +- impl_ops_vector_shifts!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_scalar_shifts!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_rotates!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_neg!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_int_min_max!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt +- ); +- impl_reduction_integer_arithmetic!( +- [$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- ); +- impl_reduction_min_max!( +- [$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- ); +- impl_reduction_bitwise!( +- [$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- | (|x|{ x as $elem_ty }) | (!(0 as $elem_ty), 0) +- ); +- impl_fmt_debug!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_lower_hex!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_upper_hex!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_octal!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_binary!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_from_array!([$elem_ty; $elem_n]: $tuple_id | $test_tt | (1, 1)); +- impl_from_vectors!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | $($from_vec_ty),* +- ); +- impl_default!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_hash!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_slice_from_slice!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_slice_write_to_slice!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_swap_bytes!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_bit_manip!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_shuffle1_dyn!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_partial_eq!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (0, 1) +- ); +- impl_cmp_eq!([$elem_ty; $elem_n]: $tuple_id | $test_tt | (0, 1)); +- impl_cmp_vertical!( +- [$elem_ty; $elem_n]: $tuple_id, $mask_ty, false, (1, 0) | $test_tt +- ); +- impl_cmp_partial_ord!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_ord!([$elem_ty; $elem_n]: $tuple_id | $test_tt | (0, 1)); +- impl_bitmask!($tuple_id | $ibitmask_ty | (-1, 0) | $test_tt); +- +- test_select!($elem_ty, $mask_ty, $tuple_id, (1, 2) | $test_tt); +- test_cmp_partial_ord_int!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- test_shuffle1_dyn!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- } +-} +- +-macro_rules! impl_u { +- ([$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); +- impl_ops_scalar_arithmetic!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_bitwise!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (!(0 as $elem_ty), 0) +- ); +- impl_ops_scalar_bitwise!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (!(0 as $elem_ty), 0) +- ); +- impl_ops_vector_shifts!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_scalar_shifts!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_rotates!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_int_min_max!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt +- ); +- impl_reduction_integer_arithmetic!( +- [$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- ); +- impl_reduction_min_max!( +- [$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- ); +- impl_reduction_bitwise!( +- [$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- | (|x|{ x as $elem_ty }) | (!(0 as $elem_ty), 0) +- ); +- impl_fmt_debug!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_lower_hex!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_upper_hex!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_octal!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_binary!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_from_array!([$elem_ty; $elem_n]: $tuple_id | $test_tt | (1, 1)); +- impl_from_vectors!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | $($from_vec_ty),* +- ); +- impl_default!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_hash!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_slice_from_slice!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_slice_write_to_slice!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_swap_bytes!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_bit_manip!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_shuffle1_dyn!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_partial_eq!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (1, 0) +- ); +- impl_cmp_eq!([$elem_ty; $elem_n]: $tuple_id | $test_tt | (0, 1)); +- impl_cmp_vertical!( +- [$elem_ty; $elem_n]: $tuple_id, $mask_ty, false, (1, 0) | $test_tt +- ); +- impl_cmp_partial_ord!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_ord!([$elem_ty; $elem_n]: $tuple_id | $test_tt | (0, 1)); +- impl_bitmask!($tuple_id | $ibitmask_ty | ($ielem_ty::max_value(), 0) | +- $test_tt); +- +- test_select!($elem_ty, $mask_ty, $tuple_id, (1, 2) | $test_tt); +- test_cmp_partial_ord_int!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- test_shuffle1_dyn!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- } +-} +- +-macro_rules! impl_f { +- ([$elem_ty:ident; $elem_n:expr]: $tuple_id:ident, $mask_ty:ident +- | $ielem_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); +- impl_ops_scalar_arithmetic!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_neg!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_ops_vector_float_min_max!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt +- ); +- impl_reduction_float_arithmetic!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_reduction_min_max!( +- [$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- ); +- impl_fmt_debug!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_from_array!([$elem_ty; $elem_n]: $tuple_id | $test_tt | (1., 1.)); +- impl_from_vectors!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | $($from_vec_ty),* +- ); +- impl_default!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_partial_eq!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (1., 0.) +- ); +- impl_slice_from_slice!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_slice_write_to_slice!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_shuffle1_dyn!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- +- impl_float_consts!([$elem_ty; $elem_n]: $tuple_id); +- impl_float_category!([$elem_ty; $elem_n]: $tuple_id, $mask_ty); +- +- // floating-point math +- impl_math_float_abs!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_cos!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_exp!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_ln!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_mul_add!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_mul_adde!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_powf!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_recpre!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_rsqrte!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_sin!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_sqrt!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_math_float_sqrte!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_vertical!( +- [$elem_ty; $elem_n]: $tuple_id, $mask_ty, false, (1., 0.) +- | $test_tt +- ); +- +- test_select!($elem_ty, $mask_ty, $tuple_id, (1., 2.) | $test_tt); +- test_reduction_float_min_max!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt +- ); +- test_shuffle1_dyn!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- } +-} +- +-macro_rules! impl_m { +- ([$elem_ty:ident; $elem_n:expr]: $tuple_id:ident +- | $ielem_ty:ident, $ibitmask_ty:ident +- | $test_tt:tt | $($elem_ids:ident),* | From: $($from_vec_ty:ident),* +- | $(#[$doc:meta])*) => { +- impl_minimal_mask!( +- [$elem_ty; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- | $($elem_ids),* | $(#[$doc])* +- ); +- impl_ops_vector_mask_bitwise!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (true, false) +- ); +- impl_ops_scalar_mask_bitwise!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (true, false) +- ); +- impl_reduction_bitwise!( +- [bool; $elem_n]: $tuple_id | $ielem_ty | $test_tt +- | (|x|{ x != 0 }) | (true, false) +- ); +- impl_reduction_mask!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_fmt_debug!([bool; $elem_n]: $tuple_id | $test_tt); +- impl_from_array!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt +- | (crate::$elem_ty::new(true), true) +- ); +- impl_from_vectors!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | $($from_vec_ty),* +- ); +- impl_default!([bool; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_partial_eq!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (true, false) +- ); +- impl_cmp_eq!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (true, false) +- ); +- impl_cmp_vertical!( +- [$elem_ty; $elem_n]: $tuple_id, $tuple_id, true, (true, false) +- | $test_tt +- ); +- impl_select!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_partial_ord!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_cmp_ord!( +- [$elem_ty; $elem_n]: $tuple_id | $test_tt | (false, true) +- ); +- impl_shuffle1_dyn!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- impl_bitmask!($tuple_id | $ibitmask_ty | (true, false) | $test_tt); +- +- test_cmp_partial_ord_mask!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- test_shuffle1_dyn_mask!([$elem_ty; $elem_n]: $tuple_id | $test_tt); +- } +-} +- +-macro_rules! impl_const_p { +- ([$elem_ty:ty; $elem_n:expr]: $tuple_id:ident, $mask_ty:ident, +- $usize_ty:ident, $isize_ty:ident +- | $test_tt:tt | $($elem_ids:ident),* +- | From: $($from_vec_ty:ident),* | $(#[$doc:meta])*) => { +- impl_minimal_p!( +- [$elem_ty; $elem_n]: $tuple_id, $mask_ty, $usize_ty, $isize_ty +- | ref_ | $test_tt | $($elem_ids),* +- | (1 as $elem_ty, 0 as $elem_ty) | $(#[$doc])* +- ); +- impl_ptr_read!([$elem_ty; $elem_n]: $tuple_id, $mask_ty | $test_tt); +- } +-} +- +-macro_rules! impl_mut_p { +- ([$elem_ty:ty; $elem_n:expr]: $tuple_id:ident, $mask_ty:ident, +- $usize_ty:ident, $isize_ty:ident +- | $test_tt:tt | $($elem_ids:ident),* +- | From: $($from_vec_ty:ident),* | $(#[$doc:meta])*) => { +- impl_minimal_p!( +- [$elem_ty; $elem_n]: $tuple_id, $mask_ty, $usize_ty, $isize_ty +- | ref_mut_ | $test_tt | $($elem_ids),* +- | (1 as $elem_ty, 0 as $elem_ty) | $(#[$doc])* +- ); +- impl_ptr_read!([$elem_ty; $elem_n]: $tuple_id, $mask_ty | $test_tt); +- impl_ptr_write!([$elem_ty; $elem_n]: $tuple_id, $mask_ty | $test_tt); +- } +-} +diff --git a/third_party/rust/packed_simd/src/api/bit_manip.rs b/third_party/rust/packed_simd/src/api/bit_manip.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/bit_manip.rs ++++ /dev/null +@@ -1,129 +0,0 @@ +-//! Bit manipulations. +- +-macro_rules! impl_bit_manip { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Returns the number of ones in the binary representation of +- /// the lanes of `self`. +- #[inline] +- pub fn count_ones(self) -> Self { +- super::codegen::bit_manip::BitManip::ctpop(self) +- } +- +- /// Returns the number of zeros in the binary representation of +- /// the lanes of `self`. +- #[inline] +- pub fn count_zeros(self) -> Self { +- super::codegen::bit_manip::BitManip::ctpop(!self) +- } +- +- /// Returns the number of leading zeros in the binary +- /// representation of the lanes of `self`. +- #[inline] +- pub fn leading_zeros(self) -> Self { +- super::codegen::bit_manip::BitManip::ctlz(self) +- } +- +- /// Returns the number of trailing zeros in the binary +- /// representation of the lanes of `self`. +- #[inline] +- pub fn trailing_zeros(self) -> Self { +- super::codegen::bit_manip::BitManip::cttz(self) +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- #[allow(overflowing_literals)] +- pub mod [<$id _bit_manip>] { +- #![allow(const_item_mutation)] +- use super::*; +- +- const LANE_WIDTH: usize = mem::size_of::<$elem_ty>() * 8; +- +- macro_rules! test_func { +- ($x:expr, $func:ident) => {{ +- let mut actual = $x; +- for i in 0..$id::lanes() { +- actual = actual.replace( +- i, +- $x.extract(i).$func() as $elem_ty +- ); +- } +- let expected = $x.$func(); +- assert_eq!(actual, expected); +- }}; +- } +- +- const BYTES: [u8; 64] = [ +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- 16, 17, 18, 19, 20, 21, 22, 23, +- 24, 25, 26, 27, 28, 29, 30, 31, +- 32, 33, 34, 35, 36, 37, 38, 39, +- 40, 41, 42, 43, 44, 45, 46, 47, +- 48, 49, 50, 51, 52, 53, 54, 55, +- 56, 57, 58, 59, 60, 61, 62, 63, +- ]; +- +- fn load_bytes() -> $id { +- let elems: &mut [$elem_ty] = unsafe { +- slice::from_raw_parts_mut( +- BYTES.as_mut_ptr() as *mut $elem_ty, +- $id::lanes(), +- ) +- }; +- $id::from_slice_unaligned(elems) +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn count_ones() { +- test_func!($id::splat(0), count_ones); +- test_func!($id::splat(!0), count_ones); +- test_func!(load_bytes(), count_ones); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn count_zeros() { +- test_func!($id::splat(0), count_zeros); +- test_func!($id::splat(!0), count_zeros); +- test_func!(load_bytes(), count_zeros); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn leading_zeros() { +- test_func!($id::splat(0), leading_zeros); +- test_func!($id::splat(1), leading_zeros); +- // some implementations use `pshufb` which has unique +- // behavior when the 8th bit is set. +- test_func!($id::splat(0b1000_0010), leading_zeros); +- test_func!($id::splat(!0), leading_zeros); +- test_func!( +- $id::splat(1 << (LANE_WIDTH - 1)), +- leading_zeros +- ); +- test_func!(load_bytes(), leading_zeros); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn trailing_zeros() { +- test_func!($id::splat(0), trailing_zeros); +- test_func!($id::splat(1), trailing_zeros); +- test_func!($id::splat(0b1000_0010), trailing_zeros); +- test_func!($id::splat(!0), trailing_zeros); +- test_func!( +- $id::splat(1 << (LANE_WIDTH - 1)), +- trailing_zeros +- ); +- test_func!(load_bytes(), trailing_zeros); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/bitmask.rs b/third_party/rust/packed_simd/src/api/bitmask.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/bitmask.rs ++++ /dev/null +@@ -1,79 +0,0 @@ +-//! Bitmask API +- +-macro_rules! impl_bitmask { +- ($id:ident | $ibitmask_ty:ident | ($set:expr, $clear:expr) +- | $test_tt:tt) => { +- impl $id { +- /// Creates a bitmask with the MSB of each vector lane. +- /// +- /// If the vector has less than 8 lanes, the bits that do not +- /// correspond to any vector lanes are cleared. +- #[inline] +- pub fn bitmask(self) -> $ibitmask_ty { +- unsafe { codegen::llvm::simd_bitmask(self.0) } +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- #[cfg(not( +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/210 +- target_endian = "big" +- ))] +- pub mod [<$id _bitmask>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn bitmask() { +- // clear all lanes +- let vec = $id::splat($clear as _); +- let bitmask: $ibitmask_ty = 0; +- assert_eq!(vec.bitmask(), bitmask); +- +- // set even lanes +- let mut vec = $id::splat($clear as _); +- for i in 0..$id::lanes() { +- if i % 2 == 0 { +- vec = vec.replace(i, $set as _); +- } +- } +- // create bitmask with even lanes set: +- let mut bitmask: $ibitmask_ty = 0; +- for i in 0..$id::lanes() { +- if i % 2 == 0 { +- bitmask |= 1 << i; +- } +- } +- assert_eq!(vec.bitmask(), bitmask); +- +- +- // set odd lanes +- let mut vec = $id::splat($clear as _); +- for i in 0..$id::lanes() { +- if i % 2 != 0 { +- vec = vec.replace(i, $set as _); +- } +- } +- // create bitmask with odd lanes set: +- let mut bitmask: $ibitmask_ty = 0; +- for i in 0..$id::lanes() { +- if i % 2 != 0 { +- bitmask |= 1 << i; +- } +- } +- assert_eq!(vec.bitmask(), bitmask); +- +- // set all lanes +- let vec = $id::splat($set as _); +- let mut bitmask: $ibitmask_ty = 0; +- for i in 0..$id::lanes() { +- bitmask |= 1 << i; +- } +- assert_eq!(vec.bitmask(), bitmask); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/cast.rs b/third_party/rust/packed_simd/src/api/cast.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cast.rs ++++ /dev/null +@@ -1,108 +0,0 @@ +-//! Implementation of `FromCast` and `IntoCast`. +-#![allow(clippy::module_name_repetitions)] +- +-/// Numeric cast from `T` to `Self`. +-/// +-/// > Note: This is a temporary workaround until the conversion traits +-/// specified > in [RFC2484] are implemented. +-/// +-/// Numeric cast between vectors with the same number of lanes, such that: +-/// +-/// * casting integer vectors whose lane types have the same size (e.g. `i32xN` +-/// -> `u32xN`) is a **no-op**, +-/// +-/// * casting from a larger integer to a smaller integer (e.g. `u32xN` -> +-/// `u8xN`) will **truncate**, +-/// +-/// * casting from a smaller integer to a larger integer (e.g. `u8xN` -> +-/// `u32xN`) will: +-/// * **zero-extend** if the source is unsigned, or +-/// * **sign-extend** if the source is signed, +-/// +-/// * casting from a float to an integer will **round the float towards zero**, +-/// +-/// * casting from an integer to float will produce the floating point +-/// representation of the integer, **rounding to nearest, ties to even**, +-/// +-/// * casting from an `f32` to an `f64` is perfect and lossless, +-/// +-/// * casting from an `f64` to an `f32` **rounds to nearest, ties to even**. +-/// +-/// [RFC2484]: https://github.com/rust-lang/rfcs/pull/2484 +-pub trait FromCast: crate::marker::Sized { +- /// Numeric cast from `T` to `Self`. +- fn from_cast(_: T) -> Self; +-} +- +-/// Numeric cast from `Self` to `T`. +-/// +-/// > Note: This is a temporary workaround until the conversion traits +-/// specified > in [RFC2484] are implemented. +-/// +-/// Numeric cast between vectors with the same number of lanes, such that: +-/// +-/// * casting integer vectors whose lane types have the same size (e.g. `i32xN` +-/// -> `u32xN`) is a **no-op**, +-/// +-/// * casting from a larger integer to a smaller integer (e.g. `u32xN` -> +-/// `u8xN`) will **truncate**, +-/// +-/// * casting from a smaller integer to a larger integer (e.g. `u8xN` -> +-/// `u32xN`) will: +-/// * **zero-extend** if the source is unsigned, or +-/// * **sign-extend** if the source is signed, +-/// +-/// * casting from a float to an integer will **round the float towards zero**, +-/// +-/// * casting from an integer to float will produce the floating point +-/// representation of the integer, **rounding to nearest, ties to even**, +-/// +-/// * casting from an `f32` to an `f64` is perfect and lossless, +-/// +-/// * casting from an `f64` to an `f32` **rounds to nearest, ties to even**. +-/// +-/// [RFC2484]: https://github.com/rust-lang/rfcs/pull/2484 +-pub trait Cast: crate::marker::Sized { +- /// Numeric cast from `self` to `T`. +- fn cast(self) -> T; +-} +- +-/// `FromCast` implies `Cast`. +-impl Cast for T +-where +- U: FromCast, +-{ +- #[inline] +- fn cast(self) -> U { +- U::from_cast(self) +- } +-} +- +-/// `FromCast` and `Cast` are reflexive +-impl FromCast for T { +- #[inline] +- fn from_cast(t: Self) -> Self { +- t +- } +-} +- +-#[macro_use] +-mod macros; +- +-mod v16; +-pub use self::v16::*; +- +-mod v32; +-pub use self::v32::*; +- +-mod v64; +-pub use self::v64::*; +- +-mod v128; +-pub use self::v128::*; +- +-mod v256; +-pub use self::v256::*; +- +-mod v512; +-pub use self::v512::*; +diff --git a/third_party/rust/packed_simd/src/api/cast/macros.rs b/third_party/rust/packed_simd/src/api/cast/macros.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cast/macros.rs ++++ /dev/null +@@ -1,82 +0,0 @@ +-//! Macros implementing `FromCast` +- +-macro_rules! impl_from_cast_ { +- ($id:ident[$test_tt:tt]: $from_ty:ident) => { +- impl crate::api::cast::FromCast<$from_ty> for $id { +- #[inline] +- fn from_cast(x: $from_ty) -> Self { +- use crate::llvm::simd_cast; +- debug_assert_eq!($from_ty::lanes(), $id::lanes()); +- Simd(unsafe { simd_cast(x.0) }) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _from_cast_ $from_ty>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn test() { +- assert_eq!($id::lanes(), $from_ty::lanes()); +- } +- } +- } +- } +- }; +-} +- +-macro_rules! impl_from_cast { +- ($id:ident[$test_tt:tt]: $($from_ty:ident),*) => { +- $( +- impl_from_cast_!($id[$test_tt]: $from_ty); +- )* +- } +-} +- +-macro_rules! impl_from_cast_mask_ { +- ($id:ident[$test_tt:tt]: $from_ty:ident) => { +- impl crate::api::cast::FromCast<$from_ty> for $id { +- #[inline] +- fn from_cast(x: $from_ty) -> Self { +- debug_assert_eq!($from_ty::lanes(), $id::lanes()); +- x.ne($from_ty::default()) +- .select($id::splat(true), $id::splat(false)) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _from_cast_ $from_ty>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn test() { +- assert_eq!($id::lanes(), $from_ty::lanes()); +- +- let x = $from_ty::default(); +- let m: $id = x.cast(); +- assert!(m.none()); +- } +- } +- } +- } +- }; +-} +- +-macro_rules! impl_from_cast_mask { +- ($id:ident[$test_tt:tt]: $($from_ty:ident),*) => { +- $( +- impl_from_cast_mask_!($id[$test_tt]: $from_ty); +- )* +- } +-} +- +-#[allow(unused)] +-macro_rules! impl_into_cast { +- ($id:ident[$test_tt:tt]: $($from_ty:ident),*) => { +- $( +- impl_from_cast_!($from_ty[$test_tt]: $id); +- )* +- } +-} +diff --git a/third_party/rust/packed_simd/src/api/cast/v128.rs b/third_party/rust/packed_simd/src/api/cast/v128.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cast/v128.rs ++++ /dev/null +@@ -1,302 +0,0 @@ +-//! `FromCast` and `IntoCast` implementations for portable 128-bit wide vectors +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_from_cast!(i8x16[test_v128]: u8x16, m8x16, i16x16, u16x16, m16x16, i32x16, u32x16, f32x16, m32x16); +-impl_from_cast!(u8x16[test_v128]: i8x16, m8x16, i16x16, u16x16, m16x16, i32x16, u32x16, f32x16, m32x16); +-impl_from_cast_mask!(m8x16[test_v128]: i8x16, u8x16, i16x16, u16x16, m16x16, i32x16, u32x16, f32x16, m32x16); +- +-impl_from_cast!( +- i16x8[test_v128]: i8x8, +- u8x8, +- m8x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast!( +- u16x8[test_v128]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast_mask!( +- m16x8[test_v128]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +- +-impl_from_cast!( +- i32x4[test_v128]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast!( +- u32x4[test_v128]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast!( +- f32x4[test_v128]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast_mask!( +- m32x4[test_v128]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +- +-impl_from_cast!( +- i64x2[test_v128]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast!( +- u64x2[test_v128]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast!( +- f64x2[test_v128]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast_mask!( +- m64x2[test_v128]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +- +-impl_from_cast!( +- isizex2[test_v128]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- usizex2, +- msizex2 +-); +-impl_from_cast!( +- usizex2[test_v128]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- msizex2 +-); +-impl_from_cast_mask!( +- msizex2[test_v128]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2 +-); +- +-// FIXME[test_v128]: 64-bit single element vectors into_cast impls +-impl_from_cast!(i128x1[test_v128]: u128x1, m128x1); +-impl_from_cast!(u128x1[test_v128]: i128x1, m128x1); +-impl_from_cast!(m128x1[test_v128]: i128x1, u128x1); +diff --git a/third_party/rust/packed_simd/src/api/cast/v16.rs b/third_party/rust/packed_simd/src/api/cast/v16.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cast/v16.rs ++++ /dev/null +@@ -1,68 +0,0 @@ +-//! `FromCast` and `IntoCast` implementations for portable 16-bit wide vectors +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_from_cast!( +- i8x2[test_v16]: u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast!( +- u8x2[test_v16]: i8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast_mask!( +- m8x2[test_v16]: i8x2, +- u8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +diff --git a/third_party/rust/packed_simd/src/api/cast/v256.rs b/third_party/rust/packed_simd/src/api/cast/v256.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cast/v256.rs ++++ /dev/null +@@ -1,298 +0,0 @@ +-//! `FromCast` and `IntoCast` implementations for portable 256-bit wide vectors +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_from_cast!(i8x32[test_v256]: u8x32, m8x32, i16x32, u16x32, m16x32); +-impl_from_cast!(u8x32[test_v256]: i8x32, m8x32, i16x32, u16x32, m16x32); +-impl_from_cast_mask!(m8x32[test_v256]: i8x32, u8x32, i16x32, u16x32, m16x32); +- +-impl_from_cast!(i16x16[test_v256]: i8x16, u8x16, m8x16, u16x16, m16x16, i32x16, u32x16, f32x16, m32x16); +-impl_from_cast!(u16x16[test_v256]: i8x16, u8x16, m8x16, i16x16, m16x16, i32x16, u32x16, f32x16, m32x16); +-impl_from_cast_mask!(m16x16[test_v256]: i8x16, u8x16, m8x16, i16x16, u16x16, i32x16, u32x16, f32x16, m32x16); +- +-impl_from_cast!( +- i32x8[test_v256]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast!( +- u32x8[test_v256]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast!( +- f32x8[test_v256]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast_mask!( +- m32x8[test_v256]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +- +-impl_from_cast!( +- i64x4[test_v256]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast!( +- u64x4[test_v256]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast!( +- f64x4[test_v256]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast_mask!( +- m64x4[test_v256]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +- +-impl_from_cast!( +- i128x2[test_v256]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast!( +- u128x2[test_v256]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast_mask!( +- m128x2[test_v256]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- m64x2, +- f64x2, +- i128x2, +- u128x2, +- isizex2, +- usizex2, +- msizex2 +-); +- +-impl_from_cast!( +- isizex4[test_v256]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- usizex4, +- msizex4 +-); +-impl_from_cast!( +- usizex4[test_v256]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- msizex4 +-); +-impl_from_cast_mask!( +- msizex4[test_v256]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4 +-); +diff --git a/third_party/rust/packed_simd/src/api/cast/v32.rs b/third_party/rust/packed_simd/src/api/cast/v32.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cast/v32.rs ++++ /dev/null +@@ -1,132 +0,0 @@ +-//! `FromCast` and `IntoCast` implementations for portable 32-bit wide vectors +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_from_cast!( +- i8x4[test_v32]: u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast!( +- u8x4[test_v32]: i8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast_mask!( +- m8x4[test_v32]: i8x4, +- u8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +- +-impl_from_cast!( +- i16x2[test_v32]: i8x2, +- u8x2, +- m8x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast!( +- u16x2[test_v32]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast_mask!( +- m16x2[test_v32]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- i32x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +diff --git a/third_party/rust/packed_simd/src/api/cast/v512.rs b/third_party/rust/packed_simd/src/api/cast/v512.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cast/v512.rs ++++ /dev/null +@@ -1,209 +0,0 @@ +-//! `FromCast` and `IntoCast` implementations for portable 512-bit wide vectors +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_from_cast!(i8x64[test_v512]: u8x64, m8x64); +-impl_from_cast!(u8x64[test_v512]: i8x64, m8x64); +-impl_from_cast_mask!(m8x64[test_v512]: i8x64, u8x64); +- +-impl_from_cast!(i16x32[test_v512]: i8x32, u8x32, m8x32, u16x32, m16x32); +-impl_from_cast!(u16x32[test_v512]: i8x32, u8x32, m8x32, i16x32, m16x32); +-impl_from_cast_mask!(m16x32[test_v512]: i8x32, u8x32, m8x32, i16x32, u16x32); +- +-impl_from_cast!(i32x16[test_v512]: i8x16, u8x16, m8x16, i16x16, u16x16, m16x16, u32x16, f32x16, m32x16); +-impl_from_cast!(u32x16[test_v512]: i8x16, u8x16, m8x16, i16x16, u16x16, m16x16, i32x16, f32x16, m32x16); +-impl_from_cast!(f32x16[test_v512]: i8x16, u8x16, m8x16, i16x16, u16x16, m16x16, i32x16, u32x16, m32x16); +-impl_from_cast_mask!(m32x16[test_v512]: i8x16, u8x16, m8x16, i16x16, u16x16, m16x16, i32x16, u32x16, f32x16); +- +-impl_from_cast!( +- i64x8[test_v512]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast!( +- u64x8[test_v512]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast!( +- f64x8[test_v512]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast_mask!( +- m64x8[test_v512]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- isizex8, +- usizex8, +- msizex8 +-); +- +-impl_from_cast!( +- i128x4[test_v512]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast!( +- u128x4[test_v512]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast_mask!( +- m128x4[test_v512]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- m64x4, +- f64x4, +- i128x4, +- u128x4, +- isizex4, +- usizex4, +- msizex4 +-); +- +-impl_from_cast!( +- isizex8[test_v512]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- usizex8, +- msizex8 +-); +-impl_from_cast!( +- usizex8[test_v512]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- msizex8 +-); +-impl_from_cast_mask!( +- msizex8[test_v512]: i8x8, +- u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8 +-); +diff --git a/third_party/rust/packed_simd/src/api/cast/v64.rs b/third_party/rust/packed_simd/src/api/cast/v64.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cast/v64.rs ++++ /dev/null +@@ -1,208 +0,0 @@ +-//! `FromCast` and `IntoCast` implementations for portable 64-bit wide vectors +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_from_cast!( +- i8x8[test_v64]: u8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast!( +- u8x8[test_v64]: i8x8, +- m8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +-impl_from_cast_mask!( +- m8x8[test_v64]: i8x8, +- u8x8, +- i16x8, +- u16x8, +- m16x8, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- isizex8, +- usizex8, +- msizex8 +-); +- +-impl_from_cast!( +- i16x4[test_v64]: i8x4, +- u8x4, +- m8x4, +- u16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast!( +- u16x4[test_v64]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- m16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +-impl_from_cast_mask!( +- m16x4[test_v64]: i8x4, +- u8x4, +- m8x4, +- i16x4, +- u16x4, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x4, +- u128x4, +- m128x4, +- isizex4, +- usizex4, +- msizex4 +-); +- +-impl_from_cast!( +- i32x2[test_v64]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- u32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast!( +- u32x2[test_v64]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- f32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast!( +- f32x2[test_v64]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- m32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +-impl_from_cast_mask!( +- m32x2[test_v64]: i8x2, +- u8x2, +- m8x2, +- i16x2, +- u16x2, +- m16x2, +- i32x2, +- u32x2, +- f32x2, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x2, +- u128x2, +- m128x2, +- isizex2, +- usizex2, +- msizex2 +-); +diff --git a/third_party/rust/packed_simd/src/api/cmp.rs b/third_party/rust/packed_simd/src/api/cmp.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cmp.rs ++++ /dev/null +@@ -1,16 +0,0 @@ +-//! Implement cmp traits for vector types +- +-#[macro_use] +-mod partial_eq; +- +-#[macro_use] +-mod eq; +- +-#[macro_use] +-mod partial_ord; +- +-#[macro_use] +-mod ord; +- +-#[macro_use] +-mod vertical; +diff --git a/third_party/rust/packed_simd/src/api/cmp/eq.rs b/third_party/rust/packed_simd/src/api/cmp/eq.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cmp/eq.rs ++++ /dev/null +@@ -1,27 +0,0 @@ +-//! Implements `Eq` for vector types. +- +-macro_rules! impl_cmp_eq { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident | $test_tt:tt | +- ($true:expr, $false:expr) +- ) => { +- impl crate::cmp::Eq for $id {} +- impl crate::cmp::Eq for LexicographicallyOrdered<$id> {} +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_eq>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn eq() { +- fn foo(_: E) {} +- let a = $id::splat($false); +- foo(a); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/cmp/ord.rs b/third_party/rust/packed_simd/src/api/cmp/ord.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cmp/ord.rs ++++ /dev/null +@@ -1,43 +0,0 @@ +-//! Implements `Ord` for vector types. +- +-macro_rules! impl_cmp_ord { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident | $test_tt:tt | +- ($true:expr, $false:expr) +- ) => { +- impl $id { +- /// Returns a wrapper that implements `Ord`. +- #[inline] +- pub fn lex_ord(&self) -> LexicographicallyOrdered<$id> { +- LexicographicallyOrdered(*self) +- } +- } +- +- impl crate::cmp::Ord for LexicographicallyOrdered<$id> { +- #[inline] +- fn cmp(&self, other: &Self) -> crate::cmp::Ordering { +- match self.partial_cmp(other) { +- Some(x) => x, +- None => unsafe { crate::hint::unreachable_unchecked() }, +- } +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_ord>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn eq() { +- fn foo(_: E) {} +- let a = $id::splat($false); +- foo(a.partial_lex_ord()); +- foo(a.lex_ord()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/cmp/partial_eq.rs b/third_party/rust/packed_simd/src/api/cmp/partial_eq.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cmp/partial_eq.rs ++++ /dev/null +@@ -1,65 +0,0 @@ +-//! Implements `PartialEq` for vector types. +- +-macro_rules! impl_cmp_partial_eq { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident | $test_tt:tt | +- ($true:expr, $false:expr) +- ) => { +- // FIXME: https://github.com/rust-lang-nursery/rust-clippy/issues/2892 +- #[allow(clippy::partialeq_ne_impl)] +- impl crate::cmp::PartialEq<$id> for $id { +- #[inline] +- fn eq(&self, other: &Self) -> bool { +- $id::eq(*self, *other).all() +- } +- #[inline] +- fn ne(&self, other: &Self) -> bool { +- $id::ne(*self, *other).any() +- } +- } +- +- // FIXME: https://github.com/rust-lang-nursery/rust-clippy/issues/2892 +- #[allow(clippy::partialeq_ne_impl)] +- impl crate::cmp::PartialEq> for LexicographicallyOrdered<$id> { +- #[inline] +- fn eq(&self, other: &Self) -> bool { +- self.0 == other.0 +- } +- #[inline] +- fn ne(&self, other: &Self) -> bool { +- self.0 != other.0 +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_PartialEq>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn partial_eq() { +- let a = $id::splat($false); +- let b = $id::splat($true); +- +- assert!(a != b); +- assert!(!(a == b)); +- assert!(a == a); +- assert!(!(a != a)); +- +- if $id::lanes() > 1 { +- let a = $id::splat($false).replace(0, $true); +- let b = $id::splat($true); +- +- assert!(a != b); +- assert!(!(a == b)); +- assert!(a == a); +- assert!(!(a != a)); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/cmp/partial_ord.rs b/third_party/rust/packed_simd/src/api/cmp/partial_ord.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cmp/partial_ord.rs ++++ /dev/null +@@ -1,230 +0,0 @@ +-//! Implements `PartialOrd` for vector types. +-//! +-//! This implements a lexicographical order. +- +-macro_rules! impl_cmp_partial_ord { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Returns a wrapper that implements `PartialOrd`. +- #[inline] +- pub fn partial_lex_ord(&self) -> LexicographicallyOrdered<$id> { +- LexicographicallyOrdered(*self) +- } +- } +- +- impl crate::cmp::PartialOrd> for LexicographicallyOrdered<$id> { +- #[inline] +- fn partial_cmp(&self, other: &Self) -> Option { +- if PartialEq::eq(self, other) { +- Some(crate::cmp::Ordering::Equal) +- } else if PartialOrd::lt(self, other) { +- Some(crate::cmp::Ordering::Less) +- } else if PartialOrd::gt(self, other) { +- Some(crate::cmp::Ordering::Greater) +- } else { +- None +- } +- } +- #[inline] +- fn lt(&self, other: &Self) -> bool { +- let m_lt = self.0.lt(other.0); +- let m_eq = self.0.eq(other.0); +- for i in 0..$id::lanes() { +- if m_eq.extract(i) { +- continue; +- } +- return m_lt.extract(i); +- } +- false +- } +- #[inline] +- fn le(&self, other: &Self) -> bool { +- self.lt(other) | PartialEq::eq(self, other) +- } +- #[inline] +- fn ge(&self, other: &Self) -> bool { +- self.gt(other) | PartialEq::eq(self, other) +- } +- #[inline] +- fn gt(&self, other: &Self) -> bool { +- let m_gt = self.0.gt(other.0); +- let m_eq = self.0.eq(other.0); +- for i in 0..$id::lanes() { +- if m_eq.extract(i) { +- continue; +- } +- return m_gt.extract(i); +- } +- false +- } +- } +- }; +-} +- +-macro_rules! test_cmp_partial_ord_int { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_PartialOrd>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn partial_lex_ord() { +- use crate::testing::utils::{test_cmp}; +- // constant values +- let a = $id::splat(0); +- let b = $id::splat(1); +- +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- +- // variable values: a = [0, 1, 2, 3]; b = [3, 2, 1, 0] +- let mut a = $id::splat(0); +- let mut b = $id::splat(0); +- for i in 0..$id::lanes() { +- a = a.replace(i, i as $elem_ty); +- b = b.replace(i, ($id::lanes() - i) as $elem_ty); +- } +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- +- // variable values: a = [0, 1, 2, 3]; b = [0, 1, 2, 4] +- let mut b = a; +- b = b.replace( +- $id::lanes() - 1, +- a.extract($id::lanes() - 1) + 1 as $elem_ty +- ); +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- +- if $id::lanes() > 2 { +- // variable values a = [0, 1, 0, 0]; b = [0, 1, 2, 3] +- let b = a; +- let mut a = $id::splat(0); +- a = a.replace(1, 1 as $elem_ty); +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- +- // variable values: a = [0, 1, 2, 3]; b = [0, 1, 3, 2] +- let mut b = a; +- b = b.replace( +- 2, a.extract($id::lanes() - 1) + 1 as $elem_ty +- ); +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(crate::cmp::Ordering::Equal)); +- } +- } +- } +- } +- } +- }; +-} +- +-macro_rules! test_cmp_partial_ord_mask { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_PartialOrd>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn partial_lex_ord() { +- use crate::testing::utils::{test_cmp}; +- use crate::cmp::Ordering; +- +- // constant values +- let a = $id::splat(false); +- let b = $id::splat(true); +- +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(Ordering::Equal)); +- +- // variable values: +- // a = [false, false, false, false]; +- // b = [false, false, false, true] +- let a = $id::splat(false); +- let mut b = $id::splat(false); +- b = b.replace($id::lanes() - 1, true); +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(Ordering::Equal)); +- +- // variable values: +- // a = [true, true, true, false]; +- // b = [true, true, true, true] +- let mut a = $id::splat(true); +- let b = $id::splat(true); +- a = a.replace($id::lanes() - 1, false); +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(Ordering::Equal)); +- +- if $id::lanes() > 2 { +- // variable values +- // a = [false, true, false, false]; +- // b = [false, true, true, true] +- let mut a = $id::splat(false); +- let mut b = $id::splat(true); +- a = a.replace(1, true); +- b = b.replace(0, false); +- test_cmp(a.partial_lex_ord(), b.partial_lex_ord(), +- Some(Ordering::Less)); +- test_cmp(b.partial_lex_ord(), a.partial_lex_ord(), +- Some(Ordering::Greater)); +- test_cmp(a.partial_lex_ord(), a.partial_lex_ord(), +- Some(Ordering::Equal)); +- test_cmp(b.partial_lex_ord(), b.partial_lex_ord(), +- Some(Ordering::Equal)); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/cmp/vertical.rs b/third_party/rust/packed_simd/src/api/cmp/vertical.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/cmp/vertical.rs ++++ /dev/null +@@ -1,114 +0,0 @@ +-//! Vertical (lane-wise) vector comparisons returning vector masks. +- +-macro_rules! impl_cmp_vertical { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident, +- $mask_ty:ident, +- $is_mask:expr,($true:expr, $false:expr) | $test_tt:tt +- ) => { +- impl $id { +- /// Lane-wise equality comparison. +- #[inline] +- pub fn eq(self, other: Self) -> $mask_ty { +- use crate::llvm::simd_eq; +- Simd(unsafe { simd_eq(self.0, other.0) }) +- } +- +- /// Lane-wise inequality comparison. +- #[inline] +- pub fn ne(self, other: Self) -> $mask_ty { +- use crate::llvm::simd_ne; +- Simd(unsafe { simd_ne(self.0, other.0) }) +- } +- +- /// Lane-wise less-than comparison. +- #[inline] +- pub fn lt(self, other: Self) -> $mask_ty { +- use crate::llvm::{simd_gt, simd_lt}; +- if $is_mask { +- Simd(unsafe { simd_gt(self.0, other.0) }) +- } else { +- Simd(unsafe { simd_lt(self.0, other.0) }) +- } +- } +- +- /// Lane-wise less-than-or-equals comparison. +- #[inline] +- pub fn le(self, other: Self) -> $mask_ty { +- use crate::llvm::{simd_ge, simd_le}; +- if $is_mask { +- Simd(unsafe { simd_ge(self.0, other.0) }) +- } else { +- Simd(unsafe { simd_le(self.0, other.0) }) +- } +- } +- +- /// Lane-wise greater-than comparison. +- #[inline] +- pub fn gt(self, other: Self) -> $mask_ty { +- use crate::llvm::{simd_gt, simd_lt}; +- if $is_mask { +- Simd(unsafe { simd_lt(self.0, other.0) }) +- } else { +- Simd(unsafe { simd_gt(self.0, other.0) }) +- } +- } +- +- /// Lane-wise greater-than-or-equals comparison. +- #[inline] +- pub fn ge(self, other: Self) -> $mask_ty { +- use crate::llvm::{simd_ge, simd_le}; +- if $is_mask { +- Simd(unsafe { simd_le(self.0, other.0) }) +- } else { +- Simd(unsafe { simd_ge(self.0, other.0) }) +- } +- } +- } +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_vertical>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn cmp() { +- let a = $id::splat($false); +- let b = $id::splat($true); +- +- let r = a.lt(b); +- let e = $mask_ty::splat(true); +- assert!(r == e); +- let r = a.le(b); +- assert!(r == e); +- +- let e = $mask_ty::splat(false); +- let r = a.gt(b); +- assert!(r == e); +- let r = a.ge(b); +- assert!(r == e); +- let r = a.eq(b); +- assert!(r == e); +- +- let mut a = a; +- let mut b = b; +- let mut e = e; +- for i in 0..$id::lanes() { +- if i % 2 == 0 { +- a = a.replace(i, $false); +- b = b.replace(i, $true); +- e = e.replace(i, true); +- } else { +- a = a.replace(i, $true); +- b = b.replace(i, $false); +- e = e.replace(i, false); +- } +- } +- let r = a.lt(b); +- assert!(r == e); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/default.rs b/third_party/rust/packed_simd/src/api/default.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/default.rs ++++ /dev/null +@@ -1,30 +0,0 @@ +-//! Implements `Default` for vector types. +- +-macro_rules! impl_default { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl Default for $id { +- #[inline] +- fn default() -> Self { +- Self::splat($elem_ty::default()) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- // Comparisons use integer casts within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- pub mod [<$id _default>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn default() { +- let a = $id::default(); +- for i in 0..$id::lanes() { +- assert_eq!(a.extract(i), $elem_ty::default()); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/fmt.rs b/third_party/rust/packed_simd/src/api/fmt.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/fmt.rs ++++ /dev/null +@@ -1,12 +0,0 @@ +-//! Implements formatting APIs +- +-#[macro_use] +-mod debug; +-#[macro_use] +-mod lower_hex; +-#[macro_use] +-mod upper_hex; +-#[macro_use] +-mod octal; +-#[macro_use] +-mod binary; +diff --git a/third_party/rust/packed_simd/src/api/fmt/binary.rs b/third_party/rust/packed_simd/src/api/fmt/binary.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/fmt/binary.rs ++++ /dev/null +@@ -1,54 +0,0 @@ +-//! Implement Octal formatting +- +-macro_rules! impl_fmt_binary { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::fmt::Binary for $id { +- #[allow(clippy::missing_inline_in_public_items)] +- fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result { +- write!(f, "{}(", stringify!($id))?; +- for i in 0..$elem_count { +- if i > 0 { +- write!(f, ", ")?; +- } +- self.extract(i).fmt(f)?; +- } +- write!(f, ")") +- } +- } +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _fmt_binary>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn binary() { +- use arrayvec::{ArrayString,ArrayVec}; +- type TinyString = ArrayString<[u8; 512]>; +- +- use crate::fmt::Write; +- let v = $id::splat($elem_ty::default()); +- let mut s = TinyString::new(); +- write!(&mut s, "{:#b}", v).unwrap(); +- +- let mut beg = TinyString::new(); +- write!(&mut beg, "{}(", stringify!($id)).unwrap(); +- assert!(s.starts_with(beg.as_str())); +- assert!(s.ends_with(")")); +- let s: ArrayVec<[TinyString; 64]> +- = s.replace(beg.as_str(), "") +- .replace(")", "").split(",") +- .map(|v| TinyString::from(v.trim()).unwrap()) +- .collect(); +- assert_eq!(s.len(), $id::lanes()); +- for (index, ss) in s.into_iter().enumerate() { +- let mut e = TinyString::new(); +- write!(&mut e, "{:#b}", v.extract(index)).unwrap(); +- assert_eq!(ss, e); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/fmt/debug.rs b/third_party/rust/packed_simd/src/api/fmt/debug.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/fmt/debug.rs ++++ /dev/null +@@ -1,60 +0,0 @@ +-//! Implement debug formatting +- +-macro_rules! impl_fmt_debug_tests { +- ([$elem_ty:ty; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _fmt_debug>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn debug() { +- use arrayvec::{ArrayString,ArrayVec}; +- type TinyString = ArrayString<[u8; 512]>; +- +- use crate::fmt::Write; +- let v = $id::default(); +- let mut s = TinyString::new(); +- write!(&mut s, "{:?}", v).unwrap(); +- +- let mut beg = TinyString::new(); +- write!(&mut beg, "{}(", stringify!($id)).unwrap(); +- assert!(s.starts_with(beg.as_str())); +- assert!(s.ends_with(")")); +- let s: ArrayVec<[TinyString; 64]> +- = s.replace(beg.as_str(), "") +- .replace(")", "").split(",") +- .map(|v| TinyString::from(v.trim()).unwrap()) +- .collect(); +- assert_eq!(s.len(), $id::lanes()); +- for (index, ss) in s.into_iter().enumerate() { +- let mut e = TinyString::new(); +- write!(&mut e, "{:?}", v.extract(index)).unwrap(); +- assert_eq!(ss, e); +- } +- } +- } +- } +- } +- }; +-} +- +-macro_rules! impl_fmt_debug { +- ([$elem_ty:ty; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::fmt::Debug for $id { +- #[allow(clippy::missing_inline_in_public_items)] +- fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result { +- write!(f, "{}(", stringify!($id))?; +- for i in 0..$elem_count { +- if i > 0 { +- write!(f, ", ")?; +- } +- self.extract(i).fmt(f)?; +- } +- write!(f, ")") +- } +- } +- impl_fmt_debug_tests!([$elem_ty; $elem_count]: $id | $test_tt); +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/fmt/lower_hex.rs b/third_party/rust/packed_simd/src/api/fmt/lower_hex.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/fmt/lower_hex.rs ++++ /dev/null +@@ -1,54 +0,0 @@ +-//! Implement `LowerHex` formatting +- +-macro_rules! impl_fmt_lower_hex { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::fmt::LowerHex for $id { +- #[allow(clippy::missing_inline_in_public_items)] +- fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result { +- write!(f, "{}(", stringify!($id))?; +- for i in 0..$elem_count { +- if i > 0 { +- write!(f, ", ")?; +- } +- self.extract(i).fmt(f)?; +- } +- write!(f, ")") +- } +- } +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _fmt_lower_hex>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn lower_hex() { +- use arrayvec::{ArrayString,ArrayVec}; +- type TinyString = ArrayString<[u8; 512]>; +- +- use crate::fmt::Write; +- let v = $id::splat($elem_ty::default()); +- let mut s = TinyString::new(); +- write!(&mut s, "{:#x}", v).unwrap(); +- +- let mut beg = TinyString::new(); +- write!(&mut beg, "{}(", stringify!($id)).unwrap(); +- assert!(s.starts_with(beg.as_str())); +- assert!(s.ends_with(")")); +- let s: ArrayVec<[TinyString; 64]> +- = s.replace(beg.as_str(), "").replace(")", "") +- .split(",") +- .map(|v| TinyString::from(v.trim()).unwrap()) +- .collect(); +- assert_eq!(s.len(), $id::lanes()); +- for (index, ss) in s.into_iter().enumerate() { +- let mut e = TinyString::new(); +- write!(&mut e, "{:#x}", v.extract(index)).unwrap(); +- assert_eq!(ss, e); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/fmt/octal.rs b/third_party/rust/packed_simd/src/api/fmt/octal.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/fmt/octal.rs ++++ /dev/null +@@ -1,54 +0,0 @@ +-//! Implement Octal formatting +- +-macro_rules! impl_fmt_octal { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::fmt::Octal for $id { +- #[allow(clippy::missing_inline_in_public_items)] +- fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result { +- write!(f, "{}(", stringify!($id))?; +- for i in 0..$elem_count { +- if i > 0 { +- write!(f, ", ")?; +- } +- self.extract(i).fmt(f)?; +- } +- write!(f, ")") +- } +- } +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _fmt_octal>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn octal_hex() { +- use arrayvec::{ArrayString,ArrayVec}; +- type TinyString = ArrayString<[u8; 512]>; +- +- use crate::fmt::Write; +- let v = $id::splat($elem_ty::default()); +- let mut s = TinyString::new(); +- write!(&mut s, "{:#o}", v).unwrap(); +- +- let mut beg = TinyString::new(); +- write!(&mut beg, "{}(", stringify!($id)).unwrap(); +- assert!(s.starts_with(beg.as_str())); +- assert!(s.ends_with(")")); +- let s: ArrayVec<[TinyString; 64]> +- = s.replace(beg.as_str(), "").replace(")", "") +- .split(",") +- .map(|v| TinyString::from(v.trim()).unwrap()) +- .collect(); +- assert_eq!(s.len(), $id::lanes()); +- for (index, ss) in s.into_iter().enumerate() { +- let mut e = TinyString::new(); +- write!(&mut e, "{:#o}", v.extract(index)).unwrap(); +- assert_eq!(ss, e); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/fmt/upper_hex.rs b/third_party/rust/packed_simd/src/api/fmt/upper_hex.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/fmt/upper_hex.rs ++++ /dev/null +@@ -1,54 +0,0 @@ +-//! Implement `UpperHex` formatting +- +-macro_rules! impl_fmt_upper_hex { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::fmt::UpperHex for $id { +- #[allow(clippy::missing_inline_in_public_items)] +- fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) -> crate::fmt::Result { +- write!(f, "{}(", stringify!($id))?; +- for i in 0..$elem_count { +- if i > 0 { +- write!(f, ", ")?; +- } +- self.extract(i).fmt(f)?; +- } +- write!(f, ")") +- } +- } +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _fmt_upper_hex>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn upper_hex() { +- use arrayvec::{ArrayString,ArrayVec}; +- type TinyString = ArrayString<[u8; 512]>; +- +- use crate::fmt::Write; +- let v = $id::splat($elem_ty::default()); +- let mut s = TinyString::new(); +- write!(&mut s, "{:#X}", v).unwrap(); +- +- let mut beg = TinyString::new(); +- write!(&mut beg, "{}(", stringify!($id)).unwrap(); +- assert!(s.starts_with(beg.as_str())); +- assert!(s.ends_with(")")); +- let s: ArrayVec<[TinyString; 64]> +- = s.replace(beg.as_str(), "").replace(")", "") +- .split(",") +- .map(|v| TinyString::from(v.trim()).unwrap()) +- .collect(); +- assert_eq!(s.len(), $id::lanes()); +- for (index, ss) in s.into_iter().enumerate() { +- let mut e = TinyString::new(); +- write!(&mut e, "{:#X}", v.extract(index)).unwrap(); +- assert_eq!(ss, e); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/from.rs b/third_party/rust/packed_simd/src/api/from.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/from.rs ++++ /dev/null +@@ -1,7 +0,0 @@ +-//! Implementations of the `From` and `Into` traits +- +-#[macro_use] +-mod from_array; +- +-#[macro_use] +-mod from_vector; +diff --git a/third_party/rust/packed_simd/src/api/from/from_array.rs b/third_party/rust/packed_simd/src/api/from/from_array.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/from/from_array.rs ++++ /dev/null +@@ -1,124 +0,0 @@ +-//! Implements `From<[T; N]>` and `Into<[T; N]>` for vector types. +- +-macro_rules! impl_from_array { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt +- | ($non_default_array:expr, $non_default_vec:expr)) => { +- impl From<[$elem_ty; $elem_count]> for $id { +- #[inline] +- fn from(array: [$elem_ty; $elem_count]) -> Self { +- union U { +- array: [$elem_ty; $elem_count], +- vec: $id, +- } +- unsafe { U { array }.vec } +- } +- } +- +- impl From<$id> for [$elem_ty; $elem_count] { +- #[inline] +- fn from(vec: $id) -> Self { +- union U { +- array: [$elem_ty; $elem_count], +- vec: $id, +- } +- unsafe { U { vec }.array } +- } +- } +- +- // FIXME: `Into::into` is not inline, but due to +- // the blanket impl in `std`, which is not +- // marked `default`, we cannot override it here with +- // specialization. +- /* +- impl Into<[$elem_ty; $elem_count]> for $id { +- #[inline] +- fn into(self) -> [$elem_ty; $elem_count] { +- union U { +- array: [$elem_ty; $elem_count], +- vec: $id, +- } +- unsafe { U { vec: self }.array } +- } +- } +- +- impl Into<$id> for [$elem_ty; $elem_count] { +- #[inline] +- fn into(self) -> $id { +- union U { +- array: [$elem_ty; $elem_count], +- vec: $id, +- } +- unsafe { U { array: self }.vec } +- } +- } +- */ +- +- test_if! { +- $test_tt: +- paste::item! { +- // Comparisons use integer casts within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- mod [<$id _from>] { +- use super::*; +- #[test] +- #[cfg_attr(miri, ignore)] +- fn array() { +- let vec: $id = Default::default(); +- +- // FIXME: Workaround for arrays with more than 32 +- // elements. +- // +- // Safe because we never take a reference to any +- // uninitialized element. +- union W { +- array: [$elem_ty; $elem_count], +- other: () +- } +- let mut array = W { other: () }; +- for i in 0..$elem_count { +- let default: $elem_ty = Default::default(); +- // note: array.other is the active member and +- // initialized so we can take a reference to it: +- let p = unsafe { +- &mut array.other as *mut () as *mut $elem_ty +- }; +- // note: default is a valid bit-pattern for +- // $elem_ty: +- unsafe { +- crate::ptr::write(p.wrapping_add(i), default) +- }; +- } +- // note: the array variant of the union is properly +- // initialized: +- let mut array = unsafe { +- array.array +- }; +- +- array[0] = $non_default_array; +- let vec = vec.replace(0, $non_default_vec); +- +- let vec_from_array = $id::from(array); +- assert_eq!(vec_from_array, vec); +- let array_from_vec +- = <[$elem_ty; $elem_count]>::from(vec); +- // FIXME: Workaround for arrays with more than 32 +- // elements. +- for i in 0..$elem_count { +- assert_eq!(array_from_vec[i], array[i]); +- } +- +- let vec_from_into_array: $id = array.into(); +- assert_eq!(vec_from_into_array, vec); +- let array_from_into_vec: [$elem_ty; $elem_count] +- = vec.into(); +- // FIXME: Workaround for arrays with more than 32 +- // elements. +- for i in 0..$elem_count { +- assert_eq!(array_from_into_vec[i], array[i]); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/from/from_vector.rs b/third_party/rust/packed_simd/src/api/from/from_vector.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/from/from_vector.rs ++++ /dev/null +@@ -1,67 +0,0 @@ +-//! Implements `From` and `Into` for vector types. +- +-macro_rules! impl_from_vector { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt +- | $source:ident) => { +- impl From<$source> for $id { +- #[inline] +- fn from(source: $source) -> Self { +- fn static_assert_same_number_of_lanes() +- where +- T: crate::sealed::Simd, +- U: crate::sealed::Simd, +- { +- } +- use crate::llvm::simd_cast; +- static_assert_same_number_of_lanes::<$id, $source>(); +- Simd(unsafe { simd_cast(source.0) }) +- } +- } +- +- // FIXME: `Into::into` is not inline, but due to the blanket impl in +- // `std`, which is not marked `default`, we cannot override it here +- // with specialization. +- +- /* +- impl Into<$id> for $source { +- #[inline] +- fn into(self) -> $id { +- unsafe { simd_cast(self) } +- } +- } +- */ +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _from_ $source>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn from() { +- assert_eq!($id::lanes(), $source::lanes()); +- let source: $source = Default::default(); +- let vec: $id = Default::default(); +- +- let e = $id::from(source); +- assert_eq!(e, vec); +- +- let e: $id = source.into(); +- assert_eq!(e, vec); +- } +- } +- } +- } +- }; +-} +- +-macro_rules! impl_from_vectors { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt +- | $($source:ident),*) => { +- $( +- impl_from_vector!( +- [$elem_ty; $elem_count]: $id | $test_tt | $source +- ); +- )* +- } +-} +diff --git a/third_party/rust/packed_simd/src/api/hash.rs b/third_party/rust/packed_simd/src/api/hash.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/hash.rs ++++ /dev/null +@@ -1,49 +0,0 @@ +-//! Implements `Hash` for vector types. +- +-macro_rules! impl_hash { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::hash::Hash for $id { +- #[inline] +- fn hash(&self, state: &mut H) { +- unsafe { +- union A { +- data: [$elem_ty; $id::lanes()], +- vec: $id, +- } +- A { vec: *self }.data.hash(state) +- } +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _hash>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn hash() { +- use crate::hash::{Hash, Hasher}; +- #[allow(deprecated)] +- use crate::hash::{SipHasher13}; +- type A = [$elem_ty; $id::lanes()]; +- let a: A = [42 as $elem_ty; $id::lanes()]; +- assert_eq!( +- crate::mem::size_of::(), +- crate::mem::size_of::<$id>() +- ); +- #[allow(deprecated)] +- let mut a_hash = SipHasher13::new(); +- let mut v_hash = a_hash.clone(); +- a.hash(&mut a_hash); +- +- // Integer within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- let v = $id::splat(42 as $elem_ty); +- v.hash(&mut v_hash); +- assert_eq!(a_hash.finish(), v_hash.finish()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/into_bits.rs b/third_party/rust/packed_simd/src/api/into_bits.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits.rs ++++ /dev/null +@@ -1,59 +0,0 @@ +-//! Implementation of `FromBits` and `IntoBits`. +- +-/// Safe lossless bitwise conversion from `T` to `Self`. +-#[cfg_attr(doc_cfg, doc(cfg(feature = "into_bits")))] +-pub trait FromBits: crate::marker::Sized { +- /// Safe lossless bitwise transmute from `T` to `Self`. +- fn from_bits(t: T) -> Self; +-} +- +-/// Safe lossless bitwise conversion from `Self` to `T`. +-#[cfg_attr(doc_cfg, doc(cfg(feature = "into_bits")))] +-pub trait IntoBits: crate::marker::Sized { +- /// Safe lossless bitwise transmute from `self` to `T`. +- fn into_bits(self) -> T; +-} +- +-/// `FromBits` implies `IntoBits`. +-impl IntoBits for T +-where +- U: FromBits, +-{ +- #[inline] +- fn into_bits(self) -> U { +- debug_assert!(crate::mem::size_of::() == crate::mem::size_of::()); +- U::from_bits(self) +- } +-} +- +-/// `FromBits` and `IntoBits` are reflexive +-impl FromBits for T { +- #[inline] +- fn from_bits(t: Self) -> Self { +- t +- } +-} +- +-#[macro_use] +-mod macros; +- +-mod v16; +-pub use self::v16::*; +- +-mod v32; +-pub use self::v32::*; +- +-mod v64; +-pub use self::v64::*; +- +-mod v128; +-pub use self::v128::*; +- +-mod v256; +-pub use self::v256::*; +- +-mod v512; +-pub use self::v512::*; +- +-mod arch_specific; +-pub use self::arch_specific::*; +diff --git a/third_party/rust/packed_simd/src/api/into_bits/arch_specific.rs b/third_party/rust/packed_simd/src/api/into_bits/arch_specific.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits/arch_specific.rs ++++ /dev/null +@@ -1,345 +0,0 @@ +-//! `FromBits` and `IntoBits` between portable vector types and the +-//! architecture-specific vector types. +-#[rustfmt::skip] +- +-// FIXME: MIPS FromBits/IntoBits +- +-#[allow(unused)] +-use crate::*; +- +-/// This macro implements FromBits for the portable and the architecture +-/// specific vector types. +-/// +-/// The "leaf" case is at the bottom, and the most generic case is at the top. +-/// The generic case is split into smaller cases recursively. +-macro_rules! impl_arch { +- ([$arch_head_i:ident[$arch_head_tt:tt]: $($arch_head_ty:ident),*], +- $([$arch_tail_i:ident[$arch_tail_tt:tt]: $($arch_tail_ty:ident),*]),* | +- from: $($from_ty:ident),* | into: $($into_ty:ident),* | +- test: $test_tt:tt) => { +- impl_arch!( +- [$arch_head_i[$arch_head_tt]: $($arch_head_ty),*] | +- from: $($from_ty),* | +- into: $($into_ty),* | +- test: $test_tt +- ); +- impl_arch!( +- $([$arch_tail_i[$arch_tail_tt]: $($arch_tail_ty),*]),* | +- from: $($from_ty),* | +- into: $($into_ty),* | +- test: $test_tt +- ); +- }; +- ([$arch:ident[$arch_tt:tt]: $($arch_ty:ident),*] | +- from: $($from_ty:ident),* | into: $($into_ty:ident),* | +- test: $test_tt:tt) => { +- // note: if target is "arm", "+v7,+neon" must be enabled +- // and the std library must be recompiled with them +- #[cfg(any( +- not(target_arch = "arm"), +- all(target_feature = "v7", target_feature = "neon", +- any(feature = "core_arch", libcore_neon))) +- )] +- // note: if target is "powerpc", "altivec" must be enabled +- // and the std library must be recompiled with it +- #[cfg(any( +- not(target_arch = "powerpc"), +- all(target_feature = "altivec", feature = "core_arch"), +- ))] +- #[cfg(target_arch = $arch_tt)] +- use crate::arch::$arch::{ +- $($arch_ty),* +- }; +- +- #[cfg(any( +- not(target_arch = "arm"), +- all(target_feature = "v7", target_feature = "neon", +- any(feature = "core_arch", libcore_neon))) +- )] +- #[cfg(any( +- not(target_arch = "powerpc"), +- all(target_feature = "altivec", feature = "core_arch"), +- ))] +- #[cfg(target_arch = $arch_tt)] +- impl_arch!($($arch_ty),* | $($from_ty),* | $($into_ty),* | +- test: $test_tt); +- }; +- ($arch_head:ident, $($arch_tail:ident),* | $($from_ty:ident),* +- | $($into_ty:ident),* | test: $test_tt:tt) => { +- impl_arch!($arch_head | $($from_ty),* | $($into_ty),* | +- test: $test_tt); +- impl_arch!($($arch_tail),* | $($from_ty),* | $($into_ty),* | +- test: $test_tt); +- }; +- ($arch_head:ident | $($from_ty:ident),* | $($into_ty:ident),* | +- test: $test_tt:tt) => { +- impl_from_bits!($arch_head[$test_tt]: $($from_ty),*); +- impl_into_bits!($arch_head[$test_tt]: $($into_ty),*); +- }; +-} +- +-//////////////////////////////////////////////////////////////////////////////// +-// Implementations for the 64-bit wide vector types: +- +-// FIXME: 64-bit single element types +-// FIXME: arm/aarch float16x4_t missing +-impl_arch!( +- [ +- arm["arm"]: int8x8_t, +- uint8x8_t, +- poly8x8_t, +- int16x4_t, +- uint16x4_t, +- poly16x4_t, +- int32x2_t, +- uint32x2_t, +- float32x2_t, +- int64x1_t, +- uint64x1_t +- ], +- [ +- aarch64["aarch64"]: int8x8_t, +- uint8x8_t, +- poly8x8_t, +- int16x4_t, +- uint16x4_t, +- poly16x4_t, +- int32x2_t, +- uint32x2_t, +- float32x2_t, +- int64x1_t, +- uint64x1_t, +- float64x1_t +- ] | from: i8x8, +- u8x8, +- m8x8, +- i16x4, +- u16x4, +- m16x4, +- i32x2, +- u32x2, +- f32x2, +- m32x2 | into: i8x8, +- u8x8, +- i16x4, +- u16x4, +- i32x2, +- u32x2, +- f32x2 | test: test_v64 +-); +- +-//////////////////////////////////////////////////////////////////////////////// +-// Implementations for the 128-bit wide vector types: +- +-// FIXME: arm/aarch float16x8_t missing +-// FIXME: ppc vector_pixel missing +-// FIXME: ppc64 vector_Float16 missing +-// FIXME: ppc64 vector_signed_long_long missing +-// FIXME: ppc64 vector_unsigned_long_long missing +-// FIXME: ppc64 vector_bool_long_long missing +-// FIXME: ppc64 vector_signed___int128 missing +-// FIXME: ppc64 vector_unsigned___int128 missing +-impl_arch!( +- [x86["x86"]: __m128, __m128i, __m128d], +- [x86_64["x86_64"]: __m128, __m128i, __m128d], +- [ +- arm["arm"]: int8x16_t, +- uint8x16_t, +- poly8x16_t, +- int16x8_t, +- uint16x8_t, +- poly16x8_t, +- int32x4_t, +- uint32x4_t, +- float32x4_t, +- int64x2_t, +- uint64x2_t +- ], +- [ +- aarch64["aarch64"]: int8x16_t, +- uint8x16_t, +- poly8x16_t, +- int16x8_t, +- uint16x8_t, +- poly16x8_t, +- int32x4_t, +- uint32x4_t, +- float32x4_t, +- int64x2_t, +- uint64x2_t, +- float64x2_t +- ], +- [ +- powerpc["powerpc"]: vector_signed_char, +- vector_unsigned_char, +- vector_signed_short, +- vector_unsigned_short, +- vector_signed_int, +- vector_unsigned_int, +- vector_float +- ], +- [ +- powerpc64["powerpc64"]: vector_signed_char, +- vector_unsigned_char, +- vector_signed_short, +- vector_unsigned_short, +- vector_signed_int, +- vector_unsigned_int, +- vector_float, +- vector_signed_long, +- vector_unsigned_long, +- vector_double +- ] | from: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 | into: i8x16, +- u8x16, +- i16x8, +- u16x8, +- i32x4, +- u32x4, +- f32x4, +- i64x2, +- u64x2, +- f64x2, +- i128x1, +- u128x1 | test: test_v128 +-); +- +-impl_arch!( +- [powerpc["powerpc"]: vector_bool_char], +- [powerpc64["powerpc64"]: vector_bool_char] | from: m8x16, +- m16x8, +- m32x4, +- m64x2, +- m128x1 | into: i8x16, +- u8x16, +- i16x8, +- u16x8, +- i32x4, +- u32x4, +- f32x4, +- i64x2, +- u64x2, +- f64x2, +- i128x1, +- u128x1, +- // Masks: +- m8x16 | test: test_v128 +-); +- +-impl_arch!( +- [powerpc["powerpc"]: vector_bool_short], +- [powerpc64["powerpc64"]: vector_bool_short] | from: m16x8, +- m32x4, +- m64x2, +- m128x1 | into: i8x16, +- u8x16, +- i16x8, +- u16x8, +- i32x4, +- u32x4, +- f32x4, +- i64x2, +- u64x2, +- f64x2, +- i128x1, +- u128x1, +- // Masks: +- m8x16, +- m16x8 | test: test_v128 +-); +- +-impl_arch!( +- [powerpc["powerpc"]: vector_bool_int], +- [powerpc64["powerpc64"]: vector_bool_int] | from: m32x4, +- m64x2, +- m128x1 | into: i8x16, +- u8x16, +- i16x8, +- u16x8, +- i32x4, +- u32x4, +- f32x4, +- i64x2, +- u64x2, +- f64x2, +- i128x1, +- u128x1, +- // Masks: +- m8x16, +- m16x8, +- m32x4 | test: test_v128 +-); +- +-impl_arch!( +- [powerpc64["powerpc64"]: vector_bool_long] | from: m64x2, +- m128x1 | into: i8x16, +- u8x16, +- i16x8, +- u16x8, +- i32x4, +- u32x4, +- f32x4, +- i64x2, +- u64x2, +- f64x2, +- i128x1, +- u128x1, +- // Masks: +- m8x16, +- m16x8, +- m32x4, +- m64x2 | test: test_v128 +-); +- +-//////////////////////////////////////////////////////////////////////////////// +-// Implementations for the 256-bit wide vector types +- +-impl_arch!( +- [x86["x86"]: __m256, __m256i, __m256d], +- [x86_64["x86_64"]: __m256, __m256i, __m256d] | from: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 | into: i8x32, +- u8x32, +- i16x16, +- u16x16, +- i32x8, +- u32x8, +- f32x8, +- i64x4, +- u64x4, +- f64x4, +- i128x2, +- u128x2 | test: test_v256 +-); +- +-//////////////////////////////////////////////////////////////////////////////// +-// FIXME: Implementations for the 512-bit wide vector types +diff --git a/third_party/rust/packed_simd/src/api/into_bits/macros.rs b/third_party/rust/packed_simd/src/api/into_bits/macros.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits/macros.rs ++++ /dev/null +@@ -1,74 +0,0 @@ +-//! Macros implementing `FromBits` +- +-macro_rules! impl_from_bits_ { +- ($id:ident[$test_tt:tt]: $from_ty:ident) => { +- impl crate::api::into_bits::FromBits<$from_ty> for $id { +- #[inline] +- fn from_bits(x: $from_ty) -> Self { +- unsafe { crate::mem::transmute(x) } +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _from_bits_ $from_ty>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn test() { +- use crate::{ +- ptr::{read_unaligned}, +- mem::{size_of, zeroed} +- }; +- use crate::IntoBits; +- assert_eq!(size_of::<$id>(), +- size_of::<$from_ty>()); +- // This is safe because we never create a reference to +- // uninitialized memory: +- let a: $from_ty = unsafe { zeroed() }; +- +- let b_0: $id = crate::FromBits::from_bits(a); +- let b_1: $id = a.into_bits(); +- +- // Check that these are byte-wise equal, that is, +- // that the bit patterns are identical: +- for i in 0..size_of::<$id>() { +- // This is safe because we only read initialized +- // memory in bounds. Also, taking a reference to +- // `b_i` is ok because the fields are initialized. +- unsafe { +- let b_0_v: u8 = read_unaligned( +- (&b_0 as *const $id as *const u8) +- .wrapping_add(i) +- ); +- let b_1_v: u8 = read_unaligned( +- (&b_1 as *const $id as *const u8) +- .wrapping_add(i) +- ); +- assert_eq!(b_0_v, b_1_v); +- } +- } +- } +- } +- } +- } +- }; +-} +- +-macro_rules! impl_from_bits { +- ($id:ident[$test_tt:tt]: $($from_ty:ident),*) => { +- $( +- impl_from_bits_!($id[$test_tt]: $from_ty); +- )* +- } +-} +- +-#[allow(unused)] +-macro_rules! impl_into_bits { +- ($id:ident[$test_tt:tt]: $($from_ty:ident),*) => { +- $( +- impl_from_bits_!($from_ty[$test_tt]: $id); +- )* +- } +-} +diff --git a/third_party/rust/packed_simd/src/api/into_bits/v128.rs b/third_party/rust/packed_simd/src/api/into_bits/v128.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits/v128.rs ++++ /dev/null +@@ -1,232 +0,0 @@ +-//! `FromBits` and `IntoBits` implementations for portable 128-bit wide vectors +-#[rustfmt::skip] +- +-#[allow(unused)] // wasm_bindgen_test +-use crate::*; +- +-impl_from_bits!( +- i8x16[test_v128]: u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!( +- u8x16[test_v128]: i8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!(m8x16[test_v128]: m16x8, m32x4, m64x2, m128x1); +- +-impl_from_bits!( +- i16x8[test_v128]: i8x16, +- u8x16, +- m8x16, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!( +- u16x8[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!(m16x8[test_v128]: m32x4, m64x2, m128x1); +- +-impl_from_bits!( +- i32x4[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!( +- u32x4[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!( +- f32x4[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!(m32x4[test_v128]: m64x2, m128x1); +- +-impl_from_bits!( +- i64x2[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!( +- u64x2[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- f64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!( +- f64x2[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- m64x2, +- i128x1, +- u128x1, +- m128x1 +-); +-impl_from_bits!(m64x2[test_v128]: m128x1); +- +-impl_from_bits!( +- i128x1[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- u128x1, +- m128x1 +-); +-impl_from_bits!( +- u128x1[test_v128]: i8x16, +- u8x16, +- m8x16, +- i16x8, +- u16x8, +- m16x8, +- i32x4, +- u32x4, +- f32x4, +- m32x4, +- i64x2, +- u64x2, +- f64x2, +- m64x2, +- i128x1, +- m128x1 +-); +-// note: m128x1 cannot be constructed from all the other masks bit patterns in +-// here +diff --git a/third_party/rust/packed_simd/src/api/into_bits/v16.rs b/third_party/rust/packed_simd/src/api/into_bits/v16.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits/v16.rs ++++ /dev/null +@@ -1,9 +0,0 @@ +-//! `FromBits` and `IntoBits` implementations for portable 16-bit wide vectors +-#[rustfmt::skip] +- +-#[allow(unused)] // wasm_bindgen_test +-use crate::*; +- +-impl_from_bits!(i8x2[test_v16]: u8x2, m8x2); +-impl_from_bits!(u8x2[test_v16]: i8x2, m8x2); +-// note: m8x2 cannot be constructed from all i8x2 or u8x2 bit patterns +diff --git a/third_party/rust/packed_simd/src/api/into_bits/v256.rs b/third_party/rust/packed_simd/src/api/into_bits/v256.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits/v256.rs ++++ /dev/null +@@ -1,232 +0,0 @@ +-//! `FromBits` and `IntoBits` implementations for portable 256-bit wide vectors +-#[rustfmt::skip] +- +-#[allow(unused)] // wasm_bindgen_test +-use crate::*; +- +-impl_from_bits!( +- i8x32[test_v256]: u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!( +- u8x32[test_v256]: i8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!(m8x32[test_v256]: m16x16, m32x8, m64x4, m128x2); +- +-impl_from_bits!( +- i16x16[test_v256]: i8x32, +- u8x32, +- m8x32, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!( +- u16x16[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!(m16x16[test_v256]: m32x8, m64x4, m128x2); +- +-impl_from_bits!( +- i32x8[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!( +- u32x8[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!( +- f32x8[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!(m32x8[test_v256]: m64x4, m128x2); +- +-impl_from_bits!( +- i64x4[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!( +- u64x4[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- f64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!( +- f64x4[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- m64x4, +- i128x2, +- u128x2, +- m128x2 +-); +-impl_from_bits!(m64x4[test_v256]: m128x2); +- +-impl_from_bits!( +- i128x2[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- u128x2, +- m128x2 +-); +-impl_from_bits!( +- u128x2[test_v256]: i8x32, +- u8x32, +- m8x32, +- i16x16, +- u16x16, +- m16x16, +- i32x8, +- u32x8, +- f32x8, +- m32x8, +- i64x4, +- u64x4, +- f64x4, +- m64x4, +- i128x2, +- m128x2 +-); +-// note: m128x2 cannot be constructed from all the other masks bit patterns in +-// here +diff --git a/third_party/rust/packed_simd/src/api/into_bits/v32.rs b/third_party/rust/packed_simd/src/api/into_bits/v32.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits/v32.rs ++++ /dev/null +@@ -1,13 +0,0 @@ +-//! `FromBits` and `IntoBits` implementations for portable 32-bit wide vectors +-#[rustfmt::skip] +- +-#[allow(unused)] // wasm_bindgen_test +-use crate::*; +- +-impl_from_bits!(i8x4[test_v32]: u8x4, m8x4, i16x2, u16x2, m16x2); +-impl_from_bits!(u8x4[test_v32]: i8x4, m8x4, i16x2, u16x2, m16x2); +-impl_from_bits!(m8x4[test_v32]: m16x2); +- +-impl_from_bits!(i16x2[test_v32]: i8x4, u8x4, m8x4, u16x2, m16x2); +-impl_from_bits!(u16x2[test_v32]: i8x4, u8x4, m8x4, i16x2, m16x2); +-// note: m16x2 cannot be constructed from all m8x4 bit patterns +diff --git a/third_party/rust/packed_simd/src/api/into_bits/v512.rs b/third_party/rust/packed_simd/src/api/into_bits/v512.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits/v512.rs ++++ /dev/null +@@ -1,232 +0,0 @@ +-//! `FromBits` and `IntoBits` implementations for portable 512-bit wide vectors +-#[rustfmt::skip] +- +-#[allow(unused)] // wasm_bindgen_test +-use crate::*; +- +-impl_from_bits!( +- i8x64[test_v512]: u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!( +- u8x64[test_v512]: i8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!(m8x64[test_v512]: m16x32, m32x16, m64x8, m128x4); +- +-impl_from_bits!( +- i16x32[test_v512]: i8x64, +- u8x64, +- m8x64, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!( +- u16x32[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!(m16x32[test_v512]: m32x16, m64x8, m128x4); +- +-impl_from_bits!( +- i32x16[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!( +- u32x16[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!( +- f32x16[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!(m32x16[test_v512]: m64x8, m128x4); +- +-impl_from_bits!( +- i64x8[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!( +- u64x8[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- f64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!( +- f64x8[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- m64x8, +- i128x4, +- u128x4, +- m128x4 +-); +-impl_from_bits!(m64x8[test_v512]: m128x4); +- +-impl_from_bits!( +- i128x4[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- u128x4, +- m128x4 +-); +-impl_from_bits!( +- u128x4[test_v512]: i8x64, +- u8x64, +- m8x64, +- i16x32, +- u16x32, +- m16x32, +- i32x16, +- u32x16, +- f32x16, +- m32x16, +- i64x8, +- u64x8, +- f64x8, +- m64x8, +- i128x4, +- m128x4 +-); +-// note: m128x4 cannot be constructed from all the other masks bit patterns in +-// here +diff --git a/third_party/rust/packed_simd/src/api/into_bits/v64.rs b/third_party/rust/packed_simd/src/api/into_bits/v64.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/into_bits/v64.rs ++++ /dev/null +@@ -1,18 +0,0 @@ +-//! `FromBits` and `IntoBits` implementations for portable 64-bit wide vectors +-#[rustfmt::skip] +- +-#[allow(unused)] // wasm_bindgen_test +-use crate::*; +- +-impl_from_bits!(i8x8[test_v64]: u8x8, m8x8, i16x4, u16x4, m16x4, i32x2, u32x2, f32x2, m32x2); +-impl_from_bits!(u8x8[test_v64]: i8x8, m8x8, i16x4, u16x4, m16x4, i32x2, u32x2, f32x2, m32x2); +-impl_from_bits!(m8x8[test_v64]: m16x4, m32x2); +- +-impl_from_bits!(i16x4[test_v64]: i8x8, u8x8, m8x8, u16x4, m16x4, i32x2, u32x2, f32x2, m32x2); +-impl_from_bits!(u16x4[test_v64]: i8x8, u8x8, m8x8, i16x4, m16x4, i32x2, u32x2, f32x2, m32x2); +-impl_from_bits!(m16x4[test_v64]: m32x2); +- +-impl_from_bits!(i32x2[test_v64]: i8x8, u8x8, m8x8, i16x4, u16x4, m16x4, u32x2, f32x2, m32x2); +-impl_from_bits!(u32x2[test_v64]: i8x8, u8x8, m8x8, i16x4, u16x4, m16x4, i32x2, f32x2, m32x2); +-impl_from_bits!(f32x2[test_v64]: i8x8, u8x8, m8x8, i16x4, u16x4, m16x4, i32x2, u32x2, m32x2); +-// note: m32x2 cannot be constructed from all m16x4 or m8x8 bit patterns +diff --git a/third_party/rust/packed_simd/src/api/math.rs b/third_party/rust/packed_simd/src/api/math.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math.rs ++++ /dev/null +@@ -1,4 +0,0 @@ +-//! Implements vertical math operations +- +-#[macro_use] +-mod float; +diff --git a/third_party/rust/packed_simd/src/api/math/float.rs b/third_party/rust/packed_simd/src/api/math/float.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float.rs ++++ /dev/null +@@ -1,61 +0,0 @@ +-//! Implements vertical floating-point math operations. +- +-#[macro_use] +-mod abs; +- +-#[macro_use] +-mod consts; +- +-#[macro_use] +-mod cos; +- +-#[macro_use] +-mod exp; +- +-#[macro_use] +-mod powf; +- +-#[macro_use] +-mod ln; +- +-#[macro_use] +-mod mul_add; +- +-#[macro_use] +-mod mul_adde; +- +-#[macro_use] +-mod recpre; +- +-#[macro_use] +-mod rsqrte; +- +-#[macro_use] +-mod sin; +- +-#[macro_use] +-mod sqrt; +- +-#[macro_use] +-mod sqrte; +- +-macro_rules! impl_float_category { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident, $mask_ty:ident) => { +- impl $id { +- #[inline] +- pub fn is_nan(self) -> $mask_ty { +- self.ne(self) +- } +- +- #[inline] +- pub fn is_infinite(self) -> $mask_ty { +- self.eq(Self::INFINITY) | self.eq(Self::NEG_INFINITY) +- } +- +- #[inline] +- pub fn is_finite(self) -> $mask_ty { +- !(self.is_nan() | self.is_infinite()) +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/abs.rs b/third_party/rust/packed_simd/src/api/math/float/abs.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/abs.rs ++++ /dev/null +@@ -1,31 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `abs`. +- +-macro_rules! impl_math_float_abs { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Absolute value. +- #[inline] +- pub fn abs(self) -> Self { +- use crate::codegen::math::float::abs::Abs; +- Abs::abs(self) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_abs>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn abs() { +- let o = $id::splat(1 as $elem_ty); +- assert_eq!(o, o.abs()); +- +- let mo = $id::splat(-1 as $elem_ty); +- assert_eq!(o, mo.abs()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/consts.rs b/third_party/rust/packed_simd/src/api/math/float/consts.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/consts.rs ++++ /dev/null +@@ -1,74 +0,0 @@ +-macro_rules! impl_float_consts { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident) => { +- impl $id { +- /// Machine epsilon value. +- pub const EPSILON: $id = $id::splat(core::$elem_ty::EPSILON); +- +- /// Smallest finite value. +- pub const MIN: $id = $id::splat(core::$elem_ty::MIN); +- +- /// Smallest positive normal value. +- pub const MIN_POSITIVE: $id = $id::splat(core::$elem_ty::MIN_POSITIVE); +- +- /// Largest finite value. +- pub const MAX: $id = $id::splat(core::$elem_ty::MAX); +- +- /// Not a Number (NaN). +- pub const NAN: $id = $id::splat(core::$elem_ty::NAN); +- +- /// Infinity (∞). +- pub const INFINITY: $id = $id::splat(core::$elem_ty::INFINITY); +- +- /// Negative infinity (-∞). +- pub const NEG_INFINITY: $id = $id::splat(core::$elem_ty::NEG_INFINITY); +- +- /// Archimedes' constant (π) +- pub const PI: $id = $id::splat(core::$elem_ty::consts::PI); +- +- /// π/2 +- pub const FRAC_PI_2: $id = $id::splat(core::$elem_ty::consts::FRAC_PI_2); +- +- /// π/3 +- pub const FRAC_PI_3: $id = $id::splat(core::$elem_ty::consts::FRAC_PI_3); +- +- /// π/4 +- pub const FRAC_PI_4: $id = $id::splat(core::$elem_ty::consts::FRAC_PI_4); +- +- /// π/6 +- pub const FRAC_PI_6: $id = $id::splat(core::$elem_ty::consts::FRAC_PI_6); +- +- /// π/8 +- pub const FRAC_PI_8: $id = $id::splat(core::$elem_ty::consts::FRAC_PI_8); +- +- /// 1/π +- pub const FRAC_1_PI: $id = $id::splat(core::$elem_ty::consts::FRAC_1_PI); +- +- /// 2/π +- pub const FRAC_2_PI: $id = $id::splat(core::$elem_ty::consts::FRAC_2_PI); +- +- /// 2/sqrt(π) +- pub const FRAC_2_SQRT_PI: $id = $id::splat(core::$elem_ty::consts::FRAC_2_SQRT_PI); +- +- /// sqrt(2) +- pub const SQRT_2: $id = $id::splat(core::$elem_ty::consts::SQRT_2); +- +- /// 1/sqrt(2) +- pub const FRAC_1_SQRT_2: $id = $id::splat(core::$elem_ty::consts::FRAC_1_SQRT_2); +- +- /// Euler's number (e) +- pub const E: $id = $id::splat(core::$elem_ty::consts::E); +- +- /// log2(e) +- pub const LOG2_E: $id = $id::splat(core::$elem_ty::consts::LOG2_E); +- +- /// log10(e) +- pub const LOG10_E: $id = $id::splat(core::$elem_ty::consts::LOG10_E); +- +- /// ln(2) +- pub const LN_2: $id = $id::splat(core::$elem_ty::consts::LN_2); +- +- /// ln(10) +- pub const LN_10: $id = $id::splat(core::$elem_ty::consts::LN_10); +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/cos.rs b/third_party/rust/packed_simd/src/api/math/float/cos.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/cos.rs ++++ /dev/null +@@ -1,44 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `cos`. +- +-macro_rules! impl_math_float_cos { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Cosine. +- #[inline] +- pub fn cos(self) -> Self { +- use crate::codegen::math::float::cos::Cos; +- Cos::cos(self) +- } +- +- /// Cosine of `self * PI`. +- #[inline] +- pub fn cos_pi(self) -> Self { +- use crate::codegen::math::float::cos_pi::CosPi; +- CosPi::cos_pi(self) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_cos>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn cos() { +- use crate::$elem_ty::consts::PI; +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let p = $id::splat(PI as $elem_ty); +- let ph = $id::splat(PI as $elem_ty / 2.); +- let z_r = $id::splat((PI as $elem_ty / 2.).cos()); +- let o_r = $id::splat((PI as $elem_ty).cos()); +- +- assert_eq!(o, z.cos()); +- assert_eq!(z_r, ph.cos()); +- assert_eq!(o_r, p.cos()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/exp.rs b/third_party/rust/packed_simd/src/api/math/float/exp.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/exp.rs ++++ /dev/null +@@ -1,33 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `exp`. +- +-macro_rules! impl_math_float_exp { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Returns the exponential function of `self`: `e^(self)`. +- #[inline] +- pub fn exp(self) -> Self { +- use crate::codegen::math::float::exp::Exp; +- Exp::exp(self) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_exp>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn exp() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- assert_eq!(o, z.exp()); +- +- let e = $id::splat(crate::f64::consts::E as $elem_ty); +- let tol = $id::splat(2.4e-4 as $elem_ty); +- assert!((e - o.exp()).abs().le(tol).all()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/ln.rs b/third_party/rust/packed_simd/src/api/math/float/ln.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/ln.rs ++++ /dev/null +@@ -1,33 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `ln`. +- +-macro_rules! impl_math_float_ln { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Returns the natural logarithm of `self`. +- #[inline] +- pub fn ln(self) -> Self { +- use crate::codegen::math::float::ln::Ln; +- Ln::ln(self) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_ln>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn ln() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- assert_eq!(z, o.ln()); +- +- let e = $id::splat(crate::f64::consts::E as $elem_ty); +- let tol = $id::splat(2.4e-4 as $elem_ty); +- assert!((o - e.ln()).abs().le(tol).all()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/mul_add.rs b/third_party/rust/packed_simd/src/api/math/float/mul_add.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/mul_add.rs ++++ /dev/null +@@ -1,44 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `mul_add`. +- +-macro_rules! impl_math_float_mul_add { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Fused multiply add: `self * y + z` +- #[inline] +- pub fn mul_add(self, y: Self, z: Self) -> Self { +- use crate::codegen::math::float::mul_add::MulAdd; +- MulAdd::mul_add(self, y, z) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_mul_add>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn mul_add() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- let t3 = $id::splat(3 as $elem_ty); +- let f = $id::splat(4 as $elem_ty); +- +- assert_eq!(z, z.mul_add(z, z)); +- assert_eq!(o, o.mul_add(o, z)); +- assert_eq!(o, o.mul_add(z, o)); +- assert_eq!(o, z.mul_add(o, o)); +- +- assert_eq!(t, o.mul_add(o, o)); +- assert_eq!(t, o.mul_add(t, z)); +- assert_eq!(t, t.mul_add(o, z)); +- +- assert_eq!(f, t.mul_add(t, z)); +- assert_eq!(f, t.mul_add(o, t)); +- assert_eq!(t3, t.mul_add(o, o)); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/mul_adde.rs b/third_party/rust/packed_simd/src/api/math/float/mul_adde.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/mul_adde.rs ++++ /dev/null +@@ -1,48 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `mul_adde`. +- +-macro_rules! impl_math_float_mul_adde { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Fused multiply add estimate: ~= `self * y + z` +- /// +- /// While fused multiply-add (`fma`) has infinite precision, +- /// `mul_adde` has _at worst_ the same precision of a multiply followed by an add. +- /// This might be more efficient on architectures that do not have an `fma` instruction. +- #[inline] +- pub fn mul_adde(self, y: Self, z: Self) -> Self { +- use crate::codegen::math::float::mul_adde::MulAddE; +- MulAddE::mul_adde(self, y, z) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_mul_adde>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn mul_adde() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- let t3 = $id::splat(3 as $elem_ty); +- let f = $id::splat(4 as $elem_ty); +- +- assert_eq!(z, z.mul_adde(z, z)); +- assert_eq!(o, o.mul_adde(o, z)); +- assert_eq!(o, o.mul_adde(z, o)); +- assert_eq!(o, z.mul_adde(o, o)); +- +- assert_eq!(t, o.mul_adde(o, o)); +- assert_eq!(t, o.mul_adde(t, z)); +- assert_eq!(t, t.mul_adde(o, z)); +- +- assert_eq!(f, t.mul_adde(t, z)); +- assert_eq!(f, t.mul_adde(o, t)); +- assert_eq!(t3, t.mul_adde(o, o)); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/powf.rs b/third_party/rust/packed_simd/src/api/math/float/powf.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/powf.rs ++++ /dev/null +@@ -1,36 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `powf`. +- +-macro_rules! impl_math_float_powf { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Raises `self` number to the floating point power of `x`. +- #[inline] +- pub fn powf(self, x: Self) -> Self { +- use crate::codegen::math::float::powf::Powf; +- Powf::powf(self, x) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_powf>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn powf() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- assert_eq!(o, o.powf(z)); +- assert_eq!(o, t.powf(z)); +- assert_eq!(o, o.powf(o)); +- assert_eq!(t, t.powf(o)); +- +- let f = $id::splat(4 as $elem_ty); +- assert_eq!(f, t.powf(t)); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/recpre.rs b/third_party/rust/packed_simd/src/api/math/float/recpre.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/recpre.rs ++++ /dev/null +@@ -1,36 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `recpre`. +- +-macro_rules! impl_math_float_recpre { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Reciprocal estimate: `~= 1. / self`. +- /// +- /// FIXME: The precision of the estimate is currently unspecified. +- #[inline] +- pub fn recpre(self) -> Self { +- $id::splat(1.) / self +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_recpre>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn recpre() { +- let tol = $id::splat(2.4e-4 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let error = (o - o.recpre()).abs(); +- assert!(error.le(tol).all()); +- +- let t = $id::splat(2 as $elem_ty); +- let e = 0.5; +- let error = (e - t.recpre()).abs(); +- assert!(error.le(tol).all()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/rsqrte.rs b/third_party/rust/packed_simd/src/api/math/float/rsqrte.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/rsqrte.rs ++++ /dev/null +@@ -1,40 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `rsqrte`. +- +-macro_rules! impl_math_float_rsqrte { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Reciprocal square-root estimate: `~= 1. / self.sqrt()`. +- /// +- /// FIXME: The precision of the estimate is currently unspecified. +- #[inline] +- pub fn rsqrte(self) -> Self { +- unsafe { +- use crate::llvm::simd_fsqrt; +- $id::splat(1.) / Simd(simd_fsqrt(self.0)) +- } +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_rsqrte>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn rsqrte() { +- use crate::$elem_ty::consts::SQRT_2; +- let tol = $id::splat(2.4e-4 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let error = (o - o.rsqrte()).abs(); +- assert!(error.le(tol).all()); +- +- let t = $id::splat(2 as $elem_ty); +- let e = 1. / SQRT_2; +- let error = (e - t.rsqrte()).abs(); +- assert!(error.le(tol).all()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/sin.rs b/third_party/rust/packed_simd/src/api/math/float/sin.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/sin.rs ++++ /dev/null +@@ -1,50 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `sin`. +- +-macro_rules! impl_math_float_sin { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Sine. +- #[inline] +- pub fn sin(self) -> Self { +- use crate::codegen::math::float::sin::Sin; +- Sin::sin(self) +- } +- +- /// Sine of `self * PI`. +- #[inline] +- pub fn sin_pi(self) -> Self { +- use crate::codegen::math::float::sin_pi::SinPi; +- SinPi::sin_pi(self) +- } +- +- /// Sine and cosine of `self * PI`. +- #[inline] +- pub fn sin_cos_pi(self) -> (Self, Self) { +- use crate::codegen::math::float::sin_cos_pi::SinCosPi; +- SinCosPi::sin_cos_pi(self) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_sin>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn sin() { +- use crate::$elem_ty::consts::PI; +- let z = $id::splat(0 as $elem_ty); +- let p = $id::splat(PI as $elem_ty); +- let ph = $id::splat(PI as $elem_ty / 2.); +- let o_r = $id::splat((PI as $elem_ty / 2.).sin()); +- let z_r = $id::splat((PI as $elem_ty).sin()); +- +- assert_eq!(z, z.sin()); +- assert_eq!(o_r, ph.sin()); +- assert_eq!(z_r, p.sin()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/sqrt.rs b/third_party/rust/packed_simd/src/api/math/float/sqrt.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/sqrt.rs ++++ /dev/null +@@ -1,35 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `sqrt`. +- +-macro_rules! impl_math_float_sqrt { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- #[inline] +- pub fn sqrt(self) -> Self { +- use crate::codegen::math::float::sqrt::Sqrt; +- Sqrt::sqrt(self) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_sqrt>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn sqrt() { +- use crate::$elem_ty::consts::SQRT_2; +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- assert_eq!(z, z.sqrt()); +- assert_eq!(o, o.sqrt()); +- +- let t = $id::splat(2 as $elem_ty); +- let e = $id::splat(SQRT_2); +- assert_eq!(e, t.sqrt()); +- +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/math/float/sqrte.rs b/third_party/rust/packed_simd/src/api/math/float/sqrte.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/math/float/sqrte.rs ++++ /dev/null +@@ -1,44 +0,0 @@ +-//! Implements vertical (lane-wise) floating-point `sqrte`. +- +-macro_rules! impl_math_float_sqrte { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Square-root estimate. +- /// +- /// FIXME: The precision of the estimate is currently unspecified. +- #[inline] +- pub fn sqrte(self) -> Self { +- use crate::codegen::math::float::sqrte::Sqrte; +- Sqrte::sqrte(self) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _math_sqrte>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn sqrte() { +- use crate::$elem_ty::consts::SQRT_2; +- let tol = $id::splat(2.4e-4 as $elem_ty); +- +- let z = $id::splat(0 as $elem_ty); +- let error = (z - z.sqrte()).abs(); +- assert!(error.le(tol).all()); +- +- let o = $id::splat(1 as $elem_ty); +- let error = (o - o.sqrte()).abs(); +- assert!(error.le(tol).all()); +- +- let t = $id::splat(2 as $elem_ty); +- let e = $id::splat(SQRT_2 as $elem_ty); +- let error = (e - t.sqrte()).abs(); +- +- assert!(error.le(tol).all()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/minimal.rs b/third_party/rust/packed_simd/src/api/minimal.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/minimal.rs ++++ /dev/null +@@ -1,6 +0,0 @@ +-#[macro_use] +-mod iuf; +-#[macro_use] +-mod mask; +-#[macro_use] +-mod ptr; +diff --git a/third_party/rust/packed_simd/src/api/minimal/iuf.rs b/third_party/rust/packed_simd/src/api/minimal/iuf.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/minimal/iuf.rs ++++ /dev/null +@@ -1,169 +0,0 @@ +-//! Minimal API of signed integer, unsigned integer, and floating-point +-//! vectors. +- +-macro_rules! impl_minimal_iuf { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $ielem_ty:ident | +- $test_tt:tt | $($elem_name:ident),+ | $(#[$doc:meta])*) => { +- +- $(#[$doc])* +- pub type $id = Simd<[$elem_ty; $elem_count]>; +- +- impl sealed::Simd for $id { +- type Element = $elem_ty; +- const LANES: usize = $elem_count; +- type LanesType = [u32; $elem_count]; +- } +- +- impl $id { +- /// Creates a new instance with each vector elements initialized +- /// with the provided values. +- #[inline] +- #[allow(clippy::too_many_arguments)] +- pub const fn new($($elem_name: $elem_ty),*) -> Self { +- Simd(codegen::$id($($elem_name as $ielem_ty),*)) +- } +- +- /// Returns the number of vector lanes. +- #[inline] +- pub const fn lanes() -> usize { +- $elem_count +- } +- +- /// Constructs a new instance with each element initialized to +- /// `value`. +- #[inline] +- pub const fn splat(value: $elem_ty) -> Self { +- Simd(codegen::$id($({ +- #[allow(non_camel_case_types, dead_code)] +- struct $elem_name; +- value as $ielem_ty +- }),*)) +- } +- +- /// Extracts the value at `index`. +- /// +- /// # Panics +- /// +- /// If `index >= Self::lanes()`. +- #[inline] +- pub fn extract(self, index: usize) -> $elem_ty { +- assert!(index < $elem_count); +- unsafe { self.extract_unchecked(index) } +- } +- +- /// Extracts the value at `index`. +- /// +- /// # Safety +- /// +- /// If `index >= Self::lanes()` the behavior is undefined. +- #[inline] +- pub unsafe fn extract_unchecked(self, index: usize) -> $elem_ty { +- use crate::llvm::simd_extract; +- let e: $ielem_ty = simd_extract(self.0, index as u32); +- e as $elem_ty +- } +- +- /// Returns a new vector where the value at `index` is replaced by `new_value`. +- /// +- /// # Panics +- /// +- /// If `index >= Self::lanes()`. +- #[inline] +- #[must_use = "replace does not modify the original value - \ +- it returns a new vector with the value at `index` \ +- replaced by `new_value`d" +- ] +- pub fn replace(self, index: usize, new_value: $elem_ty) -> Self { +- assert!(index < $elem_count); +- unsafe { self.replace_unchecked(index, new_value) } +- } +- +- /// Returns a new vector where the value at `index` is replaced by `new_value`. +- /// +- /// # Safety +- /// +- /// If `index >= Self::lanes()` the behavior is undefined. +- #[inline] +- #[must_use = "replace_unchecked does not modify the original value - \ +- it returns a new vector with the value at `index` \ +- replaced by `new_value`d" +- ] +- pub unsafe fn replace_unchecked( +- self, +- index: usize, +- new_value: $elem_ty, +- ) -> Self { +- use crate::llvm::simd_insert; +- Simd(simd_insert(self.0, index as u32, new_value as $ielem_ty)) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- // Comparisons use integer casts within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- pub mod [<$id _minimal>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn minimal() { +- // lanes: +- assert_eq!($elem_count, $id::lanes()); +- +- // splat and extract / extract_unchecked: +- const VAL: $elem_ty = 7 as $elem_ty; +- const VEC: $id = $id::splat(VAL); +- for i in 0..$id::lanes() { +- assert_eq!(VAL, VEC.extract(i)); +- assert_eq!( +- VAL, unsafe { VEC.extract_unchecked(i) } +- ); +- } +- +- // replace / replace_unchecked +- let new_vec = VEC.replace(0, 42 as $elem_ty); +- for i in 0..$id::lanes() { +- if i == 0 { +- assert_eq!(42 as $elem_ty, new_vec.extract(i)); +- } else { +- assert_eq!(VAL, new_vec.extract(i)); +- } +- } +- let new_vec = unsafe { +- VEC.replace_unchecked(0, 42 as $elem_ty) +- }; +- for i in 0..$id::lanes() { +- if i == 0 { +- assert_eq!(42 as $elem_ty, new_vec.extract(i)); +- } else { +- assert_eq!(VAL, new_vec.extract(i)); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn extract_panic_oob() { +- const VAL: $elem_ty = 7 as $elem_ty; +- const VEC: $id = $id::splat(VAL); +- let _ = VEC.extract($id::lanes()); +- } +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn replace_panic_oob() { +- const VAL: $elem_ty = 7 as $elem_ty; +- const VEC: $id = $id::splat(VAL); +- let _ = VEC.replace($id::lanes(), 42 as $elem_ty); +- } +- } +- } +- } +- } +-} +diff --git a/third_party/rust/packed_simd/src/api/minimal/mask.rs b/third_party/rust/packed_simd/src/api/minimal/mask.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/minimal/mask.rs ++++ /dev/null +@@ -1,176 +0,0 @@ +-//! Minimal API of mask vectors. +- +-macro_rules! impl_minimal_mask { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $ielem_ty:ident +- | $test_tt:tt | $($elem_name:ident),+ | $(#[$doc:meta])*) => { +- $(#[$doc])* +- pub type $id = Simd<[$elem_ty; $elem_count]>; +- +- impl sealed::Simd for $id { +- type Element = $elem_ty; +- const LANES: usize = $elem_count; +- type LanesType = [u32; $elem_count]; +- } +- +- impl $id { +- /// Creates a new instance with each vector elements initialized +- /// with the provided values. +- #[inline] +- #[allow(clippy::too_many_arguments)] +- pub const fn new($($elem_name: bool),*) -> Self { +- Simd(codegen::$id($(Self::bool_to_internal($elem_name)),*)) +- } +- +- /// Converts a boolean type into the type of the vector lanes. +- #[inline] +- #[allow(clippy::indexing_slicing)] +- const fn bool_to_internal(x: bool) -> $ielem_ty { +- [0 as $ielem_ty, !(0 as $ielem_ty)][x as usize] +- } +- +- /// Returns the number of vector lanes. +- #[inline] +- pub const fn lanes() -> usize { +- $elem_count +- } +- +- /// Constructs a new instance with each element initialized to +- /// `value`. +- #[inline] +- pub const fn splat(value: bool) -> Self { +- Simd(codegen::$id($({ +- #[allow(non_camel_case_types, dead_code)] +- struct $elem_name; +- Self::bool_to_internal(value) +- }),*)) +- } +- +- /// Extracts the value at `index`. +- /// +- /// # Panics +- /// +- /// If `index >= Self::lanes()`. +- #[inline] +- pub fn extract(self, index: usize) -> bool { +- assert!(index < $elem_count); +- unsafe { self.extract_unchecked(index) } +- } +- +- /// Extracts the value at `index`. +- /// +- /// # Safety +- /// +- /// If `index >= Self::lanes()` the behavior is undefined. +- #[inline] +- pub unsafe fn extract_unchecked(self, index: usize) -> bool { +- use crate::llvm::simd_extract; +- let x: $ielem_ty = simd_extract(self.0, index as u32); +- x != 0 +- } +- +- /// Returns a new vector where the value at `index` is replaced by +- /// `new_value`. +- /// +- /// # Panics +- /// +- /// If `index >= Self::lanes()`. +- #[inline] +- #[must_use = "replace does not modify the original value - \ +- it returns a new vector with the value at `index` \ +- replaced by `new_value`d" +- ] +- pub fn replace(self, index: usize, new_value: bool) -> Self { +- assert!(index < $elem_count); +- unsafe { self.replace_unchecked(index, new_value) } +- } +- +- /// Returns a new vector where the value at `index` is replaced by +- /// `new_value`. +- /// +- /// # Safety +- /// +- /// If `index >= Self::lanes()` the behavior is undefined. +- #[inline] +- #[must_use = "replace_unchecked does not modify the original value - \ +- it returns a new vector with the value at `index` \ +- replaced by `new_value`d" +- ] +- pub unsafe fn replace_unchecked( +- self, +- index: usize, +- new_value: bool, +- ) -> Self { +- use crate::llvm::simd_insert; +- Simd(simd_insert(self.0, index as u32, +- Self::bool_to_internal(new_value))) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _minimal>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn minimal() { +- // TODO: test new +- +- // lanes: +- assert_eq!($elem_count, $id::lanes()); +- +- // splat and extract / extract_unchecked: +- let vec = $id::splat(true); +- for i in 0..$id::lanes() { +- assert_eq!(true, vec.extract(i)); +- assert_eq!(true, +- unsafe { vec.extract_unchecked(i) } +- ); +- } +- +- // replace / replace_unchecked +- let new_vec = vec.replace(0, false); +- for i in 0..$id::lanes() { +- if i == 0 { +- assert_eq!(false, new_vec.extract(i)); +- } else { +- assert_eq!(true, new_vec.extract(i)); +- } +- } +- let new_vec = unsafe { +- vec.replace_unchecked(0, false) +- }; +- for i in 0..$id::lanes() { +- if i == 0 { +- assert_eq!(false, new_vec.extract(i)); +- } else { +- assert_eq!(true, new_vec.extract(i)); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn extract_panic_oob() { +- let vec = $id::splat(false); +- let _ = vec.extract($id::lanes()); +- } +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn replace_panic_oob() { +- let vec = $id::splat(false); +- let _ = vec.replace($id::lanes(), true); +- } +- } +- } +- } +- } +-} +diff --git a/third_party/rust/packed_simd/src/api/minimal/ptr.rs b/third_party/rust/packed_simd/src/api/minimal/ptr.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/minimal/ptr.rs ++++ /dev/null +@@ -1,1373 +0,0 @@ +-//! Minimal API of pointer vectors. +- +-macro_rules! impl_minimal_p { +- ([$elem_ty:ty; $elem_count:expr]: $id:ident, $mask_ty:ident, +- $usize_ty:ident, $isize_ty:ident | $ref:ident | $test_tt:tt +- | $($elem_name:ident),+ | ($true:expr, $false:expr) | +- $(#[$doc:meta])*) => { +- +- $(#[$doc])* +- pub type $id = Simd<[$elem_ty; $elem_count]>; +- +- impl sealed::Simd for $id { +- type Element = $elem_ty; +- const LANES: usize = $elem_count; +- type LanesType = [u32; $elem_count]; +- } +- +- impl $id { +- /// Creates a new instance with each vector elements initialized +- /// with the provided values. +- #[inline] +- #[allow(clippy::too_many_arguments)] +- pub const fn new($($elem_name: $elem_ty),*) -> Self { +- Simd(codegen::$id($($elem_name),*)) +- } +- +- /// Returns the number of vector lanes. +- #[inline] +- pub const fn lanes() -> usize { +- $elem_count +- } +- +- /// Constructs a new instance with each element initialized to +- /// `value`. +- #[inline] +- pub const fn splat(value: $elem_ty) -> Self { +- Simd(codegen::$id($({ +- #[allow(non_camel_case_types, dead_code)] +- struct $elem_name; +- value +- }),*)) +- } +- +- /// Constructs a new instance with each element initialized to +- /// `null`. +- #[inline] +- pub const fn null() -> Self { +- Self::splat(crate::ptr::null_mut() as $elem_ty) +- } +- +- /// Returns a mask that selects those lanes that contain `null` +- /// pointers. +- #[inline] +- pub fn is_null(self) -> $mask_ty { +- self.eq(Self::null()) +- } +- +- /// Extracts the value at `index`. +- /// +- /// # Panics +- /// +- /// If `index >= Self::lanes()`. +- #[inline] +- pub fn extract(self, index: usize) -> $elem_ty { +- assert!(index < $elem_count); +- unsafe { self.extract_unchecked(index) } +- } +- +- /// Extracts the value at `index`. +- /// +- /// # Safety +- /// +- /// If `index >= Self::lanes()` the behavior is undefined. +- #[inline] +- pub unsafe fn extract_unchecked(self, index: usize) -> $elem_ty { +- use crate::llvm::simd_extract; +- simd_extract(self.0, index as u32) +- } +- +- /// Returns a new vector where the value at `index` is replaced by +- /// `new_value`. +- /// +- /// # Panics +- /// +- /// If `index >= Self::lanes()`. +- #[inline] +- #[must_use = "replace does not modify the original value - \ +- it returns a new vector with the value at `index` \ +- replaced by `new_value`d" +- ] +- #[allow(clippy::not_unsafe_ptr_arg_deref)] +- pub fn replace(self, index: usize, new_value: $elem_ty) -> Self { +- assert!(index < $elem_count); +- unsafe { self.replace_unchecked(index, new_value) } +- } +- +- /// Returns a new vector where the value at `index` is replaced by `new_value`. +- /// +- /// # Safety +- /// +- /// If `index >= Self::lanes()` the behavior is undefined. +- #[inline] +- #[must_use = "replace_unchecked does not modify the original value - \ +- it returns a new vector with the value at `index` \ +- replaced by `new_value`d" +- ] +- pub unsafe fn replace_unchecked( +- self, +- index: usize, +- new_value: $elem_ty, +- ) -> Self { +- use crate::llvm::simd_insert; +- Simd(simd_insert(self.0, index as u32, new_value)) +- } +- } +- +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _minimal>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn minimal() { +- // lanes: +- assert_eq!($elem_count, $id::::lanes()); +- +- // splat and extract / extract_unchecked: +- let VAL7: <$id as sealed::Simd>::Element +- = $ref!(7); +- let VAL42: <$id as sealed::Simd>::Element +- = $ref!(42); +- let VEC: $id = $id::splat(VAL7); +- for i in 0..$id::::lanes() { +- assert_eq!(VAL7, VEC.extract(i)); +- assert_eq!( +- VAL7, unsafe { VEC.extract_unchecked(i) } +- ); +- } +- +- // replace / replace_unchecked +- let new_vec = VEC.replace(0, VAL42); +- for i in 0..$id::::lanes() { +- if i == 0 { +- assert_eq!(VAL42, new_vec.extract(i)); +- } else { +- assert_eq!(VAL7, new_vec.extract(i)); +- } +- } +- let new_vec = unsafe { +- VEC.replace_unchecked(0, VAL42) +- }; +- for i in 0..$id::::lanes() { +- if i == 0 { +- assert_eq!(VAL42, new_vec.extract(i)); +- } else { +- assert_eq!(VAL7, new_vec.extract(i)); +- } +- } +- +- let mut n = $id::::null(); +- assert_eq!( +- n, +- $id::::splat(unsafe { crate::mem::zeroed() }) +- ); +- assert!(n.is_null().all()); +- n = n.replace( +- 0, unsafe { crate::mem::transmute(1_isize) } +- ); +- assert!(!n.is_null().all()); +- if $id::::lanes() > 1 { +- assert!(n.is_null().any()); +- } else { +- assert!(!n.is_null().any()); +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn extract_panic_oob() { +- let VAL: <$id as sealed::Simd>::Element +- = $ref!(7); +- let VEC: $id = $id::splat(VAL); +- let _ = VEC.extract($id::::lanes()); +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn replace_panic_oob() { +- let VAL: <$id as sealed::Simd>::Element +- = $ref!(7); +- let VAL42: <$id as sealed::Simd>::Element +- = $ref!(42); +- let VEC: $id = $id::splat(VAL); +- let _ = VEC.replace($id::::lanes(), VAL42); +- } +- } +- } +- } +- +- impl crate::fmt::Debug for $id { +- #[allow(clippy::missing_inline_in_public_items)] +- fn fmt(&self, f: &mut crate::fmt::Formatter<'_>) +- -> crate::fmt::Result { +- write!( +- f, +- "{}<{}>(", +- stringify!($id), +- crate::intrinsics::type_name::() +- )?; +- for i in 0..$elem_count { +- if i > 0 { +- write!(f, ", ")?; +- } +- self.extract(i).fmt(f)?; +- } +- write!(f, ")") +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _fmt_debug>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn debug() { +- use arrayvec::{ArrayString,ArrayVec}; +- type TinyString = ArrayString<[u8; 512]>; +- +- use crate::fmt::Write; +- let v = $id::::default(); +- let mut s = TinyString::new(); +- write!(&mut s, "{:?}", v).unwrap(); +- +- let mut beg = TinyString::new(); +- write!(&mut beg, "{}(", stringify!($id)).unwrap(); +- assert!( +- s.starts_with(beg.as_str()), +- "s = {} (should start with = {})", s, beg +- ); +- assert!(s.ends_with(")")); +- let s: ArrayVec<[TinyString; 64]> +- = s.replace(beg.as_str(), "") +- .replace(")", "").split(",") +- .map(|v| TinyString::from(v.trim()).unwrap()) +- .collect(); +- assert_eq!(s.len(), $id::::lanes()); +- for (index, ss) in s.into_iter().enumerate() { +- let mut e = TinyString::new(); +- write!(&mut e, "{:?}", v.extract(index)).unwrap(); +- assert_eq!(ss, e); +- } +- } +- } +- } +- } +- +- impl Default for $id { +- #[inline] +- fn default() -> Self { +- // FIXME: ptrs do not implement default +- Self::null() +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _default>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn default() { +- let a = $id::::default(); +- for i in 0..$id::::lanes() { +- assert_eq!( +- a.extract(i), unsafe { crate::mem::zeroed() } +- ); +- } +- } +- } +- } +- } +- +- impl $id { +- /// Lane-wise equality comparison. +- #[inline] +- pub fn eq(self, other: Self) -> $mask_ty { +- unsafe { +- use crate::llvm::simd_eq; +- let a: $usize_ty = crate::mem::transmute(self); +- let b: $usize_ty = crate::mem::transmute(other); +- Simd(simd_eq(a.0, b.0)) +- } +- } +- +- /// Lane-wise inequality comparison. +- #[inline] +- pub fn ne(self, other: Self) -> $mask_ty { +- unsafe { +- use crate::llvm::simd_ne; +- let a: $usize_ty = crate::mem::transmute(self); +- let b: $usize_ty = crate::mem::transmute(other); +- Simd(simd_ne(a.0, b.0)) +- } +- } +- +- /// Lane-wise less-than comparison. +- #[inline] +- pub fn lt(self, other: Self) -> $mask_ty { +- unsafe { +- use crate::llvm::simd_lt; +- let a: $usize_ty = crate::mem::transmute(self); +- let b: $usize_ty = crate::mem::transmute(other); +- Simd(simd_lt(a.0, b.0)) +- } +- } +- +- /// Lane-wise less-than-or-equals comparison. +- #[inline] +- pub fn le(self, other: Self) -> $mask_ty { +- unsafe { +- use crate::llvm::simd_le; +- let a: $usize_ty = crate::mem::transmute(self); +- let b: $usize_ty = crate::mem::transmute(other); +- Simd(simd_le(a.0, b.0)) +- } +- } +- +- /// Lane-wise greater-than comparison. +- #[inline] +- pub fn gt(self, other: Self) -> $mask_ty { +- unsafe { +- use crate::llvm::simd_gt; +- let a: $usize_ty = crate::mem::transmute(self); +- let b: $usize_ty = crate::mem::transmute(other); +- Simd(simd_gt(a.0, b.0)) +- } +- } +- +- /// Lane-wise greater-than-or-equals comparison. +- #[inline] +- pub fn ge(self, other: Self) -> $mask_ty { +- unsafe { +- use crate::llvm::simd_ge; +- let a: $usize_ty = crate::mem::transmute(self); +- let b: $usize_ty = crate::mem::transmute(other); +- Simd(simd_ge(a.0, b.0)) +- } +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_vertical>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn cmp() { +- let a = $id::::null(); +- let b = $id::::splat(unsafe { +- crate::mem::transmute(1_isize) +- }); +- +- let r = a.lt(b); +- let e = $mask_ty::splat(true); +- assert!(r == e); +- let r = a.le(b); +- assert!(r == e); +- +- let e = $mask_ty::splat(false); +- let r = a.gt(b); +- assert!(r == e); +- let r = a.ge(b); +- assert!(r == e); +- let r = a.eq(b); +- assert!(r == e); +- +- let mut a = a; +- let mut b = b; +- let mut e = e; +- for i in 0..$id::::lanes() { +- if i % 2 == 0 { +- a = a.replace( +- i, +- unsafe { crate::mem::transmute(0_isize) } +- ); +- b = b.replace( +- i, +- unsafe { crate::mem::transmute(1_isize) } +- ); +- e = e.replace(i, true); +- } else { +- a = a.replace( +- i, +- unsafe { crate::mem::transmute(1_isize) } +- ); +- b = b.replace( +- i, +- unsafe { crate::mem::transmute(0_isize) } +- ); +- e = e.replace(i, false); +- } +- } +- let r = a.lt(b); +- assert!(r == e); +- } +- } +- } +- } +- +- #[allow(clippy::partialeq_ne_impl)] +- impl crate::cmp::PartialEq<$id> for $id { +- #[inline] +- fn eq(&self, other: &Self) -> bool { +- $id::::eq(*self, *other).all() +- } +- #[inline] +- fn ne(&self, other: &Self) -> bool { +- $id::::ne(*self, *other).any() +- } +- } +- +- // FIXME: https://github.com/rust-lang-nursery/rust-clippy/issues/2892 +- #[allow(clippy::partialeq_ne_impl)] +- impl crate::cmp::PartialEq>> +- for LexicographicallyOrdered<$id> +- { +- #[inline] +- fn eq(&self, other: &Self) -> bool { +- self.0 == other.0 +- } +- #[inline] +- fn ne(&self, other: &Self) -> bool { +- self.0 != other.0 +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_PartialEq>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn partial_eq() { +- let a = $id::::null(); +- let b = $id::::splat(unsafe { +- crate::mem::transmute(1_isize) +- }); +- +- assert!(a != b); +- assert!(!(a == b)); +- assert!(a == a); +- assert!(!(a != a)); +- +- if $id::::lanes() > 1 { +- let a = $id::::null().replace(0, unsafe { +- crate::mem::transmute(1_isize) +- }); +- let b = $id::::splat(unsafe { +- crate::mem::transmute(1_isize) +- }); +- +- assert!(a != b); +- assert!(!(a == b)); +- assert!(a == a); +- assert!(!(a != a)); +- } +- } +- } +- } +- } +- +- impl crate::cmp::Eq for $id {} +- impl crate::cmp::Eq for LexicographicallyOrdered<$id> {} +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _cmp_eq>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn eq() { +- fn foo(_: E) {} +- let a = $id::::null(); +- foo(a); +- } +- } +- } +- } +- +- impl From<[$elem_ty; $elem_count]> for $id { +- #[inline] +- fn from(array: [$elem_ty; $elem_count]) -> Self { +- unsafe { +- // FIXME: unnecessary zeroing; better than UB. +- let mut u: Self = crate::mem::zeroed(); +- crate::ptr::copy_nonoverlapping( +- &array as *const [$elem_ty; $elem_count] as *const u8, +- &mut u as *mut Self as *mut u8, +- crate::mem::size_of::() +- ); +- u +- } +- } +- } +- impl Into<[$elem_ty; $elem_count]> for $id { +- #[inline] +- fn into(self) -> [$elem_ty; $elem_count] { +- unsafe { +- // FIXME: unnecessary zeroing; better than UB. +- let mut u: [$elem_ty; $elem_count] = crate::mem::zeroed(); +- crate::ptr::copy_nonoverlapping( +- &self as *const $id as *const u8, +- &mut u as *mut [$elem_ty; $elem_count] as *mut u8, +- crate::mem::size_of::() +- ); +- u +- } +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _from>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn array() { +- let values = [1_i32; $elem_count]; +- +- let mut vec: $id = Default::default(); +- let mut array = [ +- $id::::null().extract(0); $elem_count +- ]; +- +- for i in 0..$elem_count { +- let ptr = &values[i] as *const i32 as *mut i32; +- vec = vec.replace(i, ptr); +- array[i] = ptr; +- } +- +- // FIXME: there is no impl of From<$id> for [$elem_ty; N] +- // let a0 = From::from(vec); +- // assert_eq!(a0, array); +- #[allow(unused_assignments)] +- let mut a1 = array; +- a1 = vec.into(); +- assert_eq!(a1, array); +- +- let v0: $id = From::from(array); +- assert_eq!(v0, vec); +- let v1: $id = array.into(); +- assert_eq!(v1, vec); +- } +- } +- } +- } +- +- impl $id { +- /// Instantiates a new vector with the values of the `slice`. +- /// +- /// # Panics +- /// +- /// If `slice.len() < Self::lanes()` or `&slice[0]` is not aligned +- /// to an `align_of::()` boundary. +- #[inline] +- pub fn from_slice_aligned(slice: &[$elem_ty]) -> Self { +- unsafe { +- assert!(slice.len() >= $elem_count); +- let target_ptr = slice.as_ptr(); +- assert!( +- target_ptr.align_offset(crate::mem::align_of::()) +- == 0 +- ); +- Self::from_slice_aligned_unchecked(slice) +- } +- } +- +- /// Instantiates a new vector with the values of the `slice`. +- /// +- /// # Panics +- /// +- /// If `slice.len() < Self::lanes()`. +- #[inline] +- pub fn from_slice_unaligned(slice: &[$elem_ty]) -> Self { +- unsafe { +- assert!(slice.len() >= $elem_count); +- Self::from_slice_unaligned_unchecked(slice) +- } +- } +- +- /// Instantiates a new vector with the values of the `slice`. +- /// +- /// # Safety +- /// +- /// If `slice.len() < Self::lanes()` or `&slice[0]` is not aligned +- /// to an `align_of::()` boundary, the behavior is undefined. +- #[inline] +- pub unsafe fn from_slice_aligned_unchecked(slice: &[$elem_ty]) +- -> Self { +- #[allow(clippy::cast_ptr_alignment)] +- *(slice.as_ptr().cast()) +- } +- +- /// Instantiates a new vector with the values of the `slice`. +- /// +- /// # Safety +- /// +- /// If `slice.len() < Self::lanes()` the behavior is undefined. +- #[inline] +- pub unsafe fn from_slice_unaligned_unchecked( +- slice: &[$elem_ty], +- ) -> Self { +- use crate::mem::size_of; +- let target_ptr = slice.as_ptr().cast(); +- let mut x = Self::splat(crate::ptr::null_mut() as $elem_ty); +- let self_ptr = &mut x as *mut Self as *mut u8; +- crate::ptr::copy_nonoverlapping( +- target_ptr, +- self_ptr, +- size_of::(), +- ); +- x +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _slice_from_slice>] { +- use super::*; +- use crate::iter::Iterator; +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn from_slice_unaligned() { +- let (null, non_null) = ptr_vals!($id); +- +- let mut unaligned = [ +- non_null; $id::::lanes() + 1 +- ]; +- unaligned[0] = null; +- let vec = $id::::from_slice_unaligned( +- &unaligned[1..] +- ); +- for (index, &b) in unaligned.iter().enumerate() { +- if index == 0 { +- assert_eq!(b, null); +- } else { +- assert_eq!(b, non_null); +- assert_eq!(b, vec.extract(index - 1)); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn from_slice_unaligned_fail() { +- let (_null, non_null) = ptr_vals!($id); +- let unaligned = [non_null; $id::::lanes() + 1]; +- // the slice is not large enough => panic +- let _vec = $id::::from_slice_unaligned( +- &unaligned[2..] +- ); +- } +- +- union A { +- data: [<$id as sealed::Simd>::Element; +- 2 * $id::::lanes()], +- _vec: $id, +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn from_slice_aligned() { +- let (null, non_null) = ptr_vals!($id); +- let mut aligned = A { +- data: [null; 2 * $id::::lanes()], +- }; +- for i in +- $id::::lanes()..(2 * $id::::lanes()) { +- unsafe { +- aligned.data[i] = non_null; +- } +- } +- +- let vec = unsafe { +- $id::::from_slice_aligned( +- &aligned.data[$id::::lanes()..] +- ) +- }; +- for (index, &b) in unsafe { +- aligned.data.iter().enumerate() +- } { +- if index < $id::::lanes() { +- assert_eq!(b, null); +- } else { +- assert_eq!(b, non_null); +- assert_eq!( +- b, vec.extract(index - $id::::lanes()) +- ); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn from_slice_aligned_fail_lanes() { +- let (_null, non_null) = ptr_vals!($id); +- let aligned = A { +- data: [non_null; 2 * $id::::lanes()], +- }; +- // the slice is not large enough => panic +- let _vec = unsafe { +- $id::::from_slice_aligned( +- &aligned.data[2 * $id::::lanes()..] +- ) +- }; +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn from_slice_aligned_fail_align() { +- unsafe { +- let (null, _non_null) = ptr_vals!($id); +- let aligned = A { +- data: [null; 2 * $id::::lanes()], +- }; +- +- // get a pointer to the front of data +- let ptr = aligned.data.as_ptr(); +- // offset pointer by one element +- let ptr = ptr.wrapping_add(1); +- +- if ptr.align_offset( +- crate::mem::align_of::<$id>() +- ) == 0 { +- // the pointer is properly aligned, so +- // from_slice_aligned won't fail here (e.g. this +- // can happen for i128x1). So we panic to make +- // the "should_fail" test pass: +- panic!("ok"); +- } +- +- // create a slice - this is safe, because the +- // elements of the slice exist, are properly +- // initialized, and properly aligned: +- let s = slice::from_raw_parts( +- ptr, $id::::lanes() +- ); +- // this should always panic because the slice +- // alignment does not match the alignment +- // requirements for the vector type: +- let _vec = $id::::from_slice_aligned(s); +- } +- } +- } +- } +- } +- +- impl $id { +- /// Writes the values of the vector to the `slice`. +- /// +- /// # Panics +- /// +- /// If `slice.len() < Self::lanes()` or `&slice[0]` is not +- /// aligned to an `align_of::()` boundary. +- #[inline] +- pub fn write_to_slice_aligned(self, slice: &mut [$elem_ty]) { +- unsafe { +- assert!(slice.len() >= $elem_count); +- let target_ptr = slice.as_mut_ptr(); +- assert!( +- target_ptr.align_offset(crate::mem::align_of::()) +- == 0 +- ); +- self.write_to_slice_aligned_unchecked(slice); +- } +- } +- +- /// Writes the values of the vector to the `slice`. +- /// +- /// # Panics +- /// +- /// If `slice.len() < Self::lanes()`. +- #[inline] +- pub fn write_to_slice_unaligned(self, slice: &mut [$elem_ty]) { +- unsafe { +- assert!(slice.len() >= $elem_count); +- self.write_to_slice_unaligned_unchecked(slice); +- } +- } +- +- /// Writes the values of the vector to the `slice`. +- /// +- /// # Safety +- /// +- /// If `slice.len() < Self::lanes()` or `&slice[0]` is not +- /// aligned to an `align_of::()` boundary, the behavior is +- /// undefined. +- #[inline] +- pub unsafe fn write_to_slice_aligned_unchecked( +- self, slice: &mut [$elem_ty], +- ) { +- #[allow(clippy::cast_ptr_alignment)] +- *(slice.as_mut_ptr().cast()) = self; +- } +- +- /// Writes the values of the vector to the `slice`. +- /// +- /// # Safety +- /// +- /// If `slice.len() < Self::lanes()` the behavior is undefined. +- #[inline] +- pub unsafe fn write_to_slice_unaligned_unchecked( +- self, slice: &mut [$elem_ty], +- ) { +- let target_ptr = slice.as_mut_ptr().cast(); +- let self_ptr = &self as *const Self as *const u8; +- crate::ptr::copy_nonoverlapping( +- self_ptr, +- target_ptr, +- crate::mem::size_of::(), +- ); +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _slice_write_to_slice>] { +- use super::*; +- use crate::iter::Iterator; +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn write_to_slice_unaligned() { +- let (null, non_null) = ptr_vals!($id); +- let mut unaligned = [null; $id::::lanes() + 1]; +- let vec = $id::::splat(non_null); +- vec.write_to_slice_unaligned(&mut unaligned[1..]); +- for (index, &b) in unaligned.iter().enumerate() { +- if index == 0 { +- assert_eq!(b, null); +- } else { +- assert_eq!(b, non_null); +- assert_eq!(b, vec.extract(index - 1)); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn write_to_slice_unaligned_fail() { +- let (null, non_null) = ptr_vals!($id); +- let mut unaligned = [null; $id::::lanes() + 1]; +- let vec = $id::::splat(non_null); +- // the slice is not large enough => panic +- vec.write_to_slice_unaligned(&mut unaligned[2..]); +- } +- +- union A { +- data: [<$id as sealed::Simd>::Element; +- 2 * $id::::lanes()], +- _vec: $id, +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn write_to_slice_aligned() { +- let (null, non_null) = ptr_vals!($id); +- let mut aligned = A { +- data: [null; 2 * $id::::lanes()], +- }; +- let vec = $id::::splat(non_null); +- unsafe { +- vec.write_to_slice_aligned( +- &mut aligned.data[$id::::lanes()..] +- ) +- }; +- for (index, &b) in +- unsafe { aligned.data.iter().enumerate() } { +- if index < $id::::lanes() { +- assert_eq!(b, null); +- } else { +- assert_eq!(b, non_null); +- assert_eq!( +- b, vec.extract(index - $id::::lanes()) +- ); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn write_to_slice_aligned_fail_lanes() { +- let (null, non_null) = ptr_vals!($id); +- let mut aligned = A { +- data: [null; 2 * $id::::lanes()], +- }; +- let vec = $id::::splat(non_null); +- // the slice is not large enough => panic +- unsafe { +- vec.write_to_slice_aligned( +- &mut aligned.data[2 * $id::::lanes()..] +- ) +- }; +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn write_to_slice_aligned_fail_align() { +- let (null, non_null) = ptr_vals!($id); +- unsafe { +- let mut aligned = A { +- data: [null; 2 * $id::::lanes()], +- }; +- +- // get a pointer to the front of data +- let ptr = aligned.data.as_mut_ptr(); +- // offset pointer by one element +- let ptr = ptr.wrapping_add(1); +- +- if ptr.align_offset( +- crate::mem::align_of::<$id>() +- ) == 0 { +- // the pointer is properly aligned, so +- // write_to_slice_aligned won't fail here (e.g. +- // this can happen for i128x1). So we panic to +- // make the "should_fail" test pass: +- panic!("ok"); +- } +- +- // create a slice - this is safe, because the +- // elements of the slice exist, are properly +- // initialized, and properly aligned: +- let s = slice::from_raw_parts_mut( +- ptr, $id::::lanes() +- ); +- // this should always panic because the slice +- // alignment does not match the alignment +- // requirements for the vector type: +- let vec = $id::::splat(non_null); +- vec.write_to_slice_aligned(s); +- } +- } +- } +- } +- } +- +- impl crate::hash::Hash for $id { +- #[inline] +- fn hash(&self, state: &mut H) { +- let s: $usize_ty = unsafe { crate::mem::transmute(*self) }; +- s.hash(state) +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _hash>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn hash() { +- use crate::hash::{Hash, Hasher}; +- #[allow(deprecated)] +- use crate::hash::{SipHasher13}; +- +- let values = [1_i32; $elem_count]; +- +- let mut vec: $id = Default::default(); +- let mut array = [ +- $id::::null().extract(0); +- $elem_count +- ]; +- +- for i in 0..$elem_count { +- let ptr = &values[i] as *const i32 as *mut i32; +- vec = vec.replace(i, ptr); +- array[i] = ptr; +- } +- +- #[allow(deprecated)] +- let mut a_hash = SipHasher13::new(); +- let mut v_hash = a_hash.clone(); +- array.hash(&mut a_hash); +- vec.hash(&mut v_hash); +- assert_eq!(a_hash.finish(), v_hash.finish()); +- } +- } +- } +- } +- +- impl $id { +- /// Calculates the offset from a pointer. +- /// +- /// `count` is in units of `T`; e.g. a count of `3` represents a +- /// pointer offset of `3 * size_of::()` bytes. +- /// +- /// # Safety +- /// +- /// If any of the following conditions are violated, the result is +- /// Undefined Behavior: +- /// +- /// * Both the starting and resulting pointer must be either in +- /// bounds or one byte past the end of an allocated object. +- /// +- /// * The computed offset, in bytes, cannot overflow an `isize`. +- /// +- /// * The offset being in bounds cannot rely on "wrapping around" +- /// the address space. That is, the infinite-precision sum, in bytes +- /// must fit in a `usize`. +- /// +- /// The compiler and standard library generally tries to ensure +- /// allocations never reach a size where an offset is a concern. For +- /// instance, `Vec` and `Box` ensure they never allocate more than +- /// `isize::MAX` bytes, so `vec.as_ptr().offset(vec.len() as isize)` +- /// is always safe. +- /// +- /// Most platforms fundamentally can't even construct such an +- /// allocation. For instance, no known 64-bit platform can ever +- /// serve a request for 263 bytes due to page-table limitations or +- /// splitting the address space. However, some 32-bit and 16-bit +- /// platforms may successfully serve a request for more than +- /// `isize::MAX` bytes with things like Physical Address Extension. +- /// As such, memory acquired directly from allocators or memory +- /// mapped files may be too large to handle with this function. +- /// +- /// Consider using `wrapping_offset` instead if these constraints +- /// are difficult to satisfy. The only advantage of this method is +- /// that it enables more aggressive compiler optimizations. +- #[inline] +- pub unsafe fn offset(self, count: $isize_ty) -> Self { +- // FIXME: should use LLVM's `add nsw nuw` +- self.wrapping_offset(count) +- } +- +- /// Calculates the offset from a pointer using wrapping arithmetic. +- /// +- /// `count` is in units of `T`; e.g. a count of `3` represents a +- /// pointer offset of `3 * size_of::()` bytes. +- /// +- /// # Safety +- /// +- /// The resulting pointer does not need to be in bounds, but it is +- /// potentially hazardous to dereference (which requires unsafe). +- /// +- /// Always use `.offset(count)` instead when possible, because +- /// offset allows the compiler to optimize better. +- #[inline] +- pub fn wrapping_offset(self, count: $isize_ty) -> Self { +- unsafe { +- let x: $isize_ty = crate::mem::transmute(self); +- // note: {+,*} currently performs a `wrapping_{add, mul}` +- crate::mem::transmute( +- x + (count * crate::mem::size_of::() as isize) +- ) +- } +- } +- +- /// Calculates the distance between two pointers. +- /// +- /// The returned value is in units of `T`: the distance in bytes is +- /// divided by `mem::size_of::()`. +- /// +- /// This function is the inverse of offset. +- /// +- /// # Safety +- /// +- /// If any of the following conditions are violated, the result is +- /// Undefined Behavior: +- /// +- /// * Both the starting and other pointer must be either in bounds +- /// or one byte past the end of the same allocated object. +- /// +- /// * The distance between the pointers, in bytes, cannot overflow +- /// an `isize`. +- /// +- /// * The distance between the pointers, in bytes, must be an exact +- /// multiple of the size of `T`. +- /// +- /// * The distance being in bounds cannot rely on "wrapping around" +- /// the address space. +- /// +- /// The compiler and standard library generally try to ensure +- /// allocations never reach a size where an offset is a concern. For +- /// instance, `Vec` and `Box` ensure they never allocate more than +- /// `isize::MAX` bytes, so `ptr_into_vec.offset_from(vec.as_ptr())` +- /// is always safe. +- /// +- /// Most platforms fundamentally can't even construct such an +- /// allocation. For instance, no known 64-bit platform can ever +- /// serve a request for 263 bytes due to page-table limitations or +- /// splitting the address space. However, some 32-bit and 16-bit +- /// platforms may successfully serve a request for more than +- /// `isize::MAX` bytes with things like Physical Address Extension. +- /// As such, memory acquired directly from allocators or memory +- /// mapped files may be too large to handle with this function. +- /// +- /// Consider using `wrapping_offset_from` instead if these constraints +- /// are difficult to satisfy. The only advantage of this method is +- /// that it enables more aggressive compiler optimizations. +- #[inline] +- pub unsafe fn offset_from(self, origin: Self) -> $isize_ty { +- // FIXME: should use LLVM's `sub nsw nuw`. +- self.wrapping_offset_from(origin) +- } +- +- /// Calculates the distance between two pointers. +- /// +- /// The returned value is in units of `T`: the distance in bytes is +- /// divided by `mem::size_of::()`. +- /// +- /// If the address different between the two pointers is not a +- /// multiple of `mem::size_of::()` then the result of the +- /// division is rounded towards zero. +- /// +- /// Though this method is safe for any two pointers, note that its +- /// result will be mostly useless if the two pointers aren't into +- /// the same allocated object, for example if they point to two +- /// different local variables. +- #[inline] +- pub fn wrapping_offset_from(self, origin: Self) -> $isize_ty { +- let x: $isize_ty = unsafe { crate::mem::transmute(self) }; +- let y: $isize_ty = unsafe { crate::mem::transmute(origin) }; +- // note: {-,/} currently perform wrapping_{sub, div} +- (y - x) / (crate::mem::size_of::() as isize) +- } +- +- /// Calculates the offset from a pointer (convenience for +- /// `.offset(count as isize)`). +- /// +- /// `count` is in units of `T`; e.g. a count of 3 represents a +- /// pointer offset of `3 * size_of::()` bytes. +- /// +- /// # Safety +- /// +- /// If any of the following conditions are violated, the result is +- /// Undefined Behavior: +- /// +- /// * Both the starting and resulting pointer must be either in +- /// bounds or one byte past the end of an allocated object. +- /// +- /// * The computed offset, in bytes, cannot overflow an `isize`. +- /// +- /// * The offset being in bounds cannot rely on "wrapping around" +- /// the address space. That is, the infinite-precision sum must fit +- /// in a `usize`. +- /// +- /// The compiler and standard library generally tries to ensure +- /// allocations never reach a size where an offset is a concern. For +- /// instance, `Vec` and `Box` ensure they never allocate more than +- /// `isize::MAX` bytes, so `vec.as_ptr().add(vec.len())` is always +- /// safe. +- /// +- /// Most platforms fundamentally can't even construct such an +- /// allocation. For instance, no known 64-bit platform can ever +- /// serve a request for 263 bytes due to page-table limitations or +- /// splitting the address space. However, some 32-bit and 16-bit +- /// platforms may successfully serve a request for more than +- /// `isize::MAX` bytes with things like Physical Address Extension. +- /// As such, memory acquired directly from allocators or memory +- /// mapped files may be too large to handle with this function. +- /// +- /// Consider using `wrapping_offset` instead if these constraints +- /// are difficult to satisfy. The only advantage of this method is +- /// that it enables more aggressive compiler optimizations. +- #[inline] +- #[allow(clippy::should_implement_trait)] +- pub unsafe fn add(self, count: $usize_ty) -> Self { +- self.offset(count.cast()) +- } +- +- /// Calculates the offset from a pointer (convenience for +- /// `.offset((count as isize).wrapping_neg())`). +- /// +- /// `count` is in units of T; e.g. a `count` of 3 represents a +- /// pointer offset of `3 * size_of::()` bytes. +- /// +- /// # Safety +- /// +- /// If any of the following conditions are violated, the result is +- /// Undefined Behavior: +- /// +- /// * Both the starting and resulting pointer must be either in +- /// bounds or one byte past the end of an allocated object. +- /// +- /// * The computed offset cannot exceed `isize::MAX` **bytes**. +- /// +- /// * The offset being in bounds cannot rely on "wrapping around" +- /// the address space. That is, the infinite-precision sum must fit +- /// in a usize. +- /// +- /// The compiler and standard library generally tries to ensure +- /// allocations never reach a size where an offset is a concern. For +- /// instance, `Vec` and `Box` ensure they never allocate more than +- /// `isize::MAX` bytes, so +- /// `vec.as_ptr().add(vec.len()).sub(vec.len())` is always safe. +- /// +- /// Most platforms fundamentally can't even construct such an +- /// allocation. For instance, no known 64-bit platform can ever +- /// serve a request for 263 bytes due to page-table +- /// limitations or splitting the address space. However, some 32-bit +- /// and 16-bit platforms may successfully serve a request for more +- /// than `isize::MAX` bytes with things like Physical Address +- /// Extension. As such, memory acquired directly from allocators or +- /// memory mapped files *may* be too large to handle with this +- /// function. +- /// +- /// Consider using `wrapping_offset` instead if these constraints +- /// are difficult to satisfy. The only advantage of this method is +- /// that it enables more aggressive compiler optimizations. +- #[inline] +- #[allow(clippy::should_implement_trait)] +- pub unsafe fn sub(self, count: $usize_ty) -> Self { +- let x: $isize_ty = count.cast(); +- // note: - is currently wrapping_neg +- self.offset(-x) +- } +- +- /// Calculates the offset from a pointer using wrapping arithmetic. +- /// (convenience for `.wrapping_offset(count as isize)`) +- /// +- /// `count` is in units of T; e.g. a `count` of 3 represents a +- /// pointer offset of `3 * size_of::()` bytes. +- /// +- /// # Safety +- /// +- /// The resulting pointer does not need to be in bounds, but it is +- /// potentially hazardous to dereference (which requires `unsafe`). +- /// +- /// Always use `.add(count)` instead when possible, because `add` +- /// allows the compiler to optimize better. +- #[inline] +- pub fn wrapping_add(self, count: $usize_ty) -> Self { +- self.wrapping_offset(count.cast()) +- } +- +- /// Calculates the offset from a pointer using wrapping arithmetic. +- /// (convenience for `.wrapping_offset((count as +- /// isize).wrapping_sub())`) +- /// +- /// `count` is in units of T; e.g. a `count` of 3 represents a +- /// pointer offset of `3 * size_of::()` bytes. +- /// +- /// # Safety +- /// +- /// The resulting pointer does not need to be in bounds, but it is +- /// potentially hazardous to dereference (which requires `unsafe`). +- /// +- /// Always use `.sub(count)` instead when possible, because `sub` +- /// allows the compiler to optimize better. +- #[inline] +- pub fn wrapping_sub(self, count: $usize_ty) -> Self { +- let x: $isize_ty = count.cast(); +- self.wrapping_offset(-1 * x) +- } +- } +- +- impl $id { +- /// Shuffle vector elements according to `indices`. +- #[inline] +- pub fn shuffle1_dyn(self, indices: I) -> Self +- where +- Self: codegen::shuffle1_dyn::Shuffle1Dyn, +- { +- codegen::shuffle1_dyn::Shuffle1Dyn::shuffle1_dyn(self, indices) +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _shuffle1_dyn>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn shuffle1_dyn() { +- let (null, non_null) = ptr_vals!($id); +- +- // alternating = [non_null, null, non_null, null, ...] +- let mut alternating = $id::::splat(null); +- for i in 0..$id::::lanes() { +- if i % 2 == 0 { +- alternating = alternating.replace(i, non_null); +- } +- } +- +- type Indices = <$id +- as codegen::shuffle1_dyn::Shuffle1Dyn>::Indices; +- // even = [0, 0, 2, 2, 4, 4, ..] +- let even = { +- let mut v = Indices::splat(0); +- for i in 0..$id::::lanes() { +- if i % 2 == 0 { +- v = v.replace(i, (i as u8).into()); +- } else { +- v = v.replace(i, (i as u8 - 1).into()); +- } +- } +- v +- }; +- // odd = [1, 1, 3, 3, 5, 5, ...] +- let odd = { +- let mut v = Indices::splat(0); +- for i in 0..$id::::lanes() { +- if i % 2 != 0 { +- v = v.replace(i, (i as u8).into()); +- } else { +- v = v.replace(i, (i as u8 + 1).into()); +- } +- } +- v +- }; +- +- assert_eq!( +- alternating.shuffle1_dyn(even), +- $id::::splat(non_null) +- ); +- if $id::::lanes() > 1 { +- assert_eq!( +- alternating.shuffle1_dyn(odd), +- $id::::splat(null) +- ); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops.rs b/third_party/rust/packed_simd/src/api/ops.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops.rs ++++ /dev/null +@@ -1,32 +0,0 @@ +-//! Implementation of the `ops` traits +-#[macro_use] +-mod vector_mask_bitwise; +-#[macro_use] +-mod scalar_mask_bitwise; +- +-#[macro_use] +-mod vector_arithmetic; +-#[macro_use] +-mod scalar_arithmetic; +- +-#[macro_use] +-mod vector_bitwise; +-#[macro_use] +-mod scalar_bitwise; +- +-#[macro_use] +-mod vector_shifts; +-#[macro_use] +-mod scalar_shifts; +- +-#[macro_use] +-mod vector_rotates; +- +-#[macro_use] +-mod vector_neg; +- +-#[macro_use] +-mod vector_int_min_max; +- +-#[macro_use] +-mod vector_float_min_max; +diff --git a/third_party/rust/packed_simd/src/api/ops/scalar_arithmetic.rs b/third_party/rust/packed_simd/src/api/ops/scalar_arithmetic.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/scalar_arithmetic.rs ++++ /dev/null +@@ -1,203 +0,0 @@ +-//! Vertical (lane-wise) vector-scalar / scalar-vector arithmetic operations. +- +-macro_rules! impl_ops_scalar_arithmetic { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::ops::Add<$elem_ty> for $id { +- type Output = Self; +- #[inline] +- fn add(self, other: $elem_ty) -> Self { +- self + $id::splat(other) +- } +- } +- impl crate::ops::Add<$id> for $elem_ty { +- type Output = $id; +- #[inline] +- fn add(self, other: $id) -> $id { +- $id::splat(self) + other +- } +- } +- +- impl crate::ops::Sub<$elem_ty> for $id { +- type Output = Self; +- #[inline] +- fn sub(self, other: $elem_ty) -> Self { +- self - $id::splat(other) +- } +- } +- impl crate::ops::Sub<$id> for $elem_ty { +- type Output = $id; +- #[inline] +- fn sub(self, other: $id) -> $id { +- $id::splat(self) - other +- } +- } +- +- impl crate::ops::Mul<$elem_ty> for $id { +- type Output = Self; +- #[inline] +- fn mul(self, other: $elem_ty) -> Self { +- self * $id::splat(other) +- } +- } +- impl crate::ops::Mul<$id> for $elem_ty { +- type Output = $id; +- #[inline] +- fn mul(self, other: $id) -> $id { +- $id::splat(self) * other +- } +- } +- +- impl crate::ops::Div<$elem_ty> for $id { +- type Output = Self; +- #[inline] +- fn div(self, other: $elem_ty) -> Self { +- self / $id::splat(other) +- } +- } +- impl crate::ops::Div<$id> for $elem_ty { +- type Output = $id; +- #[inline] +- fn div(self, other: $id) -> $id { +- $id::splat(self) / other +- } +- } +- +- impl crate::ops::Rem<$elem_ty> for $id { +- type Output = Self; +- #[inline] +- fn rem(self, other: $elem_ty) -> Self { +- self % $id::splat(other) +- } +- } +- impl crate::ops::Rem<$id> for $elem_ty { +- type Output = $id; +- #[inline] +- fn rem(self, other: $id) -> $id { +- $id::splat(self) % other +- } +- } +- +- impl crate::ops::AddAssign<$elem_ty> for $id { +- #[inline] +- fn add_assign(&mut self, other: $elem_ty) { +- *self = *self + other; +- } +- } +- +- impl crate::ops::SubAssign<$elem_ty> for $id { +- #[inline] +- fn sub_assign(&mut self, other: $elem_ty) { +- *self = *self - other; +- } +- } +- +- impl crate::ops::MulAssign<$elem_ty> for $id { +- #[inline] +- fn mul_assign(&mut self, other: $elem_ty) { +- *self = *self * other; +- } +- } +- +- impl crate::ops::DivAssign<$elem_ty> for $id { +- #[inline] +- fn div_assign(&mut self, other: $elem_ty) { +- *self = *self / other; +- } +- } +- +- impl crate::ops::RemAssign<$elem_ty> for $id { +- #[inline] +- fn rem_assign(&mut self, other: $elem_ty) { +- *self = *self % other; +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_scalar_arith>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn ops_scalar_arithmetic() { +- let zi = 0 as $elem_ty; +- let oi = 1 as $elem_ty; +- let ti = 2 as $elem_ty; +- let fi = 4 as $elem_ty; +- let z = $id::splat(zi); +- let o = $id::splat(oi); +- let t = $id::splat(ti); +- let f = $id::splat(fi); +- +- // add +- assert_eq!(zi + z, z); +- assert_eq!(z + zi, z); +- assert_eq!(oi + z, o); +- assert_eq!(o + zi, o); +- assert_eq!(ti + z, t); +- assert_eq!(t + zi, t); +- assert_eq!(ti + t, f); +- assert_eq!(t + ti, f); +- // sub +- assert_eq!(zi - z, z); +- assert_eq!(z - zi, z); +- assert_eq!(oi - z, o); +- assert_eq!(o - zi, o); +- assert_eq!(ti - z, t); +- assert_eq!(t - zi, t); +- assert_eq!(fi - t, t); +- assert_eq!(f - ti, t); +- assert_eq!(f - o - o, t); +- assert_eq!(f - oi - oi, t); +- // mul +- assert_eq!(zi * z, z); +- assert_eq!(z * zi, z); +- assert_eq!(zi * o, z); +- assert_eq!(z * oi, z); +- assert_eq!(zi * t, z); +- assert_eq!(z * ti, z); +- assert_eq!(oi * t, t); +- assert_eq!(o * ti, t); +- assert_eq!(ti * t, f); +- assert_eq!(t * ti, f); +- // div +- assert_eq!(zi / o, z); +- assert_eq!(z / oi, z); +- assert_eq!(ti / o, t); +- assert_eq!(t / oi, t); +- assert_eq!(fi / o, f); +- assert_eq!(f / oi, f); +- assert_eq!(ti / t, o); +- assert_eq!(t / ti, o); +- assert_eq!(fi / t, t); +- assert_eq!(f / ti, t); +- // rem +- assert_eq!(oi % o, z); +- assert_eq!(o % oi, z); +- assert_eq!(fi % t, z); +- assert_eq!(f % ti, z); +- +- { +- let mut v = z; +- assert_eq!(v, z); +- v += oi; // add_assign +- assert_eq!(v, o); +- v -= oi; // sub_assign +- assert_eq!(v, z); +- v = t; +- v *= oi; // mul_assign +- assert_eq!(v, t); +- v *= ti; +- assert_eq!(v, f); +- v /= oi; // div_assign +- assert_eq!(v, f); +- v /= ti; +- assert_eq!(v, t); +- v %= ti; // rem_assign +- assert_eq!(v, z); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/scalar_bitwise.rs b/third_party/rust/packed_simd/src/api/ops/scalar_bitwise.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/scalar_bitwise.rs ++++ /dev/null +@@ -1,162 +0,0 @@ +-//! Vertical (lane-wise) vector-scalar / scalar-vector bitwise operations. +- +-macro_rules! impl_ops_scalar_bitwise { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident | $test_tt:tt | +- ($true:expr, $false:expr) +- ) => { +- impl crate::ops::BitXor<$elem_ty> for $id { +- type Output = Self; +- #[inline] +- fn bitxor(self, other: $elem_ty) -> Self { +- self ^ $id::splat(other) +- } +- } +- impl crate::ops::BitXor<$id> for $elem_ty { +- type Output = $id; +- #[inline] +- fn bitxor(self, other: $id) -> $id { +- $id::splat(self) ^ other +- } +- } +- +- impl crate::ops::BitAnd<$elem_ty> for $id { +- type Output = Self; +- #[inline] +- fn bitand(self, other: $elem_ty) -> Self { +- self & $id::splat(other) +- } +- } +- impl crate::ops::BitAnd<$id> for $elem_ty { +- type Output = $id; +- #[inline] +- fn bitand(self, other: $id) -> $id { +- $id::splat(self) & other +- } +- } +- +- impl crate::ops::BitOr<$elem_ty> for $id { +- type Output = Self; +- #[inline] +- fn bitor(self, other: $elem_ty) -> Self { +- self | $id::splat(other) +- } +- } +- impl crate::ops::BitOr<$id> for $elem_ty { +- type Output = $id; +- #[inline] +- fn bitor(self, other: $id) -> $id { +- $id::splat(self) | other +- } +- } +- +- impl crate::ops::BitAndAssign<$elem_ty> for $id { +- #[inline] +- fn bitand_assign(&mut self, other: $elem_ty) { +- *self = *self & other; +- } +- } +- impl crate::ops::BitOrAssign<$elem_ty> for $id { +- #[inline] +- fn bitor_assign(&mut self, other: $elem_ty) { +- *self = *self | other; +- } +- } +- impl crate::ops::BitXorAssign<$elem_ty> for $id { +- #[inline] +- fn bitxor_assign(&mut self, other: $elem_ty) { +- *self = *self ^ other; +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_scalar_bitwise>] { +- use super::*; +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn ops_scalar_bitwise() { +- let zi = 0 as $elem_ty; +- let oi = 1 as $elem_ty; +- let ti = 2 as $elem_ty; +- let z = $id::splat(zi); +- let o = $id::splat(oi); +- let t = $id::splat(ti); +- +- // BitAnd: +- assert_eq!(oi & o, o); +- assert_eq!(o & oi, o); +- assert_eq!(oi & z, z); +- assert_eq!(o & zi, z); +- assert_eq!(zi & o, z); +- assert_eq!(z & oi, z); +- assert_eq!(zi & z, z); +- assert_eq!(z & zi, z); +- +- assert_eq!(ti & t, t); +- assert_eq!(t & ti, t); +- assert_eq!(ti & o, z); +- assert_eq!(t & oi, z); +- assert_eq!(oi & t, z); +- assert_eq!(o & ti, z); +- +- // BitOr: +- assert_eq!(oi | o, o); +- assert_eq!(o | oi, o); +- assert_eq!(oi | z, o); +- assert_eq!(o | zi, o); +- assert_eq!(zi | o, o); +- assert_eq!(z | oi, o); +- assert_eq!(zi | z, z); +- assert_eq!(z | zi, z); +- +- assert_eq!(ti | t, t); +- assert_eq!(t | ti, t); +- assert_eq!(zi | t, t); +- assert_eq!(z | ti, t); +- assert_eq!(ti | z, t); +- assert_eq!(t | zi, t); +- +- // BitXOR: +- assert_eq!(oi ^ o, z); +- assert_eq!(o ^ oi, z); +- assert_eq!(zi ^ z, z); +- assert_eq!(z ^ zi, z); +- assert_eq!(zi ^ o, o); +- assert_eq!(z ^ oi, o); +- assert_eq!(oi ^ z, o); +- assert_eq!(o ^ zi, o); +- +- assert_eq!(ti ^ t, z); +- assert_eq!(t ^ ti, z); +- assert_eq!(ti ^ z, t); +- assert_eq!(t ^ zi, t); +- assert_eq!(zi ^ t, t); +- assert_eq!(z ^ ti, t); +- +- { +- // AndAssign: +- let mut v = o; +- v &= ti; +- assert_eq!(v, z); +- } +- { +- // OrAssign: +- let mut v = z; +- v |= oi; +- assert_eq!(v, o); +- } +- { +- // XORAssign: +- let mut v = z; +- v ^= oi; +- assert_eq!(v, o); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/scalar_mask_bitwise.rs b/third_party/rust/packed_simd/src/api/ops/scalar_mask_bitwise.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/scalar_mask_bitwise.rs ++++ /dev/null +@@ -1,140 +0,0 @@ +-//! Vertical (lane-wise) vector-vector bitwise operations. +- +-macro_rules! impl_ops_scalar_mask_bitwise { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident | $test_tt:tt | +- ($true:expr, $false:expr) +- ) => { +- impl crate::ops::BitXor for $id { +- type Output = Self; +- #[inline] +- fn bitxor(self, other: bool) -> Self { +- self ^ $id::splat(other) +- } +- } +- impl crate::ops::BitXor<$id> for bool { +- type Output = $id; +- #[inline] +- fn bitxor(self, other: $id) -> $id { +- $id::splat(self) ^ other +- } +- } +- +- impl crate::ops::BitAnd for $id { +- type Output = Self; +- #[inline] +- fn bitand(self, other: bool) -> Self { +- self & $id::splat(other) +- } +- } +- impl crate::ops::BitAnd<$id> for bool { +- type Output = $id; +- #[inline] +- fn bitand(self, other: $id) -> $id { +- $id::splat(self) & other +- } +- } +- +- impl crate::ops::BitOr for $id { +- type Output = Self; +- #[inline] +- fn bitor(self, other: bool) -> Self { +- self | $id::splat(other) +- } +- } +- impl crate::ops::BitOr<$id> for bool { +- type Output = $id; +- #[inline] +- fn bitor(self, other: $id) -> $id { +- $id::splat(self) | other +- } +- } +- +- impl crate::ops::BitAndAssign for $id { +- #[inline] +- fn bitand_assign(&mut self, other: bool) { +- *self = *self & other; +- } +- } +- impl crate::ops::BitOrAssign for $id { +- #[inline] +- fn bitor_assign(&mut self, other: bool) { +- *self = *self | other; +- } +- } +- impl crate::ops::BitXorAssign for $id { +- #[inline] +- fn bitxor_assign(&mut self, other: bool) { +- *self = *self ^ other; +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_scalar_mask_bitwise>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn ops_scalar_mask_bitwise() { +- let ti = true; +- let fi = false; +- let t = $id::splat(ti); +- let f = $id::splat(fi); +- assert!(t != f); +- assert!(!(t == f)); +- +- // BitAnd: +- assert_eq!(ti & f, f); +- assert_eq!(t & fi, f); +- assert_eq!(fi & t, f); +- assert_eq!(f & ti, f); +- assert_eq!(ti & t, t); +- assert_eq!(t & ti, t); +- assert_eq!(fi & f, f); +- assert_eq!(f & fi, f); +- +- // BitOr: +- assert_eq!(ti | f, t); +- assert_eq!(t | fi, t); +- assert_eq!(fi | t, t); +- assert_eq!(f | ti, t); +- assert_eq!(ti | t, t); +- assert_eq!(t | ti, t); +- assert_eq!(fi | f, f); +- assert_eq!(f | fi, f); +- +- // BitXOR: +- assert_eq!(ti ^ f, t); +- assert_eq!(t ^ fi, t); +- assert_eq!(fi ^ t, t); +- assert_eq!(f ^ ti, t); +- assert_eq!(ti ^ t, f); +- assert_eq!(t ^ ti, f); +- assert_eq!(fi ^ f, f); +- assert_eq!(f ^ fi, f); +- +- { +- // AndAssign: +- let mut v = f; +- v &= ti; +- assert_eq!(v, f); +- } +- { +- // OrAssign: +- let mut v = f; +- v |= ti; +- assert_eq!(v, t); +- } +- { +- // XORAssign: +- let mut v = f; +- v ^= ti; +- assert_eq!(v, t); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/scalar_shifts.rs b/third_party/rust/packed_simd/src/api/ops/scalar_shifts.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/scalar_shifts.rs ++++ /dev/null +@@ -1,106 +0,0 @@ +-//! Vertical (lane-wise) vector-scalar shifts operations. +- +-macro_rules! impl_ops_scalar_shifts { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::ops::Shl for $id { +- type Output = Self; +- #[inline] +- fn shl(self, other: u32) -> Self { +- self << $id::splat(other as $elem_ty) +- } +- } +- impl crate::ops::Shr for $id { +- type Output = Self; +- #[inline] +- fn shr(self, other: u32) -> Self { +- self >> $id::splat(other as $elem_ty) +- } +- } +- +- impl crate::ops::ShlAssign for $id { +- #[inline] +- fn shl_assign(&mut self, other: u32) { +- *self = *self << other; +- } +- } +- impl crate::ops::ShrAssign for $id { +- #[inline] +- fn shr_assign(&mut self, other: u32) { +- *self = *self >> other; +- } +- } +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_scalar_shifts>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg_attr(any(target_arch = "s390x", target_arch = "sparc64"), +- allow(unreachable_code, unused_variables) +- )] +- #[cfg(not(target_arch = "aarch64"))] +- //~^ FIXME: https://github.com/rust-lang/packed_simd/issues/317 +- fn ops_scalar_shifts() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- let f = $id::splat(4 as $elem_ty); +- +- { +- let zi = 0 as u32; +- let oi = 1 as u32; +- let ti = 2 as u32; +- let maxi +- = (mem::size_of::<$elem_ty>() * 8 - 1) as u32; +- +- // shr +- assert_eq!(z >> zi, z); +- assert_eq!(z >> oi, z); +- assert_eq!(z >> ti, z); +- assert_eq!(z >> ti, z); +- +- #[cfg(any(target_arch = "s390x", target_arch = "sparc64"))] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/13 +- return; +- } +- +- assert_eq!(o >> zi, o); +- assert_eq!(t >> zi, t); +- assert_eq!(f >> zi, f); +- assert_eq!(f >> maxi, z); +- +- assert_eq!(o >> oi, z); +- assert_eq!(t >> oi, o); +- assert_eq!(t >> ti, z); +- assert_eq!(f >> oi, t); +- assert_eq!(f >> ti, o); +- assert_eq!(f >> maxi, z); +- +- // shl +- assert_eq!(z << zi, z); +- assert_eq!(o << zi, o); +- assert_eq!(t << zi, t); +- assert_eq!(f << zi, f); +- assert_eq!(f << maxi, z); +- +- assert_eq!(o << oi, t); +- assert_eq!(o << ti, f); +- assert_eq!(t << oi, f); +- +- { // shr_assign +- let mut v = o; +- v >>= oi; +- assert_eq!(v, z); +- } +- { // shl_assign +- let mut v = o; +- v <<= oi; +- assert_eq!(v, t); +- } +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/vector_arithmetic.rs b/third_party/rust/packed_simd/src/api/ops/vector_arithmetic.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/vector_arithmetic.rs ++++ /dev/null +@@ -1,148 +0,0 @@ +-//! Vertical (lane-wise) vector-vector arithmetic operations. +- +-macro_rules! impl_ops_vector_arithmetic { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::ops::Add for $id { +- type Output = Self; +- #[inline] +- fn add(self, other: Self) -> Self { +- use crate::llvm::simd_add; +- unsafe { Simd(simd_add(self.0, other.0)) } +- } +- } +- +- impl crate::ops::Sub for $id { +- type Output = Self; +- #[inline] +- fn sub(self, other: Self) -> Self { +- use crate::llvm::simd_sub; +- unsafe { Simd(simd_sub(self.0, other.0)) } +- } +- } +- +- impl crate::ops::Mul for $id { +- type Output = Self; +- #[inline] +- fn mul(self, other: Self) -> Self { +- use crate::llvm::simd_mul; +- unsafe { Simd(simd_mul(self.0, other.0)) } +- } +- } +- +- impl crate::ops::Div for $id { +- type Output = Self; +- #[inline] +- fn div(self, other: Self) -> Self { +- use crate::llvm::simd_div; +- unsafe { Simd(simd_div(self.0, other.0)) } +- } +- } +- +- impl crate::ops::Rem for $id { +- type Output = Self; +- #[inline] +- fn rem(self, other: Self) -> Self { +- use crate::llvm::simd_rem; +- unsafe { Simd(simd_rem(self.0, other.0)) } +- } +- } +- +- impl crate::ops::AddAssign for $id { +- #[inline] +- fn add_assign(&mut self, other: Self) { +- *self = *self + other; +- } +- } +- +- impl crate::ops::SubAssign for $id { +- #[inline] +- fn sub_assign(&mut self, other: Self) { +- *self = *self - other; +- } +- } +- +- impl crate::ops::MulAssign for $id { +- #[inline] +- fn mul_assign(&mut self, other: Self) { +- *self = *self * other; +- } +- } +- +- impl crate::ops::DivAssign for $id { +- #[inline] +- fn div_assign(&mut self, other: Self) { +- *self = *self / other; +- } +- } +- +- impl crate::ops::RemAssign for $id { +- #[inline] +- fn rem_assign(&mut self, other: Self) { +- *self = *self % other; +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_vector_arith>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn ops_vector_arithmetic() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- let f = $id::splat(4 as $elem_ty); +- +- // add +- assert_eq!(z + z, z); +- assert_eq!(o + z, o); +- assert_eq!(t + z, t); +- assert_eq!(t + t, f); +- // sub +- assert_eq!(z - z, z); +- assert_eq!(o - z, o); +- assert_eq!(t - z, t); +- assert_eq!(f - t, t); +- assert_eq!(f - o - o, t); +- // mul +- assert_eq!(z * z, z); +- assert_eq!(z * o, z); +- assert_eq!(z * t, z); +- assert_eq!(o * t, t); +- assert_eq!(t * t, f); +- // div +- assert_eq!(z / o, z); +- assert_eq!(t / o, t); +- assert_eq!(f / o, f); +- assert_eq!(t / t, o); +- assert_eq!(f / t, t); +- // rem +- assert_eq!(o % o, z); +- assert_eq!(f % t, z); +- +- { +- let mut v = z; +- assert_eq!(v, z); +- v += o; // add_assign +- assert_eq!(v, o); +- v -= o; // sub_assign +- assert_eq!(v, z); +- v = t; +- v *= o; // mul_assign +- assert_eq!(v, t); +- v *= t; +- assert_eq!(v, f); +- v /= o; // div_assign +- assert_eq!(v, f); +- v /= t; +- assert_eq!(v, t); +- v %= t; // rem_assign +- assert_eq!(v, z); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/vector_bitwise.rs b/third_party/rust/packed_simd/src/api/ops/vector_bitwise.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/vector_bitwise.rs ++++ /dev/null +@@ -1,129 +0,0 @@ +-//! Vertical (lane-wise) vector-vector bitwise operations. +- +-macro_rules! impl_ops_vector_bitwise { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident | $test_tt:tt | +- ($true:expr, $false:expr) +- ) => { +- impl crate::ops::Not for $id { +- type Output = Self; +- #[inline] +- fn not(self) -> Self { +- Self::splat($true) ^ self +- } +- } +- impl crate::ops::BitXor for $id { +- type Output = Self; +- #[inline] +- fn bitxor(self, other: Self) -> Self { +- use crate::llvm::simd_xor; +- unsafe { Simd(simd_xor(self.0, other.0)) } +- } +- } +- impl crate::ops::BitAnd for $id { +- type Output = Self; +- #[inline] +- fn bitand(self, other: Self) -> Self { +- use crate::llvm::simd_and; +- unsafe { Simd(simd_and(self.0, other.0)) } +- } +- } +- impl crate::ops::BitOr for $id { +- type Output = Self; +- #[inline] +- fn bitor(self, other: Self) -> Self { +- use crate::llvm::simd_or; +- unsafe { Simd(simd_or(self.0, other.0)) } +- } +- } +- impl crate::ops::BitAndAssign for $id { +- #[inline] +- fn bitand_assign(&mut self, other: Self) { +- *self = *self & other; +- } +- } +- impl crate::ops::BitOrAssign for $id { +- #[inline] +- fn bitor_assign(&mut self, other: Self) { +- *self = *self | other; +- } +- } +- impl crate::ops::BitXorAssign for $id { +- #[inline] +- fn bitxor_assign(&mut self, other: Self) { +- *self = *self ^ other; +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_vector_bitwise>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn ops_vector_bitwise() { +- +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- let m = $id::splat(!z.extract(0)); +- +- // Not: +- assert_eq!(!z, m); +- assert_eq!(!m, z); +- +- // BitAnd: +- assert_eq!(o & o, o); +- assert_eq!(o & z, z); +- assert_eq!(z & o, z); +- assert_eq!(z & z, z); +- +- assert_eq!(t & t, t); +- assert_eq!(t & o, z); +- assert_eq!(o & t, z); +- +- // BitOr: +- assert_eq!(o | o, o); +- assert_eq!(o | z, o); +- assert_eq!(z | o, o); +- assert_eq!(z | z, z); +- +- assert_eq!(t | t, t); +- assert_eq!(z | t, t); +- assert_eq!(t | z, t); +- +- // BitXOR: +- assert_eq!(o ^ o, z); +- assert_eq!(z ^ z, z); +- assert_eq!(z ^ o, o); +- assert_eq!(o ^ z, o); +- +- assert_eq!(t ^ t, z); +- assert_eq!(t ^ z, t); +- assert_eq!(z ^ t, t); +- +- { +- // AndAssign: +- let mut v = o; +- v &= t; +- assert_eq!(v, z); +- } +- { +- // OrAssign: +- let mut v = z; +- v |= o; +- assert_eq!(v, o); +- } +- { +- // XORAssign: +- let mut v = z; +- v ^= o; +- assert_eq!(v, o); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/vector_float_min_max.rs b/third_party/rust/packed_simd/src/api/ops/vector_float_min_max.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/vector_float_min_max.rs ++++ /dev/null +@@ -1,74 +0,0 @@ +-//! Vertical (lane-wise) vector `min` and `max` for floating-point vectors. +- +-macro_rules! impl_ops_vector_float_min_max { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Minimum of two vectors. +- /// +- /// Returns a new vector containing the minimum value of each of +- /// the input vector lanes. +- #[inline] +- pub fn min(self, x: Self) -> Self { +- use crate::llvm::simd_fmin; +- unsafe { Simd(simd_fmin(self.0, x.0)) } +- } +- +- /// Maximum of two vectors. +- /// +- /// Returns a new vector containing the maximum value of each of +- /// the input vector lanes. +- #[inline] +- pub fn max(self, x: Self) -> Self { +- use crate::llvm::simd_fmax; +- unsafe { Simd(simd_fmax(self.0, x.0)) } +- } +- } +- test_if!{ +- $test_tt: +- paste::item! { +- #[cfg(not(any( +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/223 +- all(target_arch = "mips", target_endian = "big"), +- target_arch = "mips64", +- )))] +- pub mod [<$id _ops_vector_min_max>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn min_max() { +- let n = crate::$elem_ty::NAN; +- let o = $id::splat(1. as $elem_ty); +- let t = $id::splat(2. as $elem_ty); +- +- let mut m = o; // [1., 2., 1., 2., ...] +- let mut on = o; +- for i in 0..$id::lanes() { +- if i % 2 == 0 { +- m = m.replace(i, 2. as $elem_ty); +- on = on.replace(i, n); +- } +- } +- +- assert_eq!(o.min(t), o); +- assert_eq!(t.min(o), o); +- assert_eq!(m.min(o), o); +- assert_eq!(o.min(m), o); +- assert_eq!(m.min(t), m); +- assert_eq!(t.min(m), m); +- +- assert_eq!(o.max(t), t); +- assert_eq!(t.max(o), t); +- assert_eq!(m.max(o), m); +- assert_eq!(o.max(m), m); +- assert_eq!(m.max(t), t); +- assert_eq!(t.max(m), t); +- +- assert_eq!(on.min(o), o); +- assert_eq!(o.min(on), o); +- assert_eq!(on.max(o), o); +- assert_eq!(o.max(on), o); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/vector_int_min_max.rs b/third_party/rust/packed_simd/src/api/ops/vector_int_min_max.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/vector_int_min_max.rs ++++ /dev/null +@@ -1,57 +0,0 @@ +-//! Vertical (lane-wise) vector `min` and `max` for integer vectors. +- +-macro_rules! impl_ops_vector_int_min_max { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Minimum of two vectors. +- /// +- /// Returns a new vector containing the minimum value of each of +- /// the input vector lanes. +- #[inline] +- pub fn min(self, x: Self) -> Self { +- self.lt(x).select(self, x) +- } +- +- /// Maximum of two vectors. +- /// +- /// Returns a new vector containing the maximum value of each of +- /// the input vector lanes. +- #[inline] +- pub fn max(self, x: Self) -> Self { +- self.gt(x).select(self, x) +- } +- } +- test_if!{$test_tt: +- paste::item! { +- pub mod [<$id _ops_vector_min_max>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn min_max() { +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- +- let mut m = o; +- for i in 0..$id::lanes() { +- if i % 2 == 0 { +- m = m.replace(i, 2 as $elem_ty); +- } +- } +- assert_eq!(o.min(t), o); +- assert_eq!(t.min(o), o); +- assert_eq!(m.min(o), o); +- assert_eq!(o.min(m), o); +- assert_eq!(m.min(t), m); +- assert_eq!(t.min(m), m); +- +- assert_eq!(o.max(t), t); +- assert_eq!(t.max(o), t); +- assert_eq!(m.max(o), m); +- assert_eq!(o.max(m), m); +- assert_eq!(m.max(t), t); +- assert_eq!(t.max(m), t); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/vector_mask_bitwise.rs b/third_party/rust/packed_simd/src/api/ops/vector_mask_bitwise.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/vector_mask_bitwise.rs ++++ /dev/null +@@ -1,116 +0,0 @@ +-//! Vertical (lane-wise) vector-vector bitwise operations. +- +-macro_rules! impl_ops_vector_mask_bitwise { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident | $test_tt:tt | +- ($true:expr, $false:expr) +- ) => { +- impl crate::ops::Not for $id { +- type Output = Self; +- #[inline] +- fn not(self) -> Self { +- Self::splat($true) ^ self +- } +- } +- impl crate::ops::BitXor for $id { +- type Output = Self; +- #[inline] +- fn bitxor(self, other: Self) -> Self { +- use crate::llvm::simd_xor; +- unsafe { Simd(simd_xor(self.0, other.0)) } +- } +- } +- impl crate::ops::BitAnd for $id { +- type Output = Self; +- #[inline] +- fn bitand(self, other: Self) -> Self { +- use crate::llvm::simd_and; +- unsafe { Simd(simd_and(self.0, other.0)) } +- } +- } +- impl crate::ops::BitOr for $id { +- type Output = Self; +- #[inline] +- fn bitor(self, other: Self) -> Self { +- use crate::llvm::simd_or; +- unsafe { Simd(simd_or(self.0, other.0)) } +- } +- } +- impl crate::ops::BitAndAssign for $id { +- #[inline] +- fn bitand_assign(&mut self, other: Self) { +- *self = *self & other; +- } +- } +- impl crate::ops::BitOrAssign for $id { +- #[inline] +- fn bitor_assign(&mut self, other: Self) { +- *self = *self | other; +- } +- } +- impl crate::ops::BitXorAssign for $id { +- #[inline] +- fn bitxor_assign(&mut self, other: Self) { +- *self = *self ^ other; +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_vector_mask_bitwise>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn ops_vector_mask_bitwise() { +- let t = $id::splat(true); +- let f = $id::splat(false); +- assert!(t != f); +- assert!(!(t == f)); +- +- // Not: +- assert_eq!(!t, f); +- assert_eq!(t, !f); +- +- // BitAnd: +- assert_eq!(t & f, f); +- assert_eq!(f & t, f); +- assert_eq!(t & t, t); +- assert_eq!(f & f, f); +- +- // BitOr: +- assert_eq!(t | f, t); +- assert_eq!(f | t, t); +- assert_eq!(t | t, t); +- assert_eq!(f | f, f); +- +- // BitXOR: +- assert_eq!(t ^ f, t); +- assert_eq!(f ^ t, t); +- assert_eq!(t ^ t, f); +- assert_eq!(f ^ f, f); +- +- { +- // AndAssign: +- let mut v = f; +- v &= t; +- assert_eq!(v, f); +- } +- { +- // OrAssign: +- let mut v = f; +- v |= t; +- assert_eq!(v, t); +- } +- { +- // XORAssign: +- let mut v = f; +- v ^= t; +- assert_eq!(v, t); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/vector_neg.rs b/third_party/rust/packed_simd/src/api/ops/vector_neg.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/vector_neg.rs ++++ /dev/null +@@ -1,43 +0,0 @@ +-//! Vertical (lane-wise) vector `Neg`. +- +-macro_rules! impl_ops_vector_neg { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::ops::Neg for $id { +- type Output = Self; +- #[inline] +- fn neg(self) -> Self { +- Self::splat(-1 as $elem_ty) * self +- } +- } +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_vector_neg>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn neg() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- let f = $id::splat(4 as $elem_ty); +- +- let nz = $id::splat(-(0 as $elem_ty)); +- let no = $id::splat(-(1 as $elem_ty)); +- let nt = $id::splat(-(2 as $elem_ty)); +- let nf = $id::splat(-(4 as $elem_ty)); +- +- assert_eq!(-z, nz); +- assert_eq!(-o, no); +- assert_eq!(-t, nt); +- assert_eq!(-f, nf); +- +- assert_eq!(z, -nz); +- assert_eq!(o, -no); +- assert_eq!(t, -nt); +- assert_eq!(f, -nf); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/vector_rotates.rs b/third_party/rust/packed_simd/src/api/ops/vector_rotates.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/vector_rotates.rs ++++ /dev/null +@@ -1,92 +0,0 @@ +-//! Vertical (lane-wise) vector rotates operations. +-#![allow(unused)] +- +-macro_rules! impl_ops_vector_rotates { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Shifts the bits of each lane to the left by the specified +- /// amount in the corresponding lane of `n`, wrapping the +- /// truncated bits to the end of the resulting integer. +- /// +- /// Note: this is neither the same operation as `<<` nor equivalent +- /// to `slice::rotate_left`. +- #[inline] +- pub fn rotate_left(self, n: $id) -> $id { +- const LANE_WIDTH: $elem_ty = +- crate::mem::size_of::<$elem_ty>() as $elem_ty * 8; +- // Protect against undefined behavior for over-long bit shifts +- let n = n % LANE_WIDTH; +- (self << n) | (self >> ((LANE_WIDTH - n) % LANE_WIDTH)) +- } +- +- /// Shifts the bits of each lane to the right by the specified +- /// amount in the corresponding lane of `n`, wrapping the +- /// truncated bits to the beginning of the resulting integer. +- /// +- /// Note: this is neither the same operation as `>>` nor equivalent +- /// to `slice::rotate_right`. +- #[inline] +- pub fn rotate_right(self, n: $id) -> $id { +- const LANE_WIDTH: $elem_ty = +- crate::mem::size_of::<$elem_ty>() as $elem_ty * 8; +- // Protect against undefined behavior for over-long bit shifts +- let n = n % LANE_WIDTH; +- (self >> n) | (self << ((LANE_WIDTH - n) % LANE_WIDTH)) +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- // FIXME: +- // https://github.com/rust-lang-nursery/packed_simd/issues/75 +- #[cfg(not(any( +- target_arch = "s390x", +- target_arch = "sparc64", +- )))] +- pub mod [<$id _ops_vector_rotate>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "aarch64"))] +- //~^ FIXME: https://github.com/rust-lang/packed_simd/issues/317 +- fn rotate_ops() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- let f = $id::splat(4 as $elem_ty); +- +- let max = $id::splat( +- (mem::size_of::<$elem_ty>() * 8 - 1) as $elem_ty); +- +- // rotate_right +- assert_eq!(z.rotate_right(z), z); +- assert_eq!(z.rotate_right(o), z); +- assert_eq!(z.rotate_right(t), z); +- +- assert_eq!(o.rotate_right(z), o); +- assert_eq!(t.rotate_right(z), t); +- assert_eq!(f.rotate_right(z), f); +- assert_eq!(f.rotate_right(max), f << 1); +- +- assert_eq!(o.rotate_right(o), o << max); +- assert_eq!(t.rotate_right(o), o); +- assert_eq!(t.rotate_right(t), o << max); +- assert_eq!(f.rotate_right(o), t); +- assert_eq!(f.rotate_right(t), o); +- +- // rotate_left +- assert_eq!(z.rotate_left(z), z); +- assert_eq!(o.rotate_left(z), o); +- assert_eq!(t.rotate_left(z), t); +- assert_eq!(f.rotate_left(z), f); +- assert_eq!(f.rotate_left(max), t); +- +- assert_eq!(o.rotate_left(o), t); +- assert_eq!(o.rotate_left(t), f); +- assert_eq!(t.rotate_left(o), f); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ops/vector_shifts.rs b/third_party/rust/packed_simd/src/api/ops/vector_shifts.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ops/vector_shifts.rs ++++ /dev/null +@@ -1,106 +0,0 @@ +-//! Vertical (lane-wise) vector-vector shifts operations. +- +-macro_rules! impl_ops_vector_shifts { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl crate::ops::Shl<$id> for $id { +- type Output = Self; +- #[inline] +- fn shl(self, other: Self) -> Self { +- use crate::llvm::simd_shl; +- unsafe { Simd(simd_shl(self.0, other.0)) } +- } +- } +- impl crate::ops::Shr<$id> for $id { +- type Output = Self; +- #[inline] +- fn shr(self, other: Self) -> Self { +- use crate::llvm::simd_shr; +- unsafe { Simd(simd_shr(self.0, other.0)) } +- } +- } +- impl crate::ops::ShlAssign<$id> for $id { +- #[inline] +- fn shl_assign(&mut self, other: Self) { +- *self = *self << other; +- } +- } +- impl crate::ops::ShrAssign<$id> for $id { +- #[inline] +- fn shr_assign(&mut self, other: Self) { +- *self = *self >> other; +- } +- } +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _ops_vector_shifts>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg_attr(any(target_arch = "s390x", target_arch = "sparc64"), +- allow(unreachable_code, unused_variables) +- )] +- #[cfg(not(target_arch = "aarch64"))] +- //~^ FIXME: https://github.com/rust-lang/packed_simd/issues/317 +- fn ops_vector_shifts() { +- let z = $id::splat(0 as $elem_ty); +- let o = $id::splat(1 as $elem_ty); +- let t = $id::splat(2 as $elem_ty); +- let f = $id::splat(4 as $elem_ty); +- +- let max =$id::splat( +- (mem::size_of::<$elem_ty>() * 8 - 1) as $elem_ty +- ); +- +- // shr +- assert_eq!(z >> z, z); +- assert_eq!(z >> o, z); +- assert_eq!(z >> t, z); +- assert_eq!(z >> t, z); +- +- #[cfg(any(target_arch = "s390x", target_arch = "sparc64"))] { +- // FIXME: rust produces bad codegen for shifts: +- // https://github.com/rust-lang-nursery/packed_simd/issues/13 +- return; +- } +- +- assert_eq!(o >> z, o); +- assert_eq!(t >> z, t); +- assert_eq!(f >> z, f); +- assert_eq!(f >> max, z); +- +- assert_eq!(o >> o, z); +- assert_eq!(t >> o, o); +- assert_eq!(t >> t, z); +- assert_eq!(f >> o, t); +- assert_eq!(f >> t, o); +- assert_eq!(f >> max, z); +- +- // shl +- assert_eq!(z << z, z); +- assert_eq!(o << z, o); +- assert_eq!(t << z, t); +- assert_eq!(f << z, f); +- assert_eq!(f << max, z); +- +- assert_eq!(o << o, t); +- assert_eq!(o << t, f); +- assert_eq!(t << o, f); +- +- { +- // shr_assign +- let mut v = o; +- v >>= o; +- assert_eq!(v, z); +- } +- { +- // shl_assign +- let mut v = o; +- v <<= o; +- assert_eq!(v, t); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/ptr.rs b/third_party/rust/packed_simd/src/api/ptr.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ptr.rs ++++ /dev/null +@@ -1,4 +0,0 @@ +-//! Vector of pointers +- +-#[macro_use] +-mod gather_scatter; +diff --git a/third_party/rust/packed_simd/src/api/ptr/gather_scatter.rs b/third_party/rust/packed_simd/src/api/ptr/gather_scatter.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/ptr/gather_scatter.rs ++++ /dev/null +@@ -1,216 +0,0 @@ +-//! Implements masked gather and scatters for vectors of pointers +- +-macro_rules! impl_ptr_read { +- ([$elem_ty:ty; $elem_count:expr]: $id:ident, $mask_ty:ident +- | $test_tt:tt) => { +- impl $id +- where +- [T; $elem_count]: sealed::SimdArray, +- { +- /// Reads selected vector elements from memory. +- /// +- /// Instantiates a new vector by reading the values from `self` for +- /// those lanes whose `mask` is `true`, and using the elements of +- /// `value` otherwise. +- /// +- /// No memory is accessed for those lanes of `self` whose `mask` is +- /// `false`. +- /// +- /// # Safety +- /// +- /// This method is unsafe because it dereferences raw pointers. The +- /// pointers must be aligned to `mem::align_of::()`. +- #[inline] +- pub unsafe fn read( +- self, +- mask: Simd<[M; $elem_count]>, +- value: Simd<[T; $elem_count]>, +- ) -> Simd<[T; $elem_count]> +- where +- M: sealed::Mask, +- [M; $elem_count]: sealed::SimdArray, +- { +- use crate::llvm::simd_gather; +- Simd(simd_gather(value.0, self.0, mask.0)) +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- mod [<$id _read>] { +- use super::*; +- #[test] +- fn read() { +- let mut v = [0_i32; $elem_count]; +- for i in 0..$elem_count { +- v[i] = i as i32; +- } +- +- let mut ptr = $id::::null(); +- +- for i in 0..$elem_count { +- ptr = ptr.replace(i, +- &v[i] as *const i32 as *mut i32 +- ); +- } +- +- // all mask elements are true: +- let mask = $mask_ty::splat(true); +- let def = Simd::<[i32; $elem_count]>::splat(42_i32); +- let r: Simd<[i32; $elem_count]> = unsafe { +- ptr.read(mask, def) +- }; +- assert_eq!( +- r, +- Simd::<[i32; $elem_count]>::from_slice_unaligned( +- &v +- ) +- ); +- +- let mut mask = mask; +- for i in 0..$elem_count { +- if i % 2 != 0 { +- mask = mask.replace(i, false); +- } +- } +- +- // even mask elements are true, odd ones are false: +- let r: Simd<[i32; $elem_count]> = unsafe { +- ptr.read(mask, def) +- }; +- let mut e = v; +- for i in 0..$elem_count { +- if i % 2 != 0 { +- e[i] = 42; +- } +- } +- assert_eq!( +- r, +- Simd::<[i32; $elem_count]>::from_slice_unaligned( +- &e +- ) +- ); +- +- // all mask elements are false: +- let mask = $mask_ty::splat(false); +- let def = Simd::<[i32; $elem_count]>::splat(42_i32); +- let r: Simd<[i32; $elem_count]> = unsafe { +- ptr.read(mask, def) } +- ; +- assert_eq!(r, def); +- } +- } +- } +- } +- }; +-} +- +-macro_rules! impl_ptr_write { +- ([$elem_ty:ty; $elem_count:expr]: $id:ident, $mask_ty:ident +- | $test_tt:tt) => { +- impl $id +- where +- [T; $elem_count]: sealed::SimdArray, +- { +- /// Writes selected vector elements to memory. +- /// +- /// Writes the lanes of `values` for which the mask is `true` to +- /// their corresponding memory addresses in `self`. +- /// +- /// No memory is accessed for those lanes of `self` whose `mask` is +- /// `false`. +- /// +- /// Overlapping memory addresses of `self` are written to in order +- /// from the lest-significant to the most-significant element. +- /// +- /// # Safety +- /// +- /// This method is unsafe because it dereferences raw pointers. The +- /// pointers must be aligned to `mem::align_of::()`. +- #[inline] +- pub unsafe fn write(self, mask: Simd<[M; $elem_count]>, value: Simd<[T; $elem_count]>) +- where +- M: sealed::Mask, +- [M; $elem_count]: sealed::SimdArray, +- { +- use crate::llvm::simd_scatter; +- simd_scatter(value.0, self.0, mask.0) +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- mod [<$id _write>] { +- use super::*; +- #[test] +- fn write() { +- // forty_two = [42, 42, 42, ...] +- let forty_two +- = Simd::<[i32; $elem_count]>::splat(42_i32); +- +- // This test will write to this array +- let mut arr = [0_i32; $elem_count]; +- for i in 0..$elem_count { +- arr[i] = i as i32; +- } +- // arr = [0, 1, 2, ...] +- +- let mut ptr = $id::::null(); +- for i in 0..$elem_count { +- ptr = ptr.replace(i, unsafe { +- arr.as_ptr().add(i) as *mut i32 +- }); +- } +- // ptr = [&arr[0], &arr[1], ...] +- +- // write `forty_two` to all elements of `v` +- { +- let backup = arr; +- unsafe { +- ptr.write($mask_ty::splat(true), forty_two) +- }; +- assert_eq!(arr, [42_i32; $elem_count]); +- arr = backup; // arr = [0, 1, 2, ...] +- } +- +- // write 42 to even elements of arr: +- { +- // set odd elements of the mask to false +- let mut mask = $mask_ty::splat(true); +- for i in 0..$elem_count { +- if i % 2 != 0 { +- mask = mask.replace(i, false); +- } +- } +- // mask = [true, false, true, false, ...] +- +- // expected result r = [42, 1, 42, 3, 42, 5, ...] +- let mut r = arr; +- for i in 0..$elem_count { +- if i % 2 == 0 { +- r[i] = 42; +- } +- } +- +- let backup = arr; +- unsafe { ptr.write(mask, forty_two) }; +- assert_eq!(arr, r); +- arr = backup; // arr = [0, 1, 2, 3, ...] +- } +- +- // write 42 to no elements of arr +- { +- let backup = arr; +- unsafe { +- ptr.write($mask_ty::splat(false), forty_two) +- }; +- assert_eq!(arr, backup); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/reductions.rs b/third_party/rust/packed_simd/src/api/reductions.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/reductions.rs ++++ /dev/null +@@ -1,12 +0,0 @@ +-//! Reductions +- +-#[macro_use] +-mod float_arithmetic; +-#[macro_use] +-mod integer_arithmetic; +-#[macro_use] +-mod bitwise; +-#[macro_use] +-mod mask; +-#[macro_use] +-mod min_max; +diff --git a/third_party/rust/packed_simd/src/api/reductions/bitwise.rs b/third_party/rust/packed_simd/src/api/reductions/bitwise.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/reductions/bitwise.rs ++++ /dev/null +@@ -1,151 +0,0 @@ +-//! Implements portable horizontal bitwise vector reductions. +-#![allow(unused)] +- +-macro_rules! impl_reduction_bitwise { +- ( +- [$elem_ty:ident; $elem_count:expr]: +- $id:ident | $ielem_ty:ident | $test_tt:tt | +- ($convert:expr) | +- ($true:expr, $false:expr) +- ) => { +- impl $id { +- /// Lane-wise bitwise `and` of the vector elements. +- /// +- /// Note: if the vector has one lane, the first element of the +- /// vector is returned. +- #[inline] +- pub fn and(self) -> $elem_ty { +- #[cfg(not(target_arch = "aarch64"))] +- { +- use crate::llvm::simd_reduce_and; +- let r: $ielem_ty = unsafe { simd_reduce_and(self.0) }; +- $convert(r) +- } +- #[cfg(target_arch = "aarch64")] +- { +- // FIXME: broken on aarch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- let mut x = self.extract(0) as $elem_ty; +- for i in 1..$id::lanes() { +- x &= self.extract(i) as $elem_ty; +- } +- x +- } +- } +- +- /// Lane-wise bitwise `or` of the vector elements. +- /// +- /// Note: if the vector has one lane, the first element of the +- /// vector is returned. +- #[inline] +- pub fn or(self) -> $elem_ty { +- #[cfg(not(target_arch = "aarch64"))] +- { +- use crate::llvm::simd_reduce_or; +- let r: $ielem_ty = unsafe { simd_reduce_or(self.0) }; +- $convert(r) +- } +- #[cfg(target_arch = "aarch64")] +- { +- // FIXME: broken on aarch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- let mut x = self.extract(0) as $elem_ty; +- for i in 1..$id::lanes() { +- x |= self.extract(i) as $elem_ty; +- } +- x +- } +- } +- +- /// Lane-wise bitwise `xor` of the vector elements. +- /// +- /// Note: if the vector has one lane, the first element of the +- /// vector is returned. +- #[inline] +- pub fn xor(self) -> $elem_ty { +- #[cfg(not(target_arch = "aarch64"))] +- { +- use crate::llvm::simd_reduce_xor; +- let r: $ielem_ty = unsafe { simd_reduce_xor(self.0) }; +- $convert(r) +- } +- #[cfg(target_arch = "aarch64")] +- { +- // FIXME: broken on aarch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- let mut x = self.extract(0) as $elem_ty; +- for i in 1..$id::lanes() { +- x ^= self.extract(i) as $elem_ty; +- } +- x +- } +- } +- } +- +- test_if!{ +- $test_tt: +- paste::item! { +- pub mod [<$id _reduction_bitwise>] { +- use super::*; +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn and() { +- let v = $id::splat($false); +- assert_eq!(v.and(), $false); +- let v = $id::splat($true); +- assert_eq!(v.and(), $true); +- let v = $id::splat($false); +- let v = v.replace(0, $true); +- if $id::lanes() > 1 { +- assert_eq!(v.and(), $false); +- } else { +- assert_eq!(v.and(), $true); +- } +- let v = $id::splat($true); +- let v = v.replace(0, $false); +- assert_eq!(v.and(), $false); +- +- } +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn or() { +- let v = $id::splat($false); +- assert_eq!(v.or(), $false); +- let v = $id::splat($true); +- assert_eq!(v.or(), $true); +- let v = $id::splat($false); +- let v = v.replace(0, $true); +- assert_eq!(v.or(), $true); +- let v = $id::splat($true); +- let v = v.replace(0, $false); +- if $id::lanes() > 1 { +- assert_eq!(v.or(), $true); +- } else { +- assert_eq!(v.or(), $false); +- } +- } +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn xor() { +- let v = $id::splat($false); +- assert_eq!(v.xor(), $false); +- let v = $id::splat($true); +- if $id::lanes() > 1 { +- assert_eq!(v.xor(), $false); +- } else { +- assert_eq!(v.xor(), $true); +- } +- let v = $id::splat($false); +- let v = v.replace(0, $true); +- assert_eq!(v.xor(), $true); +- let v = $id::splat($true); +- let v = v.replace(0, $false); +- if $id::lanes() > 1 { +- assert_eq!(v.xor(), $true); +- } else { +- assert_eq!(v.xor(), $false); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/reductions/float_arithmetic.rs b/third_party/rust/packed_simd/src/api/reductions/float_arithmetic.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/reductions/float_arithmetic.rs ++++ /dev/null +@@ -1,313 +0,0 @@ +-//! Implements portable horizontal float vector arithmetic reductions. +- +-macro_rules! impl_reduction_float_arithmetic { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Horizontal sum of the vector elements. +- /// +- /// The intrinsic performs a tree-reduction of the vector elements. +- /// That is, for an 8 element vector: +- /// +- /// > ((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7)) +- /// +- /// If one of the vector element is `NaN` the reduction returns +- /// `NaN`. The resulting `NaN` is not required to be equal to any +- /// of the `NaN`s in the vector. +- #[inline] +- pub fn sum(self) -> $elem_ty { +- #[cfg(not(target_arch = "aarch64"))] +- { +- use crate::llvm::simd_reduce_add_ordered; +- unsafe { simd_reduce_add_ordered(self.0, 0 as $elem_ty) } +- } +- #[cfg(target_arch = "aarch64")] +- { +- // FIXME: broken on AArch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- let mut x = self.extract(0) as $elem_ty; +- for i in 1..$id::lanes() { +- x += self.extract(i) as $elem_ty; +- } +- x +- } +- } +- +- /// Horizontal product of the vector elements. +- /// +- /// The intrinsic performs a tree-reduction of the vector elements. +- /// That is, for an 8 element vector: +- /// +- /// > ((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7)) +- /// +- /// If one of the vector element is `NaN` the reduction returns +- /// `NaN`. The resulting `NaN` is not required to be equal to any +- /// of the `NaN`s in the vector. +- #[inline] +- pub fn product(self) -> $elem_ty { +- #[cfg(not(target_arch = "aarch64"))] +- { +- use crate::llvm::simd_reduce_mul_ordered; +- unsafe { simd_reduce_mul_ordered(self.0, 1 as $elem_ty) } +- } +- #[cfg(target_arch = "aarch64")] +- { +- // FIXME: broken on AArch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- let mut x = self.extract(0) as $elem_ty; +- for i in 1..$id::lanes() { +- x *= self.extract(i) as $elem_ty; +- } +- x +- } +- } +- } +- +- impl crate::iter::Sum for $id { +- #[inline] +- fn sum>(iter: I) -> $id { +- iter.fold($id::splat(0.), crate::ops::Add::add) +- } +- } +- +- impl crate::iter::Product for $id { +- #[inline] +- fn product>(iter: I) -> $id { +- iter.fold($id::splat(1.), crate::ops::Mul::mul) +- } +- } +- +- impl<'a> crate::iter::Sum<&'a $id> for $id { +- #[inline] +- fn sum>(iter: I) -> $id { +- iter.fold($id::splat(0.), |a, b| crate::ops::Add::add(a, *b)) +- } +- } +- +- impl<'a> crate::iter::Product<&'a $id> for $id { +- #[inline] +- fn product>(iter: I) -> $id { +- iter.fold($id::splat(1.), |a, b| crate::ops::Mul::mul(a, *b)) +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- // Comparisons use integer casts within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- pub mod [<$id _reduction_float_arith>] { +- use super::*; +- fn alternating(x: usize) -> $id { +- let mut v = $id::splat(1 as $elem_ty); +- for i in 0..$id::lanes() { +- if i % x == 0 { +- v = v.replace(i, 2 as $elem_ty); +- } +- } +- v +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn sum() { +- let v = $id::splat(0 as $elem_ty); +- assert_eq!(v.sum(), 0 as $elem_ty); +- let v = $id::splat(1 as $elem_ty); +- assert_eq!(v.sum(), $id::lanes() as $elem_ty); +- let v = alternating(2); +- assert_eq!( +- v.sum(), +- ($id::lanes() / 2 + $id::lanes()) as $elem_ty +- ); +- } +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn product() { +- let v = $id::splat(0 as $elem_ty); +- assert_eq!(v.product(), 0 as $elem_ty); +- let v = $id::splat(1 as $elem_ty); +- assert_eq!(v.product(), 1 as $elem_ty); +- let f = match $id::lanes() { +- 64 => 16, +- 32 => 8, +- 16 => 4, +- _ => 2, +- }; +- let v = alternating(f); +- assert_eq!( +- v.product(), +- (2_usize.pow(($id::lanes() / f) as u32) +- as $elem_ty) +- ); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[allow(unreachable_code)] +- fn sum_nan() { +- // FIXME: https://bugs.llvm.org/show_bug.cgi?id=36732 +- // https://github.com/rust-lang-nursery/packed_simd/issues/6 +- return; +- +- let n0 = crate::$elem_ty::NAN; +- let v0 = $id::splat(-3.0); +- for i in 0..$id::lanes() { +- let mut v = v0.replace(i, n0); +- // If the vector contains a NaN the result is NaN: +- assert!( +- v.sum().is_nan(), +- "nan at {} => {} | {:?}", +- i, +- v.sum(), +- v +- ); +- for j in 0..i { +- v = v.replace(j, n0); +- assert!(v.sum().is_nan()); +- } +- } +- let v = $id::splat(n0); +- assert!(v.sum().is_nan(), "all nans | {:?}", v); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[allow(unreachable_code)] +- fn product_nan() { +- // FIXME: https://bugs.llvm.org/show_bug.cgi?id=36732 +- // https://github.com/rust-lang-nursery/packed_simd/issues/6 +- return; +- +- let n0 = crate::$elem_ty::NAN; +- let v0 = $id::splat(-3.0); +- for i in 0..$id::lanes() { +- let mut v = v0.replace(i, n0); +- // If the vector contains a NaN the result is NaN: +- assert!( +- v.product().is_nan(), +- "nan at {} => {} | {:?}", +- i, +- v.product(), +- v +- ); +- for j in 0..i { +- v = v.replace(j, n0); +- assert!(v.product().is_nan()); +- } +- } +- let v = $id::splat(n0); +- assert!(v.product().is_nan(), "all nans | {:?}", v); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[allow(unused, dead_code)] +- fn sum_roundoff() { +- // Performs a tree-reduction +- fn tree_reduce_sum(a: &[$elem_ty]) -> $elem_ty { +- assert!(!a.is_empty()); +- if a.len() == 1 { +- a[0] +- } else if a.len() == 2 { +- a[0] + a[1] +- } else { +- let mid = a.len() / 2; +- let (left, right) = a.split_at(mid); +- tree_reduce_sum(left) + tree_reduce_sum(right) +- } +- } +- +- let mut start = crate::$elem_ty::EPSILON; +- let mut scalar_reduction = 0. as $elem_ty; +- +- let mut v = $id::splat(0. as $elem_ty); +- for i in 0..$id::lanes() { +- let c = if i % 2 == 0 { 1e3 } else { -1. }; +- start *= ::core::$elem_ty::consts::PI * c; +- scalar_reduction += start; +- v = v.replace(i, start); +- } +- let simd_reduction = v.sum(); +- +- let mut a = [0. as $elem_ty; $id::lanes()]; +- v.write_to_slice_unaligned(&mut a); +- let tree_reduction = tree_reduce_sum(&a); +- +- // tolerate 1 ULP difference: +- let red_bits = simd_reduction.to_bits(); +- let tree_bits = tree_reduction.to_bits(); +- assert!( +- if red_bits > tree_bits { +- red_bits - tree_bits +- } else { +- tree_bits - red_bits +- } < 2, +- "vector: {:?} | simd_reduction: {:?} | \ +-tree_reduction: {} | scalar_reduction: {}", +- v, +- simd_reduction, +- tree_reduction, +- scalar_reduction +- ); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[allow(unused, dead_code)] +- fn product_roundoff() { +- use ::core::convert::TryInto; +- // Performs a tree-reduction +- fn tree_reduce_product(a: &[$elem_ty]) -> $elem_ty { +- assert!(!a.is_empty()); +- if a.len() == 1 { +- a[0] +- } else if a.len() == 2 { +- a[0] * a[1] +- } else { +- let mid = a.len() / 2; +- let (left, right) = a.split_at(mid); +- tree_reduce_product(left) +- * tree_reduce_product(right) +- } +- } +- +- let mut start = crate::$elem_ty::EPSILON; +- let mut scalar_reduction = 1. as $elem_ty; +- +- let mut v = $id::splat(0. as $elem_ty); +- for i in 0..$id::lanes() { +- let c = if i % 2 == 0 { 1e3 } else { -1. }; +- start *= ::core::$elem_ty::consts::PI * c; +- scalar_reduction *= start; +- v = v.replace(i, start); +- } +- let simd_reduction = v.product(); +- +- let mut a = [0. as $elem_ty; $id::lanes()]; +- v.write_to_slice_unaligned(&mut a); +- let tree_reduction = tree_reduce_product(&a); +- +- // FIXME: Too imprecise, even only for product(f32x8). +- // Figure out how to narrow this down. +- let ulp_limit = $id::lanes() / 2; +- let red_bits = simd_reduction.to_bits(); +- let tree_bits = tree_reduction.to_bits(); +- assert!( +- if red_bits > tree_bits { +- red_bits - tree_bits +- } else { +- tree_bits - red_bits +- } < ulp_limit.try_into().unwrap(), +- "vector: {:?} | simd_reduction: {:?} | \ +-tree_reduction: {} | scalar_reduction: {}", +- v, +- simd_reduction, +- tree_reduction, +- scalar_reduction +- ); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/reductions/integer_arithmetic.rs b/third_party/rust/packed_simd/src/api/reductions/integer_arithmetic.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/reductions/integer_arithmetic.rs ++++ /dev/null +@@ -1,193 +0,0 @@ +-//! Implements portable horizontal integer vector arithmetic reductions. +- +-macro_rules! impl_reduction_integer_arithmetic { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $ielem_ty:ident +- | $test_tt:tt) => { +- impl $id { +- /// Horizontal wrapping sum of the vector elements. +- /// +- /// The intrinsic performs a tree-reduction of the vector elements. +- /// That is, for an 8 element vector: +- /// +- /// > ((x0 + x1) + (x2 + x3)) + ((x4 + x5) + (x6 + x7)) +- /// +- /// If an operation overflows it returns the mathematical result +- /// modulo `2^n` where `n` is the number of times it overflows. +- #[inline] +- pub fn wrapping_sum(self) -> $elem_ty { +- #[cfg(not(target_arch = "aarch64"))] +- { +- use crate::llvm::simd_reduce_add_ordered; +- let v: $ielem_ty = unsafe { simd_reduce_add_ordered(self.0, 0 as $ielem_ty) }; +- v as $elem_ty +- } +- #[cfg(target_arch = "aarch64")] +- { +- // FIXME: broken on AArch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- let mut x = self.extract(0) as $elem_ty; +- for i in 1..$id::lanes() { +- x = x.wrapping_add(self.extract(i) as $elem_ty); +- } +- x +- } +- } +- +- /// Horizontal wrapping product of the vector elements. +- /// +- /// The intrinsic performs a tree-reduction of the vector elements. +- /// That is, for an 8 element vector: +- /// +- /// > ((x0 * x1) * (x2 * x3)) * ((x4 * x5) * (x6 * x7)) +- /// +- /// If an operation overflows it returns the mathematical result +- /// modulo `2^n` where `n` is the number of times it overflows. +- #[inline] +- pub fn wrapping_product(self) -> $elem_ty { +- #[cfg(not(target_arch = "aarch64"))] +- { +- use crate::llvm::simd_reduce_mul_ordered; +- let v: $ielem_ty = unsafe { simd_reduce_mul_ordered(self.0, 1 as $ielem_ty) }; +- v as $elem_ty +- } +- #[cfg(target_arch = "aarch64")] +- { +- // FIXME: broken on AArch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- let mut x = self.extract(0) as $elem_ty; +- for i in 1..$id::lanes() { +- x = x.wrapping_mul(self.extract(i) as $elem_ty); +- } +- x +- } +- } +- } +- +- impl crate::iter::Sum for $id { +- #[inline] +- fn sum>(iter: I) -> $id { +- iter.fold($id::splat(0), crate::ops::Add::add) +- } +- } +- +- impl crate::iter::Product for $id { +- #[inline] +- fn product>(iter: I) -> $id { +- iter.fold($id::splat(1), crate::ops::Mul::mul) +- } +- } +- +- impl<'a> crate::iter::Sum<&'a $id> for $id { +- #[inline] +- fn sum>(iter: I) -> $id { +- iter.fold($id::splat(0), |a, b| crate::ops::Add::add(a, *b)) +- } +- } +- +- impl<'a> crate::iter::Product<&'a $id> for $id { +- #[inline] +- fn product>(iter: I) -> $id { +- iter.fold($id::splat(1), |a, b| crate::ops::Mul::mul(a, *b)) +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _reduction_int_arith>] { +- use super::*; +- +- fn alternating(x: usize) -> $id { +- let mut v = $id::splat(1 as $elem_ty); +- for i in 0..$id::lanes() { +- if i % x == 0 { +- v = v.replace(i, 2 as $elem_ty); +- } +- } +- v +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn wrapping_sum() { +- let v = $id::splat(0 as $elem_ty); +- assert_eq!(v.wrapping_sum(), 0 as $elem_ty); +- let v = $id::splat(1 as $elem_ty); +- assert_eq!(v.wrapping_sum(), $id::lanes() as $elem_ty); +- let v = alternating(2); +- if $id::lanes() > 1 { +- assert_eq!( +- v.wrapping_sum(), +- ($id::lanes() / 2 + $id::lanes()) as $elem_ty +- ); +- } else { +- assert_eq!( +- v.wrapping_sum(), +- 2 as $elem_ty +- ); +- } +- } +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn wrapping_sum_overflow() { +- let start = $elem_ty::max_value() +- - ($id::lanes() as $elem_ty / 2); +- +- let v = $id::splat(start as $elem_ty); +- let vwrapping_sum = v.wrapping_sum(); +- +- let mut wrapping_sum = start; +- for _ in 1..$id::lanes() { +- wrapping_sum = wrapping_sum.wrapping_add(start); +- } +- assert_eq!(wrapping_sum, vwrapping_sum, "v = {:?}", v); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn wrapping_product() { +- let v = $id::splat(0 as $elem_ty); +- assert_eq!(v.wrapping_product(), 0 as $elem_ty); +- let v = $id::splat(1 as $elem_ty); +- assert_eq!(v.wrapping_product(), 1 as $elem_ty); +- let f = match $id::lanes() { +- 64 => 16, +- 32 => 8, +- 16 => 4, +- _ => 2, +- }; +- let v = alternating(f); +- if $id::lanes() > 1 { +- assert_eq!( +- v.wrapping_product(), +- (2_usize.pow(($id::lanes() / f) as u32) +- as $elem_ty) +- ); +- } else { +- assert_eq!( +- v.wrapping_product(), +- 2 as $elem_ty +- ); +- } +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn wrapping_product_overflow() { +- let start = $elem_ty::max_value() +- - ($id::lanes() as $elem_ty / 2); +- +- let v = $id::splat(start as $elem_ty); +- let vmul = v.wrapping_product(); +- +- let mut mul = start; +- for _ in 1..$id::lanes() { +- mul = mul.wrapping_mul(start); +- } +- assert_eq!(mul, vmul, "v = {:?}", v); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/reductions/mask.rs b/third_party/rust/packed_simd/src/api/reductions/mask.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/reductions/mask.rs ++++ /dev/null +@@ -1,89 +0,0 @@ +-//! Implements portable horizontal mask reductions. +- +-macro_rules! impl_reduction_mask { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Are `all` vector lanes `true`? +- #[inline] +- pub fn all(self) -> bool { +- unsafe { crate::codegen::reductions::mask::All::all(self) } +- } +- /// Is `any` vector lane `true`? +- #[inline] +- pub fn any(self) -> bool { +- unsafe { crate::codegen::reductions::mask::Any::any(self) } +- } +- /// Are `all` vector lanes `false`? +- #[inline] +- pub fn none(self) -> bool { +- !self.any() +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _reduction>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn all() { +- let a = $id::splat(true); +- assert!(a.all()); +- let a = $id::splat(false); +- assert!(!a.all()); +- +- if $id::lanes() > 1 { +- for i in 0..$id::lanes() { +- let mut a = $id::splat(true); +- a = a.replace(i, false); +- assert!(!a.all()); +- let mut a = $id::splat(false); +- a = a.replace(i, true); +- assert!(!a.all()); +- } +- } +- } +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn any() { +- let a = $id::splat(true); +- assert!(a.any()); +- let a = $id::splat(false); +- assert!(!a.any()); +- +- if $id::lanes() > 1 { +- for i in 0..$id::lanes() { +- let mut a = $id::splat(true); +- a = a.replace(i, false); +- assert!(a.any()); +- let mut a = $id::splat(false); +- a = a.replace(i, true); +- assert!(a.any()); +- } +- } +- } +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn none() { +- let a = $id::splat(true); +- assert!(!a.none()); +- let a = $id::splat(false); +- assert!(a.none()); +- +- if $id::lanes() > 1 { +- for i in 0..$id::lanes() { +- let mut a = $id::splat(true); +- a = a.replace(i, false); +- assert!(!a.none()); +- let mut a = $id::splat(false); +- a = a.replace(i, true); +- assert!(!a.none()); +- } +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/reductions/min_max.rs b/third_party/rust/packed_simd/src/api/reductions/min_max.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/reductions/min_max.rs ++++ /dev/null +@@ -1,360 +0,0 @@ +-//! Implements portable horizontal vector min/max reductions. +- +-macro_rules! impl_reduction_min_max { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident +- | $ielem_ty:ident | $test_tt:tt) => { +- impl $id { +- /// Largest vector element value. +- #[inline] +- pub fn max_element(self) -> $elem_ty { +- #[cfg(not(any( +- target_arch = "aarch64", +- target_arch = "arm", +- target_arch = "powerpc64", +- target_arch = "wasm32", +- )))] +- { +- use crate::llvm::simd_reduce_max; +- let v: $ielem_ty = unsafe { simd_reduce_max(self.0) }; +- v as $elem_ty +- } +- #[cfg(any( +- target_arch = "aarch64", +- target_arch = "arm", +- target_arch = "powerpc64", +- target_arch = "wasm32", +- ))] +- { +- // FIXME: broken on AArch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- // FIXME: broken on WASM32 +- // https://github.com/rust-lang-nursery/packed_simd/issues/91 +- let mut x = self.extract(0); +- for i in 1..$id::lanes() { +- x = x.max(self.extract(i)); +- } +- x +- } +- } +- +- /// Smallest vector element value. +- #[inline] +- pub fn min_element(self) -> $elem_ty { +- #[cfg(not(any( +- target_arch = "aarch64", +- target_arch = "arm", +- all(target_arch = "x86", not(target_feature = "sse2")), +- target_arch = "powerpc64", +- target_arch = "wasm32", +- ),))] +- { +- use crate::llvm::simd_reduce_min; +- let v: $ielem_ty = unsafe { simd_reduce_min(self.0) }; +- v as $elem_ty +- } +- #[cfg(any( +- target_arch = "aarch64", +- target_arch = "arm", +- all(target_arch = "x86", not(target_feature = "sse2")), +- target_arch = "powerpc64", +- target_arch = "wasm32", +- ))] +- { +- // FIXME: broken on AArch64 +- // https://github.com/rust-lang-nursery/packed_simd/issues/15 +- // FIXME: broken on i586-unknown-linux-gnu +- // https://github.com/rust-lang-nursery/packed_simd/issues/22 +- // FIXME: broken on WASM32 +- // https://github.com/rust-lang-nursery/packed_simd/issues/91 +- let mut x = self.extract(0); +- for i in 1..$id::lanes() { +- x = x.min(self.extract(i)); +- } +- x +- } +- } +- } +- test_if! {$test_tt: +- paste::item! { +- // Comparisons use integer casts within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- pub mod [<$id _reduction_min_max>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- pub fn max_element() { +- let v = $id::splat(0 as $elem_ty); +- assert_eq!(v.max_element(), 0 as $elem_ty); +- if $id::lanes() > 1 { +- let v = v.replace(1, 1 as $elem_ty); +- assert_eq!(v.max_element(), 1 as $elem_ty); +- } +- let v = v.replace(0, 2 as $elem_ty); +- assert_eq!(v.max_element(), 2 as $elem_ty); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- pub fn min_element() { +- let v = $id::splat(0 as $elem_ty); +- assert_eq!(v.min_element(), 0 as $elem_ty); +- if $id::lanes() > 1 { +- let v = v.replace(1, 1 as $elem_ty); +- assert_eq!(v.min_element(), 0 as $elem_ty); +- } +- let v = $id::splat(1 as $elem_ty); +- let v = v.replace(0, 2 as $elem_ty); +- if $id::lanes() > 1 { +- assert_eq!(v.min_element(), 1 as $elem_ty); +- } else { +- assert_eq!(v.min_element(), 2 as $elem_ty); +- } +- if $id::lanes() > 1 { +- let v = $id::splat(2 as $elem_ty); +- let v = v.replace(1, 1 as $elem_ty); +- assert_eq!(v.min_element(), 1 as $elem_ty); +- } +- } +- } +- } +- } +- }; +-} +- +-macro_rules! test_reduction_float_min_max { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- test_if! { +- $test_tt: +- paste::item! { +- // Comparisons use integer casts within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- pub mod [<$id _reduction_min_max_nan>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn min_element_test() { +- let n = crate::$elem_ty::NAN; +- +- assert_eq!(n.min(-3.), -3.); +- assert_eq!((-3. as $elem_ty).min(n), -3.); +- +- let v0 = $id::splat(-3.); +- +- let target_with_broken_last_lane_nan = !cfg!(any( +- target_arch = "arm", target_arch = "aarch64", +- all(target_arch = "x86", +- not(target_feature = "sse2") +- ), +- target_arch = "powerpc64", +- target_arch = "wasm32", +- )); +- +- // The vector is initialized to `-3.`s: [-3, -3, -3, -3] +- for i in 0..$id::lanes() { +- // We replace the i-th element of the vector with +- // `NaN`: [-3, -3, -3, NaN] +- let mut v = v0.replace(i, n); +- +- // If the NaN is in the last place, the LLVM +- // implementation of these methods is broken on some +- // targets: +- if i == $id::lanes() - 1 && +- target_with_broken_last_lane_nan { +- assert_eq!(v.min_element(), -3., +- "[A]: nan at {} => {} | {:?}", +- i, v.min_element(), v); +- +- // If we replace all the elements in the vector +- // up-to the `i-th` lane with `NaN`s, the result +- // is still always `-3.` unless all elements of +- // the vector are `NaN`s: +- for j in 0..i { +- v = v.replace(j, n); +- if j == i-1 { +- assert!(v.min_element().is_nan(), +- "[B]: nan at {} => {} | {:?}", +- i, v.min_element(), v); +- } else { +- assert_eq!(v.min_element(), -3., +- "[B]: nan at {} => {} | {:?}", +- i, v.min_element(), v); +- } +- } +- +- // We are done here, since we were in the last +- // lane which is the last iteration of the loop. +- break +- } +- +- // We are not in the last lane, and there is only +- // one `NaN` in the vector. +- +- // If the vector has one lane, the result is `NaN`: +- if $id::lanes() == 1 { +- assert!(v.min_element().is_nan(), +- "[C]: all nans | v={:?} | min={} | \ +-is_nan: {}", +- v, v.min_element(), +- v.min_element().is_nan() +- ); +- +- // And we are done, since the vector only has +- // one lane anyways. +- break; +- } +- +- // The vector has more than one lane, since there is +- // only one `NaN` in the vector, the result is +- // always `-3`. +- assert_eq!(v.min_element(), -3., +- "[D]: nan at {} => {} | {:?}", +- i, v.min_element(), v); +- +- // If we replace all the elements in the vector +- // up-to the `i-th` lane with `NaN`s, the result is +- // still always `-3.` unless all elements of the +- // vector are `NaN`s: +- for j in 0..i { +- v = v.replace(j, n); +- +- if i == $id::lanes() - 1 && j == i - 1 { +- // All elements of the vector are `NaN`s, +- // therefore the result is NaN as well. +- // +- // Note: the #lanes of the vector is > 1, so +- // "i - 1" does not overflow. +- assert!(v.min_element().is_nan(), +- "[E]: all nans | v={:?} | min={} | \ +-is_nan: {}", +- v, v.min_element(), +- v.min_element().is_nan()); +- } else { +- // There are non-`NaN` elements in the +- // vector, therefore the result is `-3.`: +- assert_eq!(v.min_element(), -3., +- "[F]: nan at {} => {} | {:?}", +- i, v.min_element(), v); +- } +- } +- } +- +- // If the vector contains all NaNs the result is NaN: +- assert!($id::splat(n).min_element().is_nan(), +- "all nans | v={:?} | min={} | is_nan: {}", +- $id::splat(n), $id::splat(n).min_element(), +- $id::splat(n).min_element().is_nan()); +- } +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn max_element_test() { +- let n = crate::$elem_ty::NAN; +- +- assert_eq!(n.max(-3.), -3.); +- assert_eq!((-3. as $elem_ty).max(n), -3.); +- +- let v0 = $id::splat(-3.); +- +- let target_with_broken_last_lane_nan = !cfg!(any( +- target_arch = "arm", target_arch = "aarch64", +- target_arch = "powerpc64", target_arch = "wasm32", +- )); +- +- // The vector is initialized to `-3.`s: [-3, -3, -3, -3] +- for i in 0..$id::lanes() { +- // We replace the i-th element of the vector with +- // `NaN`: [-3, -3, -3, NaN] +- let mut v = v0.replace(i, n); +- +- // If the NaN is in the last place, the LLVM +- // implementation of these methods is broken on some +- // targets: +- if i == $id::lanes() - 1 && +- target_with_broken_last_lane_nan { +- assert_eq!(v.max_element(), -3., +- "[A]: nan at {} => {} | {:?}", +- i, v.max_element(), v); +- +- // If we replace all the elements in the vector +- // up-to the `i-th` lane with `NaN`s, the result +- // is still always `-3.` unless all elements of +- // the vector are `NaN`s: +- for j in 0..i { +- v = v.replace(j, n); +- if j == i-1 { +- assert!(v.min_element().is_nan(), +- "[B]: nan at {} => {} | {:?}", +- i, v.min_element(), v); +- } else { +- assert_eq!(v.max_element(), -3., +- "[B]: nan at {} => {} | {:?}", +- i, v.max_element(), v); +- } +- } +- +- // We are done here, since we were in the last +- // lane which is the last iteration of the loop. +- break +- } +- +- // We are not in the last lane, and there is only +- // one `NaN` in the vector. +- +- // If the vector has one lane, the result is `NaN`: +- if $id::lanes() == 1 { +- assert!(v.max_element().is_nan(), +- "[C]: all nans | v={:?} | min={} | \ +-is_nan: {}", +- v, v.max_element(), +- v.max_element().is_nan()); +- +- // And we are done, since the vector only has +- // one lane anyways. +- break; +- } +- +- // The vector has more than one lane, since there is +- // only one `NaN` in the vector, the result is +- // always `-3`. +- assert_eq!(v.max_element(), -3., +- "[D]: nan at {} => {} | {:?}", +- i, v.max_element(), v); +- +- // If we replace all the elements in the vector +- // up-to the `i-th` lane with `NaN`s, the result is +- // still always `-3.` unless all elements of the +- // vector are `NaN`s: +- for j in 0..i { +- v = v.replace(j, n); +- +- if i == $id::lanes() - 1 && j == i - 1 { +- // All elements of the vector are `NaN`s, +- // therefore the result is NaN as well. +- // +- // Note: the #lanes of the vector is > 1, so +- // "i - 1" does not overflow. +- assert!(v.max_element().is_nan(), +- "[E]: all nans | v={:?} | max={} | \ +-is_nan: {}", +- v, v.max_element(), +- v.max_element().is_nan()); +- } else { +- // There are non-`NaN` elements in the +- // vector, therefore the result is `-3.`: +- assert_eq!(v.max_element(), -3., +- "[F]: nan at {} => {} | {:?}", +- i, v.max_element(), v); +- } +- } +- } +- +- // If the vector contains all NaNs the result is NaN: +- assert!($id::splat(n).max_element().is_nan(), +- "all nans | v={:?} | max={} | is_nan: {}", +- $id::splat(n), $id::splat(n).max_element(), +- $id::splat(n).max_element().is_nan()); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/select.rs b/third_party/rust/packed_simd/src/api/select.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/select.rs ++++ /dev/null +@@ -1,73 +0,0 @@ +-//! Implements mask's `select`. +- +-/// Implements mask select method +-macro_rules! impl_select { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Selects elements of `a` and `b` using mask. +- /// +- /// The lanes of the result for which the mask is `true` contain +- /// the values of `a`. The remaining lanes contain the values of +- /// `b`. +- #[inline] +- pub fn select(self, a: Simd, b: Simd) -> Simd +- where +- T: sealed::SimdArray::NT>, +- { +- use crate::llvm::simd_select; +- Simd(unsafe { simd_select(self.0, a.0, b.0) }) +- } +- } +- +- test_select!(bool, $id, $id, (false, true) | $test_tt); +- }; +-} +- +-macro_rules! test_select { +- ( +- $elem_ty:ident, +- $mask_ty:ident, +- $vec_ty:ident,($small:expr, $large:expr) | +- $test_tt:tt +- ) => { +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$vec_ty _select>] { +- use super::*; +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn select() { +- let o = $small as $elem_ty; +- let t = $large as $elem_ty; +- +- let a = $vec_ty::splat(o); +- let b = $vec_ty::splat(t); +- let m = a.lt(b); +- assert_eq!(m.select(a, b), a); +- +- let m = b.lt(a); +- assert_eq!(m.select(b, a), a); +- +- let mut c = a; +- let mut d = b; +- let mut m_e = $mask_ty::splat(false); +- for i in 0..$vec_ty::lanes() { +- if i % 2 == 0 { +- let c_tmp = c.extract(i); +- c = c.replace(i, d.extract(i)); +- d = d.replace(i, c_tmp); +- } else { +- m_e = m_e.replace(i, true); +- } +- } +- +- let m = c.lt(d); +- assert_eq!(m_e, m); +- assert_eq!(m.select(c, d), a); +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/shuffle.rs b/third_party/rust/packed_simd/src/api/shuffle.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/shuffle.rs ++++ /dev/null +@@ -1,184 +0,0 @@ +-//! Implements portable vector shuffles with immediate indices. +- +-// FIXME: comprehensive tests +-// https://github.com/rust-lang-nursery/packed_simd/issues/20 +- +-/// Shuffles vector elements. +-/// +-/// This macro returns a new vector that contains a shuffle of the elements in +-/// one (`shuffle!(vec, [indices...])`) or two (`shuffle!(vec0, vec1, +-/// [indices...])`) input vectors. +-/// +-/// The type of `vec0` and `vec1` must be equal, and the element type of the +-/// resulting vector is the element type of the input vector. +-/// +-/// The number of `indices` must be a power-of-two in range `[0, 64)`, since +-/// currently, the largest vector supported by the library has 64 lanes. The +-/// length of the resulting vector equals the number of indices provided. +-/// +-/// The indices must be in range `[0, M * N)` where `M` is the number of input +-/// vectors (`1` or `2`) and `N` is the number of lanes of the input vectors. +-/// The indices `i` in range `[0, N)` refer to the `i`-th element of `vec0`, +-/// while the indices in range `[N, 2*N)` refer to the `i - N`-th element of +-/// `vec1`. +-/// +-/// # Examples +-/// +-/// Shuffling elements of two vectors: +-/// +-/// ``` +-/// # use packed_simd::*; +-/// # fn main() { +-/// // Shuffle allows reordering the elements: +-/// let x = i32x4::new(1, 2, 3, 4); +-/// let y = i32x4::new(5, 6, 7, 8); +-/// let r = shuffle!(x, y, [4, 0, 5, 1]); +-/// assert_eq!(r, i32x4::new(5, 1, 6, 2)); +-/// +-/// // The resulting vector can als be smaller than the input: +-/// let r = shuffle!(x, y, [1, 6]); +-/// assert_eq!(r, i32x2::new(2, 7)); +-/// +-/// // Or larger: +-/// let r = shuffle!(x, y, [1, 3, 4, 2, 1, 7, 2, 2]); +-/// assert_eq!(r, i32x8::new(2, 4, 5, 3, 2, 8, 3, 3)); +-/// // At most 2 * the number of lanes in the input vector. +-/// # } +-/// ``` +-/// +-/// Shuffling elements of one vector: +-/// +-/// ``` +-/// # use packed_simd::*; +-/// # fn main() { +-/// // Shuffle allows reordering the elements of a vector: +-/// let x = i32x4::new(1, 2, 3, 4); +-/// let r = shuffle!(x, [2, 1, 3, 0]); +-/// assert_eq!(r, i32x4::new(3, 2, 4, 1)); +-/// +-/// // The resulting vector can be smaller than the input: +-/// let r = shuffle!(x, [1, 3]); +-/// assert_eq!(r, i32x2::new(2, 4)); +-/// +-/// // Equal: +-/// let r = shuffle!(x, [1, 3, 2, 0]); +-/// assert_eq!(r, i32x4::new(2, 4, 3, 1)); +-/// +-/// // Or larger: +-/// let r = shuffle!(x, [1, 3, 2, 2, 1, 3, 2, 2]); +-/// assert_eq!(r, i32x8::new(2, 4, 3, 3, 2, 4, 3, 3)); +-/// // At most 2 * the number of lanes in the input vector. +-/// # } +-/// ``` +-#[macro_export] +-macro_rules! shuffle { +- ($vec0:expr, $vec1:expr, [$l0:expr, $l1:expr]) => {{ +- #[allow(unused_unsafe)] +- unsafe { +- $crate::Simd($crate::__shuffle_vector2::<{[$l0, $l1]}, _, _>( +- $vec0.0, +- $vec1.0, +- )) +- } +- }}; +- ($vec0:expr, $vec1:expr, [$l0:expr, $l1:expr, $l2:expr, $l3:expr]) => {{ +- #[allow(unused_unsafe)] +- unsafe { +- $crate::Simd($crate::__shuffle_vector4::<{[$l0, $l1, $l2, $l3]}, _, _>( +- $vec0.0, +- $vec1.0, +- )) +- } +- }}; +- ($vec0:expr, $vec1:expr, +- [$l0:expr, $l1:expr, $l2:expr, $l3:expr, +- $l4:expr, $l5:expr, $l6:expr, $l7:expr]) => {{ +- #[allow(unused_unsafe)] +- unsafe { +- $crate::Simd($crate::__shuffle_vector8::<{[$l0, $l1, $l2, $l3, $l4, $l5, $l6, $l7]}, _, _>( +- $vec0.0, +- $vec1.0, +- )) +- } +- }}; +- ($vec0:expr, $vec1:expr, +- [$l0:expr, $l1:expr, $l2:expr, $l3:expr, +- $l4:expr, $l5:expr, $l6:expr, $l7:expr, +- $l8:expr, $l9:expr, $l10:expr, $l11:expr, +- $l12:expr, $l13:expr, $l14:expr, $l15:expr]) => {{ +- #[allow(unused_unsafe)] +- unsafe { +- $crate::Simd($crate::__shuffle_vector16::<{ +- [ +- $l0, $l1, $l2, $l3, $l4, $l5, $l6, $l7, $l8, $l9, $l10, +- $l11, $l12, $l13, $l14, $l15, +- ] +- }, _, _>( +- $vec0.0, +- $vec1.0, +- )) +- } +- }}; +- ($vec0:expr, $vec1:expr, +- [$l0:expr, $l1:expr, $l2:expr, $l3:expr, +- $l4:expr, $l5:expr, $l6:expr, $l7:expr, +- $l8:expr, $l9:expr, $l10:expr, $l11:expr, +- $l12:expr, $l13:expr, $l14:expr, $l15:expr, +- $l16:expr, $l17:expr, $l18:expr, $l19:expr, +- $l20:expr, $l21:expr, $l22:expr, $l23:expr, +- $l24:expr, $l25:expr, $l26:expr, $l27:expr, +- $l28:expr, $l29:expr, $l30:expr, $l31:expr]) => {{ +- #[allow(unused_unsafe)] +- unsafe { +- $crate::Simd($crate::__shuffle_vector32::<{ +- [ +- $l0, $l1, $l2, $l3, $l4, $l5, $l6, $l7, $l8, $l9, $l10, +- $l11, $l12, $l13, $l14, $l15, $l16, $l17, $l18, $l19, +- $l20, $l21, $l22, $l23, $l24, $l25, $l26, $l27, $l28, +- $l29, $l30, $l31, +- ] +- }, _, _>( +- $vec0.0, +- $vec1.0, +- )) +- } +- }}; +- ($vec0:expr, $vec1:expr, +- [$l0:expr, $l1:expr, $l2:expr, $l3:expr, +- $l4:expr, $l5:expr, $l6:expr, $l7:expr, +- $l8:expr, $l9:expr, $l10:expr, $l11:expr, +- $l12:expr, $l13:expr, $l14:expr, $l15:expr, +- $l16:expr, $l17:expr, $l18:expr, $l19:expr, +- $l20:expr, $l21:expr, $l22:expr, $l23:expr, +- $l24:expr, $l25:expr, $l26:expr, $l27:expr, +- $l28:expr, $l29:expr, $l30:expr, $l31:expr, +- $l32:expr, $l33:expr, $l34:expr, $l35:expr, +- $l36:expr, $l37:expr, $l38:expr, $l39:expr, +- $l40:expr, $l41:expr, $l42:expr, $l43:expr, +- $l44:expr, $l45:expr, $l46:expr, $l47:expr, +- $l48:expr, $l49:expr, $l50:expr, $l51:expr, +- $l52:expr, $l53:expr, $l54:expr, $l55:expr, +- $l56:expr, $l57:expr, $l58:expr, $l59:expr, +- $l60:expr, $l61:expr, $l62:expr, $l63:expr]) => {{ +- #[allow(unused_unsafe)] +- unsafe { +- $crate::Simd($crate::__shuffle_vector64::<{[ +- $l0, $l1, $l2, $l3, $l4, $l5, $l6, $l7, $l8, $l9, $l10, +- $l11, $l12, $l13, $l14, $l15, $l16, $l17, $l18, $l19, +- $l20, $l21, $l22, $l23, $l24, $l25, $l26, $l27, $l28, +- $l29, $l30, $l31, $l32, $l33, $l34, $l35, $l36, $l37, +- $l38, $l39, $l40, $l41, $l42, $l43, $l44, $l45, $l46, +- $l47, $l48, $l49, $l50, $l51, $l52, $l53, $l54, $l55, +- $l56, $l57, $l58, $l59, $l60, $l61, $l62, $l63, +- ]}, _, _>( +- $vec0.0, +- $vec1.0, +- )) +- } +- }}; +- ($vec:expr, [$($l:expr),*]) => { +- match $vec { +- v => shuffle!(v, v, [$($l),*]) +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/shuffle1_dyn.rs b/third_party/rust/packed_simd/src/api/shuffle1_dyn.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/shuffle1_dyn.rs ++++ /dev/null +@@ -1,159 +0,0 @@ +-//! Shuffle vector elements according to a dynamic vector of indices. +- +-macro_rules! impl_shuffle1_dyn { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Shuffle vector elements according to `indices`. +- #[inline] +- pub fn shuffle1_dyn(self, indices: I) -> Self +- where +- Self: codegen::shuffle1_dyn::Shuffle1Dyn, +- { +- codegen::shuffle1_dyn::Shuffle1Dyn::shuffle1_dyn(self, indices) +- } +- } +- }; +-} +- +-macro_rules! test_shuffle1_dyn { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _shuffle1_dyn>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn shuffle1_dyn() { +- let increasing = { +- let mut v = $id::splat(0 as $elem_ty); +- for i in 0..$id::lanes() { +- v = v.replace(i, i as $elem_ty); +- } +- v +- }; +- let decreasing = { +- let mut v = $id::splat(0 as $elem_ty); +- for i in 0..$id::lanes() { +- v = v.replace( +- i, +- ($id::lanes() - 1 - i) as $elem_ty +- ); +- } +- v +- }; +- +- type Indices = < +- $id as codegen::shuffle1_dyn::Shuffle1Dyn +- >::Indices; +- let increasing_ids: Indices = increasing.cast(); +- let decreasing_ids: Indices = decreasing.cast(); +- +- assert_eq!( +- increasing.shuffle1_dyn(increasing_ids), +- increasing, +- "(i,i)=>i" +- ); +- assert_eq!( +- decreasing.shuffle1_dyn(increasing_ids), +- decreasing, +- "(d,i)=>d" +- ); +- assert_eq!( +- increasing.shuffle1_dyn(decreasing_ids), +- decreasing, +- "(i,d)=>d" +- ); +- assert_eq!( +- decreasing.shuffle1_dyn(decreasing_ids), +- increasing, +- "(d,d)=>i" +- ); +- +- for i in 0..$id::lanes() { +- let v_ids: Indices +- = $id::splat(i as $elem_ty).cast(); +- assert_eq!(increasing.shuffle1_dyn(v_ids), +- $id::splat(increasing.extract(i)) +- ); +- assert_eq!(decreasing.shuffle1_dyn(v_ids), +- $id::splat(decreasing.extract(i)) +- ); +- assert_eq!( +- $id::splat(i as $elem_ty) +- .shuffle1_dyn(increasing_ids), +- $id::splat(i as $elem_ty) +- ); +- assert_eq!( +- $id::splat(i as $elem_ty) +- .shuffle1_dyn(decreasing_ids), +- $id::splat(i as $elem_ty) +- ); +- } +- } +- } +- } +- } +- }; +-} +- +-macro_rules! test_shuffle1_dyn_mask { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _shuffle1_dyn>] { +- use super::*; +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn shuffle1_dyn() { +- // alternating = [true, false, true, false, ...] +- let mut alternating = $id::splat(false); +- for i in 0..$id::lanes() { +- if i % 2 == 0 { +- alternating = alternating.replace(i, true); +- } +- } +- +- type Indices = < +- $id as codegen::shuffle1_dyn::Shuffle1Dyn +- >::Indices; +- // even = [0, 0, 2, 2, 4, 4, ..] +- let even = { +- let mut v = Indices::splat(0); +- for i in 0..$id::lanes() { +- if i % 2 == 0 { +- v = v.replace(i, (i as u8).into()); +- } else { +- v = v.replace(i, (i as u8 - 1).into()); +- } +- } +- v +- }; +- // odd = [1, 1, 3, 3, 5, 5, ...] +- let odd = { +- let mut v = Indices::splat(0); +- for i in 0..$id::lanes() { +- if i % 2 != 0 { +- v = v.replace(i, (i as u8).into()); +- } else { +- v = v.replace(i, (i as u8 + 1).into()); +- } +- } +- v +- }; +- +- assert_eq!( +- alternating.shuffle1_dyn(even), +- $id::splat(true) +- ); +- if $id::lanes() > 1 { +- assert_eq!( +- alternating.shuffle1_dyn(odd), +- $id::splat(false) +- ); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/slice.rs b/third_party/rust/packed_simd/src/api/slice.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/slice.rs ++++ /dev/null +@@ -1,7 +0,0 @@ +-//! Slice from/to methods +- +-#[macro_use] +-mod from_slice; +- +-#[macro_use] +-mod write_to_slice; +diff --git a/third_party/rust/packed_simd/src/api/slice/from_slice.rs b/third_party/rust/packed_simd/src/api/slice/from_slice.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/slice/from_slice.rs ++++ /dev/null +@@ -1,202 +0,0 @@ +-//! Implements methods to read a vector type from a slice. +- +-macro_rules! impl_slice_from_slice { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Instantiates a new vector with the values of the `slice`. +- /// +- /// # Panics +- /// +- /// If `slice.len() < Self::lanes()` or `&slice[0]` is not aligned +- /// to an `align_of::()` boundary. +- #[inline] +- pub fn from_slice_aligned(slice: &[$elem_ty]) -> Self { +- unsafe { +- assert!(slice.len() >= $elem_count); +- let target_ptr = slice.as_ptr(); +- assert_eq!(target_ptr.align_offset(crate::mem::align_of::()), 0); +- Self::from_slice_aligned_unchecked(slice) +- } +- } +- +- /// Instantiates a new vector with the values of the `slice`. +- /// +- /// # Panics +- /// +- /// If `slice.len() < Self::lanes()`. +- #[inline] +- pub fn from_slice_unaligned(slice: &[$elem_ty]) -> Self { +- unsafe { +- assert!(slice.len() >= $elem_count); +- Self::from_slice_unaligned_unchecked(slice) +- } +- } +- +- /// Instantiates a new vector with the values of the `slice`. +- /// +- /// # Safety +- /// +- /// If `slice.len() < Self::lanes()` or `&slice[0]` is not aligned +- /// to an `align_of::()` boundary, the behavior is undefined. +- #[inline] +- pub unsafe fn from_slice_aligned_unchecked(slice: &[$elem_ty]) -> Self { +- debug_assert!(slice.len() >= $elem_count); +- let target_ptr = slice.as_ptr(); +- debug_assert_eq!(target_ptr.align_offset(crate::mem::align_of::()), 0); +- +- #[allow(clippy::cast_ptr_alignment)] +- *(target_ptr as *const Self) +- } +- +- /// Instantiates a new vector with the values of the `slice`. +- /// +- /// # Safety +- /// +- /// If `slice.len() < Self::lanes()` the behavior is undefined. +- #[inline] +- pub unsafe fn from_slice_unaligned_unchecked(slice: &[$elem_ty]) -> Self { +- use crate::mem::size_of; +- debug_assert!(slice.len() >= $elem_count); +- let target_ptr = slice.as_ptr().cast(); +- let mut x = Self::splat(0 as $elem_ty); +- let self_ptr = &mut x as *mut Self as *mut u8; +- crate::ptr::copy_nonoverlapping(target_ptr, self_ptr, size_of::()); +- x +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- // Comparisons use integer casts within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- pub mod [<$id _slice_from_slice>] { +- use super::*; +- use crate::iter::Iterator; +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn from_slice_unaligned() { +- let mut unaligned = [42 as $elem_ty; $id::lanes() + 1]; +- unaligned[0] = 0 as $elem_ty; +- let vec = $id::from_slice_unaligned(&unaligned[1..]); +- for (index, &b) in unaligned.iter().enumerate() { +- if index == 0 { +- assert_eq!(b, 0 as $elem_ty); +- } else { +- assert_eq!(b, 42 as $elem_ty); +- assert_eq!(b, vec.extract(index - 1)); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn from_slice_unaligned_fail() { +- let mut unaligned = [42 as $elem_ty; $id::lanes() + 1]; +- unaligned[0] = 0 as $elem_ty; +- // the slice is not large enough => panic +- let _vec = $id::from_slice_unaligned(&unaligned[2..]); +- } +- +- union A { +- data: [$elem_ty; 2 * $id::lanes()], +- _vec: $id, +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn from_slice_aligned() { +- let mut aligned = A { +- data: [0 as $elem_ty; 2 * $id::lanes()], +- }; +- for i in $id::lanes()..(2 * $id::lanes()) { +- unsafe { +- aligned.data[i] = 42 as $elem_ty; +- } +- } +- +- let vec = unsafe { +- $id::from_slice_aligned( +- &aligned.data[$id::lanes()..] +- ) +- }; +- for (index, &b) in +- unsafe { aligned.data.iter().enumerate() } { +- if index < $id::lanes() { +- assert_eq!(b, 0 as $elem_ty); +- } else { +- assert_eq!(b, 42 as $elem_ty); +- assert_eq!( +- b, vec.extract(index - $id::lanes()) +- ); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn from_slice_aligned_fail_lanes() { +- let aligned = A { +- data: [0 as $elem_ty; 2 * $id::lanes()], +- }; +- let _vec = unsafe { +- $id::from_slice_aligned( +- &aligned.data[2 * $id::lanes()..] +- ) +- }; +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn from_slice_aligned_fail_align() { +- unsafe { +- let aligned = A { +- data: [0 as $elem_ty; 2 * $id::lanes()], +- }; +- +- // get a pointer to the front of data +- let ptr: *const $elem_ty = aligned.data.as_ptr() +- as *const $elem_ty; +- // offset pointer by one element +- let ptr = ptr.wrapping_add(1); +- +- if ptr.align_offset( +- crate::mem::align_of::<$id>() +- ) == 0 { +- // the pointer is properly aligned, so +- // from_slice_aligned won't fail here (e.g. this +- // can happen for i128x1). So we panic to make +- // the "should_fail" test pass: +- panic!("ok"); +- } +- +- // create a slice - this is safe, because the +- // elements of the slice exist, are properly +- // initialized, and properly aligned: +- let s: &[$elem_ty] = slice::from_raw_parts( +- ptr, $id::lanes() +- ); +- // this should always panic because the slice +- // alignment does not match the alignment +- // requirements for the vector type: +- let _vec = $id::from_slice_aligned(s); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/slice/write_to_slice.rs b/third_party/rust/packed_simd/src/api/slice/write_to_slice.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/slice/write_to_slice.rs ++++ /dev/null +@@ -1,196 +0,0 @@ +-//! Implements methods to write a vector type to a slice. +- +-macro_rules! impl_slice_write_to_slice { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Writes the values of the vector to the `slice`. +- /// +- /// # Panics +- /// +- /// If `slice.len() < Self::lanes()` or `&slice[0]` is not +- /// aligned to an `align_of::()` boundary. +- #[inline] +- pub fn write_to_slice_aligned(self, slice: &mut [$elem_ty]) { +- unsafe { +- assert!(slice.len() >= $elem_count); +- let target_ptr = slice.as_mut_ptr(); +- assert_eq!(target_ptr.align_offset(crate::mem::align_of::()), 0); +- self.write_to_slice_aligned_unchecked(slice); +- } +- } +- +- /// Writes the values of the vector to the `slice`. +- /// +- /// # Panics +- /// +- /// If `slice.len() < Self::lanes()`. +- #[inline] +- pub fn write_to_slice_unaligned(self, slice: &mut [$elem_ty]) { +- unsafe { +- assert!(slice.len() >= $elem_count); +- self.write_to_slice_unaligned_unchecked(slice); +- } +- } +- +- /// Writes the values of the vector to the `slice`. +- /// +- /// # Safety +- /// +- /// If `slice.len() < Self::lanes()` or `&slice[0]` is not +- /// aligned to an `align_of::()` boundary, the behavior is +- /// undefined. +- #[inline] +- pub unsafe fn write_to_slice_aligned_unchecked(self, slice: &mut [$elem_ty]) { +- debug_assert!(slice.len() >= $elem_count); +- let target_ptr = slice.as_mut_ptr(); +- debug_assert_eq!(target_ptr.align_offset(crate::mem::align_of::()), 0); +- +- #[allow(clippy::cast_ptr_alignment)] +- #[allow(clippy::cast_ptr_alignment)] +- #[allow(clippy::cast_ptr_alignment)] +- #[allow(clippy::cast_ptr_alignment)] +- *(target_ptr as *mut Self) = self; +- } +- +- /// Writes the values of the vector to the `slice`. +- /// +- /// # Safety +- /// +- /// If `slice.len() < Self::lanes()` the behavior is undefined. +- #[inline] +- pub unsafe fn write_to_slice_unaligned_unchecked(self, slice: &mut [$elem_ty]) { +- debug_assert!(slice.len() >= $elem_count); +- let target_ptr = slice.as_mut_ptr().cast(); +- let self_ptr = &self as *const Self as *const u8; +- crate::ptr::copy_nonoverlapping(self_ptr, target_ptr, crate::mem::size_of::()); +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- // Comparisons use integer casts within mantissa^1 range. +- #[allow(clippy::float_cmp)] +- pub mod [<$id _slice_write_to_slice>] { +- use super::*; +- use crate::iter::Iterator; +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn write_to_slice_unaligned() { +- let mut unaligned = [0 as $elem_ty; $id::lanes() + 1]; +- let vec = $id::splat(42 as $elem_ty); +- vec.write_to_slice_unaligned(&mut unaligned[1..]); +- for (index, &b) in unaligned.iter().enumerate() { +- if index == 0 { +- assert_eq!(b, 0 as $elem_ty); +- } else { +- assert_eq!(b, 42 as $elem_ty); +- assert_eq!(b, vec.extract(index - 1)); +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn write_to_slice_unaligned_fail() { +- let mut unaligned = [0 as $elem_ty; $id::lanes() + 1]; +- let vec = $id::splat(42 as $elem_ty); +- vec.write_to_slice_unaligned(&mut unaligned[2..]); +- } +- +- union A { +- data: [$elem_ty; 2 * $id::lanes()], +- _vec: $id, +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] +- #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn write_to_slice_aligned() { +- let mut aligned = A { +- data: [0 as $elem_ty; 2 * $id::lanes()], +- }; +- let vec = $id::splat(42 as $elem_ty); +- unsafe { +- vec.write_to_slice_aligned( +- &mut aligned.data[$id::lanes()..] +- ); +- for (idx, &b) in aligned.data.iter().enumerate() { +- if idx < $id::lanes() { +- assert_eq!(b, 0 as $elem_ty); +- } else { +- assert_eq!(b, 42 as $elem_ty); +- assert_eq!( +- b, vec.extract(idx - $id::lanes()) +- ); +- } +- } +- } +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn write_to_slice_aligned_fail_lanes() { +- let mut aligned = A { +- data: [0 as $elem_ty; 2 * $id::lanes()], +- }; +- let vec = $id::splat(42 as $elem_ty); +- unsafe { +- vec.write_to_slice_aligned( +- &mut aligned.data[2 * $id::lanes()..] +- ) +- }; +- } +- +- // FIXME: wasm-bindgen-test does not support #[should_panic] +- // #[cfg_attr(not(target_arch = "wasm32"), test)] +- // #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- #[cfg(not(target_arch = "wasm32"))] +- #[test] +- #[should_panic] +- fn write_to_slice_aligned_fail_align() { +- unsafe { +- let mut aligned = A { +- data: [0 as $elem_ty; 2 * $id::lanes()], +- }; +- +- // get a pointer to the front of data +- let ptr: *mut $elem_ty +- = aligned.data.as_mut_ptr() as *mut $elem_ty; +- // offset pointer by one element +- let ptr = ptr.wrapping_add(1); +- +- if ptr.align_offset(crate::mem::align_of::<$id>()) +- == 0 { +- // the pointer is properly aligned, so +- // write_to_slice_aligned won't fail here (e.g. +- // this can happen for i128x1). So we panic to +- // make the "should_fail" test pass: +- panic!("ok"); +- } +- +- // create a slice - this is safe, because the +- // elements of the slice exist, are properly +- // initialized, and properly aligned: +- let s: &mut [$elem_ty] +- = slice::from_raw_parts_mut(ptr, $id::lanes()); +- // this should always panic because the slice +- // alignment does not match the alignment +- // requirements for the vector type: +- let vec = $id::splat(42 as $elem_ty); +- vec.write_to_slice_aligned(s); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/api/swap_bytes.rs b/third_party/rust/packed_simd/src/api/swap_bytes.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/api/swap_bytes.rs ++++ /dev/null +@@ -1,192 +0,0 @@ +-//! Horizontal swap bytes +- +-macro_rules! impl_swap_bytes { +- ([$elem_ty:ident; $elem_count:expr]: $id:ident | $test_tt:tt) => { +- impl $id { +- /// Reverses the byte order of the vector. +- #[inline] +- pub fn swap_bytes(self) -> Self { +- super::codegen::swap_bytes::SwapBytes::swap_bytes(self) +- } +- +- /// Converts self to little endian from the target's endianness. +- /// +- /// On little endian this is a no-op. On big endian the bytes are +- /// swapped. +- #[inline] +- pub fn to_le(self) -> Self { +- #[cfg(target_endian = "little")] +- { +- self +- } +- #[cfg(not(target_endian = "little"))] +- { +- self.swap_bytes() +- } +- } +- +- /// Converts self to big endian from the target's endianness. +- /// +- /// On big endian this is a no-op. On little endian the bytes are +- /// swapped. +- #[inline] +- pub fn to_be(self) -> Self { +- #[cfg(target_endian = "big")] +- { +- self +- } +- #[cfg(not(target_endian = "big"))] +- { +- self.swap_bytes() +- } +- } +- +- /// Converts a vector from little endian to the target's endianness. +- /// +- /// On little endian this is a no-op. On big endian the bytes are +- /// swapped. +- #[inline] +- pub fn from_le(x: Self) -> Self { +- #[cfg(target_endian = "little")] +- { +- x +- } +- #[cfg(not(target_endian = "little"))] +- { +- x.swap_bytes() +- } +- } +- +- /// Converts a vector from big endian to the target's endianness. +- /// +- /// On big endian this is a no-op. On little endian the bytes are +- /// swapped. +- #[inline] +- pub fn from_be(x: Self) -> Self { +- #[cfg(target_endian = "big")] +- { +- x +- } +- #[cfg(not(target_endian = "big"))] +- { +- x.swap_bytes() +- } +- } +- } +- +- test_if! { +- $test_tt: +- paste::item! { +- pub mod [<$id _swap_bytes>] { +- use super::*; +- +- const BYTES: [u8; 64] = [ +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- 16, 17, 18, 19, 20, 21, 22, 23, +- 24, 25, 26, 27, 28, 29, 30, 31, +- 32, 33, 34, 35, 36, 37, 38, 39, +- 40, 41, 42, 43, 44, 45, 46, 47, +- 48, 49, 50, 51, 52, 53, 54, 55, +- 56, 57, 58, 59, 60, 61, 62, 63, +- ]; +- +- macro_rules! swap { +- ($func: ident) => {{ +- // catch possible future >512 vectors +- assert!(mem::size_of::<$id>() <= 64); +- +- let mut actual = BYTES; +- let elems: &mut [$elem_ty] = unsafe { +- slice::from_raw_parts_mut( +- actual.as_mut_ptr() as *mut $elem_ty, +- $id::lanes(), +- ) +- }; +- +- let vec = $id::from_slice_unaligned(elems); +- $id::$func(vec).write_to_slice_unaligned(elems); +- +- actual +- }}; +- } +- +- macro_rules! test_swap { +- ($func: ident) => {{ +- let actual = swap!($func); +- let expected = +- BYTES.iter().rev() +- .skip(64 - crate::mem::size_of::<$id>()); +- assert!(actual.iter().zip(expected) +- .all(|(x, y)| x == y)); +- }}; +- } +- +- macro_rules! test_no_swap { +- ($func: ident) => {{ +- let actual = swap!($func); +- let expected = BYTES.iter() +- .take(mem::size_of::<$id>()); +- +- assert!(actual.iter().zip(expected) +- .all(|(x, y)| x == y)); +- }}; +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn swap_bytes() { +- test_swap!(swap_bytes); +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn to_le() { +- #[cfg(target_endian = "little")] +- { +- test_no_swap!(to_le); +- } +- #[cfg(not(target_endian = "little"))] +- { +- test_swap!(to_le); +- } +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn to_be() { +- #[cfg(target_endian = "big")] +- { +- test_no_swap!(to_be); +- } +- #[cfg(not(target_endian = "big"))] +- { +- test_swap!(to_be); +- } +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn from_le() { +- #[cfg(target_endian = "little")] +- { +- test_no_swap!(from_le); +- } +- #[cfg(not(target_endian = "little"))] +- { +- test_swap!(from_le); +- } +- } +- +- #[cfg_attr(not(target_arch = "wasm32"), test)] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +- fn from_be() { +- #[cfg(target_endian = "big")] +- { +- test_no_swap!(from_be); +- } +- #[cfg(not(target_endian = "big"))] +- { +- test_swap!(from_be); +- } +- } +- } +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen.rs b/third_party/rust/packed_simd/src/codegen.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen.rs ++++ /dev/null +@@ -1,62 +0,0 @@ +-//! Code-generation utilities +- +-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($(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; +- type NT = [u32; $elem_count]; +- } +- +- impl crate::sealed::Seal for $tuple_id {} +- impl crate::sealed::Simd for $tuple_id { +- type Element = $elem_ty; +- const LANES: usize = $elem_count; +- type LanesType = [u32; $elem_count]; +- } +- +- } +-} +- +-pub(crate) mod pointer_sized_int; +- +-pub(crate) mod v16; +-pub(crate) use self::v16::*; +- +-pub(crate) mod v32; +-pub(crate) use self::v32::*; +- +-pub(crate) mod v64; +-pub(crate) use self::v64::*; +- +-pub(crate) mod v128; +-pub(crate) use self::v128::*; +- +-pub(crate) mod v256; +-pub(crate) use self::v256::*; +- +-pub(crate) mod v512; +-pub(crate) use self::v512::*; +- +-pub(crate) mod vSize; +-pub(crate) use self::vSize::*; +- +-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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/bit_manip.rs ++++ /dev/null +@@ -1,347 +0,0 @@ +-//! LLVM bit manipulation intrinsics. +-#[rustfmt::skip] +- +-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"] +- fn ctlz_u8x8(x: u8x8, is_zero_undef: bool) -> u8x8; +- #[link_name = "llvm.ctlz.v16i8"] +- fn ctlz_u8x16(x: u8x16, is_zero_undef: bool) -> u8x16; +- #[link_name = "llvm.ctlz.v32i8"] +- fn ctlz_u8x32(x: u8x32, is_zero_undef: bool) -> u8x32; +- #[link_name = "llvm.ctlz.v64i8"] +- fn ctlz_u8x64(x: u8x64, is_zero_undef: bool) -> u8x64; +- +- #[link_name = "llvm.ctlz.v2i16"] +- fn ctlz_u16x2(x: u16x2, is_zero_undef: bool) -> u16x2; +- #[link_name = "llvm.ctlz.v4i16"] +- fn ctlz_u16x4(x: u16x4, is_zero_undef: bool) -> u16x4; +- #[link_name = "llvm.ctlz.v8i16"] +- fn ctlz_u16x8(x: u16x8, is_zero_undef: bool) -> u16x8; +- #[link_name = "llvm.ctlz.v16i16"] +- fn ctlz_u16x16(x: u16x16, is_zero_undef: bool) -> u16x16; +- #[link_name = "llvm.ctlz.v32i16"] +- fn ctlz_u16x32(x: u16x32, is_zero_undef: bool) -> u16x32; +- +- #[link_name = "llvm.ctlz.v2i32"] +- fn ctlz_u32x2(x: u32x2, is_zero_undef: bool) -> u32x2; +- #[link_name = "llvm.ctlz.v4i32"] +- fn ctlz_u32x4(x: u32x4, is_zero_undef: bool) -> u32x4; +- #[link_name = "llvm.ctlz.v8i32"] +- fn ctlz_u32x8(x: u32x8, is_zero_undef: bool) -> u32x8; +- #[link_name = "llvm.ctlz.v16i32"] +- fn ctlz_u32x16(x: u32x16, is_zero_undef: bool) -> u32x16; +- +- #[link_name = "llvm.ctlz.v2i64"] +- fn ctlz_u64x2(x: u64x2, is_zero_undef: bool) -> u64x2; +- #[link_name = "llvm.ctlz.v4i64"] +- fn ctlz_u64x4(x: u64x4, is_zero_undef: bool) -> u64x4; +- #[link_name = "llvm.ctlz.v8i64"] +- fn ctlz_u64x8(x: u64x8, is_zero_undef: bool) -> u64x8; +- +- #[link_name = "llvm.ctlz.v1i128"] +- fn ctlz_u128x1(x: u128x1, is_zero_undef: bool) -> u128x1; +- #[link_name = "llvm.ctlz.v2i128"] +- fn ctlz_u128x2(x: u128x2, is_zero_undef: bool) -> u128x2; +- #[link_name = "llvm.ctlz.v4i128"] +- fn ctlz_u128x4(x: u128x4, is_zero_undef: bool) -> u128x4; +- +- #[link_name = "llvm.cttz.v2i8"] +- fn cttz_u8x2(x: u8x2, is_zero_undef: bool) -> u8x2; +- #[link_name = "llvm.cttz.v4i8"] +- fn cttz_u8x4(x: u8x4, is_zero_undef: bool) -> u8x4; +- #[link_name = "llvm.cttz.v8i8"] +- fn cttz_u8x8(x: u8x8, is_zero_undef: bool) -> u8x8; +- #[link_name = "llvm.cttz.v16i8"] +- fn cttz_u8x16(x: u8x16, is_zero_undef: bool) -> u8x16; +- #[link_name = "llvm.cttz.v32i8"] +- fn cttz_u8x32(x: u8x32, is_zero_undef: bool) -> u8x32; +- #[link_name = "llvm.cttz.v64i8"] +- fn cttz_u8x64(x: u8x64, is_zero_undef: bool) -> u8x64; +- +- #[link_name = "llvm.cttz.v2i16"] +- fn cttz_u16x2(x: u16x2, is_zero_undef: bool) -> u16x2; +- #[link_name = "llvm.cttz.v4i16"] +- fn cttz_u16x4(x: u16x4, is_zero_undef: bool) -> u16x4; +- #[link_name = "llvm.cttz.v8i16"] +- fn cttz_u16x8(x: u16x8, is_zero_undef: bool) -> u16x8; +- #[link_name = "llvm.cttz.v16i16"] +- fn cttz_u16x16(x: u16x16, is_zero_undef: bool) -> u16x16; +- #[link_name = "llvm.cttz.v32i16"] +- fn cttz_u16x32(x: u16x32, is_zero_undef: bool) -> u16x32; +- +- #[link_name = "llvm.cttz.v2i32"] +- fn cttz_u32x2(x: u32x2, is_zero_undef: bool) -> u32x2; +- #[link_name = "llvm.cttz.v4i32"] +- fn cttz_u32x4(x: u32x4, is_zero_undef: bool) -> u32x4; +- #[link_name = "llvm.cttz.v8i32"] +- fn cttz_u32x8(x: u32x8, is_zero_undef: bool) -> u32x8; +- #[link_name = "llvm.cttz.v16i32"] +- fn cttz_u32x16(x: u32x16, is_zero_undef: bool) -> u32x16; +- +- #[link_name = "llvm.cttz.v2i64"] +- fn cttz_u64x2(x: u64x2, is_zero_undef: bool) -> u64x2; +- #[link_name = "llvm.cttz.v4i64"] +- fn cttz_u64x4(x: u64x4, is_zero_undef: bool) -> u64x4; +- #[link_name = "llvm.cttz.v8i64"] +- fn cttz_u64x8(x: u64x8, is_zero_undef: bool) -> u64x8; +- +- #[link_name = "llvm.cttz.v1i128"] +- fn cttz_u128x1(x: u128x1, is_zero_undef: bool) -> u128x1; +- #[link_name = "llvm.cttz.v2i128"] +- fn cttz_u128x2(x: u128x2, is_zero_undef: bool) -> u128x2; +- #[link_name = "llvm.cttz.v4i128"] +- fn cttz_u128x4(x: u128x4, is_zero_undef: bool) -> u128x4; +- +- #[link_name = "llvm.ctpop.v2i8"] +- fn ctpop_u8x2(x: u8x2) -> u8x2; +- #[link_name = "llvm.ctpop.v4i8"] +- fn ctpop_u8x4(x: u8x4) -> u8x4; +- #[link_name = "llvm.ctpop.v8i8"] +- fn ctpop_u8x8(x: u8x8) -> u8x8; +- #[link_name = "llvm.ctpop.v16i8"] +- fn ctpop_u8x16(x: u8x16) -> u8x16; +- #[link_name = "llvm.ctpop.v32i8"] +- fn ctpop_u8x32(x: u8x32) -> u8x32; +- #[link_name = "llvm.ctpop.v64i8"] +- fn ctpop_u8x64(x: u8x64) -> u8x64; +- +- #[link_name = "llvm.ctpop.v2i16"] +- fn ctpop_u16x2(x: u16x2) -> u16x2; +- #[link_name = "llvm.ctpop.v4i16"] +- fn ctpop_u16x4(x: u16x4) -> u16x4; +- #[link_name = "llvm.ctpop.v8i16"] +- fn ctpop_u16x8(x: u16x8) -> u16x8; +- #[link_name = "llvm.ctpop.v16i16"] +- fn ctpop_u16x16(x: u16x16) -> u16x16; +- #[link_name = "llvm.ctpop.v32i16"] +- fn ctpop_u16x32(x: u16x32) -> u16x32; +- +- #[link_name = "llvm.ctpop.v2i32"] +- fn ctpop_u32x2(x: u32x2) -> u32x2; +- #[link_name = "llvm.ctpop.v4i32"] +- fn ctpop_u32x4(x: u32x4) -> u32x4; +- #[link_name = "llvm.ctpop.v8i32"] +- fn ctpop_u32x8(x: u32x8) -> u32x8; +- #[link_name = "llvm.ctpop.v16i32"] +- fn ctpop_u32x16(x: u32x16) -> u32x16; +- +- #[link_name = "llvm.ctpop.v2i64"] +- fn ctpop_u64x2(x: u64x2) -> u64x2; +- #[link_name = "llvm.ctpop.v4i64"] +- fn ctpop_u64x4(x: u64x4) -> u64x4; +- #[link_name = "llvm.ctpop.v8i64"] +- fn ctpop_u64x8(x: u64x8) -> u64x8; +- +- #[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; +-} +- +-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) => { +- // FIXME: several LLVM intrinsics break on s390x https://github.com/rust-lang-nursery/packed_simd/issues/192 +- #[cfg(target_arch = "s390x")] +- impl_bit_manip! { scalar: $ty, $scalar } +- #[cfg(not(target_arch = "s390x"))] +- impl BitManip for $ty { +- #[inline] +- fn ctpop(self) -> Self { +- let y: $uty = self.cast(); +- unsafe { $ctpop(y).cast() } +- } +- +- #[inline] +- fn ctlz(self) -> Self { +- let y: $uty = self.cast(); +- // the ctxx intrinsics need compile-time constant +- // `is_zero_undef` +- unsafe { $ctlz(y, false).cast() } +- } +- +- #[inline] +- fn cttz(self) -> Self { +- let y: $uty = self.cast(); +- unsafe { $cttz(y, false).cast() } +- } +- } +- }; +- (sized_inner: $ty:ident, $scalar:ty, $uty:ident) => { +- #[cfg(target_arch = "s390x")] +- impl_bit_manip! { scalar: $ty, $scalar } +- #[cfg(not(target_arch = "s390x"))] +- impl BitManip for $ty { +- #[inline] +- fn ctpop(self) -> Self { +- let y: $uty = self.cast(); +- $uty::ctpop(y).cast() +- } +- +- #[inline] +- fn ctlz(self) -> Self { +- let y: $uty = self.cast(); +- $uty::ctlz(y).cast() +- } +- +- #[inline] +- fn cttz(self) -> Self { +- let y: $uty = self.cast(); +- $uty::cttz(y).cast() +- } +- } +- }; +- (scalar: $ty:ident, $scalar:ty) => { +- impl BitManip for $ty { +- #[inline] +- fn ctpop(self) -> Self { +- let mut ones = self; +- for i in 0..Self::lanes() { +- ones = ones.replace(i, self.extract(i).count_ones() as $scalar); +- } +- ones +- } +- +- #[inline] +- fn ctlz(self) -> Self { +- let mut lz = self; +- for i in 0..Self::lanes() { +- lz = lz.replace(i, self.extract(i).leading_zeros() as $scalar); +- } +- lz +- } +- +- #[inline] +- fn cttz(self) -> Self { +- let mut tz = self; +- for i in 0..Self::lanes() { +- tz = tz.replace(i, self.extract(i).trailing_zeros() as $scalar); +- } +- tz +- } +- } +- }; +- ($uty:ident, $uscalar:ty, $ity:ident, $iscalar:ty, +- $ctpop:ident, $ctlz:ident, $cttz:ident) => { +- impl_bit_manip! { inner: $uty, $uscalar, $uty, $ctpop, $ctlz, $cttz } +- impl_bit_manip! { inner: $ity, $iscalar, $uty, $ctpop, $ctlz, $cttz } +- }; +- (sized: $usize:ident, $uscalar:ty, $isize:ident, +- $iscalar:ty, $ty:ident) => { +- impl_bit_manip! { sized_inner: $usize, $uscalar, $ty } +- impl_bit_manip! { sized_inner: $isize, $iscalar, $ty } +- }; +-} +- +-impl_bit_manip! { u8x2 , u8, i8x2, i8, ctpop_u8x2, ctlz_u8x2, cttz_u8x2 } +-impl_bit_manip! { u8x4 , u8, i8x4, i8, ctpop_u8x4, ctlz_u8x4, cttz_u8x4 } +-#[cfg(not(target_arch = "aarch64"))] // see below +-impl_bit_manip! { u8x8 , u8, i8x8, i8, ctpop_u8x8, ctlz_u8x8, cttz_u8x8 } +-impl_bit_manip! { u8x16 , u8, i8x16, i8, ctpop_u8x16, ctlz_u8x16, cttz_u8x16 } +-impl_bit_manip! { u8x32 , u8, i8x32, i8, ctpop_u8x32, ctlz_u8x32, cttz_u8x32 } +-impl_bit_manip! { u8x64 , u8, i8x64, i8, ctpop_u8x64, ctlz_u8x64, cttz_u8x64 } +-impl_bit_manip! { u16x2 , u16, i16x2, i16, ctpop_u16x2, ctlz_u16x2, cttz_u16x2 } +-impl_bit_manip! { u16x4 , u16, i16x4, i16, ctpop_u16x4, ctlz_u16x4, cttz_u16x4 } +-impl_bit_manip! { u16x8 , u16, i16x8, i16, ctpop_u16x8, ctlz_u16x8, cttz_u16x8 } +-impl_bit_manip! { u16x16 , u16, i16x16, i16, ctpop_u16x16, ctlz_u16x16, cttz_u16x16 } +-impl_bit_manip! { u16x32 , u16, i16x32, i16, ctpop_u16x32, ctlz_u16x32, cttz_u16x32 } +-impl_bit_manip! { u32x2 , u32, i32x2, i32, ctpop_u32x2, ctlz_u32x2, cttz_u32x2 } +-impl_bit_manip! { u32x4 , u32, i32x4, i32, ctpop_u32x4, ctlz_u32x4, cttz_u32x4 } +-impl_bit_manip! { u32x8 , u32, i32x8, i32, ctpop_u32x8, ctlz_u32x8, cttz_u32x8 } +-impl_bit_manip! { u32x16 , u32, i32x16, i32, ctpop_u32x16, ctlz_u32x16, cttz_u32x16 } +-impl_bit_manip! { u64x2 , u64, i64x2, i64, ctpop_u64x2, ctlz_u64x2, cttz_u64x2 } +-impl_bit_manip! { u64x4 , u64, i64x4, i64, ctpop_u64x4, ctlz_u64x4, cttz_u64x4 } +-impl_bit_manip! { u64x8 , u64, i64x8, i64, ctpop_u64x8, ctlz_u64x8, cttz_u64x8 } +-impl_bit_manip! { u128x1 , u128, i128x1, i128, ctpop_u128x1, ctlz_u128x1, cttz_u128x1 } +-impl_bit_manip! { u128x2 , u128, i128x2, i128, ctpop_u128x2, ctlz_u128x2, cttz_u128x2 } +-impl_bit_manip! { u128x4 , u128, i128x4, i128, ctpop_u128x4, ctlz_u128x4, cttz_u128x4 } +- +-#[cfg(target_arch = "aarch64")] +-impl BitManip for u8x8 { +- #[inline] +- fn ctpop(self) -> Self { +- let y: u8x8 = self.cast(); +- unsafe { ctpop_u8x8(y).cast() } +- } +- +- #[inline] +- fn ctlz(self) -> Self { +- let y: u8x8 = self.cast(); +- unsafe { ctlz_u8x8(y, false).cast() } +- } +- +- #[inline] +- fn cttz(self) -> Self { +- // FIXME: LLVM cttz.v8i8 broken on aarch64 https://github.com/rust-lang-nursery/packed_simd/issues/191 +- // OPTIMIZE: adapt the algorithm used for v8i16/etc to Rust's aarch64 +- // intrinsics +- let mut tz = self; +- for i in 0..Self::lanes() { +- tz = tz.replace(i, self.extract(i).trailing_zeros() as u8); +- } +- tz +- } +-} +-#[cfg(target_arch = "aarch64")] +-impl BitManip for i8x8 { +- #[inline] +- fn ctpop(self) -> Self { +- let y: u8x8 = self.cast(); +- unsafe { ctpop_u8x8(y).cast() } +- } +- +- #[inline] +- fn ctlz(self) -> Self { +- let y: u8x8 = self.cast(); +- unsafe { ctlz_u8x8(y, false).cast() } +- } +- +- #[inline] +- fn cttz(self) -> Self { +- // FIXME: LLVM cttz.v8i8 broken on aarch64 https://github.com/rust-lang-nursery/packed_simd/issues/191 +- // OPTIMIZE: adapt the algorithm used for v8i16/etc to Rust's aarch64 +- // intrinsics +- let mut tz = self; +- for i in 0..Self::lanes() { +- tz = tz.replace(i, self.extract(i).trailing_zeros() as i8); +- } +- tz +- } +-} +- +-cfg_if! { +- if #[cfg(target_pointer_width = "8")] { +- impl_bit_manip! { sized: usizex2, usize, isizex2, isize, u8x2 } +- impl_bit_manip! { sized: usizex4, usize, isizex4, isize, u8x4 } +- impl_bit_manip! { sized: usizex8, usize, isizex8, isize, u8x8 } +- } else if #[cfg(target_pointer_width = "16")] { +- impl_bit_manip! { sized: usizex2, usize, isizex2, isize, u16x2 } +- impl_bit_manip! { sized: usizex4, usize, isizex4, isize, u16x4 } +- impl_bit_manip! { sized: usizex8, usize, isizex8, isize, u16x8 } +- } else if #[cfg(target_pointer_width = "32")] { +- impl_bit_manip! { sized: usizex2, usize, isizex2, isize, u32x2 } +- impl_bit_manip! { sized: usizex4, usize, isizex4, isize, u32x4 } +- impl_bit_manip! { sized: usizex8, usize, isizex8, isize, u32x8 } +- } else if #[cfg(target_pointer_width = "64")] { +- impl_bit_manip! { sized: usizex2, usize, isizex2, isize, u64x2 } +- impl_bit_manip! { sized: usizex4, usize, isizex4, isize, u64x4 } +- impl_bit_manip! { sized: usizex8, usize, isizex8, isize, u64x8 } +- } else { +- compile_error!("unsupported target_pointer_width"); +- } +-} +diff --git a/third_party/rust/packed_simd/src/codegen/llvm.rs b/third_party/rust/packed_simd/src/codegen/llvm.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/llvm.rs ++++ /dev/null +@@ -1,122 +0,0 @@ +-//! LLVM's platform intrinsics +-#![allow(dead_code)] +- +-use crate::sealed::Shuffle; +-#[allow(unused_imports)] // FIXME: spurious warning? +-use crate::sealed::Simd; +- +-extern "platform-intrinsic" { +- fn simd_shuffle(x: T, y: T, idx: I) -> U; +-} +- +-#[allow(clippy::missing_safety_doc)] +-#[inline] +-pub unsafe fn __shuffle_vector2(x: T, y: T) -> U +-where +- T: Simd, +- ::Element: Shuffle<[u32; 2], Output = U>, +-{ +- simd_shuffle(x, y, IDX) +-} +- +-#[allow(clippy::missing_safety_doc)] +-#[inline] +-pub unsafe fn __shuffle_vector4(x: T, y: T) -> U +-where +- T: Simd, +- ::Element: Shuffle<[u32; 4], Output = U>, +-{ +- simd_shuffle(x, y, IDX) +-} +- +-#[allow(clippy::missing_safety_doc)] +-#[inline] +-pub unsafe fn __shuffle_vector8(x: T, y: T) -> U +-where +- T: Simd, +- ::Element: Shuffle<[u32; 8], Output = U>, +-{ +- simd_shuffle(x, y, IDX) +-} +- +-#[allow(clippy::missing_safety_doc)] +-#[inline] +-pub unsafe fn __shuffle_vector16(x: T, y: T) -> U +-where +- T: Simd, +- ::Element: Shuffle<[u32; 16], Output = U>, +-{ +- simd_shuffle(x, y, IDX) +-} +- +-#[allow(clippy::missing_safety_doc)] +-#[inline] +-pub unsafe fn __shuffle_vector32(x: T, y: T) -> U +-where +- T: Simd, +- ::Element: Shuffle<[u32; 32], Output = U>, +-{ +- simd_shuffle(x, y, IDX) +-} +- +-#[allow(clippy::missing_safety_doc)] +-#[inline] +-pub unsafe fn __shuffle_vector64(x: T, y: T) -> U +-where +- T: Simd, +- ::Element: Shuffle<[u32; 64], Output = U>, +-{ +- simd_shuffle(x, y, IDX) +-} +- +-extern "platform-intrinsic" { +- 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; +- +- pub(crate) fn simd_insert(x: T, idx: u32, val: U) -> T; +- pub(crate) fn simd_extract(x: T, idx: u32) -> U; +- +- pub(crate) fn simd_cast(x: T) -> U; +- +- 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; +- +- 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; +- +- pub(crate) fn simd_select(m: M, 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; +- +- pub(crate) fn simd_fsqrt(a: T) -> T; +- pub(crate) fn simd_fma(a: T, b: T, c: T) -> T; +- +- pub(crate) fn simd_gather(value: T, pointers: P, mask: M) -> T; +- pub(crate) fn simd_scatter(value: T, pointers: P, mask: M); +- +- 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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math.rs ++++ /dev/null +@@ -1,3 +0,0 @@ +-//! Vertical math operations +- +-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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float.rs ++++ /dev/null +@@ -1,18 +0,0 @@ +-//! Vertical floating-point math operations. +-#![allow(clippy::useless_transmute)] +- +-#[macro_use] +-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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/abs.rs ++++ /dev/null +@@ -1,103 +0,0 @@ +-//! Vertical floating-point `fabs` +-#![allow(unused)] +- +-// FIXME 64-bit 1 elem vectors fabs +- +-use crate::*; +- +-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"] +- fn fabs_v4f32(x: f32x4) -> f32x4; +- #[link_name = "llvm.fabs.v8f32"] +- fn fabs_v8f32(x: f32x8) -> f32x8; +- #[link_name = "llvm.fabs.v16f32"] +- fn fabs_v16f32(x: f32x16) -> f32x16; +- /* FIXME 64-bit fabsgle elem vectors +- #[link_name = "llvm.fabs.v1f64"] +- fn fabs_v1f64(x: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.fabs.v2f64"] +- fn fabs_v2f64(x: f64x2) -> f64x2; +- #[link_name = "llvm.fabs.v4f64"] +- fn fabs_v4f64(x: f64x4) -> f64x4; +- #[link_name = "llvm.fabs.v8f64"] +- fn fabs_v8f64(x: f64x8) -> f64x8; +- +- #[link_name = "llvm.fabs.f32"] +- fn fabs_f32(x: f32) -> f32; +- #[link_name = "llvm.fabs.f64"] +- fn fabs_f64(x: f64) -> f64; +-} +- +-gen_unary_impl_table!(Abs, abs); +- +-cfg_if! { +- if #[cfg(target_arch = "s390x")] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- impl_unary!(f32x2[f32; 2]: fabs_f32); +- impl_unary!(f32x4[f32; 4]: fabs_f32); +- impl_unary!(f32x8[f32; 8]: fabs_f32); +- impl_unary!(f32x16[f32; 16]: fabs_f32); +- +- impl_unary!(f64x2[f64; 2]: fabs_f64); +- impl_unary!(f64x4[f64; 4]: fabs_f64); +- impl_unary!(f64x8[f64; 8]: fabs_f64); +- } else if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_fabsf4_avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_fabsf8_avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_fabsd4_avx2); +- +- impl_unary!(f32x4: Sleef_fabsf4_avx2128); +- impl_unary!(f32x8: Sleef_fabsf8_avx2); +- impl_unary!(f64x2: Sleef_fabsd2_avx2128); +- impl_unary!(f64x4: Sleef_fabsd4_avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_fabsf4_sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_fabsf8_avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_fabsd4_avx); +- +- impl_unary!(f32x4: Sleef_fabsf4_sse4); +- impl_unary!(f32x8: Sleef_fabsf8_avx); +- impl_unary!(f64x2: Sleef_fabsd2_sse4); +- impl_unary!(f64x4: Sleef_fabsd4_avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_fabsf4_sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_fabsf4_sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_fabsd2_sse4); +- +- impl_unary!(f32x4: Sleef_fabsf4_sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_fabsf4_sse4); +- impl_unary!(f64x2: Sleef_fabsd2_sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_fabsd2_sse4); +- } else { +- impl_unary!(f32x2[f32; 2]: fabs_f32); +- impl_unary!(f32x16: fabs_v16f32); +- impl_unary!(f64x8: fabs_v8f64); +- +- impl_unary!(f32x4: fabs_v4f32); +- impl_unary!(f32x8: fabs_v8f32); +- impl_unary!(f64x2: fabs_v2f64); +- impl_unary!(f64x4: fabs_v4f64); +- } +- } +- } else { +- impl_unary!(f32x2[f32; 2]: fabs_f32); +- impl_unary!(f32x4: fabs_v4f32); +- impl_unary!(f32x8: fabs_v8f32); +- impl_unary!(f32x16: fabs_v16f32); +- +- impl_unary!(f64x2: fabs_v2f64); +- impl_unary!(f64x4: fabs_v4f64); +- impl_unary!(f64x8: fabs_v8f64); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/cos.rs ++++ /dev/null +@@ -1,103 +0,0 @@ +-//! Vertical floating-point `cos` +-#![allow(unused)] +- +-// FIXME 64-bit 1 elem vector cos +- +-use crate::*; +- +-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"] +- fn cos_v4f32(x: f32x4) -> f32x4; +- #[link_name = "llvm.cos.v8f32"] +- fn cos_v8f32(x: f32x8) -> f32x8; +- #[link_name = "llvm.cos.v16f32"] +- fn cos_v16f32(x: f32x16) -> f32x16; +- /* FIXME 64-bit cosgle elem vectors +- #[link_name = "llvm.cos.v1f64"] +- fn cos_v1f64(x: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.cos.v2f64"] +- fn cos_v2f64(x: f64x2) -> f64x2; +- #[link_name = "llvm.cos.v4f64"] +- fn cos_v4f64(x: f64x4) -> f64x4; +- #[link_name = "llvm.cos.v8f64"] +- fn cos_v8f64(x: f64x8) -> f64x8; +- +- #[link_name = "llvm.cos.f32"] +- fn cos_f32(x: f32) -> f32; +- #[link_name = "llvm.cos.f64"] +- fn cos_f64(x: f64) -> f64; +-} +- +-gen_unary_impl_table!(Cos, cos); +- +-cfg_if! { +- if #[cfg(target_arch = "s390x")] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- impl_unary!(f32x2[f32; 2]: cos_f32); +- impl_unary!(f32x4[f32; 4]: cos_f32); +- impl_unary!(f32x8[f32; 8]: cos_f32); +- impl_unary!(f32x16[f32; 16]: cos_f32); +- +- impl_unary!(f64x2[f64; 2]: cos_f64); +- impl_unary!(f64x4[f64; 4]: cos_f64); +- impl_unary!(f64x8[f64; 8]: cos_f64); +- } else if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_cosf4_u10avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_cosf8_u10avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_cosd4_u10avx2); +- +- impl_unary!(f32x4: Sleef_cosf4_u10avx2128); +- impl_unary!(f32x8: Sleef_cosf8_u10avx2); +- impl_unary!(f64x2: Sleef_cosd2_u10avx2128); +- impl_unary!(f64x4: Sleef_cosd4_u10avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_cosf4_u10sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_cosf8_u10avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_cosd4_u10avx); +- +- impl_unary!(f32x4: Sleef_cosf4_u10sse4); +- impl_unary!(f32x8: Sleef_cosf8_u10avx); +- impl_unary!(f64x2: Sleef_cosd2_u10sse4); +- impl_unary!(f64x4: Sleef_cosd4_u10avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_cosf4_u10sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_cosf4_u10sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_cosd2_u10sse4); +- +- impl_unary!(f32x4: Sleef_cosf4_u10sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_cosf4_u10sse4); +- impl_unary!(f64x2: Sleef_cosd2_u10sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_cosd2_u10sse4); +- } else { +- impl_unary!(f32x2[f32; 2]: cos_f32); +- impl_unary!(f32x16: cos_v16f32); +- impl_unary!(f64x8: cos_v8f64); +- +- impl_unary!(f32x4: cos_v4f32); +- impl_unary!(f32x8: cos_v8f32); +- impl_unary!(f64x2: cos_v2f64); +- impl_unary!(f64x4: cos_v4f64); +- } +- } +- } else { +- impl_unary!(f32x2[f32; 2]: cos_f32); +- impl_unary!(f32x4: cos_v4f32); +- impl_unary!(f32x8: cos_v8f32); +- impl_unary!(f32x16: cos_v16f32); +- +- impl_unary!(f64x2: cos_v2f64); +- impl_unary!(f64x4: cos_v4f64); +- impl_unary!(f64x8: cos_v8f64); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/cos_pi.rs ++++ /dev/null +@@ -1,87 +0,0 @@ +-//! Vertical floating-point `cos` +-#![allow(unused)] +- +-// FIXME 64-bit 1 elem vectors cos_pi +- +-use crate::*; +- +-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 { +- #[inline] +- fn cos_pi(self) -> Self { +- (self * Self::splat($PI)).cos() +- } +- } +- }; +-} +-macro_rules! impl_def32 { +- ($vid:ident) => { +- impl_def!($vid, crate::f32::consts::PI); +- }; +-} +-macro_rules! impl_def64 { +- ($vid:ident) => { +- impl_def!($vid, crate::f64::consts::PI); +- }; +-} +- +-cfg_if! { +- if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_cospif4_u05avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_cospif8_u05avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_cospid4_u05avx2); +- +- impl_unary!(f32x4: Sleef_cospif4_u05avx2128); +- impl_unary!(f32x8: Sleef_cospif8_u05avx2); +- impl_unary!(f64x2: Sleef_cospid2_u05avx2128); +- impl_unary!(f64x4: Sleef_cospid4_u05avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_cospif4_u05sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_cospif8_u05avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_cospid4_u05avx); +- +- impl_unary!(f32x4: Sleef_cospif4_u05sse4); +- impl_unary!(f32x8: Sleef_cospif8_u05avx); +- impl_unary!(f64x2: Sleef_cospid2_u05sse4); +- impl_unary!(f64x4: Sleef_cospid4_u05avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_cospif4_u05sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_cospif4_u05sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_cospid2_u05sse4); +- +- impl_unary!(f32x4: Sleef_cospif4_u05sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_cospif4_u05sse4); +- impl_unary!(f64x2: Sleef_cospid2_u05sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_cospid2_u05sse4); +- } else { +- impl_def32!(f32x2); +- impl_def32!(f32x4); +- impl_def32!(f32x8); +- impl_def32!(f32x16); +- +- impl_def64!(f64x2); +- impl_def64!(f64x4); +- impl_def64!(f64x8); +- } +- } +- } else { +- impl_def32!(f32x2); +- impl_def32!(f32x4); +- impl_def32!(f32x8); +- impl_def32!(f32x16); +- +- impl_def64!(f64x2); +- impl_def64!(f64x4); +- impl_def64!(f64x8); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/exp.rs ++++ /dev/null +@@ -1,112 +0,0 @@ +-//! Vertical floating-point `exp` +-#![allow(unused)] +- +-// FIXME 64-bit expgle elem vectors misexpg +- +-use crate::*; +- +-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"] +- fn exp_v4f32(x: f32x4) -> f32x4; +- #[link_name = "llvm.exp.v8f32"] +- fn exp_v8f32(x: f32x8) -> f32x8; +- #[link_name = "llvm.exp.v16f32"] +- fn exp_v16f32(x: f32x16) -> f32x16; +- /* FIXME 64-bit expgle elem vectors +- #[link_name = "llvm.exp.v1f64"] +- fn exp_v1f64(x: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.exp.v2f64"] +- fn exp_v2f64(x: f64x2) -> f64x2; +- #[link_name = "llvm.exp.v4f64"] +- fn exp_v4f64(x: f64x4) -> f64x4; +- #[link_name = "llvm.exp.v8f64"] +- fn exp_v8f64(x: f64x8) -> f64x8; +- +- #[link_name = "llvm.exp.f32"] +- fn exp_f32(x: f32) -> f32; +- #[link_name = "llvm.exp.f64"] +- fn exp_f64(x: f64) -> f64; +-} +- +-gen_unary_impl_table!(Exp, exp); +- +-cfg_if! { +- if #[cfg(target_arch = "s390x")] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- impl_unary!(f32x2[f32; 2]: exp_f32); +- impl_unary!(f32x4[f32; 4]: exp_f32); +- impl_unary!(f32x8[f32; 8]: exp_f32); +- impl_unary!(f32x16[f32; 16]: exp_f32); +- +- impl_unary!(f64x2[f64; 2]: exp_f64); +- impl_unary!(f64x4[f64; 4]: exp_f64); +- impl_unary!(f64x8[f64; 8]: exp_f64); +- } else if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_expf4_u10avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_expf8_u10avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_expd4_u10avx2); +- +- impl_unary!(f32x4: Sleef_expf4_u10avx2128); +- impl_unary!(f32x8: Sleef_expf8_u10avx2); +- impl_unary!(f64x2: Sleef_expd2_u10avx2128); +- impl_unary!(f64x4: Sleef_expd4_u10avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_expf4_u10sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_expf8_u10avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_expd4_u10avx); +- +- impl_unary!(f32x4: Sleef_expf4_u10sse4); +- impl_unary!(f32x8: Sleef_expf8_u10avx); +- impl_unary!(f64x2: Sleef_expd2_u10sse4); +- impl_unary!(f64x4: Sleef_expd4_u10avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_expf4_u10sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_expf4_u10sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_expd2_u10sse4); +- +- impl_unary!(f32x4: Sleef_expf4_u10sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_expf4_u10sse4); +- impl_unary!(f64x2: Sleef_expd2_u10sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_expd2_u10sse4); +- } else if #[cfg(target_feature = "sse2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_expf4_u10sse2); +- impl_unary!(f32x16[q => f32x4]: Sleef_expf4_u10sse2); +- impl_unary!(f64x8[q => f64x2]: Sleef_expd2_u10sse2); +- +- impl_unary!(f32x4: Sleef_expf4_u10sse2); +- impl_unary!(f32x8[h => f32x4]: Sleef_expf4_u10sse2); +- impl_unary!(f64x2: Sleef_expd2_u10sse2); +- impl_unary!(f64x4[h => f64x2]: Sleef_expd2_u10sse2); +- } else { +- impl_unary!(f32x2[f32; 2]: exp_f32); +- impl_unary!(f32x16: exp_v16f32); +- impl_unary!(f64x8: exp_v8f64); +- +- impl_unary!(f32x4: exp_v4f32); +- impl_unary!(f32x8: exp_v8f32); +- impl_unary!(f64x2: exp_v2f64); +- impl_unary!(f64x4: exp_v4f64); +- } +- } +- } else { +- impl_unary!(f32x2[f32; 2]: exp_f32); +- impl_unary!(f32x4: exp_v4f32); +- impl_unary!(f32x8: exp_v8f32); +- impl_unary!(f32x16: exp_v16f32); +- +- impl_unary!(f64x2: exp_v2f64); +- impl_unary!(f64x4: exp_v4f64); +- impl_unary!(f64x8: exp_v8f64); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/ln.rs ++++ /dev/null +@@ -1,112 +0,0 @@ +-//! Vertical floating-point `ln` +-#![allow(unused)] +- +-// FIXME 64-bit lngle elem vectors mislng +- +-use crate::*; +- +-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"] +- fn ln_v4f32(x: f32x4) -> f32x4; +- #[link_name = "llvm.log.v8f32"] +- fn ln_v8f32(x: f32x8) -> f32x8; +- #[link_name = "llvm.log.v16f32"] +- fn ln_v16f32(x: f32x16) -> f32x16; +- /* FIXME 64-bit lngle elem vectors +- #[link_name = "llvm.log.v1f64"] +- fn ln_v1f64(x: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.log.v2f64"] +- fn ln_v2f64(x: f64x2) -> f64x2; +- #[link_name = "llvm.log.v4f64"] +- fn ln_v4f64(x: f64x4) -> f64x4; +- #[link_name = "llvm.log.v8f64"] +- fn ln_v8f64(x: f64x8) -> f64x8; +- +- #[link_name = "llvm.log.f32"] +- fn ln_f32(x: f32) -> f32; +- #[link_name = "llvm.log.f64"] +- fn ln_f64(x: f64) -> f64; +-} +- +-gen_unary_impl_table!(Ln, ln); +- +-cfg_if! { +- if #[cfg(target_arch = "s390x")] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- impl_unary!(f32x2[f32; 2]: ln_f32); +- impl_unary!(f32x4[f32; 4]: ln_f32); +- impl_unary!(f32x8[f32; 8]: ln_f32); +- impl_unary!(f32x16[f32; 16]: ln_f32); +- +- impl_unary!(f64x2[f64; 2]: ln_f64); +- impl_unary!(f64x4[f64; 4]: ln_f64); +- impl_unary!(f64x8[f64; 8]: ln_f64); +- } else if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_logf4_u10avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_logf8_u10avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_logd4_u10avx2); +- +- impl_unary!(f32x4: Sleef_logf4_u10avx2128); +- impl_unary!(f32x8: Sleef_logf8_u10avx2); +- impl_unary!(f64x2: Sleef_logd2_u10avx2128); +- impl_unary!(f64x4: Sleef_logd4_u10avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_logf4_u10sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_logf8_u10avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_logd4_u10avx); +- +- impl_unary!(f32x4: Sleef_logf4_u10sse4); +- impl_unary!(f32x8: Sleef_logf8_u10avx); +- impl_unary!(f64x2: Sleef_logd2_u10sse4); +- impl_unary!(f64x4: Sleef_logd4_u10avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_logf4_u10sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_logf4_u10sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_logd2_u10sse4); +- +- impl_unary!(f32x4: Sleef_logf4_u10sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_logf4_u10sse4); +- impl_unary!(f64x2: Sleef_logd2_u10sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_logd2_u10sse4); +- } else if #[cfg(target_feature = "sse2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_logf4_u10sse2); +- impl_unary!(f32x16[q => f32x4]: Sleef_logf4_u10sse2); +- impl_unary!(f64x8[q => f64x2]: Sleef_logd2_u10sse2); +- +- impl_unary!(f32x4: Sleef_logf4_u10sse2); +- impl_unary!(f32x8[h => f32x4]: Sleef_logf4_u10sse2); +- impl_unary!(f64x2: Sleef_logd2_u10sse2); +- impl_unary!(f64x4[h => f64x2]: Sleef_logd2_u10sse2); +- } else { +- impl_unary!(f32x2[f32; 2]: ln_f32); +- impl_unary!(f32x16: ln_v16f32); +- impl_unary!(f64x8: ln_v8f64); +- +- impl_unary!(f32x4: ln_v4f32); +- impl_unary!(f32x8: ln_v8f32); +- impl_unary!(f64x2: ln_v2f64); +- impl_unary!(f64x4: ln_v4f64); +- } +- } +- } else { +- impl_unary!(f32x2[f32; 2]: ln_f32); +- impl_unary!(f32x4: ln_v4f32); +- impl_unary!(f32x8: ln_v8f32); +- impl_unary!(f32x16: ln_v16f32); +- +- impl_unary!(f64x2: ln_v2f64); +- impl_unary!(f64x4: ln_v4f64); +- impl_unary!(f64x8: ln_v8f64); +- } +-} +diff --git a/third_party/rust/packed_simd/src/codegen/math/float/macros.rs b/third_party/rust/packed_simd/src/codegen/math/float/macros.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/macros.rs ++++ /dev/null +@@ -1,470 +0,0 @@ +-//! Utility macros +-#![allow(unused)] +- +-macro_rules! impl_unary_ { +- // implementation mapping 1:1 +- (vec | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self) -> Self { +- unsafe { +- use crate::mem::transmute; +- transmute($fun(transmute(self))) +- } +- } +- } +- }; +- // implementation mapping 1:1 for when `$fun` is a generic function +- // like some of the fp math rustc intrinsics (e.g. `fn fun(x: T) -> T`). +- (gen | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self) -> Self { +- unsafe { +- use crate::mem::transmute; +- transmute($fun(self.0)) +- } +- } +- } +- }; +- (scalar | $trait_id:ident, $trait_method:ident, +- $vec_id:ident, [$sid:ident; $scount:expr], $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self) -> Self { +- unsafe { +- union U { +- vec: $vec_id, +- scalars: [$sid; $scount], +- } +- let mut scalars = U { vec: self }.scalars; +- for i in &mut scalars { +- *i = $fun(*i); +- } +- U { scalars }.vec +- } +- } +- } +- }; +- // implementation calling fun twice on each of the vector halves: +- (halves | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vech_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self) -> Self { +- unsafe { +- use crate::mem::transmute; +- union U { +- vec: $vec_id, +- halves: [$vech_id; 2], +- } +- +- let mut halves = U { vec: self }.halves; +- +- *halves.get_unchecked_mut(0) = transmute($fun(transmute(*halves.get_unchecked(0)))); +- *halves.get_unchecked_mut(1) = transmute($fun(transmute(*halves.get_unchecked(1)))); +- +- U { halves }.vec +- } +- } +- } +- }; +- // implementation calling fun four times on each of the vector quarters: +- (quarter | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vecq_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self) -> Self { +- unsafe { +- use crate::mem::transmute; +- union U { +- vec: $vec_id, +- quarters: [$vecq_id; 4], +- } +- +- let mut quarters = U { vec: self }.quarters; +- +- *quarters.get_unchecked_mut(0) = transmute($fun(transmute(*quarters.get_unchecked(0)))); +- *quarters.get_unchecked_mut(1) = transmute($fun(transmute(*quarters.get_unchecked(1)))); +- *quarters.get_unchecked_mut(2) = transmute($fun(transmute(*quarters.get_unchecked(2)))); +- *quarters.get_unchecked_mut(3) = transmute($fun(transmute(*quarters.get_unchecked(3)))); +- +- U { quarters }.vec +- } +- } +- } +- }; +- // implementation calling fun once on a vector twice as large: +- (twice | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vect_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self) -> Self { +- unsafe { +- use crate::mem::{transmute, uninitialized}; +- +- union U { +- vec: [$vec_id; 2], +- twice: $vect_id, +- } +- +- let twice = U { vec: [self, uninitialized()] }.twice; +- let twice = transmute($fun(transmute(twice))); +- +- *(U { twice }.vec.get_unchecked(0)) +- } +- } +- } +- }; +-} +- +-macro_rules! gen_unary_impl_table { +- ($trait_id:ident, $trait_method:ident) => { +- macro_rules! impl_unary { +- ($vid:ident: $fun:ident) => { +- impl_unary_!(vec | $trait_id, $trait_method, $vid, $fun); +- }; +- ($vid:ident[g]: $fun:ident) => { +- impl_unary_!(gen | $trait_id, $trait_method, $vid, $fun); +- }; +- ($vid:ident[$sid:ident; $sc:expr]: $fun:ident) => { +- impl_unary_!(scalar | $trait_id, $trait_method, $vid, [$sid; $sc], $fun); +- }; +- ($vid:ident[s]: $fun:ident) => { +- impl_unary_!(scalar | $trait_id, $trait_method, $vid, $fun); +- }; +- ($vid:ident[h => $vid_h:ident]: $fun:ident) => { +- impl_unary_!(halves | $trait_id, $trait_method, $vid, $vid_h, $fun); +- }; +- ($vid:ident[q => $vid_q:ident]: $fun:ident) => { +- impl_unary_!(quarter | $trait_id, $trait_method, $vid, $vid_q, $fun); +- }; +- ($vid:ident[t => $vid_t:ident]: $fun:ident) => { +- impl_unary_!(twice | $trait_id, $trait_method, $vid, $vid_t, $fun); +- }; +- } +- }; +-} +- +-macro_rules! impl_tertiary_ { +- // implementation mapping 1:1 +- (vec | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self, z: Self) -> Self { +- unsafe { +- use crate::mem::transmute; +- transmute($fun(transmute(self), transmute(y), transmute(z))) +- } +- } +- } +- }; +- (scalar | $trait_id:ident, $trait_method:ident, +- $vec_id:ident, [$sid:ident; $scount:expr], $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self, z: Self) -> Self { +- unsafe { +- union U { +- vec: $vec_id, +- scalars: [$sid; $scount], +- } +- let mut x = U { vec: self }.scalars; +- let y = U { vec: y }.scalars; +- let z = U { vec: z }.scalars; +- for (x, (y, z)) in (&mut scalars).zip(&y).zip(&z) { +- *i = $fun(*i, *y, *z); +- } +- U { vec: x }.vec +- } +- } +- } +- }; +- // implementation calling fun twice on each of the vector halves: +- (halves | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vech_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self, z: Self) -> Self { +- unsafe { +- use crate::mem::transmute; +- union U { +- vec: $vec_id, +- halves: [$vech_id; 2], +- } +- +- let mut x_halves = U { vec: self }.halves; +- let y_halves = U { vec: y }.halves; +- let z_halves = U { vec: z }.halves; +- +- *x_halves.get_unchecked_mut(0) = transmute($fun( +- transmute(*x_halves.get_unchecked(0)), +- transmute(*y_halves.get_unchecked(0)), +- transmute(*z_halves.get_unchecked(0)), +- )); +- *x_halves.get_unchecked_mut(1) = transmute($fun( +- transmute(*x_halves.get_unchecked(1)), +- transmute(*y_halves.get_unchecked(1)), +- transmute(*z_halves.get_unchecked(1)), +- )); +- +- U { halves: x_halves }.vec +- } +- } +- } +- }; +- // implementation calling fun four times on each of the vector quarters: +- (quarter | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vecq_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self, z: Self) -> Self { +- unsafe { +- use crate::mem::transmute; +- union U { +- vec: $vec_id, +- quarters: [$vecq_id; 4], +- } +- +- let mut x_quarters = U { vec: self }.quarters; +- let y_quarters = U { vec: y }.quarters; +- let z_quarters = U { vec: z }.quarters; +- +- *x_quarters.get_unchecked_mut(0) = transmute($fun( +- transmute(*x_quarters.get_unchecked(0)), +- transmute(*y_quarters.get_unchecked(0)), +- transmute(*z_quarters.get_unchecked(0)), +- )); +- +- *x_quarters.get_unchecked_mut(1) = transmute($fun( +- transmute(*x_quarters.get_unchecked(1)), +- transmute(*y_quarters.get_unchecked(1)), +- transmute(*z_quarters.get_unchecked(1)), +- )); +- +- *x_quarters.get_unchecked_mut(2) = transmute($fun( +- transmute(*x_quarters.get_unchecked(2)), +- transmute(*y_quarters.get_unchecked(2)), +- transmute(*z_quarters.get_unchecked(2)), +- )); +- +- *x_quarters.get_unchecked_mut(3) = transmute($fun( +- transmute(*x_quarters.get_unchecked(3)), +- transmute(*y_quarters.get_unchecked(3)), +- transmute(*z_quarters.get_unchecked(3)), +- )); +- +- U { quarters: x_quarters }.vec +- } +- } +- } +- }; +- // implementation calling fun once on a vector twice as large: +- (twice | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vect_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self, z: Self) -> Self { +- unsafe { +- use crate::mem::{transmute, uninitialized}; +- +- union U { +- vec: [$vec_id; 2], +- twice: $vect_id, +- } +- +- let x_twice = U { vec: [self, uninitialized()] }.twice; +- let y_twice = U { vec: [y, uninitialized()] }.twice; +- let z_twice = U { vec: [z, uninitialized()] }.twice; +- let twice: $vect_id = +- transmute($fun(transmute(x_twice), transmute(y_twice), transmute(z_twice))); +- +- *(U { twice }.vec.get_unchecked(0)) +- } +- } +- } +- }; +-} +- +-macro_rules! gen_tertiary_impl_table { +- ($trait_id:ident, $trait_method:ident) => { +- macro_rules! impl_tertiary { +- ($vid:ident: $fun:ident) => { +- impl_tertiary_!(vec | $trait_id, $trait_method, $vid, $fun); +- }; +- ($vid:ident[$sid:ident; $sc:expr]: $fun:ident) => { +- impl_tertiary_!(scalar | $trait_id, $trait_method, $vid, [$sid; $sc], $fun); +- }; +- ($vid:ident[s]: $fun:ident) => { +- impl_tertiary_!(scalar | $trait_id, $trait_method, $vid, $fun); +- }; +- ($vid:ident[h => $vid_h:ident]: $fun:ident) => { +- impl_tertiary_!(halves | $trait_id, $trait_method, $vid, $vid_h, $fun); +- }; +- ($vid:ident[q => $vid_q:ident]: $fun:ident) => { +- impl_tertiary_!(quarter | $trait_id, $trait_method, $vid, $vid_q, $fun); +- }; +- ($vid:ident[t => $vid_t:ident]: $fun:ident) => { +- impl_tertiary_!(twice | $trait_id, $trait_method, $vid, $vid_t, $fun); +- }; +- } +- }; +-} +- +-macro_rules! impl_binary_ { +- // implementation mapping 1:1 +- (vec | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self) -> Self { +- unsafe { +- use crate::mem::transmute; +- transmute($fun(transmute(self), transmute(y))) +- } +- } +- } +- }; +- (scalar | $trait_id:ident, $trait_method:ident, +- $vec_id:ident, [$sid:ident; $scount:expr], $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self) -> Self { +- unsafe { +- union U { +- vec: $vec_id, +- scalars: [$sid; $scount], +- } +- let mut x = U { vec: self }.scalars; +- let y = U { vec: y }.scalars; +- for (x, y) in x.iter_mut().zip(&y) { +- *x = $fun(*x, *y); +- } +- U { scalars: x }.vec +- } +- } +- } +- }; +- // implementation calling fun twice on each of the vector halves: +- (halves | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vech_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self) -> Self { +- unsafe { +- use crate::mem::transmute; +- union U { +- vec: $vec_id, +- halves: [$vech_id; 2], +- } +- +- let mut x_halves = U { vec: self }.halves; +- let y_halves = U { vec: y }.halves; +- +- *x_halves.get_unchecked_mut(0) = transmute($fun( +- transmute(*x_halves.get_unchecked(0)), +- transmute(*y_halves.get_unchecked(0)), +- )); +- *x_halves.get_unchecked_mut(1) = transmute($fun( +- transmute(*x_halves.get_unchecked(1)), +- transmute(*y_halves.get_unchecked(1)), +- )); +- +- U { halves: x_halves }.vec +- } +- } +- } +- }; +- // implementation calling fun four times on each of the vector quarters: +- (quarter | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vecq_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self) -> Self { +- unsafe { +- use crate::mem::transmute; +- union U { +- vec: $vec_id, +- quarters: [$vecq_id; 4], +- } +- +- let mut x_quarters = U { vec: self }.quarters; +- let y_quarters = U { vec: y }.quarters; +- +- *x_quarters.get_unchecked_mut(0) = transmute($fun( +- transmute(*x_quarters.get_unchecked(0)), +- transmute(*y_quarters.get_unchecked(0)), +- )); +- +- *x_quarters.get_unchecked_mut(1) = transmute($fun( +- transmute(*x_quarters.get_unchecked(1)), +- transmute(*y_quarters.get_unchecked(1)), +- )); +- +- *x_quarters.get_unchecked_mut(2) = transmute($fun( +- transmute(*x_quarters.get_unchecked(2)), +- transmute(*y_quarters.get_unchecked(2)), +- )); +- +- *x_quarters.get_unchecked_mut(3) = transmute($fun( +- transmute(*x_quarters.get_unchecked(3)), +- transmute(*y_quarters.get_unchecked(3)), +- )); +- +- U { quarters: x_quarters }.vec +- } +- } +- } +- }; +- // implementation calling fun once on a vector twice as large: +- (twice | $trait_id:ident, $trait_method:ident, $vec_id:ident, +- $vect_id:ident, $fun:ident) => { +- impl $trait_id for $vec_id { +- #[inline] +- fn $trait_method(self, y: Self) -> Self { +- unsafe { +- use crate::mem::{transmute, uninitialized}; +- +- union U { +- vec: [$vec_id; 2], +- twice: $vect_id, +- } +- +- let x_twice = U { vec: [self, uninitialized()] }.twice; +- let y_twice = U { vec: [y, uninitialized()] }.twice; +- let twice: $vect_id = transmute($fun(transmute(x_twice), transmute(y_twice))); +- +- *(U { twice }.vec.get_unchecked(0)) +- } +- } +- } +- }; +-} +- +-macro_rules! gen_binary_impl_table { +- ($trait_id:ident, $trait_method:ident) => { +- macro_rules! impl_binary { +- ($vid:ident: $fun:ident) => { +- impl_binary_!(vec | $trait_id, $trait_method, $vid, $fun); +- }; +- ($vid:ident[$sid:ident; $sc:expr]: $fun:ident) => { +- impl_binary_!(scalar | $trait_id, $trait_method, $vid, [$sid; $sc], $fun); +- }; +- ($vid:ident[s]: $fun:ident) => { +- impl_binary_!(scalar | $trait_id, $trait_method, $vid, $fun); +- }; +- ($vid:ident[h => $vid_h:ident]: $fun:ident) => { +- impl_binary_!(halves | $trait_id, $trait_method, $vid, $vid_h, $fun); +- }; +- ($vid:ident[q => $vid_q:ident]: $fun:ident) => { +- impl_binary_!(quarter | $trait_id, $trait_method, $vid, $vid_q, $fun); +- }; +- ($vid:ident[t => $vid_t:ident]: $fun:ident) => { +- impl_binary_!(twice | $trait_id, $trait_method, $vid, $vid_t, $fun); +- }; +- } +- }; +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/mul_add.rs ++++ /dev/null +@@ -1,109 +0,0 @@ +-//! Vertical floating-point `mul_add` +-#![allow(unused)] +-use crate::*; +- +-// FIXME: 64-bit 1 element mul_add +- +-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; +- #[link_name = "llvm.fma.v4f32"] +- fn fma_v4f32(x: f32x4, y: f32x4, z: f32x4) -> f32x4; +- #[link_name = "llvm.fma.v8f32"] +- fn fma_v8f32(x: f32x8, y: f32x8, z: f32x8) -> f32x8; +- #[link_name = "llvm.fma.v16f32"] +- fn fma_v16f32(x: f32x16, y: f32x16, z: f32x16) -> f32x16; +- /* FIXME 64-bit single elem vectors +- #[link_name = "llvm.fma.v1f64"] +- fn fma_v1f64(x: f64x1, y: f64x1, z: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.fma.v2f64"] +- fn fma_v2f64(x: f64x2, y: f64x2, z: f64x2) -> f64x2; +- #[link_name = "llvm.fma.v4f64"] +- fn fma_v4f64(x: f64x4, y: f64x4, z: f64x4) -> f64x4; +- #[link_name = "llvm.fma.v8f64"] +- fn fma_v8f64(x: f64x8, y: f64x8, z: f64x8) -> f64x8; +-} +- +-gen_tertiary_impl_table!(MulAdd, mul_add); +- +-cfg_if! { +- if #[cfg(target_arch = "s390x")] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- macro_rules! impl_broken { +- ($id:ident) => { +- impl MulAdd for $id { +- #[inline] +- fn mul_add(self, y: Self, z: Self) -> Self { +- self * y + z +- } +- } +- }; +- } +- +- impl_broken!(f32x2); +- impl_broken!(f32x4); +- impl_broken!(f32x8); +- impl_broken!(f32x16); +- +- impl_broken!(f64x2); +- impl_broken!(f64x4); +- impl_broken!(f64x8); +- } else if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_tertiary!(f32x2[t => f32x4]: Sleef_fmaf4_avx2128); +- impl_tertiary!(f32x16[h => f32x8]: Sleef_fmaf8_avx2); +- impl_tertiary!(f64x8[h => f64x4]: Sleef_fmad4_avx2); +- +- impl_tertiary!(f32x4: Sleef_fmaf4_avx2128); +- impl_tertiary!(f32x8: Sleef_fmaf8_avx2); +- impl_tertiary!(f64x2: Sleef_fmad2_avx2128); +- impl_tertiary!(f64x4: Sleef_fmad4_avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_tertiary!(f32x2[t => f32x4]: Sleef_fmaf4_sse4); +- impl_tertiary!(f32x16[h => f32x8]: Sleef_fmaf8_avx); +- impl_tertiary!(f64x8[h => f64x4]: Sleef_fmad4_avx); +- +- impl_tertiary!(f32x4: Sleef_fmaf4_sse4); +- impl_tertiary!(f32x8: Sleef_fmaf8_avx); +- impl_tertiary!(f64x2: Sleef_fmad2_sse4); +- impl_tertiary!(f64x4: Sleef_fmad4_avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_tertiary!(f32x2[t => f32x4]: Sleef_fmaf4_sse4); +- impl_tertiary!(f32x16[q => f32x4]: Sleef_fmaf4_sse4); +- impl_tertiary!(f64x8[q => f64x2]: Sleef_fmad2_sse4); +- +- impl_tertiary!(f32x4: Sleef_fmaf4_sse4); +- impl_tertiary!(f32x8[h => f32x4]: Sleef_fmaf4_sse4); +- impl_tertiary!(f64x2: Sleef_fmad2_sse4); +- impl_tertiary!(f64x4[h => f64x2]: Sleef_fmad2_sse4); +- } else { +- impl_tertiary!(f32x2: fma_v2f32); +- impl_tertiary!(f32x16: fma_v16f32); +- impl_tertiary!(f64x8: fma_v8f64); +- +- impl_tertiary!(f32x4: fma_v4f32); +- impl_tertiary!(f32x8: fma_v8f32); +- impl_tertiary!(f64x2: fma_v2f64); +- impl_tertiary!(f64x4: fma_v4f64); +- } +- } +- } else { +- impl_tertiary!(f32x2: fma_v2f32); +- impl_tertiary!(f32x4: fma_v4f32); +- impl_tertiary!(f32x8: fma_v8f32); +- impl_tertiary!(f32x16: fma_v16f32); +- // impl_tertiary!(f64x1: fma_v1f64); // FIXME 64-bit fmagle elem vectors +- impl_tertiary!(f64x2: fma_v2f64); +- impl_tertiary!(f64x4: fma_v4f64); +- impl_tertiary!(f64x8: fma_v8f64); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/mul_adde.rs ++++ /dev/null +@@ -1,60 +0,0 @@ +-//! Approximation for floating-point `mul_add` +-use crate::*; +- +-// FIXME: 64-bit 1 element mul_adde +- +-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; +- #[link_name = "llvm.fmuladd.v4f32"] +- fn fmuladd_v4f32(x: f32x4, y: f32x4, z: f32x4) -> f32x4; +- #[link_name = "llvm.fmuladd.v8f32"] +- fn fmuladd_v8f32(x: f32x8, y: f32x8, z: f32x8) -> f32x8; +- #[link_name = "llvm.fmuladd.v16f32"] +- fn fmuladd_v16f32(x: f32x16, y: f32x16, z: f32x16) -> f32x16; +- /* FIXME 64-bit single elem vectors +- #[link_name = "llvm.fmuladd.v1f64"] +- fn fmuladd_v1f64(x: f64x1, y: f64x1, z: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.fmuladd.v2f64"] +- fn fmuladd_v2f64(x: f64x2, y: f64x2, z: f64x2) -> f64x2; +- #[link_name = "llvm.fmuladd.v4f64"] +- fn fmuladd_v4f64(x: f64x4, y: f64x4, z: f64x4) -> f64x4; +- #[link_name = "llvm.fmuladd.v8f64"] +- fn fmuladd_v8f64(x: f64x8, y: f64x8, z: f64x8) -> f64x8; +-} +- +-macro_rules! impl_mul_adde { +- ($id:ident : $fn:ident) => { +- impl MulAddE for $id { +- #[inline] +- fn mul_adde(self, y: Self, z: Self) -> Self { +- #[cfg(not(target_arch = "s390x"))] +- { +- use crate::mem::transmute; +- unsafe { transmute($fn(transmute(self), transmute(y), transmute(z))) } +- } +- #[cfg(target_arch = "s390x")] +- { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- self * y + z +- } +- } +- } +- }; +-} +- +-impl_mul_adde!(f32x2: fmuladd_v2f32); +-impl_mul_adde!(f32x4: fmuladd_v4f32); +-impl_mul_adde!(f32x8: fmuladd_v8f32); +-impl_mul_adde!(f32x16: fmuladd_v16f32); +-// impl_mul_adde!(f64x1: fma_v1f64); // FIXME 64-bit fmagle elem vectors +-impl_mul_adde!(f64x2: fmuladd_v2f64); +-impl_mul_adde!(f64x4: fmuladd_v4f64); +-impl_mul_adde!(f64x8: fmuladd_v8f64); +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/powf.rs ++++ /dev/null +@@ -1,112 +0,0 @@ +-//! Vertical floating-point `powf` +-#![allow(unused)] +- +-// FIXME 64-bit powfgle elem vectors mispowfg +- +-use crate::*; +- +-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"] +- fn powf_v4f32(x: f32x4, y: f32x4) -> f32x4; +- #[link_name = "llvm.pow.v8f32"] +- fn powf_v8f32(x: f32x8, y: f32x8) -> f32x8; +- #[link_name = "llvm.pow.v16f32"] +- fn powf_v16f32(x: f32x16, y: f32x16) -> f32x16; +- /* FIXME 64-bit powfgle elem vectors +- #[link_name = "llvm.pow.v1f64"] +- fn powf_v1f64(x: f64x1, y: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.pow.v2f64"] +- fn powf_v2f64(x: f64x2, y: f64x2) -> f64x2; +- #[link_name = "llvm.pow.v4f64"] +- fn powf_v4f64(x: f64x4, y: f64x4) -> f64x4; +- #[link_name = "llvm.pow.v8f64"] +- fn powf_v8f64(x: f64x8, y: f64x8) -> f64x8; +- +- #[link_name = "llvm.pow.f32"] +- fn powf_f32(x: f32, y: f32) -> f32; +- #[link_name = "llvm.pow.f64"] +- fn powf_f64(x: f64, y: f64) -> f64; +-} +- +-gen_binary_impl_table!(Powf, powf); +- +-cfg_if! { +- if #[cfg(target_arch = "s390x")] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- impl_binary!(f32x2[f32; 2]: powf_f32); +- impl_binary!(f32x4[f32; 4]: powf_f32); +- impl_binary!(f32x8[f32; 8]: powf_f32); +- impl_binary!(f32x16[f32; 16]: powf_f32); +- +- impl_binary!(f64x2[f64; 2]: powf_f64); +- impl_binary!(f64x4[f64; 4]: powf_f64); +- impl_binary!(f64x8[f64; 8]: powf_f64); +- } else if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_binary!(f32x2[t => f32x4]: Sleef_powf4_u10avx2128); +- impl_binary!(f32x16[h => f32x8]: Sleef_powf8_u10avx2); +- impl_binary!(f64x8[h => f64x4]: Sleef_powd4_u10avx2); +- +- impl_binary!(f32x4: Sleef_powf4_u10avx2128); +- impl_binary!(f32x8: Sleef_powf8_u10avx2); +- impl_binary!(f64x2: Sleef_powd2_u10avx2128); +- impl_binary!(f64x4: Sleef_powd4_u10avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_binary!(f32x2[t => f32x4]: Sleef_powf4_u10sse4); +- impl_binary!(f32x16[h => f32x8]: Sleef_powf8_u10avx); +- impl_binary!(f64x8[h => f64x4]: Sleef_powd4_u10avx); +- +- impl_binary!(f32x4: Sleef_powf4_u10sse4); +- impl_binary!(f32x8: Sleef_powf8_u10avx); +- impl_binary!(f64x2: Sleef_powd2_u10sse4); +- impl_binary!(f64x4: Sleef_powd4_u10avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_binary!(f32x2[t => f32x4]: Sleef_powf4_u10sse4); +- impl_binary!(f32x16[q => f32x4]: Sleef_powf4_u10sse4); +- impl_binary!(f64x8[q => f64x2]: Sleef_powd2_u10sse4); +- +- impl_binary!(f32x4: Sleef_powf4_u10sse4); +- impl_binary!(f32x8[h => f32x4]: Sleef_powf4_u10sse4); +- impl_binary!(f64x2: Sleef_powd2_u10sse4); +- impl_binary!(f64x4[h => f64x2]: Sleef_powd2_u10sse4); +- } else if #[cfg(target_feature = "sse2")] { +- impl_binary!(f32x2[t => f32x4]: Sleef_powf4_u10sse2); +- impl_binary!(f32x16[q => f32x4]: Sleef_powf4_u10sse2); +- impl_binary!(f64x8[q => f64x2]: Sleef_powd2_u10sse2); +- +- impl_binary!(f32x4: Sleef_powf4_u10sse2); +- impl_binary!(f32x8[h => f32x4]: Sleef_powf4_u10sse2); +- impl_binary!(f64x2: Sleef_powd2_u10sse2); +- impl_binary!(f64x4[h => f64x2]: Sleef_powd2_u10sse2); +- } else { +- impl_binary!(f32x2[f32; 2]: powf_f32); +- impl_binary!(f32x4: powf_v4f32); +- impl_binary!(f32x8: powf_v8f32); +- impl_binary!(f32x16: powf_v16f32); +- +- impl_binary!(f64x2: powf_v2f64); +- impl_binary!(f64x4: powf_v4f64); +- impl_binary!(f64x8: powf_v8f64); +- } +- } +- } else { +- impl_binary!(f32x2[f32; 2]: powf_f32); +- impl_binary!(f32x4: powf_v4f32); +- impl_binary!(f32x8: powf_v8f32); +- impl_binary!(f32x16: powf_v16f32); +- +- impl_binary!(f64x2: powf_v2f64); +- impl_binary!(f64x4: powf_v4f64); +- impl_binary!(f64x8: powf_v8f64); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/sin.rs ++++ /dev/null +@@ -1,103 +0,0 @@ +-//! Vertical floating-point `sin` +-#![allow(unused)] +- +-// FIXME 64-bit 1 elem vectors sin +- +-use crate::*; +- +-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"] +- fn sin_v4f32(x: f32x4) -> f32x4; +- #[link_name = "llvm.sin.v8f32"] +- fn sin_v8f32(x: f32x8) -> f32x8; +- #[link_name = "llvm.sin.v16f32"] +- fn sin_v16f32(x: f32x16) -> f32x16; +- /* FIXME 64-bit single elem vectors +- #[link_name = "llvm.sin.v1f64"] +- fn sin_v1f64(x: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.sin.v2f64"] +- fn sin_v2f64(x: f64x2) -> f64x2; +- #[link_name = "llvm.sin.v4f64"] +- fn sin_v4f64(x: f64x4) -> f64x4; +- #[link_name = "llvm.sin.v8f64"] +- fn sin_v8f64(x: f64x8) -> f64x8; +- +- #[link_name = "llvm.sin.f32"] +- fn sin_f32(x: f32) -> f32; +- #[link_name = "llvm.sin.f64"] +- fn sin_f64(x: f64) -> f64; +-} +- +-gen_unary_impl_table!(Sin, sin); +- +-cfg_if! { +- if #[cfg(target_arch = "s390x")] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- impl_unary!(f32x2[f32; 2]: sin_f32); +- impl_unary!(f32x4[f32; 4]: sin_f32); +- impl_unary!(f32x8[f32; 8]: sin_f32); +- impl_unary!(f32x16[f32; 16]: sin_f32); +- +- impl_unary!(f64x2[f64; 2]: sin_f64); +- impl_unary!(f64x4[f64; 4]: sin_f64); +- impl_unary!(f64x8[f64; 8]: sin_f64); +- } else if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sinf4_u10avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_sinf8_u10avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_sind4_u10avx2); +- +- impl_unary!(f32x4: Sleef_sinf4_u10avx2128); +- impl_unary!(f32x8: Sleef_sinf8_u10avx2); +- impl_unary!(f64x2: Sleef_sind2_u10avx2128); +- impl_unary!(f64x4: Sleef_sind4_u10avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sinf4_u10sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_sinf8_u10avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_sind4_u10avx); +- +- impl_unary!(f32x4: Sleef_sinf4_u10sse4); +- impl_unary!(f32x8: Sleef_sinf8_u10avx); +- impl_unary!(f64x2: Sleef_sind2_u10sse4); +- impl_unary!(f64x4: Sleef_sind4_u10avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sinf4_u10sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_sinf4_u10sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_sind2_u10sse4); +- +- impl_unary!(f32x4: Sleef_sinf4_u10sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_sinf4_u10sse4); +- impl_unary!(f64x2: Sleef_sind2_u10sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_sind2_u10sse4); +- } else { +- impl_unary!(f32x2[f32; 2]: sin_f32); +- impl_unary!(f32x16: sin_v16f32); +- impl_unary!(f64x8: sin_v8f64); +- +- impl_unary!(f32x4: sin_v4f32); +- impl_unary!(f32x8: sin_v8f32); +- impl_unary!(f64x2: sin_v2f64); +- impl_unary!(f64x4: sin_v4f64); +- } +- } +- } else { +- impl_unary!(f32x2[f32; 2]: sin_f32); +- impl_unary!(f32x4: sin_v4f32); +- impl_unary!(f32x8: sin_v8f32); +- impl_unary!(f32x16: sin_v16f32); +- +- impl_unary!(f64x2: sin_v2f64); +- impl_unary!(f64x4: sin_v4f64); +- impl_unary!(f64x8: sin_v8f64); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/sin_cos_pi.rs ++++ /dev/null +@@ -1,188 +0,0 @@ +-//! Vertical floating-point `sin_cos` +-#![allow(unused)] +- +-// FIXME 64-bit 1 elem vectors sin_cos +- +-use crate::*; +- +-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); +- #[inline] +- fn sin_cos_pi(self) -> Self::Output { +- let v = self * Self::splat($PI); +- (v.sin(), v.cos()) +- } +- } +- }; +-} +- +-macro_rules! impl_def32 { +- ($vid:ident) => { +- impl_def!($vid, crate::f32::consts::PI); +- }; +-} +-macro_rules! impl_def64 { +- ($vid:ident) => { +- impl_def!($vid, crate::f64::consts::PI); +- }; +-} +- +-macro_rules! impl_unary_t { +- ($vid:ident: $fun:ident) => { +- impl SinCosPi for $vid { +- type Output = (Self, Self); +- fn sin_cos_pi(self) -> Self::Output { +- unsafe { +- use crate::mem::transmute; +- transmute($fun(transmute(self))) +- } +- } +- } +- }; +- ($vid:ident[t => $vid_t:ident]: $fun:ident) => { +- impl SinCosPi for $vid { +- type Output = (Self, Self); +- fn sin_cos_pi(self) -> Self::Output { +- unsafe { +- use crate::mem::{transmute, uninitialized}; +- +- union U { +- vec: [$vid; 2], +- twice: $vid_t, +- } +- +- let twice = U { vec: [self, uninitialized()] }.twice; +- let twice = transmute($fun(transmute(twice))); +- +- union R { +- twice: ($vid_t, $vid_t), +- vecs: ([$vid; 2], [$vid; 2]), +- } +- let r = R { twice }.vecs; +- (*r.0.get_unchecked(0), *r.0.get_unchecked(1)) +- } +- } +- } +- }; +- ($vid:ident[h => $vid_h:ident]: $fun:ident) => { +- impl SinCosPi for $vid { +- type Output = (Self, Self); +- fn sin_cos_pi(self) -> Self::Output { +- unsafe { +- use crate::mem::transmute; +- +- union U { +- vec: $vid, +- halves: [$vid_h; 2], +- } +- +- let halves = U { vec: self }.halves; +- +- let res_0: ($vid_h, $vid_h) = transmute($fun(transmute(*halves.get_unchecked(0)))); +- let res_1: ($vid_h, $vid_h) = transmute($fun(transmute(*halves.get_unchecked(1)))); +- +- union R { +- result: ($vid, $vid), +- halves: ([$vid_h; 2], [$vid_h; 2]), +- } +- R { halves: ([res_0.0, res_1.0], [res_0.1, res_1.1]) }.result +- } +- } +- } +- }; +- ($vid:ident[q => $vid_q:ident]: $fun:ident) => { +- impl SinCosPi for $vid { +- type Output = (Self, Self); +- fn sin_cos_pi(self) -> Self::Output { +- unsafe { +- use crate::mem::transmute; +- +- union U { +- vec: $vid, +- quarters: [$vid_q; 4], +- } +- +- let quarters = U { vec: self }.quarters; +- +- let res_0: ($vid_q, $vid_q) = transmute($fun(transmute(*quarters.get_unchecked(0)))); +- let res_1: ($vid_q, $vid_q) = transmute($fun(transmute(*quarters.get_unchecked(1)))); +- let res_2: ($vid_q, $vid_q) = transmute($fun(transmute(*quarters.get_unchecked(2)))); +- let res_3: ($vid_q, $vid_q) = transmute($fun(transmute(*quarters.get_unchecked(3)))); +- +- union R { +- result: ($vid, $vid), +- quarters: ([$vid_q; 4], [$vid_q; 4]), +- } +- R { +- quarters: ( +- [res_0.0, res_1.0, res_2.0, res_3.0], +- [res_0.1, res_1.1, res_2.1, res_3.1], +- ), +- } +- .result +- } +- } +- } +- }; +-} +- +-cfg_if! { +- if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary_t!(f32x2[t => f32x4]: Sleef_sincospif4_u05avx2128); +- impl_unary_t!(f32x16[h => f32x8]: Sleef_sincospif8_u05avx2); +- impl_unary_t!(f64x8[h => f64x4]: Sleef_sincospid4_u05avx2); +- +- impl_unary_t!(f32x4: Sleef_sincospif4_u05avx2128); +- impl_unary_t!(f32x8: Sleef_sincospif8_u05avx2); +- impl_unary_t!(f64x2: Sleef_sincospid2_u05avx2128); +- impl_unary_t!(f64x4: Sleef_sincospid4_u05avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary_t!(f32x2[t => f32x4]: Sleef_sincospif4_u05sse4); +- impl_unary_t!(f32x16[h => f32x8]: Sleef_sincospif8_u05avx); +- impl_unary_t!(f64x8[h => f64x4]: Sleef_sincospid4_u05avx); +- +- impl_unary_t!(f32x4: Sleef_sincospif4_u05sse4); +- impl_unary_t!(f32x8: Sleef_sincospif8_u05avx); +- impl_unary_t!(f64x2: Sleef_sincospid2_u05sse4); +- impl_unary_t!(f64x4: Sleef_sincospid4_u05avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary_t!(f32x2[t => f32x4]: Sleef_sincospif4_u05sse4); +- impl_unary_t!(f32x16[q => f32x4]: Sleef_sincospif4_u05sse4); +- impl_unary_t!(f64x8[q => f64x2]: Sleef_sincospid2_u05sse4); +- +- impl_unary_t!(f32x4: Sleef_sincospif4_u05sse4); +- impl_unary_t!(f32x8[h => f32x4]: Sleef_sincospif4_u05sse4); +- impl_unary_t!(f64x2: Sleef_sincospid2_u05sse4); +- impl_unary_t!(f64x4[h => f64x2]: Sleef_sincospid2_u05sse4); +- } else { +- impl_def32!(f32x2); +- impl_def32!(f32x4); +- impl_def32!(f32x8); +- impl_def32!(f32x16); +- +- impl_def64!(f64x2); +- impl_def64!(f64x4); +- impl_def64!(f64x8); +- } +- } +- } else { +- impl_def32!(f32x2); +- impl_def32!(f32x4); +- impl_def32!(f32x8); +- impl_def32!(f32x16); +- +- impl_def64!(f64x2); +- impl_def64!(f64x4); +- impl_def64!(f64x8); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/sin_pi.rs ++++ /dev/null +@@ -1,87 +0,0 @@ +-//! Vertical floating-point `sin_pi` +-#![allow(unused)] +- +-// FIXME 64-bit 1 elem vectors sin_pi +- +-use crate::*; +- +-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 { +- #[inline] +- fn sin_pi(self) -> Self { +- (self * Self::splat($PI)).sin() +- } +- } +- }; +-} +-macro_rules! impl_def32 { +- ($vid:ident) => { +- impl_def!($vid, crate::f32::consts::PI); +- }; +-} +-macro_rules! impl_def64 { +- ($vid:ident) => { +- impl_def!($vid, crate::f64::consts::PI); +- }; +-} +- +-cfg_if! { +- if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sinpif4_u05avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_sinpif8_u05avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_sinpid4_u05avx2); +- +- impl_unary!(f32x4: Sleef_sinpif4_u05avx2128); +- impl_unary!(f32x8: Sleef_sinpif8_u05avx2); +- impl_unary!(f64x2: Sleef_sinpid2_u05avx2128); +- impl_unary!(f64x4: Sleef_sinpid4_u05avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sinpif4_u05sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_sinpif8_u05avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_sinpid4_u05avx); +- +- impl_unary!(f32x4: Sleef_sinpif4_u05sse4); +- impl_unary!(f32x8: Sleef_sinpif8_u05avx); +- impl_unary!(f64x2: Sleef_sinpid2_u05sse4); +- impl_unary!(f64x4: Sleef_sinpid4_u05avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sinpif4_u05sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_sinpif4_u05sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_sinpid2_u05sse4); +- +- impl_unary!(f32x4: Sleef_sinpif4_u05sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_sinpif4_u05sse4); +- impl_unary!(f64x2: Sleef_sinpid2_u05sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_sinpid2_u05sse4); +- } else { +- impl_def32!(f32x2); +- impl_def32!(f32x4); +- impl_def32!(f32x8); +- impl_def32!(f32x16); +- +- impl_def64!(f64x2); +- impl_def64!(f64x4); +- impl_def64!(f64x8); +- } +- } +- } else { +- impl_def32!(f32x2); +- impl_def32!(f32x4); +- impl_def32!(f32x8); +- impl_def32!(f32x16); +- +- impl_def64!(f64x2); +- impl_def64!(f64x4); +- impl_def64!(f64x8); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/sqrt.rs ++++ /dev/null +@@ -1,103 +0,0 @@ +-//! Vertical floating-point `sqrt` +-#![allow(unused)] +- +-// FIXME 64-bit 1 elem vectors sqrt +- +-use crate::*; +- +-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"] +- fn sqrt_v4f32(x: f32x4) -> f32x4; +- #[link_name = "llvm.sqrt.v8f32"] +- fn sqrt_v8f32(x: f32x8) -> f32x8; +- #[link_name = "llvm.sqrt.v16f32"] +- fn sqrt_v16f32(x: f32x16) -> f32x16; +- /* FIXME 64-bit sqrtgle elem vectors +- #[link_name = "llvm.sqrt.v1f64"] +- fn sqrt_v1f64(x: f64x1) -> f64x1; +- */ +- #[link_name = "llvm.sqrt.v2f64"] +- fn sqrt_v2f64(x: f64x2) -> f64x2; +- #[link_name = "llvm.sqrt.v4f64"] +- fn sqrt_v4f64(x: f64x4) -> f64x4; +- #[link_name = "llvm.sqrt.v8f64"] +- fn sqrt_v8f64(x: f64x8) -> f64x8; +- +- #[link_name = "llvm.sqrt.f32"] +- fn sqrt_f32(x: f32) -> f32; +- #[link_name = "llvm.sqrt.f64"] +- fn sqrt_f64(x: f64) -> f64; +-} +- +-gen_unary_impl_table!(Sqrt, sqrt); +- +-cfg_if! { +- if #[cfg(target_arch = "s390x")] { +- // FIXME: https://github.com/rust-lang-nursery/packed_simd/issues/14 +- impl_unary!(f32x2[f32; 2]: sqrt_f32); +- impl_unary!(f32x4[f32; 4]: sqrt_f32); +- impl_unary!(f32x8[f32; 8]: sqrt_f32); +- impl_unary!(f32x16[f32; 16]: sqrt_f32); +- +- impl_unary!(f64x2[f64; 2]: sqrt_f64); +- impl_unary!(f64x4[f64; 4]: sqrt_f64); +- impl_unary!(f64x8[f64; 8]: sqrt_f64); +- } else if #[cfg(all(target_arch = "x86_64", feature = "sleef-sys"))] { +- use sleef_sys::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sqrtf4_avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_sqrtf8_avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_sqrtd4_avx2); +- +- impl_unary!(f32x4: Sleef_sqrtf4_avx2128); +- impl_unary!(f32x8: Sleef_sqrtf8_avx2); +- impl_unary!(f64x2: Sleef_sqrtd2_avx2128); +- impl_unary!(f64x4: Sleef_sqrtd4_avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sqrtf4_sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_sqrtf8_avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_sqrtd4_avx); +- +- impl_unary!(f32x4: Sleef_sqrtf4_sse4); +- impl_unary!(f32x8: Sleef_sqrtf8_avx); +- impl_unary!(f64x2: Sleef_sqrtd2_sse4); +- impl_unary!(f64x4: Sleef_sqrtd4_avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sqrtf4_sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_sqrtf4_sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_sqrtd2_sse4); +- +- impl_unary!(f32x4: Sleef_sqrtf4_sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_sqrtf4_sse4); +- impl_unary!(f64x2: Sleef_sqrtd2_sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_sqrtd2_sse4); +- } else { +- impl_unary!(f32x2[f32; 2]: sqrt_f32); +- impl_unary!(f32x16: sqrt_v16f32); +- impl_unary!(f64x8: sqrt_v8f64); +- +- impl_unary!(f32x4: sqrt_v4f32); +- impl_unary!(f32x8: sqrt_v8f32); +- impl_unary!(f64x2: sqrt_v2f64); +- impl_unary!(f64x4: sqrt_v4f64); +- } +- } +- } else { +- impl_unary!(f32x2[f32; 2]: sqrt_f32); +- impl_unary!(f32x4: sqrt_v4f32); +- impl_unary!(f32x8: sqrt_v8f32); +- impl_unary!(f32x16: sqrt_v16f32); +- +- impl_unary!(f64x2: sqrt_v2f64); +- impl_unary!(f64x4: sqrt_v4f64); +- impl_unary!(f64x8: sqrt_v8f64); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/math/float/sqrte.rs ++++ /dev/null +@@ -1,67 +0,0 @@ +-//! Vertical floating-point `sqrt` +-#![allow(unused)] +- +-// FIXME 64-bit 1 elem vectors sqrte +- +-use crate::llvm::simd_fsqrt; +-use crate::*; +- +-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::*; +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sqrtf4_u35avx2128); +- impl_unary!(f32x16[h => f32x8]: Sleef_sqrtf8_u35avx2); +- impl_unary!(f64x8[h => f64x4]: Sleef_sqrtd4_u35avx2); +- +- impl_unary!(f32x4: Sleef_sqrtf4_u35avx2128); +- impl_unary!(f32x8: Sleef_sqrtf8_u35avx2); +- impl_unary!(f64x2: Sleef_sqrtd2_u35avx2128); +- impl_unary!(f64x4: Sleef_sqrtd4_u35avx2); +- } else if #[cfg(target_feature = "avx")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sqrtf4_u35sse4); +- impl_unary!(f32x16[h => f32x8]: Sleef_sqrtf8_u35avx); +- impl_unary!(f64x8[h => f64x4]: Sleef_sqrtd4_u35avx); +- +- impl_unary!(f32x4: Sleef_sqrtf4_u35sse4); +- impl_unary!(f32x8: Sleef_sqrtf8_u35avx); +- impl_unary!(f64x2: Sleef_sqrtd2_u35sse4); +- impl_unary!(f64x4: Sleef_sqrtd4_u35avx); +- } else if #[cfg(target_feature = "sse4.2")] { +- impl_unary!(f32x2[t => f32x4]: Sleef_sqrtf4_u35sse4); +- impl_unary!(f32x16[q => f32x4]: Sleef_sqrtf4_u35sse4); +- impl_unary!(f64x8[q => f64x2]: Sleef_sqrtd2_u35sse4); +- +- impl_unary!(f32x4: Sleef_sqrtf4_u35sse4); +- impl_unary!(f32x8[h => f32x4]: Sleef_sqrtf4_u35sse4); +- impl_unary!(f64x2: Sleef_sqrtd2_u35sse4); +- impl_unary!(f64x4[h => f64x2]: Sleef_sqrtd2_u35sse4); +- } else { +- impl_unary!(f32x2[g]: simd_fsqrt); +- impl_unary!(f32x16[g]: simd_fsqrt); +- impl_unary!(f64x8[g]: simd_fsqrt); +- +- impl_unary!(f32x4[g]: simd_fsqrt); +- impl_unary!(f32x8[g]: simd_fsqrt); +- impl_unary!(f64x2[g]: simd_fsqrt); +- impl_unary!(f64x4[g]: simd_fsqrt); +- } +- } +- } else { +- impl_unary!(f32x2[g]: simd_fsqrt); +- impl_unary!(f32x4[g]: simd_fsqrt); +- impl_unary!(f32x8[g]: simd_fsqrt); +- impl_unary!(f32x16[g]: simd_fsqrt); +- +- impl_unary!(f64x2[g]: simd_fsqrt); +- impl_unary!(f64x4[g]: simd_fsqrt); +- impl_unary!(f64x8[g]: simd_fsqrt); +- } +-} +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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/pointer_sized_int.rs ++++ /dev/null +@@ -1,28 +0,0 @@ +-//! Provides `isize` and `usize` +- +-use cfg_if::cfg_if; +- +-cfg_if! { +- if #[cfg(target_pointer_width = "8")] { +- pub(crate) type isize_ = i8; +- pub(crate) type usize_ = u8; +- } else if #[cfg(target_pointer_width = "16")] { +- pub(crate) type isize_ = i16; +- pub(crate) type usize_ = u16; +- } else if #[cfg(target_pointer_width = "32")] { +- pub(crate) type isize_ = i32; +- pub(crate) type usize_ = u32; +- +- } else if #[cfg(target_pointer_width = "64")] { +- pub(crate) type isize_ = i64; +- pub(crate) type usize_ = u64; +- } else if #[cfg(target_pointer_width = "64")] { +- pub(crate) type isize_ = i64; +- pub(crate) type usize_ = u64; +- } else if #[cfg(target_pointer_width = "128")] { +- 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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions.rs ++++ /dev/null +@@ -1,1 +0,0 @@ +-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 +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask.rs ++++ /dev/null +@@ -1,69 +0,0 @@ +-//! Code generation workaround for `all()` mask horizontal reduction. +-//! +-//! Works around [LLVM bug 36702]. +-//! +-//! [LLVM bug 36702]: https://bugs.llvm.org/show_bug.cgi?id=36702 +-#![allow(unused_macros)] +- +-use crate::*; +- +-pub(crate) trait All: crate::marker::Sized { +- unsafe fn all(self) -> bool; +-} +- +-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"))] { +- #[macro_use] +- mod x86; +- } else if #[cfg(all(target_arch = "arm", target_feature = "v7", +- target_feature = "neon", +- any(feature = "core_arch", libcore_neon)))] { +- #[macro_use] +- mod arm; +- } else if #[cfg(all(target_arch = "aarch64", target_feature = "neon"))] { +- #[macro_use] +- mod aarch64; +- } else { +- #[macro_use] +- mod fallback; +- } +-} +- +-impl_mask_reductions!(m8x2); +-impl_mask_reductions!(m8x4); +-impl_mask_reductions!(m8x8); +-impl_mask_reductions!(m8x16); +-impl_mask_reductions!(m8x32); +-impl_mask_reductions!(m8x64); +- +-impl_mask_reductions!(m16x2); +-impl_mask_reductions!(m16x4); +-impl_mask_reductions!(m16x8); +-impl_mask_reductions!(m16x16); +-impl_mask_reductions!(m16x32); +- +-impl_mask_reductions!(m32x2); +-impl_mask_reductions!(m32x4); +-impl_mask_reductions!(m32x8); +-impl_mask_reductions!(m32x16); +- +-// FIXME: 64-bit single element vector +-// impl_mask_reductions!(m64x1); +-impl_mask_reductions!(m64x2); +-impl_mask_reductions!(m64x4); +-impl_mask_reductions!(m64x8); +- +-impl_mask_reductions!(m128x1); +-impl_mask_reductions!(m128x2); +-impl_mask_reductions!(m128x4); +- +-impl_mask_reductions!(msizex2); +-impl_mask_reductions!(msizex4); +-impl_mask_reductions!(msizex8); +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/aarch64.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/aarch64.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/aarch64.rs ++++ /dev/null +@@ -1,81 +0,0 @@ +-//! Mask reductions implementation for `aarch64` targets +- +-/// 128-bit wide vectors +-macro_rules! aarch64_128_neon_impl { +- ($id:ident, $vmin:ident, $vmax:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "neon")] +- unsafe fn all(self) -> bool { +- use crate::arch::aarch64::$vmin; +- $vmin(crate::mem::transmute(self)) != 0 +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "neon")] +- unsafe fn any(self) -> bool { +- use crate::arch::aarch64::$vmax; +- $vmax(crate::mem::transmute(self)) != 0 +- } +- } +- }; +-} +- +-/// 64-bit wide vectors +-macro_rules! aarch64_64_neon_impl { +- ($id:ident, $vec128:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "neon")] +- unsafe fn all(self) -> bool { +- // Duplicates the 64-bit vector into a 128-bit one and +- // calls all on that. +- union U { +- halves: ($id, $id), +- vec: $vec128, +- } +- U { halves: (self, self) }.vec.all() +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "neon")] +- unsafe fn any(self) -> bool { +- union U { +- halves: ($id, $id), +- vec: $vec128, +- } +- U { halves: (self, self) }.vec.any() +- } +- } +- }; +-} +- +-/// Mask reduction implementation for `aarch64` targets +-macro_rules! impl_mask_reductions { +- // 64-bit wide masks +- (m8x8) => { +- aarch64_64_neon_impl!(m8x8, m8x16); +- }; +- (m16x4) => { +- aarch64_64_neon_impl!(m16x4, m16x8); +- }; +- (m32x2) => { +- aarch64_64_neon_impl!(m32x2, m32x4); +- }; +- // 128-bit wide masks +- (m8x16) => { +- aarch64_128_neon_impl!(m8x16, vminvq_u8, vmaxvq_u8); +- }; +- (m16x8) => { +- aarch64_128_neon_impl!(m16x8, vminvq_u16, vmaxvq_u16); +- }; +- (m32x4) => { +- aarch64_128_neon_impl!(m32x4, vminvq_u32, vmaxvq_u32); +- }; +- // Fallback to LLVM's default code-generation: +- ($id:ident) => { +- fallback_impl!($id); +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/arm.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/arm.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/arm.rs ++++ /dev/null +@@ -1,56 +0,0 @@ +-//! Mask reductions implementation for `arm` targets +- +-/// Implementation for ARM + v7 + NEON for 64-bit or 128-bit wide vectors with +-/// more than two elements. +-macro_rules! arm_128_v7_neon_impl { +- ($id:ident, $half:ident, $vpmin:ident, $vpmax:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "v7,neon")] +- unsafe fn all(self) -> bool { +- use crate::arch::arm::$vpmin; +- use crate::mem::transmute; +- union U { +- halves: ($half, $half), +- vec: $id, +- } +- let halves = U { vec: self }.halves; +- let h: $half = transmute($vpmin(transmute(halves.0), transmute(halves.1))); +- h.all() +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "v7,neon")] +- unsafe fn any(self) -> bool { +- use crate::arch::arm::$vpmax; +- use crate::mem::transmute; +- union U { +- halves: ($half, $half), +- vec: $id, +- } +- let halves = U { vec: self }.halves; +- let h: $half = transmute($vpmax(transmute(halves.0), transmute(halves.1))); +- h.any() +- } +- } +- }; +-} +- +-/// Mask reduction implementation for `arm` targets +-macro_rules! impl_mask_reductions { +- // 128-bit wide masks +- (m8x16) => { +- arm_128_v7_neon_impl!(m8x16, m8x8, vpmin_u8, vpmax_u8); +- }; +- (m16x8) => { +- arm_128_v7_neon_impl!(m16x8, m16x4, vpmin_u16, vpmax_u16); +- }; +- (m32x4) => { +- arm_128_v7_neon_impl!(m32x4, m32x2, vpmin_u32, vpmax_u32); +- }; +- // Fallback to LLVM's default code-generation: +- ($id:ident) => { +- fallback_impl!($id); +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/fallback.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/fallback.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/fallback.rs ++++ /dev/null +@@ -1,8 +0,0 @@ +-//! Default mask reduction implementations. +- +-/// Default mask reduction implementation +-macro_rules! impl_mask_reductions { +- ($id:ident) => { +- fallback_impl!($id); +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/fallback_impl.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/fallback_impl.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/fallback_impl.rs ++++ /dev/null +@@ -1,237 +0,0 @@ +-//! Default implementation of a mask reduction for any target. +- +-macro_rules! fallback_to_other_impl { +- ($id:ident, $other:ident) => { +- impl All for $id { +- #[inline] +- unsafe fn all(self) -> bool { +- let m: $other = crate::mem::transmute(self); +- m.all() +- } +- } +- impl Any for $id { +- #[inline] +- unsafe fn any(self) -> bool { +- let m: $other = crate::mem::transmute(self); +- m.any() +- } +- } +- }; +-} +- +-/// Fallback implementation. +-macro_rules! fallback_impl { +- // 16-bit wide masks: +- (m8x2) => { +- impl All for m8x2 { +- #[inline] +- unsafe fn all(self) -> bool { +- let i: u16 = crate::mem::transmute(self); +- i == u16::max_value() +- } +- } +- impl Any for m8x2 { +- #[inline] +- unsafe fn any(self) -> bool { +- let i: u16 = crate::mem::transmute(self); +- i != 0 +- } +- } +- }; +- // 32-bit wide masks +- (m8x4) => { +- impl All for m8x4 { +- #[inline] +- unsafe fn all(self) -> bool { +- let i: u32 = crate::mem::transmute(self); +- i == u32::max_value() +- } +- } +- impl Any for m8x4 { +- #[inline] +- unsafe fn any(self) -> bool { +- let i: u32 = crate::mem::transmute(self); +- i != 0 +- } +- } +- }; +- (m16x2) => { +- fallback_to_other_impl!(m16x2, m8x4); +- }; +- // 64-bit wide masks: +- (m8x8) => { +- impl All for m8x8 { +- #[inline] +- unsafe fn all(self) -> bool { +- let i: u64 = crate::mem::transmute(self); +- i == u64::max_value() +- } +- } +- impl Any for m8x8 { +- #[inline] +- unsafe fn any(self) -> bool { +- let i: u64 = crate::mem::transmute(self); +- i != 0 +- } +- } +- }; +- (m16x4) => { +- fallback_to_other_impl!(m16x4, m8x8); +- }; +- (m32x2) => { +- fallback_to_other_impl!(m32x2, m16x4); +- }; +- // FIXME: 64x1 maxk +- // 128-bit wide masks: +- (m8x16) => { +- impl All for m8x16 { +- #[inline] +- unsafe fn all(self) -> bool { +- let i: u128 = crate::mem::transmute(self); +- i == u128::max_value() +- } +- } +- impl Any for m8x16 { +- #[inline] +- unsafe fn any(self) -> bool { +- let i: u128 = crate::mem::transmute(self); +- i != 0 +- } +- } +- }; +- (m16x8) => { +- fallback_to_other_impl!(m16x8, m8x16); +- }; +- (m32x4) => { +- fallback_to_other_impl!(m32x4, m16x8); +- }; +- (m64x2) => { +- fallback_to_other_impl!(m64x2, m32x4); +- }; +- (m128x1) => { +- fallback_to_other_impl!(m128x1, m64x2); +- }; +- // 256-bit wide masks +- (m8x32) => { +- impl All for m8x32 { +- #[inline] +- unsafe fn all(self) -> bool { +- let i: [u128; 2] = crate::mem::transmute(self); +- let o: [u128; 2] = [u128::max_value(); 2]; +- i == o +- } +- } +- impl Any for m8x32 { +- #[inline] +- unsafe fn any(self) -> bool { +- let i: [u128; 2] = crate::mem::transmute(self); +- let o: [u128; 2] = [0; 2]; +- i != o +- } +- } +- }; +- (m16x16) => { +- fallback_to_other_impl!(m16x16, m8x32); +- }; +- (m32x8) => { +- fallback_to_other_impl!(m32x8, m16x16); +- }; +- (m64x4) => { +- fallback_to_other_impl!(m64x4, m32x8); +- }; +- (m128x2) => { +- fallback_to_other_impl!(m128x2, m64x4); +- }; +- // 512-bit wide masks +- (m8x64) => { +- impl All for m8x64 { +- #[inline] +- unsafe fn all(self) -> bool { +- let i: [u128; 4] = crate::mem::transmute(self); +- let o: [u128; 4] = [u128::max_value(); 4]; +- i == o +- } +- } +- impl Any for m8x64 { +- #[inline] +- unsafe fn any(self) -> bool { +- let i: [u128; 4] = crate::mem::transmute(self); +- let o: [u128; 4] = [0; 4]; +- i != o +- } +- } +- }; +- (m16x32) => { +- fallback_to_other_impl!(m16x32, m8x64); +- }; +- (m32x16) => { +- fallback_to_other_impl!(m32x16, m16x32); +- }; +- (m64x8) => { +- fallback_to_other_impl!(m64x8, m32x16); +- }; +- (m128x4) => { +- fallback_to_other_impl!(m128x4, m64x8); +- }; +- // Masks with pointer-sized elements64 +- (msizex2) => { +- cfg_if! { +- if #[cfg(target_pointer_width = "64")] { +- fallback_to_other_impl!(msizex2, m64x2); +- } else if #[cfg(target_pointer_width = "32")] { +- fallback_to_other_impl!(msizex2, m32x2); +- } else { +- compile_error!("unsupported target_pointer_width"); +- } +- } +- }; +- (msizex4) => { +- cfg_if! { +- if #[cfg(target_pointer_width = "64")] { +- fallback_to_other_impl!(msizex4, m64x4); +- } else if #[cfg(target_pointer_width = "32")] { +- fallback_to_other_impl!(msizex4, m32x4); +- } else { +- compile_error!("unsupported target_pointer_width"); +- } +- } +- }; +- (msizex8) => { +- cfg_if! { +- if #[cfg(target_pointer_width = "64")] { +- fallback_to_other_impl!(msizex8, m64x8); +- } else if #[cfg(target_pointer_width = "32")] { +- fallback_to_other_impl!(msizex8, m32x8); +- } else { +- compile_error!("unsupported target_pointer_width"); +- } +- } +- }; +-} +- +-macro_rules! recurse_half { +- ($vid:ident, $vid_h:ident) => { +- impl All for $vid { +- #[inline] +- unsafe fn all(self) -> bool { +- union U { +- halves: ($vid_h, $vid_h), +- vec: $vid, +- } +- let halves = U { vec: self }.halves; +- halves.0.all() && halves.1.all() +- } +- } +- impl Any for $vid { +- #[inline] +- unsafe fn any(self) -> bool { +- union U { +- halves: ($vid_h, $vid_h), +- vec: $vid, +- } +- let halves = U { vec: self }.halves; +- halves.0.any() || halves.1.any() +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/x86.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86.rs ++++ /dev/null +@@ -1,216 +0,0 @@ +-//! Mask reductions implementation for `x86` and `x86_64` targets +- +-#[cfg(target_feature = "sse")] +-#[macro_use] +-mod sse; +- +-#[cfg(target_feature = "sse2")] +-#[macro_use] +-mod sse2; +- +-#[cfg(target_feature = "avx")] +-#[macro_use] +-mod avx; +- +-#[cfg(target_feature = "avx2")] +-#[macro_use] +-mod avx2; +- +-/// x86 64-bit m8x8 implementation +-macro_rules! x86_m8x8_impl { +- ($id:ident) => { +- fallback_impl!($id); +- }; +-} +- +-/// x86 128-bit m8x16 implementation +-macro_rules! x86_m8x16_impl { +- ($id:ident) => { +- cfg_if! { +- if #[cfg(target_feature = "sse2")] { +- x86_m8x16_sse2_impl!($id); +- } else { +- fallback_impl!($id); +- } +- } +- }; +-} +- +-/// x86 128-bit m32x4 implementation +-macro_rules! x86_m32x4_impl { +- ($id:ident) => { +- cfg_if! { +- if #[cfg(target_feature = "sse")] { +- x86_m32x4_sse_impl!($id); +- } else { +- fallback_impl!($id); +- } +- } +- }; +-} +- +-/// x86 128-bit m64x2 implementation +-macro_rules! x86_m64x2_impl { +- ($id:ident) => { +- cfg_if! { +- if #[cfg(target_feature = "sse2")] { +- x86_m64x2_sse2_impl!($id); +- } else if #[cfg(target_feature = "sse")] { +- x86_m32x4_sse_impl!($id); +- } else { +- fallback_impl!($id); +- } +- } +- }; +-} +- +-/// x86 256-bit m8x32 implementation +-macro_rules! x86_m8x32_impl { +- ($id:ident, $half_id:ident) => { +- cfg_if! { +- if #[cfg(target_feature = "avx2")] { +- x86_m8x32_avx2_impl!($id); +- } else if #[cfg(target_feature = "avx")] { +- x86_m8x32_avx_impl!($id); +- } else if #[cfg(target_feature = "sse2")] { +- recurse_half!($id, $half_id); +- } else { +- fallback_impl!($id); +- } +- } +- }; +-} +- +-/// x86 256-bit m32x8 implementation +-macro_rules! x86_m32x8_impl { +- ($id:ident, $half_id:ident) => { +- cfg_if! { +- if #[cfg(target_feature = "avx")] { +- x86_m32x8_avx_impl!($id); +- } else if #[cfg(target_feature = "sse")] { +- recurse_half!($id, $half_id); +- } else { +- fallback_impl!($id); +- } +- } +- }; +-} +- +-/// x86 256-bit m64x4 implementation +-macro_rules! x86_m64x4_impl { +- ($id:ident, $half_id:ident) => { +- cfg_if! { +- if #[cfg(target_feature = "avx")] { +- x86_m64x4_avx_impl!($id); +- } else if #[cfg(target_feature = "sse")] { +- recurse_half!($id, $half_id); +- } else { +- fallback_impl!($id); +- } +- } +- }; +-} +- +-/// Fallback implementation. +-macro_rules! x86_intr_impl { +- ($id:ident) => { +- impl All for $id { +- #[inline] +- unsafe fn all(self) -> bool { +- use crate::llvm::simd_reduce_all; +- simd_reduce_all(self.0) +- } +- } +- impl Any for $id { +- #[inline] +- unsafe fn any(self) -> bool { +- use crate::llvm::simd_reduce_any; +- simd_reduce_any(self.0) +- } +- } +- }; +-} +- +-/// Mask reduction implementation for `x86` and `x86_64` targets +-macro_rules! impl_mask_reductions { +- // 64-bit wide masks +- (m8x8) => { +- x86_m8x8_impl!(m8x8); +- }; +- (m16x4) => { +- x86_m8x8_impl!(m16x4); +- }; +- (m32x2) => { +- x86_m8x8_impl!(m32x2); +- }; +- // 128-bit wide masks +- (m8x16) => { +- x86_m8x16_impl!(m8x16); +- }; +- (m16x8) => { +- x86_m8x16_impl!(m16x8); +- }; +- (m32x4) => { +- x86_m32x4_impl!(m32x4); +- }; +- (m64x2) => { +- x86_m64x2_impl!(m64x2); +- }; +- (m128x1) => { +- x86_intr_impl!(m128x1); +- }; +- // 256-bit wide masks: +- (m8x32) => { +- x86_m8x32_impl!(m8x32, m8x16); +- }; +- (m16x16) => { +- x86_m8x32_impl!(m16x16, m16x8); +- }; +- (m32x8) => { +- x86_m32x8_impl!(m32x8, m32x4); +- }; +- (m64x4) => { +- x86_m64x4_impl!(m64x4, m64x2); +- }; +- (m128x2) => { +- x86_intr_impl!(m128x2); +- }; +- (msizex2) => { +- cfg_if! { +- if #[cfg(target_pointer_width = "64")] { +- fallback_to_other_impl!(msizex2, m64x2); +- } else if #[cfg(target_pointer_width = "32")] { +- fallback_to_other_impl!(msizex2, m32x2); +- } else { +- compile_error!("unsupported target_pointer_width"); +- } +- } +- }; +- (msizex4) => { +- cfg_if! { +- if #[cfg(target_pointer_width = "64")] { +- fallback_to_other_impl!(msizex4, m64x4); +- } else if #[cfg(target_pointer_width = "32")] { +- fallback_to_other_impl!(msizex4, m32x4); +- } else { +- compile_error!("unsupported target_pointer_width"); +- } +- } +- }; +- (msizex8) => { +- cfg_if! { +- if #[cfg(target_pointer_width = "64")] { +- fallback_to_other_impl!(msizex8, m64x8); +- } else if #[cfg(target_pointer_width = "32")] { +- fallback_to_other_impl!(msizex8, m32x8); +- } else { +- compile_error!("unsupported target_pointer_width"); +- } +- } +- }; +- +- // Fallback to LLVM's default code-generation: +- ($id:ident) => { +- fallback_impl!($id); +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/avx.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/avx.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/avx.rs ++++ /dev/null +@@ -1,95 +0,0 @@ +-//! Mask reductions implementation for `x86` and `x86_64` targets with `AVX` +- +-/// `x86`/`x86_64` 256-bit `AVX` implementation +-/// FIXME: it might be faster here to do two `_mm_movmask_epi8` +-#[cfg(target_feature = "avx")] +-macro_rules! x86_m8x32_avx_impl { +- ($id:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "avx")] +- unsafe fn all(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm256_testc_si256; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm256_testc_si256; +- _mm256_testc_si256(crate::mem::transmute(self), crate::mem::transmute($id::splat(true))) != 0 +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "avx")] +- unsafe fn any(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm256_testz_si256; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm256_testz_si256; +- _mm256_testz_si256(crate::mem::transmute(self), crate::mem::transmute(self)) == 0 +- } +- } +- }; +-} +- +-/// `x86`/`x86_64` 256-bit m32x8 `AVX` implementation +-macro_rules! x86_m32x8_avx_impl { +- ($id:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "sse")] +- unsafe fn all(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm256_movemask_ps; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm256_movemask_ps; +- // _mm256_movemask_ps(a) creates a 8bit mask containing the +- // most significant bit of each lane of `a`. If all bits are +- // set, then all 8 lanes of the mask are true. +- _mm256_movemask_ps(crate::mem::transmute(self)) == 0b_1111_1111_i32 +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "sse")] +- unsafe fn any(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm256_movemask_ps; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm256_movemask_ps; +- +- _mm256_movemask_ps(crate::mem::transmute(self)) != 0 +- } +- } +- }; +-} +- +-/// `x86`/`x86_64` 256-bit m64x4 `AVX` implementation +-macro_rules! x86_m64x4_avx_impl { +- ($id:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "sse")] +- unsafe fn all(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm256_movemask_pd; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm256_movemask_pd; +- // _mm256_movemask_pd(a) creates a 4bit mask containing the +- // most significant bit of each lane of `a`. If all bits are +- // set, then all 4 lanes of the mask are true. +- _mm256_movemask_pd(crate::mem::transmute(self)) == 0b_1111_i32 +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "sse")] +- unsafe fn any(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm256_movemask_pd; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm256_movemask_pd; +- +- _mm256_movemask_pd(crate::mem::transmute(self)) != 0 +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/avx2.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/avx2.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/avx2.rs ++++ /dev/null +@@ -1,35 +0,0 @@ +-//! Mask reductions implementation for `x86` and `x86_64` targets with `AVX2`. +-#![allow(unused)] +- +-/// x86/x86_64 256-bit m8x32 AVX2 implementation +-macro_rules! x86_m8x32_avx2_impl { +- ($id:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "sse2")] +- unsafe fn all(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm256_movemask_epi8; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm256_movemask_epi8; +- // _mm256_movemask_epi8(a) creates a 32bit mask containing the +- // most significant bit of each byte of `a`. If all +- // bits are set, then all 32 lanes of the mask are +- // true. +- _mm256_movemask_epi8(crate::mem::transmute(self)) == -1_i32 +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "sse2")] +- unsafe fn any(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm256_movemask_epi8; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm256_movemask_epi8; +- +- _mm256_movemask_epi8(crate::mem::transmute(self)) != 0 +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/sse.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/sse.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/sse.rs ++++ /dev/null +@@ -1,35 +0,0 @@ +-//! Mask reductions implementation for `x86` and `x86_64` targets with `SSE`. +-#![allow(unused)] +- +-/// `x86`/`x86_64` 128-bit `m32x4` `SSE` implementation +-macro_rules! x86_m32x4_sse_impl { +- ($id:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "sse")] +- unsafe fn all(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm_movemask_ps; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm_movemask_ps; +- // _mm_movemask_ps(a) creates a 4bit mask containing the +- // most significant bit of each lane of `a`. If all +- // bits are set, then all 4 lanes of the mask are +- // true. +- _mm_movemask_ps(crate::mem::transmute(self)) == 0b_1111_i32 +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "sse")] +- unsafe fn any(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm_movemask_ps; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm_movemask_ps; +- +- _mm_movemask_ps(crate::mem::transmute(self)) != 0 +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/sse2.rs b/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/sse2.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/reductions/mask/x86/sse2.rs ++++ /dev/null +@@ -1,68 +0,0 @@ +-//! Mask reductions implementation for `x86` and `x86_64` targets with `SSE2`. +-#![allow(unused)] +- +-/// `x86`/`x86_64` 128-bit m64x2 `SSE2` implementation +-macro_rules! x86_m64x2_sse2_impl { +- ($id:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "sse")] +- unsafe fn all(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm_movemask_pd; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm_movemask_pd; +- // _mm_movemask_pd(a) creates a 2bit mask containing the +- // most significant bit of each lane of `a`. If all +- // bits are set, then all 2 lanes of the mask are +- // true. +- _mm_movemask_pd(crate::mem::transmute(self)) == 0b_11_i32 +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "sse")] +- unsafe fn any(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm_movemask_pd; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm_movemask_pd; +- +- _mm_movemask_pd(crate::mem::transmute(self)) != 0 +- } +- } +- }; +-} +- +-/// `x86`/`x86_64` 128-bit m8x16 `SSE2` implementation +-macro_rules! x86_m8x16_sse2_impl { +- ($id:ident) => { +- impl All for $id { +- #[inline] +- #[target_feature(enable = "sse2")] +- unsafe fn all(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm_movemask_epi8; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm_movemask_epi8; +- // _mm_movemask_epi8(a) creates a 16bit mask containing the +- // most significant bit of each byte of `a`. If all +- // bits are set, then all 16 lanes of the mask are +- // true. +- _mm_movemask_epi8(crate::mem::transmute(self)) == i32::from(u16::max_value()) +- } +- } +- impl Any for $id { +- #[inline] +- #[target_feature(enable = "sse2")] +- unsafe fn any(self) -> bool { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm_movemask_epi8; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm_movemask_epi8; +- +- _mm_movemask_epi8(crate::mem::transmute(self)) != 0 +- } +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/codegen/shuffle.rs b/third_party/rust/packed_simd/src/codegen/shuffle.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/shuffle.rs ++++ /dev/null +@@ -1,150 +0,0 @@ +-//! Implementations of the `ShuffleResult` trait for the different numbers of +-//! lanes and vector element types. +- +-use crate::masks::*; +-use crate::sealed::{Seal, Shuffle}; +- +-macro_rules! impl_shuffle { +- ($array:ty, $base:ty, $out:ty) => { +- impl Seal<$array> for $base {} +- impl Shuffle<$array> for $base { +- type Output = $out; +- } +- }; +-} +- +-impl_shuffle! { [u32; 2], i8, crate::codegen::i8x2 } +-impl_shuffle! { [u32; 4], i8, crate::codegen::i8x4 } +-impl_shuffle! { [u32; 8], i8, crate::codegen::i8x8 } +-impl_shuffle! { [u32; 16], i8, crate::codegen::i8x16 } +-impl_shuffle! { [u32; 32], i8, crate::codegen::i8x32 } +-impl_shuffle! { [u32; 64], i8, crate::codegen::i8x64 } +- +-impl_shuffle! { [u32; 2], u8, crate::codegen::u8x2 } +-impl_shuffle! { [u32; 4], u8, crate::codegen::u8x4 } +-impl_shuffle! { [u32; 8], u8, crate::codegen::u8x8 } +-impl_shuffle! { [u32; 16], u8, crate::codegen::u8x16 } +-impl_shuffle! { [u32; 32], u8, crate::codegen::u8x32 } +-impl_shuffle! { [u32; 64], u8, crate::codegen::u8x64 } +- +-impl_shuffle! { [u32; 2], m8, crate::codegen::m8x2 } +-impl_shuffle! { [u32; 4], m8, crate::codegen::m8x4 } +-impl_shuffle! { [u32; 8], m8, crate::codegen::m8x8 } +-impl_shuffle! { [u32; 16], m8, crate::codegen::m8x16 } +-impl_shuffle! { [u32; 32], m8, crate::codegen::m8x32 } +-impl_shuffle! { [u32; 64], m8, crate::codegen::m8x64 } +- +-impl_shuffle! { [u32; 2], i16, crate::codegen::i16x2 } +-impl_shuffle! { [u32; 4], i16, crate::codegen::i16x4 } +-impl_shuffle! { [u32; 8], i16, crate::codegen::i16x8 } +-impl_shuffle! { [u32; 16], i16, crate::codegen::i16x16 } +-impl_shuffle! { [u32; 32], i16, crate::codegen::i16x32 } +- +-impl_shuffle! { [u32; 2], u16, crate::codegen::u16x2 } +-impl_shuffle! { [u32; 4], u16, crate::codegen::u16x4 } +-impl_shuffle! { [u32; 8], u16, crate::codegen::u16x8 } +-impl_shuffle! { [u32; 16], u16, crate::codegen::u16x16 } +-impl_shuffle! { [u32; 32], u16, crate::codegen::u16x32 } +- +-impl_shuffle! { [u32; 2], m16, crate::codegen::m16x2 } +-impl_shuffle! { [u32; 4], m16, crate::codegen::m16x4 } +-impl_shuffle! { [u32; 8], m16, crate::codegen::m16x8 } +-impl_shuffle! { [u32; 16], m16, crate::codegen::m16x16 } +- +-impl_shuffle! { [u32; 2], i32, crate::codegen::i32x2 } +-impl_shuffle! { [u32; 4], i32, crate::codegen::i32x4 } +-impl_shuffle! { [u32; 8], i32, crate::codegen::i32x8 } +-impl_shuffle! { [u32; 16], i32, crate::codegen::i32x16 } +- +-impl_shuffle! { [u32; 2], u32, crate::codegen::u32x2 } +-impl_shuffle! { [u32; 4], u32, crate::codegen::u32x4 } +-impl_shuffle! { [u32; 8], u32, crate::codegen::u32x8 } +-impl_shuffle! { [u32; 16], u32, crate::codegen::u32x16 } +- +-impl_shuffle! { [u32; 2], f32, crate::codegen::f32x2 } +-impl_shuffle! { [u32; 4], f32, crate::codegen::f32x4 } +-impl_shuffle! { [u32; 8], f32, crate::codegen::f32x8 } +-impl_shuffle! { [u32; 16], f32, crate::codegen::f32x16 } +- +-impl_shuffle! { [u32; 2], m32, crate::codegen::m32x2 } +-impl_shuffle! { [u32; 4], m32, crate::codegen::m32x4 } +-impl_shuffle! { [u32; 8], m32, crate::codegen::m32x8 } +-impl_shuffle! { [u32; 16], m32, crate::codegen::m32x16 } +- +-/* FIXME: 64-bit single element vector +-impl_shuffle! { [u32; 1], i64, crate::codegen::i64x1 } +-*/ +-impl_shuffle! { [u32; 2], i64, crate::codegen::i64x2 } +-impl_shuffle! { [u32; 4], i64, crate::codegen::i64x4 } +-impl_shuffle! { [u32; 8], i64, crate::codegen::i64x8 } +- +-/* FIXME: 64-bit single element vector +-impl_shuffle! { [u32; 1], i64, crate::codegen::i64x1 } +-*/ +-impl_shuffle! { [u32; 2], u64, crate::codegen::u64x2 } +-impl_shuffle! { [u32; 4], u64, crate::codegen::u64x4 } +-impl_shuffle! { [u32; 8], u64, crate::codegen::u64x8 } +- +-/* FIXME: 64-bit single element vector +-impl_shuffle! { [u32; 1], i64, crate::codegen::i64x1 } +-*/ +-impl_shuffle! { [u32; 2], f64, crate::codegen::f64x2 } +-impl_shuffle! { [u32; 4], f64, crate::codegen::f64x4 } +-impl_shuffle! { [u32; 8], f64, crate::codegen::f64x8 } +- +-/* FIXME: 64-bit single element vector +-impl_shuffle! { [u32; 1], i64, crate::codegen::i64x1 } +-*/ +-impl_shuffle! { [u32; 2], m64, crate::codegen::m64x2 } +-impl_shuffle! { [u32; 4], m64, crate::codegen::m64x4 } +-impl_shuffle! { [u32; 8], m64, crate::codegen::m64x8 } +- +-impl_shuffle! { [u32; 2], isize, crate::codegen::isizex2 } +-impl_shuffle! { [u32; 4], isize, crate::codegen::isizex4 } +-impl_shuffle! { [u32; 8], isize, crate::codegen::isizex8 } +- +-impl_shuffle! { [u32; 2], usize, crate::codegen::usizex2 } +-impl_shuffle! { [u32; 4], usize, crate::codegen::usizex4 } +-impl_shuffle! { [u32; 8], usize, crate::codegen::usizex8 } +- +-impl_shuffle! { [u32; 2], msize, crate::codegen::msizex2 } +-impl_shuffle! { [u32; 4], msize, crate::codegen::msizex4 } +-impl_shuffle! { [u32; 8], msize, crate::codegen::msizex8 } +- +-impl Seal<[u32; 2]> for *const T {} +-impl Shuffle<[u32; 2]> for *const T { +- type Output = crate::codegen::cptrx2; +-} +-impl Seal<[u32; 4]> for *const T {} +-impl Shuffle<[u32; 4]> for *const T { +- type Output = crate::codegen::cptrx4; +-} +-impl Seal<[u32; 8]> for *const T {} +-impl Shuffle<[u32; 8]> for *const T { +- type Output = crate::codegen::cptrx8; +-} +- +-impl Seal<[u32; 2]> for *mut T {} +-impl Shuffle<[u32; 2]> for *mut T { +- type Output = crate::codegen::mptrx2; +-} +-impl Seal<[u32; 4]> for *mut T {} +-impl Shuffle<[u32; 4]> for *mut T { +- type Output = crate::codegen::mptrx4; +-} +-impl Seal<[u32; 8]> for *mut T {} +-impl Shuffle<[u32; 8]> for *mut T { +- type Output = crate::codegen::mptrx8; +-} +- +-impl_shuffle! { [u32; 1], i128, crate::codegen::i128x1 } +-impl_shuffle! { [u32; 2], i128, crate::codegen::i128x2 } +-impl_shuffle! { [u32; 4], i128, crate::codegen::i128x4 } +- +-impl_shuffle! { [u32; 1], u128, crate::codegen::u128x1 } +-impl_shuffle! { [u32; 2], u128, crate::codegen::u128x2 } +-impl_shuffle! { [u32; 4], u128, crate::codegen::u128x4 } +- +-impl_shuffle! { [u32; 1], m128, crate::codegen::m128x1 } +-impl_shuffle! { [u32; 2], m128, crate::codegen::m128x2 } +-impl_shuffle! { [u32; 4], m128, crate::codegen::m128x4 } +diff --git a/third_party/rust/packed_simd/src/codegen/shuffle1_dyn.rs b/third_party/rust/packed_simd/src/codegen/shuffle1_dyn.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/shuffle1_dyn.rs ++++ /dev/null +@@ -1,408 +0,0 @@ +-//! Shuffle vector lanes with run-time indices. +- +-use crate::*; +- +-pub trait Shuffle1Dyn { +- type Indices; +- fn shuffle1_dyn(self, _: Self::Indices) -> Self; +-} +- +-// Fallback implementation +-macro_rules! impl_fallback { +- ($id:ident) => { +- impl Shuffle1Dyn for $id { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- let mut result = Self::splat(0); +- for i in 0..$id::lanes() { +- result = result.replace(i, self.extract(indices.extract(i) as usize)); +- } +- result +- } +- } +- }; +-} +- +-macro_rules! impl_shuffle1_dyn { +- (u8x8) => { +- cfg_if! { +- if #[cfg(all( +- any( +- all(target_arch = "aarch64", target_feature = "neon"), +- all(target_arch = "doesnotexist", target_feature = "v7", +- target_feature = "neon") +- ), +- any(feature = "core_arch", libcore_neon) +- ) +- )] { +- impl Shuffle1Dyn for u8x8 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- #[cfg(target_arch = "aarch64")] +- use crate::arch::aarch64::vtbl1_u8; +- #[cfg(target_arch = "doesnotexist")] +- use crate::arch::arm::vtbl1_u8; +- +- // This is safe because the binary is compiled with +- // neon enabled at compile-time and can therefore only +- // run on CPUs that have it enabled. +- unsafe { +- Simd(mem::transmute( +- vtbl1_u8(mem::transmute(self.0), +- crate::mem::transmute(indices.0)) +- )) +- } +- } +- } +- } else { +- impl_fallback!(u8x8); +- } +- } +- }; +- (u8x16) => { +- cfg_if! { +- if #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), +- target_feature = "ssse3"))] { +- impl Shuffle1Dyn for u8x16 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::_mm_shuffle_epi8; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::_mm_shuffle_epi8; +- // This is safe because the binary is compiled with +- // ssse3 enabled at compile-time and can therefore only +- // run on CPUs that have it enabled. +- unsafe { +- Simd(mem::transmute( +- _mm_shuffle_epi8(mem::transmute(self.0), +- crate::mem::transmute(indices)) +- )) +- } +- } +- } +- } else if #[cfg(all(target_arch = "aarch64", target_feature = "neon", +- any(feature = "core_arch", libcore_neon)))] { +- impl Shuffle1Dyn for u8x16 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- use crate::arch::aarch64::vqtbl1q_u8; +- +- // This is safe because the binary is compiled with +- // neon enabled at compile-time and can therefore only +- // run on CPUs that have it enabled. +- unsafe { +- Simd(mem::transmute( +- vqtbl1q_u8(mem::transmute(self.0), +- crate::mem::transmute(indices.0)) +- )) +- } +- } +- } +- } else if #[cfg(all(target_arch = "doesnotexist", target_feature = "v7", +- target_feature = "neon", +- any(feature = "core_arch", libcore_neon)))] { +- impl Shuffle1Dyn for u8x16 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- use crate::arch::arm::vtbl2_u8; +- +- // This is safe because the binary is compiled with +- // neon enabled at compile-time and can therefore only +- // run on CPUs that have it enabled. +- unsafe { +- union U { +- j: u8x16, +- s: (u8x8, u8x8), +- } +- +- let (i0, i1) = U { j: y }.s; +- +- let r0 = vtbl2_u8( +- mem::transmute(x), +- crate::mem::transmute(i0) +- ); +- let r1 = vtbl2_u8( +- mem::transmute(x), +- crate::mem::transmute(i1) +- ); +- +- let r = U { s: (r0, r1) }.j; +- +- Simd(mem::transmute(r)) +- } +- } +- } +- } else { +- impl_fallback!(u8x16); +- } +- } +- }; +- (u16x8) => { +- impl Shuffle1Dyn for u16x8 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- let indices: u8x8 = (indices * 2).cast(); +- let indices: u8x16 = shuffle!(indices, [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7]); +- let v = u8x16::new(0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1); +- let indices = indices + v; +- unsafe { +- let s: u8x16 = crate::mem::transmute(self); +- crate::mem::transmute(s.shuffle1_dyn(indices)) +- } +- } +- } +- }; +- (u32x4) => { +- cfg_if! { +- if #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), +- target_feature = "avx"))] { +- impl Shuffle1Dyn for u32x4 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::{_mm_permutevar_ps}; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::{_mm_permutevar_ps}; +- +- unsafe { +- crate::mem::transmute( +- _mm_permutevar_ps( +- crate::mem::transmute(self.0), +- crate::mem::transmute(indices.0) +- ) +- ) +- } +- } +- } +- } else { +- impl Shuffle1Dyn for u32x4 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- let indices: u8x4 = (indices * 4).cast(); +- let indices: u8x16 = shuffle!( +- indices, +- [0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3] +- ); +- let v = u8x16::new( +- 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3 +- ); +- let indices = indices + v; +- unsafe { +- let s: u8x16 =crate::mem::transmute(self); +- crate::mem::transmute(s.shuffle1_dyn(indices)) +- } +- } +- } +- } +- } +- }; +- (u64x2) => { +- cfg_if! { +- if #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"), +- target_feature = "avx"))] { +- impl Shuffle1Dyn for u64x2 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- #[cfg(target_arch = "x86")] +- use crate::arch::x86::{_mm_permutevar_pd}; +- #[cfg(target_arch = "x86_64")] +- use crate::arch::x86_64::{_mm_permutevar_pd}; +- // _mm_permutevar_pd uses the _second_ bit of each +- // element to perform the selection, that is: 0b00 => 0, +- // 0b10 => 1: +- let indices = indices << 1; +- unsafe { +- crate::mem::transmute( +- _mm_permutevar_pd( +- crate::mem::transmute(self), +- crate::mem::transmute(indices) +- ) +- ) +- } +- } +- } +- } else { +- impl Shuffle1Dyn for u64x2 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- let indices: u8x2 = (indices * 8).cast(); +- let indices: u8x16 = shuffle!( +- indices, +- [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1] +- ); +- let v = u8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7 +- ); +- let indices = indices + v; +- unsafe { +- let s: u8x16 =crate::mem::transmute(self); +- crate::mem::transmute(s.shuffle1_dyn(indices)) +- } +- } +- } +- } +- } +- }; +- (u128x1) => { +- impl Shuffle1Dyn for u128x1 { +- type Indices = Self; +- #[inline] +- fn shuffle1_dyn(self, _indices: Self::Indices) -> Self { +- self +- } +- } +- }; +- ($id:ident) => { +- impl_fallback!($id); +- }; +-} +- +-impl_shuffle1_dyn!(u8x2); +-impl_shuffle1_dyn!(u8x4); +-impl_shuffle1_dyn!(u8x8); +-impl_shuffle1_dyn!(u8x16); +-impl_shuffle1_dyn!(u8x32); +-impl_shuffle1_dyn!(u8x64); +- +-impl_shuffle1_dyn!(u16x2); +-impl_shuffle1_dyn!(u16x4); +-impl_shuffle1_dyn!(u16x8); +-impl_shuffle1_dyn!(u16x16); +-impl_shuffle1_dyn!(u16x32); +- +-impl_shuffle1_dyn!(u32x2); +-impl_shuffle1_dyn!(u32x4); +-impl_shuffle1_dyn!(u32x8); +-impl_shuffle1_dyn!(u32x16); +- +-impl_shuffle1_dyn!(u64x2); +-impl_shuffle1_dyn!(u64x4); +-impl_shuffle1_dyn!(u64x8); +- +-impl_shuffle1_dyn!(usizex2); +-impl_shuffle1_dyn!(usizex4); +-impl_shuffle1_dyn!(usizex8); +- +-impl_shuffle1_dyn!(u128x1); +-impl_shuffle1_dyn!(u128x2); +-impl_shuffle1_dyn!(u128x4); +- +-// Implementation for non-unsigned vector types +-macro_rules! impl_shuffle1_dyn_non_u { +- ($id:ident, $uid:ident) => { +- impl Shuffle1Dyn for $id { +- type Indices = $uid; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- unsafe { +- let u: $uid = crate::mem::transmute(self); +- crate::mem::transmute(u.shuffle1_dyn(indices)) +- } +- } +- } +- }; +-} +- +-impl_shuffle1_dyn_non_u!(i8x2, u8x2); +-impl_shuffle1_dyn_non_u!(i8x4, u8x4); +-impl_shuffle1_dyn_non_u!(i8x8, u8x8); +-impl_shuffle1_dyn_non_u!(i8x16, u8x16); +-impl_shuffle1_dyn_non_u!(i8x32, u8x32); +-impl_shuffle1_dyn_non_u!(i8x64, u8x64); +- +-impl_shuffle1_dyn_non_u!(i16x2, u16x2); +-impl_shuffle1_dyn_non_u!(i16x4, u16x4); +-impl_shuffle1_dyn_non_u!(i16x8, u16x8); +-impl_shuffle1_dyn_non_u!(i16x16, u16x16); +-impl_shuffle1_dyn_non_u!(i16x32, u16x32); +- +-impl_shuffle1_dyn_non_u!(i32x2, u32x2); +-impl_shuffle1_dyn_non_u!(i32x4, u32x4); +-impl_shuffle1_dyn_non_u!(i32x8, u32x8); +-impl_shuffle1_dyn_non_u!(i32x16, u32x16); +- +-impl_shuffle1_dyn_non_u!(i64x2, u64x2); +-impl_shuffle1_dyn_non_u!(i64x4, u64x4); +-impl_shuffle1_dyn_non_u!(i64x8, u64x8); +- +-impl_shuffle1_dyn_non_u!(isizex2, usizex2); +-impl_shuffle1_dyn_non_u!(isizex4, usizex4); +-impl_shuffle1_dyn_non_u!(isizex8, usizex8); +- +-impl_shuffle1_dyn_non_u!(i128x1, u128x1); +-impl_shuffle1_dyn_non_u!(i128x2, u128x2); +-impl_shuffle1_dyn_non_u!(i128x4, u128x4); +- +-impl_shuffle1_dyn_non_u!(m8x2, u8x2); +-impl_shuffle1_dyn_non_u!(m8x4, u8x4); +-impl_shuffle1_dyn_non_u!(m8x8, u8x8); +-impl_shuffle1_dyn_non_u!(m8x16, u8x16); +-impl_shuffle1_dyn_non_u!(m8x32, u8x32); +-impl_shuffle1_dyn_non_u!(m8x64, u8x64); +- +-impl_shuffle1_dyn_non_u!(m16x2, u16x2); +-impl_shuffle1_dyn_non_u!(m16x4, u16x4); +-impl_shuffle1_dyn_non_u!(m16x8, u16x8); +-impl_shuffle1_dyn_non_u!(m16x16, u16x16); +-impl_shuffle1_dyn_non_u!(m16x32, u16x32); +- +-impl_shuffle1_dyn_non_u!(m32x2, u32x2); +-impl_shuffle1_dyn_non_u!(m32x4, u32x4); +-impl_shuffle1_dyn_non_u!(m32x8, u32x8); +-impl_shuffle1_dyn_non_u!(m32x16, u32x16); +- +-impl_shuffle1_dyn_non_u!(m64x2, u64x2); +-impl_shuffle1_dyn_non_u!(m64x4, u64x4); +-impl_shuffle1_dyn_non_u!(m64x8, u64x8); +- +-impl_shuffle1_dyn_non_u!(msizex2, usizex2); +-impl_shuffle1_dyn_non_u!(msizex4, usizex4); +-impl_shuffle1_dyn_non_u!(msizex8, usizex8); +- +-impl_shuffle1_dyn_non_u!(m128x1, u128x1); +-impl_shuffle1_dyn_non_u!(m128x2, u128x2); +-impl_shuffle1_dyn_non_u!(m128x4, u128x4); +- +-impl_shuffle1_dyn_non_u!(f32x2, u32x2); +-impl_shuffle1_dyn_non_u!(f32x4, u32x4); +-impl_shuffle1_dyn_non_u!(f32x8, u32x8); +-impl_shuffle1_dyn_non_u!(f32x16, u32x16); +- +-impl_shuffle1_dyn_non_u!(f64x2, u64x2); +-impl_shuffle1_dyn_non_u!(f64x4, u64x4); +-impl_shuffle1_dyn_non_u!(f64x8, u64x8); +- +-// Implementation for non-unsigned vector types +-macro_rules! impl_shuffle1_dyn_ptr { +- ($id:ident, $uid:ident) => { +- impl Shuffle1Dyn for $id { +- type Indices = $uid; +- #[inline] +- fn shuffle1_dyn(self, indices: Self::Indices) -> Self { +- unsafe { +- let u: $uid = crate::mem::transmute(self); +- crate::mem::transmute(u.shuffle1_dyn(indices)) +- } +- } +- } +- }; +-} +- +-impl_shuffle1_dyn_ptr!(cptrx2, usizex2); +-impl_shuffle1_dyn_ptr!(cptrx4, usizex4); +-impl_shuffle1_dyn_ptr!(cptrx8, usizex8); +- +-impl_shuffle1_dyn_ptr!(mptrx2, usizex2); +-impl_shuffle1_dyn_ptr!(mptrx4, usizex4); +-impl_shuffle1_dyn_ptr!(mptrx8, usizex8); +diff --git a/third_party/rust/packed_simd/src/codegen/swap_bytes.rs b/third_party/rust/packed_simd/src/codegen/swap_bytes.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/swap_bytes.rs ++++ /dev/null +@@ -1,149 +0,0 @@ +-//! Horizontal swap bytes reductions. +- +-// FIXME: investigate using `llvm.bswap` +-// https://github.com/rust-lang-nursery/packed_simd/issues/19 +- +-use crate::*; +- +-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 { +- shuffle!(self, [1, 0]) +- } +- } +- )+ +- }; +- (v32: $($id:ident,)+) => { +- $( +- impl SwapBytes for $id { +- #[inline] +- #[allow(clippy::useless_transmute)] +- fn swap_bytes(self) -> Self { +- unsafe { +- let bytes: u8x4 = crate::mem::transmute(self); +- let result: u8x4 = shuffle!(bytes, [3, 2, 1, 0]); +- crate::mem::transmute(result) +- } +- } +- } +- )+ +- }; +- (v64: $($id:ident,)+) => { +- $( +- impl SwapBytes for $id { +- #[inline] +- #[allow(clippy::useless_transmute)] +- fn swap_bytes(self) -> Self { +- unsafe { +- let bytes: u8x8 = crate::mem::transmute(self); +- let result: u8x8 = shuffle!( +- bytes, [7, 6, 5, 4, 3, 2, 1, 0] +- ); +- crate::mem::transmute(result) +- } +- } +- } +- )+ +- }; +- (v128: $($id:ident,)+) => { +- $( +- impl SwapBytes for $id { +- #[inline] +- #[allow(clippy::useless_transmute)] +- fn swap_bytes(self) -> Self { +- unsafe { +- let bytes: u8x16 = crate::mem::transmute(self); +- let result: u8x16 = shuffle!(bytes, [ +- 15, 14, 13, 12, 11, 10, 9, 8, +- 7, 6, 5, 4, 3, 2, 1, 0 +- ]); +- crate::mem::transmute(result) +- } +- } +- } +- )+ +- }; +- (v256: $($id:ident,)+) => { +- $( +- impl SwapBytes for $id { +- #[inline] +- #[allow(clippy::useless_transmute)] +- fn swap_bytes(self) -> Self { +- unsafe { +- let bytes: u8x32 = crate::mem::transmute(self); +- let result: u8x32 = shuffle!(bytes, [ +- 31, 30, 29, 28, 27, 26, 25, 24, +- 23, 22, 21, 20, 19, 18, 17, 16, +- 15, 14, 13, 12, 11, 10, 9, 8, +- 7, 6, 5, 4, 3, 2, 1, 0 +- ]); +- crate::mem::transmute(result) +- } +- } +- } +- )+ +- }; +- (v512: $($id:ident,)+) => { +- $( +- impl SwapBytes for $id { +- #[inline] +- #[allow(clippy::useless_transmute)] +- fn swap_bytes(self) -> Self { +- unsafe { +- let bytes: u8x64 = crate::mem::transmute(self); +- let result: u8x64 = shuffle!(bytes, [ +- 63, 62, 61, 60, 59, 58, 57, 56, +- 55, 54, 53, 52, 51, 50, 49, 48, +- 47, 46, 45, 44, 43, 42, 41, 40, +- 39, 38, 37, 36, 35, 34, 33, 32, +- 31, 30, 29, 28, 27, 26, 25, 24, +- 23, 22, 21, 20, 19, 18, 17, 16, +- 15, 14, 13, 12, 11, 10, 9, 8, +- 7, 6, 5, 4, 3, 2, 1, 0 +- ]); +- crate::mem::transmute(result) +- } +- } +- } +- )+ +- }; +-} +- +-impl_swap_bytes!(v16: u8x2, i8x2,); +-impl_swap_bytes!(v32: u8x4, i8x4, u16x2, i16x2,); +-// FIXME: 64-bit single element vector +-impl_swap_bytes!(v64: u8x8, i8x8, u16x4, i16x4, u32x2, i32x2 /* u64x1, i64x1, */,); +- +-impl_swap_bytes!(v128: u8x16, i8x16, u16x8, i16x8, u32x4, i32x4, u64x2, i64x2, u128x1, i128x1,); +-impl_swap_bytes!(v256: u8x32, i8x32, u16x16, i16x16, u32x8, i32x8, u64x4, i64x4, u128x2, i128x2,); +- +-impl_swap_bytes!(v512: u8x64, i8x64, u16x32, i16x32, u32x16, i32x16, u64x8, i64x8, u128x4, i128x4,); +- +-cfg_if! { +- if #[cfg(target_pointer_width = "8")] { +- impl_swap_bytes!(v16: isizex2, usizex2,); +- impl_swap_bytes!(v32: isizex4, usizex4,); +- impl_swap_bytes!(v64: isizex8, usizex8,); +- } else if #[cfg(target_pointer_width = "16")] { +- impl_swap_bytes!(v32: isizex2, usizex2,); +- impl_swap_bytes!(v64: isizex4, usizex4,); +- impl_swap_bytes!(v128: isizex8, usizex8,); +- } else if #[cfg(target_pointer_width = "32")] { +- impl_swap_bytes!(v64: isizex2, usizex2,); +- impl_swap_bytes!(v128: isizex4, usizex4,); +- impl_swap_bytes!(v256: isizex8, usizex8,); +- } else if #[cfg(target_pointer_width = "64")] { +- impl_swap_bytes!(v128: isizex2, usizex2,); +- impl_swap_bytes!(v256: isizex4, usizex4,); +- impl_swap_bytes!(v512: isizex8, usizex8,); +- } else { +- compile_error!("unsupported target_pointer_width"); +- } +-} +diff --git a/third_party/rust/packed_simd/src/codegen/v128.rs b/third_party/rust/packed_simd/src/codegen/v128.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/v128.rs ++++ /dev/null +@@ -1,46 +0,0 @@ +-//! Internal 128-bit wide vector types +- +-use crate::masks::*; +- +-#[rustfmt::skip] +-impl_simd_array!( +- [i8; 16]: i8x16 | +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [u8; 16]: u8x16 | +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [m8; 16]: m8x16 | +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8 +-); +- +-impl_simd_array!([i16; 8]: i16x8 | i16, i16, i16, i16, i16, i16, i16, i16); +-impl_simd_array!([u16; 8]: u16x8 | u16, u16, u16, u16, u16, u16, u16, u16); +-impl_simd_array!([m16; 8]: m16x8 | i16, i16, i16, i16, i16, i16, i16, i16); +- +-impl_simd_array!([i32; 4]: i32x4 | i32, i32, i32, i32); +-impl_simd_array!([u32; 4]: u32x4 | u32, u32, u32, u32); +-impl_simd_array!([f32; 4]: f32x4 | f32, f32, f32, f32); +-impl_simd_array!([m32; 4]: m32x4 | i32, i32, i32, i32); +- +-impl_simd_array!([i64; 2]: i64x2 | i64, i64); +-impl_simd_array!([u64; 2]: u64x2 | u64, u64); +-impl_simd_array!([f64; 2]: f64x2 | f64, f64); +-impl_simd_array!([m64; 2]: m64x2 | i64, i64); +- +-impl_simd_array!([i128; 1]: i128x1 | i128); +-impl_simd_array!([u128; 1]: u128x1 | u128); +-impl_simd_array!([m128; 1]: m128x1 | i128); +diff --git a/third_party/rust/packed_simd/src/codegen/v16.rs b/third_party/rust/packed_simd/src/codegen/v16.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/v16.rs ++++ /dev/null +@@ -1,7 +0,0 @@ +-//! Internal 16-bit wide vector types +- +-use crate::masks::*; +- +-impl_simd_array!([i8; 2]: i8x2 | i8, i8); +-impl_simd_array!([u8; 2]: u8x2 | u8, u8); +-impl_simd_array!([m8; 2]: m8x2 | i8, i8); +diff --git a/third_party/rust/packed_simd/src/codegen/v256.rs b/third_party/rust/packed_simd/src/codegen/v256.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/v256.rs ++++ /dev/null +@@ -1,78 +0,0 @@ +-//! Internal 256-bit wide vector types +- +-use crate::masks::*; +- +-#[rustfmt::skip] +-impl_simd_array!( +- [i8; 32]: i8x32 | +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [u8; 32]: u8x32 | +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [m8; 32]: m8x32 | +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [i16; 16]: i16x16 | +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [u16; 16]: u16x16 | +- u16, u16, u16, u16, +- u16, u16, u16, u16, +- u16, u16, u16, u16, +- u16, u16, u16, u16 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [m16; 16]: m16x16 | +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16 +-); +- +-impl_simd_array!([i32; 8]: i32x8 | i32, i32, i32, i32, i32, i32, i32, i32); +-impl_simd_array!([u32; 8]: u32x8 | u32, u32, u32, u32, u32, u32, u32, u32); +-impl_simd_array!([f32; 8]: f32x8 | f32, f32, f32, f32, f32, f32, f32, f32); +-impl_simd_array!([m32; 8]: m32x8 | i32, i32, i32, i32, i32, i32, i32, i32); +- +-impl_simd_array!([i64; 4]: i64x4 | i64, i64, i64, i64); +-impl_simd_array!([u64; 4]: u64x4 | u64, u64, u64, u64); +-impl_simd_array!([f64; 4]: f64x4 | f64, f64, f64, f64); +-impl_simd_array!([m64; 4]: m64x4 | i64, i64, i64, i64); +- +-impl_simd_array!([i128; 2]: i128x2 | i128, i128); +-impl_simd_array!([u128; 2]: u128x2 | u128, u128); +-impl_simd_array!([m128; 2]: m128x2 | i128, i128); +diff --git a/third_party/rust/packed_simd/src/codegen/v32.rs b/third_party/rust/packed_simd/src/codegen/v32.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/v32.rs ++++ /dev/null +@@ -1,11 +0,0 @@ +-//! Internal 32-bit wide vector types +- +-use crate::masks::*; +- +-impl_simd_array!([i8; 4]: i8x4 | i8, i8, i8, i8); +-impl_simd_array!([u8; 4]: u8x4 | u8, u8, u8, u8); +-impl_simd_array!([m8; 4]: m8x4 | i8, i8, i8, i8); +- +-impl_simd_array!([i16; 2]: i16x2 | i16, i16); +-impl_simd_array!([u16; 2]: u16x2 | u16, u16); +-impl_simd_array!([m16; 2]: m16x2 | i16, i16); +diff --git a/third_party/rust/packed_simd/src/codegen/v512.rs b/third_party/rust/packed_simd/src/codegen/v512.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/v512.rs ++++ /dev/null +@@ -1,145 +0,0 @@ +-//! Internal 512-bit wide vector types +- +-use crate::masks::*; +- +-#[rustfmt::skip] +-impl_simd_array!( +- [i8; 64]: i8x64 | +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [u8; 64]: u8x64 | +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8, +- u8, u8, u8, u8 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [m8; 64]: m8x64 | +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8, +- i8, i8, i8, i8 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [i16; 32]: i16x32 | +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [u16; 32]: u16x32 | +- u16, u16, u16, u16, +- u16, u16, u16, u16, +- u16, u16, u16, u16, +- u16, u16, u16, u16, +- u16, u16, u16, u16, +- u16, u16, u16, u16, +- u16, u16, u16, u16, +- u16, u16, u16, u16 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [m16; 32]: m16x32 | +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16, +- i16, i16, i16, i16 +-); +- +-#[rustfmt::skip] +-impl_simd_array!( +- [i32; 16]: i32x16 | +- i32, i32, i32, i32, +- i32, i32, i32, i32, +- i32, i32, i32, i32, +- i32, i32, i32, i32 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [u32; 16]: u32x16 | +- u32, u32, u32, u32, +- u32, u32, u32, u32, +- u32, u32, u32, u32, +- u32, u32, u32, u32 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [f32; 16]: f32x16 | +- f32, f32, f32, f32, +- f32, f32, f32, f32, +- f32, f32, f32, f32, +- f32, f32, f32, f32 +-); +-#[rustfmt::skip] +-impl_simd_array!( +- [m32; 16]: m32x16 | +- i32, i32, i32, i32, +- i32, i32, i32, i32, +- i32, i32, i32, i32, +- i32, i32, i32, i32 +-); +- +-impl_simd_array!([i64; 8]: i64x8 | i64, i64, i64, i64, i64, i64, i64, i64); +-impl_simd_array!([u64; 8]: u64x8 | u64, u64, u64, u64, u64, u64, u64, u64); +-impl_simd_array!([f64; 8]: f64x8 | f64, f64, f64, f64, f64, f64, f64, f64); +-impl_simd_array!([m64; 8]: m64x8 | i64, i64, i64, i64, i64, i64, i64, i64); +- +-impl_simd_array!([i128; 4]: i128x4 | i128, i128, i128, i128); +-impl_simd_array!([u128; 4]: u128x4 | u128, u128, u128, u128); +-impl_simd_array!([m128; 4]: m128x4 | i128, i128, i128, i128); +diff --git a/third_party/rust/packed_simd/src/codegen/v64.rs b/third_party/rust/packed_simd/src/codegen/v64.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/v64.rs ++++ /dev/null +@@ -1,21 +0,0 @@ +-//! Internal 64-bit wide vector types +- +-use crate::masks::*; +- +-impl_simd_array!([i8; 8]: i8x8 | i8, i8, i8, i8, i8, i8, i8, i8); +-impl_simd_array!([u8; 8]: u8x8 | u8, u8, u8, u8, u8, u8, u8, u8); +-impl_simd_array!([m8; 8]: m8x8 | i8, i8, i8, i8, i8, i8, i8, i8); +- +-impl_simd_array!([i16; 4]: i16x4 | i16, i16, i16, i16); +-impl_simd_array!([u16; 4]: u16x4 | u16, u16, u16, u16); +-impl_simd_array!([m16; 4]: m16x4 | i16, i16, i16, i16); +- +-impl_simd_array!([i32; 2]: i32x2 | i32, i32); +-impl_simd_array!([u32; 2]: u32x2 | u32, u32); +-impl_simd_array!([f32; 2]: f32x2 | f32, f32); +-impl_simd_array!([m32; 2]: m32x2 | i32, i32); +- +-impl_simd_array!([i64; 1]: i64x1 | i64); +-impl_simd_array!([u64; 1]: u64x1 | u64); +-impl_simd_array!([f64; 1]: f64x1 | f64); +-impl_simd_array!([m64; 1]: m64x1 | i64); +diff --git a/third_party/rust/packed_simd/src/codegen/vPtr.rs b/third_party/rust/packed_simd/src/codegen/vPtr.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/vPtr.rs ++++ /dev/null +@@ -1,35 +0,0 @@ +-//! 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>($(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]; +- } +- +- impl<$ty> crate::sealed::Seal for $tuple_id<$ptr_ty> {} +- impl<$ty> crate::sealed::Simd for $tuple_id<$ptr_ty> { +- type Element = $ptr_ty; +- const LANES: usize = $elem_count; +- type LanesType = [u32; $elem_count]; +- } +- +- } +-} +- +-impl_simd_ptr!([*const T; 2]: cptrx2 | T | T, T); +-impl_simd_ptr!([*const T; 4]: cptrx4 | T | T, T, T, T); +-impl_simd_ptr!([*const T; 8]: cptrx8 | T | T, T, T, T, T, T, T, T); +- +-impl_simd_ptr!([*mut T; 2]: mptrx2 | T | T, T); +-impl_simd_ptr!([*mut T; 4]: mptrx4 | T | T, T, T, T); +-impl_simd_ptr!([*mut T; 8]: mptrx8 | T | T, T, T, T, T, T, T, T); +diff --git a/third_party/rust/packed_simd/src/codegen/vSize.rs b/third_party/rust/packed_simd/src/codegen/vSize.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/codegen/vSize.rs ++++ /dev/null +@@ -1,16 +0,0 @@ +-//! Vector types with pointer-sized elements +- +-use crate::codegen::pointer_sized_int::{isize_, usize_}; +-use crate::masks::*; +- +-impl_simd_array!([isize; 2]: isizex2 | isize_, isize_); +-impl_simd_array!([usize; 2]: usizex2 | usize_, usize_); +-impl_simd_array!([msize; 2]: msizex2 | isize_, isize_); +- +-impl_simd_array!([isize; 4]: isizex4 | isize_, isize_, isize_, isize_); +-impl_simd_array!([usize; 4]: usizex4 | usize_, usize_, usize_, usize_); +-impl_simd_array!([msize; 4]: msizex4 | isize_, isize_, isize_, isize_); +- +-impl_simd_array!([isize; 8]: isizex8 | isize_, isize_, isize_, isize_, isize_, isize_, isize_, isize_); +-impl_simd_array!([usize; 8]: usizex8 | usize_, usize_, usize_, usize_, usize_, usize_, usize_, usize_); +-impl_simd_array!([msize; 8]: msizex8 | isize_, isize_, isize_, isize_, isize_, isize_, isize_, isize_); +diff --git a/third_party/rust/packed_simd/src/lib.rs b/third_party/rust/packed_simd/src/lib.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/lib.rs ++++ /dev/null +@@ -1,348 +0,0 @@ +-//! # Portable packed SIMD vectors +-//! +-//! This crate is proposed for stabilization as `std::packed_simd` in [RFC2366: +-//! `std::simd`](https://github.com/rust-lang/rfcs/pull/2366) . +-//! +-//! The examples available in the +-//! [`examples/`](https://github.com/rust-lang-nursery/packed_simd/tree/master/examples) +-//! sub-directory of the crate showcase how to use the library in practice. +-//! +-//! ## Table of contents +-//! +-//! - [Introduction](#introduction) +-//! - [Vector types](#vector-types) +-//! - [Conditional operations](#conditional-operations) +-//! - [Conversions](#conversions) +-//! - [Hardware Features](#hardware-features) +-//! - [Performance guide](https://rust-lang-nursery.github.io/packed_simd/perf-guide/) +-//! +-//! ## Introduction +-//! +-//! This crate exports [`Simd<[T; N]>`][`Simd`]: a packed vector of `N` +-//! elements of type `T` as well as many type aliases for this type: for +-//! example, [`f32x4`], which is just an alias for `Simd<[f32; 4]>`. +-//! +-//! The operations on packed vectors are, by default, "vertical", that is, they +-//! are applied to each vector lane in isolation of the others: +-//! +-//! ``` +-//! # use packed_simd::*; +-//! let a = i32x4::new(1, 2, 3, 4); +-//! let b = i32x4::new(5, 6, 7, 8); +-//! assert_eq!(a + b, i32x4::new(6, 8, 10, 12)); +-//! ``` +-//! +-//! Many "horizontal" operations are also provided: +-//! +-//! ``` +-//! # use packed_simd::*; +-//! # let a = i32x4::new(1, 2, 3, 4); +-//! assert_eq!(a.wrapping_sum(), 10); +-//! ``` +-//! +-//! In virtually all architectures vertical operations are fast, while +-//! horizontal operations are, by comparison, much slower. That is, the +-//! most portably-efficient way of performing a reduction over a slice +-//! is to collect the results into a vector using vertical operations, +-//! and performing a single horizontal operation at the end: +-//! +-//! ``` +-//! # use packed_simd::*; +-//! fn reduce(x: &[i32]) -> i32 { +-//! assert_eq!(x.len() % 4, 0); +-//! let mut sum = i32x4::splat(0); // [0, 0, 0, 0] +-//! for i in (0..x.len()).step_by(4) { +-//! sum += i32x4::from_slice_unaligned(&x[i..]); +-//! } +-//! sum.wrapping_sum() +-//! } +-//! +-//! let x = [0, 1, 2, 3, 4, 5, 6, 7]; +-//! assert_eq!(reduce(&x), 28); +-//! ``` +-//! +-//! ## Vector types +-//! +-//! The vector type aliases are named according to the following scheme: +-//! +-//! > `{element_type}x{number_of_lanes} == Simd<[element_type; +-//! number_of_lanes]>` +-//! +-//! where the following element types are supported: +-//! +-//! * `i{element_width}`: signed integer +-//! * `u{element_width}`: unsigned integer +-//! * `f{element_width}`: float +-//! * `m{element_width}`: mask (see below) +-//! * `*{const,mut} T`: `const` and `mut` pointers +-//! +-//! ## Basic operations +-//! +-//! ``` +-//! # use packed_simd::*; +-//! // Sets all elements to `0`: +-//! let a = i32x4::splat(0); +-//! +-//! // Reads a vector from a slice: +-//! let mut arr = [0, 0, 0, 1, 2, 3, 4, 5]; +-//! let b = i32x4::from_slice_unaligned(&arr); +-//! +-//! // Reads the 4-th element of a vector: +-//! assert_eq!(b.extract(3), 1); +-//! +-//! // Returns a new vector where the 4-th element is replaced with `1`: +-//! let a = a.replace(3, 1); +-//! assert_eq!(a, b); +-//! +-//! // Writes a vector to a slice: +-//! let a = a.replace(2, 1); +-//! a.write_to_slice_unaligned(&mut arr[4..]); +-//! assert_eq!(arr, [0, 0, 0, 1, 0, 0, 1, 1]); +-//! ``` +-//! +-//! ## Conditional operations +-//! +-//! One often needs to perform an operation on some lanes of the vector. Vector +-//! masks, like `m32x4`, allow selecting on which vector lanes an operation is +-//! to be performed: +-//! +-//! ``` +-//! # use packed_simd::*; +-//! let a = i32x4::new(1, 1, 2, 2); +-//! +-//! // Add `1` to the first two lanes of the vector. +-//! let m = m16x4::new(true, true, false, false); +-//! let a = m.select(a + 1, a); +-//! assert_eq!(a, i32x4::splat(2)); +-//! ``` +-//! +-//! The elements of a vector mask are either `true` or `false`. Here `true` +-//! means that a lane is "selected", while `false` means that a lane is not +-//! selected. +-//! +-//! All vector masks implement a `mask.select(a: T, b: T) -> T` method that +-//! works on all vectors that have the same number of lanes as the mask. The +-//! resulting vector contains the elements of `a` for those lanes for which the +-//! mask is `true`, and the elements of `b` otherwise. +-//! +-//! The example constructs a mask with the first two lanes set to `true` and +-//! the last two lanes set to `false`. This selects the first two lanes of `a + +-//! 1` and the last two lanes of `a`, producing a vector where the first two +-//! lanes have been incremented by `1`. +-//! +-//! > note: mask `select` can be used on vector types that have the same number +-//! > of lanes as the mask. The example shows this by using [`m16x4`] instead +-//! > of [`m32x4`]. It is _typically_ more performant to use a mask element +-//! > width equal to the element width of the vectors being operated upon. +-//! > This is, however, not true for 512-bit wide vectors when targeting +-//! > AVX-512, where the most efficient masks use only 1-bit per element. +-//! +-//! All vertical comparison operations returns masks: +-//! +-//! ``` +-//! # use packed_simd::*; +-//! let a = i32x4::new(1, 1, 3, 3); +-//! let b = i32x4::new(2, 2, 0, 0); +-//! +-//! // ge: >= (Greater Eequal; see also lt, le, gt, eq, ne). +-//! let m = a.ge(i32x4::splat(2)); +-//! +-//! if m.any() { +-//! // all / any / none allow coherent control flow +-//! let d = m.select(a, b); +-//! assert_eq!(d, i32x4::new(2, 2, 3, 3)); +-//! } +-//! ``` +-//! +-//! ## Conversions +-//! +-//! * **lossless widening conversions**: [`From`]/[`Into`] are implemented for +-//! vectors with the same number of lanes when the conversion is value +-//! preserving (same as in `std`). +-//! +-//! * **safe bitwise conversions**: The cargo feature `into_bits` provides the +-//! `IntoBits/FromBits` traits (`x.into_bits()`). These perform safe bitwise +-//! `transmute`s when all bit patterns of the source type are valid bit +-//! patterns of the target type and are also implemented for the +-//! architecture-specific vector types of `std::arch`. For example, `let x: +-//! u8x8 = m8x8::splat(true).into_bits();` is provided because all `m8x8` bit +-//! patterns are valid `u8x8` bit patterns. However, the opposite is not +-//! true, not all `u8x8` bit patterns are valid `m8x8` bit-patterns, so this +-//! operation cannot be performed safely using `x.into_bits()`; one needs to +-//! use `unsafe { crate::mem::transmute(x) }` for that, making sure that the +-//! value in the `u8x8` is a valid bit-pattern of `m8x8`. +-//! +-//! * **numeric casts** (`as`): are performed using [`FromCast`]/[`Cast`] +-//! (`x.cast()`), just like `as`: +-//! +-//! * casting integer vectors whose lane types have the same size (e.g. +-//! `i32xN` -> `u32xN`) is a **no-op**, +-//! +-//! * casting from a larger integer to a smaller integer (e.g. `u32xN` -> +-//! `u8xN`) will **truncate**, +-//! +-//! * casting from a smaller integer to a larger integer (e.g. `u8xN` -> +-//! `u32xN`) will: +-//! * **zero-extend** if the source is unsigned, or +-//! * **sign-extend** if the source is signed, +-//! +-//! * casting from a float to an integer will **round the float towards +-//! zero**, +-//! +-//! * casting from an integer to float will produce the floating point +-//! representation of the integer, **rounding to nearest, ties to even**, +-//! +-//! * casting from an `f32` to an `f64` is perfect and lossless, +-//! +-//! * casting from an `f64` to an `f32` **rounds to nearest, ties to even**. +-//! +-//! Numeric casts are not very "precise": sometimes lossy, sometimes value +-//! preserving, etc. +-//! +-//! ## Hardware Features +-//! +-//! This crate can use different hardware features based on your configured +-//! `RUSTFLAGS`. For example, with no configured `RUSTFLAGS`, `u64x8` on +-//! x86_64 will use SSE2 operations like `PCMPEQD`. If you configure +-//! `RUSTFLAGS='-C target-feature=+avx2,+avx'` on supported x86_64 hardware +-//! the same `u64x8` may use wider AVX2 operations like `VPCMPEQQ`. It is +-//! important for performance and for hardware support requirements that +-//! you choose an appropriate set of `target-feature` and `target-cpu` +-//! options during builds. For more information, see the [Performance +-//! guide](https://rust-lang-nursery.github.io/packed_simd/perf-guide/) +- +-#![feature( +- adt_const_params, +- repr_simd, +- rustc_attrs, +- platform_intrinsics, +- stdsimd, +- arm_target_feature, +- link_llvm_intrinsics, +- core_intrinsics, +- stmt_expr_attributes, +- custom_inner_attributes, +-)] +-#![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 +- improper_ctypes_definitions, +- incomplete_features, +- clippy::cast_possible_truncation, +- clippy::cast_lossless, +- clippy::cast_possible_wrap, +- clippy::cast_precision_loss, +- // TODO: manually add the `#[must_use]` attribute where appropriate +- clippy::must_use_candidate, +- // This lint is currently broken for generic code +- // See https://github.com/rust-lang/rust-clippy/issues/3410 +- clippy::use_self, +- clippy::wrong_self_convention, +- clippy::from_over_into, +-)] +-#![cfg_attr(test, feature(hashmap_internals))] +-#![cfg_attr(doc_cfg, feature(doc_cfg))] +-#![deny(rust_2018_idioms, clippy::missing_inline_in_public_items)] +-#![no_std] +- +-use cfg_if::cfg_if; +- +-cfg_if! { +- if #[cfg(feature = "core_arch")] { +- #[allow(unused_imports)] +- use core_arch as arch; +- } else { +- #[allow(unused_imports)] +- use core::arch; +- } +-} +- +-#[cfg(all(target_arch = "wasm32", test))] +-use wasm_bindgen_test::*; +- +-#[allow(unused_imports)] +-use core::{ +- /* arch (handled above), */ cmp, f32, f64, fmt, hash, hint, i128, i16, i32, i64, i8, intrinsics, +- isize, iter, marker, mem, ops, ptr, slice, u128, u16, u32, u64, u8, usize, +-}; +- +-#[macro_use] +-mod testing; +-#[macro_use] +-mod api; +-mod codegen; +-mod sealed; +- +-pub use crate::sealed::{Mask, Shuffle, Simd as SimdVector, SimdArray}; +- +-/// Packed SIMD vector type. +-/// +-/// # Examples +-/// +-/// ``` +-/// # use packed_simd::Simd; +-/// let v = Simd::<[i32; 4]>::new(0, 1, 2, 3); +-/// assert_eq!(v.extract(2), 2); +-/// ``` +-#[repr(transparent)] +-#[derive(Copy, Clone)] +-pub struct Simd( +- // FIXME: this type should be private, +- // but it currently must be public for the +- // `shuffle!` macro to work: it needs to +- // access the internal `repr(simd)` type +- // to call the shuffle intrinsics. +- #[doc(hidden)] pub ::Tuple, +-); +- +-impl sealed::Seal for Simd {} +- +-/// Wrapper over `T` implementing a lexicoraphical order via the `PartialOrd` +-/// and/or `Ord` traits. +-#[repr(transparent)] +-#[derive(Copy, Clone, Debug)] +-#[allow(clippy::missing_inline_in_public_items)] +-pub struct LexicographicallyOrdered(T); +- +-mod masks; +-pub use self::masks::*; +- +-mod v16; +-pub use self::v16::*; +- +-mod v32; +-pub use self::v32::*; +- +-mod v64; +-pub use self::v64::*; +- +-mod v128; +-pub use self::v128::*; +- +-mod v256; +-pub use self::v256::*; +- +-mod v512; +-pub use self::v512::*; +- +-mod vSize; +-pub use self::vSize::*; +- +-mod vPtr; +-pub use self::vPtr::*; +- +-pub use self::api::cast::*; +- +-#[cfg(feature = "into_bits")] +-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, +-}; +- +-pub(crate) mod llvm { +- pub(crate) use crate::codegen::llvm::*; +-} +diff --git a/third_party/rust/packed_simd/src/masks.rs b/third_party/rust/packed_simd/src/masks.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/masks.rs ++++ /dev/null +@@ -1,126 +0,0 @@ +-//! Mask types +- +-macro_rules! impl_mask_ty { +- ($id:ident : $elem_ty:ident | #[$doc:meta]) => { +- #[$doc] +- #[derive(Copy, Clone)] +- pub struct $id($elem_ty); +- +- impl crate::sealed::Seal for $id {} +- impl crate::sealed::Mask for $id { +- #[inline] +- fn test(&self) -> bool { +- $id::test(self) +- } +- } +- +- impl $id { +- /// Instantiate a mask with `value` +- #[inline] +- pub fn new(x: bool) -> Self { +- if x { +- $id(!0) +- } else { +- $id(0) +- } +- } +- /// Test if the mask is set +- #[inline] +- pub fn test(&self) -> bool { +- self.0 != 0 +- } +- } +- +- impl Default for $id { +- #[inline] +- fn default() -> Self { +- $id(0) +- } +- } +- +- #[allow(clippy::partialeq_ne_impl)] +- impl PartialEq<$id> for $id { +- #[inline] +- fn eq(&self, other: &Self) -> bool { +- self.0 == other.0 +- } +- #[inline] +- fn ne(&self, other: &Self) -> bool { +- self.0 != other.0 +- } +- } +- +- impl Eq for $id {} +- +- impl PartialOrd<$id> for $id { +- #[inline] +- fn partial_cmp(&self, other: &Self) -> Option { +- use crate::cmp::Ordering; +- if self == other { +- Some(Ordering::Equal) +- } else if self.0 > other.0 { +- // Note: +- // * false = 0_i +- // * true == !0_i == -1_i +- Some(Ordering::Less) +- } else { +- Some(Ordering::Greater) +- } +- } +- +- #[inline] +- fn lt(&self, other: &Self) -> bool { +- self.0 > other.0 +- } +- #[inline] +- fn gt(&self, other: &Self) -> bool { +- self.0 < other.0 +- } +- #[inline] +- fn le(&self, other: &Self) -> bool { +- self.0 >= other.0 +- } +- #[inline] +- fn ge(&self, other: &Self) -> bool { +- self.0 <= other.0 +- } +- } +- +- impl Ord for $id { +- #[inline] +- fn cmp(&self, other: &Self) -> crate::cmp::Ordering { +- match self.partial_cmp(other) { +- Some(x) => x, +- None => unsafe { crate::hint::unreachable_unchecked() }, +- } +- } +- } +- +- impl crate::hash::Hash for $id { +- #[inline] +- fn hash(&self, state: &mut H) { +- (self.0 != 0).hash(state); +- } +- } +- +- impl crate::fmt::Debug for $id { +- #[inline] +- fn fmt(&self, fmtter: &mut crate::fmt::Formatter<'_>) -> Result<(), crate::fmt::Error> { +- write!(fmtter, "{}({})", stringify!($id), self.0 != 0) +- } +- } +- }; +-} +- +-impl_mask_ty!(m8: i8 | /// 8-bit wide mask. +-); +-impl_mask_ty!(m16: i16 | /// 16-bit wide mask. +-); +-impl_mask_ty!(m32: i32 | /// 32-bit wide mask. +-); +-impl_mask_ty!(m64: i64 | /// 64-bit wide mask. +-); +-impl_mask_ty!(m128: i128 | /// 128-bit wide mask. +-); +-impl_mask_ty!(msize: isize | /// isize-wide mask. +-); +diff --git a/third_party/rust/packed_simd/src/sealed.rs b/third_party/rust/packed_simd/src/sealed.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/sealed.rs ++++ /dev/null +@@ -1,42 +0,0 @@ +-//! Sealed traits +- +-/// A sealed trait, this is logically private to the crate +-/// and will prevent implementations from outside the crate +-pub trait Seal {} +- +-/// Trait implemented by arrays that can be SIMD types. +-pub trait SimdArray: Seal { +- /// The type of the #[repr(simd)] type. +- type Tuple: Copy + Clone; +- /// The element type of the vector. +- type T; +- /// The number of elements in the array. +- const N: usize; +- /// The type: `[u32; Self::N]`. +- type NT; +-} +- +-/// This traits is used to constraint the arguments +-/// and result type of the portable shuffles. +-#[doc(hidden)] +-pub trait Shuffle: Seal { +- // Lanes is a `[u32; N]` where `N` is the number of vector lanes +- +- /// The result type of the shuffle. +- type Output; +-} +- +-/// This trait is implemented by all SIMD vector types. +-pub trait Simd: Seal { +- /// Element type of the SIMD vector +- type Element; +- /// The number of elements in the SIMD vector. +- const LANES: usize; +- /// The type: `[u32; Self::N]`. +- type LanesType; +-} +- +-/// This trait is implemented by all mask types +-pub trait Mask: Seal { +- fn test(&self) -> bool; +-} +diff --git a/third_party/rust/packed_simd/src/testing.rs b/third_party/rust/packed_simd/src/testing.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/testing.rs ++++ /dev/null +@@ -1,8 +0,0 @@ +-//! Testing macros and other utilities. +- +-#[macro_use] +-mod macros; +- +-#[cfg(test)] +-#[macro_use] +-pub(crate) mod utils; +diff --git a/third_party/rust/packed_simd/src/testing/macros.rs b/third_party/rust/packed_simd/src/testing/macros.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/testing/macros.rs ++++ /dev/null +@@ -1,44 +0,0 @@ +-//! Testing macros +- +-macro_rules! test_if { +- ($cfg_tt:tt: $it:item) => { +- #[cfg(any( +- // Test everything if: +- // +- // * tests are enabled, +- // * no features about exclusively testing +- // specific vector classes are enabled +- all(test, not(any( +- test_v16, +- test_v32, +- test_v64, +- test_v128, +- test_v256, +- test_v512, +- test_none, // disables all tests +- ))), +- // Test if: +- // +- // * tests are enabled +- // * a particular cfg token tree returns true +- all(test, $cfg_tt), +- ))] +- $it +- }; +-} +- +-#[cfg(test)] +-#[allow(unused)] +-macro_rules! ref_ { +- ($anything:tt) => { +- &$anything +- }; +-} +- +-#[cfg(test)] +-#[allow(unused)] +-macro_rules! ref_mut_ { +- ($anything:tt) => { +- &mut $anything +- }; +-} +diff --git a/third_party/rust/packed_simd/src/testing/utils.rs b/third_party/rust/packed_simd/src/testing/utils.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/testing/utils.rs ++++ /dev/null +@@ -1,130 +0,0 @@ +-//! Testing utilities +- +-#![allow(dead_code)] +-// FIXME: Or don't. But it's true this is a problematic comparison. +-#![allow(clippy::neg_cmp_op_on_partial_ord)] +- +-use crate::{cmp::PartialOrd, fmt::Debug, LexicographicallyOrdered}; +- +-/// Tests PartialOrd for `a` and `b` where `a < b` is true. +-pub fn test_lt(a: LexicographicallyOrdered, b: LexicographicallyOrdered) +-where +- LexicographicallyOrdered: Debug + PartialOrd, +-{ +- assert!(a < b, "{:?}, {:?}", a, b); +- assert!(b > a, "{:?}, {:?}", a, b); +- +- assert!(!(a == b), "{:?}, {:?}", a, b); +- assert_ne!(a, b, "{:?}, {:?}", a, b); +- +- assert!(a <= b, "{:?}, {:?}", a, b); +- assert!(b >= a, "{:?}, {:?}", a, b); +- +- // The elegance of the mathematical expression of irreflexivity is more +- // than clippy can handle. +- #[allow(clippy::eq_op)] +- { +- // Irreflexivity +- assert!(!(a < a), "{:?}, {:?}", a, b); +- assert!(!(b < b), "{:?}, {:?}", a, b); +- assert!(!(a > a), "{:?}, {:?}", a, b); +- assert!(!(b > b), "{:?}, {:?}", a, b); +- +- assert!(a <= a, "{:?}, {:?}", a, b); +- assert!(b <= b, "{:?}, {:?}", a, b); +- } +-} +- +-/// Tests PartialOrd for `a` and `b` where `a <= b` is true. +-pub fn test_le(a: LexicographicallyOrdered, b: LexicographicallyOrdered) +-where +- LexicographicallyOrdered: Debug + PartialOrd, +-{ +- assert!(a <= b, "{:?}, {:?}", a, b); +- assert!(b >= a, "{:?}, {:?}", a, b); +- +- assert!(a <= b, "{:?}, {:?}", a, b); +- assert!(b >= a, "{:?}, {:?}", a, b); +- +- if a == b { +- assert!(!(a < b), "{:?}, {:?}", a, b); +- assert!(!(b > a), "{:?}, {:?}", a, b); +- +- assert!(!(a != b), "{:?}, {:?}", a, b); +- } else { +- assert_ne!(a, b, "{:?}, {:?}", a, b); +- test_lt(a, b); +- } +-} +- +-/// Test PartialOrd::partial_cmp for `a` and `b` returning `Ordering` +-pub fn test_cmp( +- a: LexicographicallyOrdered, +- b: LexicographicallyOrdered, +- o: Option, +-) where +- LexicographicallyOrdered: PartialOrd + Debug, +- T: Debug + crate::sealed::Simd + Copy + Clone, +- ::Element: Default + Copy + Clone + PartialOrd, +-{ +- assert!(T::LANES <= 64, "array length in these two arrays needs updating"); +- let mut arr_a: [T::Element; 64] = [Default::default(); 64]; +- let mut arr_b: [T::Element; 64] = [Default::default(); 64]; +- +- unsafe { crate::ptr::write_unaligned(arr_a.as_mut_ptr() as *mut LexicographicallyOrdered, a) } +- unsafe { crate::ptr::write_unaligned(arr_b.as_mut_ptr() as *mut LexicographicallyOrdered, b) } +- let expected = arr_a[0..T::LANES].partial_cmp(&arr_b[0..T::LANES]); +- let result = a.partial_cmp(&b); +- assert_eq!(expected, result, "{:?}, {:?}", a, b); +- assert_eq!(o, result, "{:?}, {:?}", a, b); +- match o { +- Some(crate::cmp::Ordering::Less) => { +- test_lt(a, b); +- test_le(a, b); +- } +- Some(crate::cmp::Ordering::Greater) => { +- test_lt(b, a); +- test_le(b, a); +- } +- Some(crate::cmp::Ordering::Equal) => { +- assert!(a == b, "{:?}, {:?}", a, b); +- assert!(!(a != b), "{:?}, {:?}", a, b); +- assert!(!(a < b), "{:?}, {:?}", a, b); +- assert!(!(b < a), "{:?}, {:?}", a, b); +- assert!(!(a > b), "{:?}, {:?}", a, b); +- assert!(!(b > a), "{:?}, {:?}", a, b); +- +- test_le(a, b); +- test_le(b, a); +- } +- None => { +- assert!(!(a == b), "{:?}, {:?}", a, b); +- assert!(!(a != b), "{:?}, {:?}", a, b); +- assert!(!(a < b), "{:?}, {:?}", a, b); +- assert!(!(a > b), "{:?}, {:?}", a, b); +- assert!(!(b < a), "{:?}, {:?}", a, b); +- assert!(!(b > a), "{:?}, {:?}", a, b); +- assert!(!(a <= b), "{:?}, {:?}", a, b); +- assert!(!(b <= a), "{:?}, {:?}", a, b); +- assert!(!(a >= b), "{:?}, {:?}", a, b); +- assert!(!(b >= a), "{:?}, {:?}", a, b); +- } +- } +-} +- +-// Returns a tuple containing two distinct pointer values of the same type as +-// the element type of the Simd vector `$id`. +-#[allow(unused)] +-macro_rules! ptr_vals { +- ($id:ty) => { +- // expands to an expression +- #[allow(unused_unsafe)] +- unsafe { +- // all bits cleared +- let clear: <$id as sealed::Simd>::Element = crate::mem::zeroed(); +- // all bits set +- let set: <$id as sealed::Simd>::Element = crate::mem::transmute(-1_isize); +- (clear, set) +- } +- }; +-} +diff --git a/third_party/rust/packed_simd/src/v128.rs b/third_party/rust/packed_simd/src/v128.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/v128.rs ++++ /dev/null +@@ -1,80 +0,0 @@ +-//! 128-bit wide vector types +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_i!([i8; 16]: i8x16, m8x16 | i8, u16 | test_v128 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: | +- /// A 128-bit vector with 16 `i8` lanes. +-); +-impl_u!([u8; 16]: u8x16, m8x16 | u8, u16 | test_v128 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: | +- /// A 128-bit vector with 16 `u8` lanes. +-); +-impl_m!([m8; 16]: m8x16 | i8, u16 | test_v128 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: m16x16 | +- /// A 128-bit vector mask with 16 `m8` lanes. +-); +- +-impl_i!([i16; 8]: i16x8, m16x8 | i16, u8 | test_v128 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: i8x8, u8x8 | +- /// A 128-bit vector with 8 `i16` lanes. +-); +-impl_u!([u16; 8]: u16x8, m16x8 | u16, u8 | test_v128 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: u8x8 | +- /// A 128-bit vector with 8 `u16` lanes. +-); +-impl_m!([m16; 8]: m16x8 | i16, u8 | test_v128 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: m8x8, m32x8 | +- /// A 128-bit vector mask with 8 `m16` lanes. +-); +- +-impl_i!([i32; 4]: i32x4, m32x4 | i32, u8 | test_v128 | x0, x1, x2, x3 | +- From: i8x4, u8x4, i16x4, u16x4 | +- /// A 128-bit vector with 4 `i32` lanes. +-); +-impl_u!([u32; 4]: u32x4, m32x4 | u32, u8 | test_v128 | x0, x1, x2, x3 | +- From: u8x4, u16x4 | +- /// A 128-bit vector with 4 `u32` lanes. +-); +-impl_f!([f32; 4]: f32x4, m32x4 | f32 | test_v128 | x0, x1, x2, x3 | +- From: i8x4, u8x4, i16x4, u16x4 | +- /// A 128-bit vector with 4 `f32` lanes. +-); +-impl_m!([m32; 4]: m32x4 | i32, u8 | test_v128 | x0, x1, x2, x3 | +- From: m8x4, m16x4, m64x4 | +- /// A 128-bit vector mask with 4 `m32` lanes. +-); +- +-impl_i!([i64; 2]: i64x2, m64x2 | i64, u8 | test_v128 | x0, x1 | +- From: i8x2, u8x2, i16x2, u16x2, i32x2, u32x2 | +- /// A 128-bit vector with 2 `i64` lanes. +-); +-impl_u!([u64; 2]: u64x2, m64x2 | u64, u8 | test_v128 | x0, x1 | +- From: u8x2, u16x2, u32x2 | +- /// A 128-bit vector with 2 `u64` lanes. +-); +-impl_f!([f64; 2]: f64x2, m64x2 | f64 | test_v128 | x0, x1 | +- From: i8x2, u8x2, i16x2, u16x2, i32x2, u32x2, f32x2 | +- /// A 128-bit vector with 2 `f64` lanes. +-); +-impl_m!([m64; 2]: m64x2 | i64, u8 | test_v128 | x0, x1 | +- From: m8x2, m16x2, m32x2, m128x2 | +- /// A 128-bit vector mask with 2 `m64` lanes. +-); +- +-impl_i!([i128; 1]: i128x1, m128x1 | i128, u8 | test_v128 | x0 | +- From: /*i8x1, u8x1, i16x1, u16x1, i32x1, u32x1, i64x1, u64x1 */ | // FIXME: unary small vector types +- /// A 128-bit vector with 1 `i128` lane. +-); +-impl_u!([u128; 1]: u128x1, m128x1 | u128, u8 | test_v128 | x0 | +- From: /*u8x1, u16x1, u32x1, u64x1 */ | // FIXME: unary small vector types +- /// A 128-bit vector with 1 `u128` lane. +-); +-impl_m!([m128; 1]: m128x1 | i128, u8 | test_v128 | x0 | +- From: /*m8x1, m16x1, m32x1, m64x1 */ | // FIXME: unary small vector types +- /// A 128-bit vector mask with 1 `m128` lane. +-); +diff --git a/third_party/rust/packed_simd/src/v16.rs b/third_party/rust/packed_simd/src/v16.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/v16.rs ++++ /dev/null +@@ -1,16 +0,0 @@ +-//! 16-bit wide vector types +- +-use crate::*; +- +-impl_i!([i8; 2]: i8x2, m8x2 | i8, u8 | test_v16 | x0, x1 | +- From: | +- /// A 16-bit vector with 2 `i8` lanes. +-); +-impl_u!([u8; 2]: u8x2, m8x2 | u8, u8 | test_v16 | x0, x1 | +- From: | +- /// A 16-bit vector with 2 `u8` lanes. +-); +-impl_m!([m8; 2]: m8x2 | i8, u8 | test_v16 | x0, x1 | +- From: m16x2, m32x2, m64x2, m128x2 | +- /// A 16-bit vector mask with 2 `m8` lanes. +-); +diff --git a/third_party/rust/packed_simd/src/v256.rs b/third_party/rust/packed_simd/src/v256.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/v256.rs ++++ /dev/null +@@ -1,86 +0,0 @@ +-//! 256-bit wide vector types +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_i!([i8; 32]: i8x32, m8x32 | i8, u32 | test_v256 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31 | +- From: | +- /// A 256-bit vector with 32 `i8` lanes. +-); +-impl_u!([u8; 32]: u8x32, m8x32 | u8, u32 | test_v256 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31 | +- From: | +- /// A 256-bit vector with 32 `u8` lanes. +-); +-impl_m!([m8; 32]: m8x32 | i8, u32 | test_v256 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31 | +- From: | +- /// A 256-bit vector mask with 32 `m8` lanes. +-); +- +-impl_i!([i16; 16]: i16x16, m16x16 | i16, u16 | test_v256 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: i8x16, u8x16 | +- /// A 256-bit vector with 16 `i16` lanes. +-); +-impl_u!([u16; 16]: u16x16, m16x16 | u16, u16 | test_v256 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: u8x16 | +- /// A 256-bit vector with 16 `u16` lanes. +-); +-impl_m!([m16; 16]: m16x16 | i16, u16 | test_v256 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: m8x16 | +- /// A 256-bit vector mask with 16 `m16` lanes. +-); +- +-impl_i!([i32; 8]: i32x8, m32x8 | i32, u8 | test_v256 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: i8x8, u8x8, i16x8, u16x8 | +- /// A 256-bit vector with 8 `i32` lanes. +-); +-impl_u!([u32; 8]: u32x8, m32x8 | u32, u8 | test_v256 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: u8x8, u16x8 | +- /// A 256-bit vector with 8 `u32` lanes. +-); +-impl_f!([f32; 8]: f32x8, m32x8 | f32 | test_v256 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: i8x8, u8x8, i16x8, u16x8 | +- /// A 256-bit vector with 8 `f32` lanes. +-); +-impl_m!([m32; 8]: m32x8 | i32, u8 | test_v256 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: m8x8, m16x8 | +- /// A 256-bit vector mask with 8 `m32` lanes. +-); +- +-impl_i!([i64; 4]: i64x4, m64x4 | i64, u8 | test_v256 | x0, x1, x2, x3 | +- From: i8x4, u8x4, i16x4, u16x4, i32x4, u32x4 | +- /// A 256-bit vector with 4 `i64` lanes. +-); +-impl_u!([u64; 4]: u64x4, m64x4 | u64, u8 | test_v256 | x0, x1, x2, x3 | +- From: u8x4, u16x4, u32x4 | +- /// A 256-bit vector with 4 `u64` lanes. +-); +-impl_f!([f64; 4]: f64x4, m64x4 | f64 | test_v256 | x0, x1, x2, x3 | +- From: i8x4, u8x4, i16x4, u16x4, i32x4, u32x4, f32x4 | +- /// A 256-bit vector with 4 `f64` lanes. +-); +-impl_m!([m64; 4]: m64x4 | i64, u8 | test_v256 | x0, x1, x2, x3 | +- From: m8x4, m16x4, m32x4 | +- /// A 256-bit vector mask with 4 `m64` lanes. +-); +- +-impl_i!([i128; 2]: i128x2, m128x2 | i128, u8 | test_v256 | x0, x1 | +- From: i8x2, u8x2, i16x2, u16x2, i32x2, u32x2, i64x2, u64x2 | +- /// A 256-bit vector with 2 `i128` lanes. +-); +-impl_u!([u128; 2]: u128x2, m128x2 | u128, u8 | test_v256 | x0, x1 | +- From: u8x2, u16x2, u32x2, u64x2 | +- /// A 256-bit vector with 2 `u128` lanes. +-); +-impl_m!([m128; 2]: m128x2 | i128, u8 | test_v256 | x0, x1 | +- From: m8x2, m16x2, m32x2, m64x2 | +- /// A 256-bit vector mask with 2 `m128` lanes. +-); +diff --git a/third_party/rust/packed_simd/src/v32.rs b/third_party/rust/packed_simd/src/v32.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/v32.rs ++++ /dev/null +@@ -1,29 +0,0 @@ +-//! 32-bit wide vector types +- +-use crate::*; +- +-impl_i!([i8; 4]: i8x4, m8x4 | i8, u8 | test_v32 | x0, x1, x2, x3 | +- From: | +- /// A 32-bit vector with 4 `i8` lanes. +-); +-impl_u!([u8; 4]: u8x4, m8x4 | u8, u8 | test_v32 | x0, x1, x2, x3 | +- From: | +- /// A 32-bit vector with 4 `u8` lanes. +-); +-impl_m!([m8; 4]: m8x4 | i8, u8 | test_v32 | x0, x1, x2, x3 | +- From: m16x4, m32x4, m64x4 | +- /// A 32-bit vector mask with 4 `m8` lanes. +-); +- +-impl_i!([i16; 2]: i16x2, m16x2 | i16, u8 | test_v32 | x0, x1 | +- From: i8x2, u8x2 | +- /// A 32-bit vector with 2 `i16` lanes. +-); +-impl_u!([u16; 2]: u16x2, m16x2 | u16, u8 | test_v32 | x0, x1 | +- From: u8x2 | +- /// A 32-bit vector with 2 `u16` lanes. +-); +-impl_m!([m16; 2]: m16x2 | i16, u8 | test_v32 | x0, x1 | +- From: m8x2, m32x2, m64x2, m128x2 | +- /// A 32-bit vector mask with 2 `m16` lanes. +-); +diff --git a/third_party/rust/packed_simd/src/v512.rs b/third_party/rust/packed_simd/src/v512.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/v512.rs ++++ /dev/null +@@ -1,99 +0,0 @@ +-//! 512-bit wide vector types +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_i!([i8; 64]: i8x64, m8x64 | i8, u64 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, +- x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, +- x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63 | +- From: | +- /// A 512-bit vector with 64 `i8` lanes. +-); +-impl_u!([u8; 64]: u8x64, m8x64 | u8, u64 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, +- x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, +- x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63 | +- From: | +- /// A 512-bit vector with 64 `u8` lanes. +-); +-impl_m!([m8; 64]: m8x64 | i8, u64 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31, +- x32, x33, x34, x35, x36, x37, x38, x39, x40, x41, x42, x43, x44, x45, x46, x47, +- x48, x49, x50, x51, x52, x53, x54, x55, x56, x57, x58, x59, x60, x61, x62, x63 | +- From: | +- /// A 512-bit vector mask with 64 `m8` lanes. +-); +- +-impl_i!([i16; 32]: i16x32, m16x32 | i16, u32 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31 | +- From: i8x32, u8x32 | +- /// A 512-bit vector with 32 `i16` lanes. +-); +-impl_u!([u16; 32]: u16x32, m16x32 | u16, u32 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31 | +- From: u8x32 | +- /// A 512-bit vector with 32 `u16` lanes. +-); +-impl_m!([m16; 32]: m16x32 | i16, u32 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, +- x16, x17, x18, x19, x20, x21, x22, x23, x24, x25, x26, x27, x28, x29, x30, x31 | +- From: m8x32 | +- /// A 512-bit vector mask with 32 `m16` lanes. +-); +- +-impl_i!([i32; 16]: i32x16, m32x16 | i32, u16 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: i8x16, u8x16, i16x16, u16x16 | +- /// A 512-bit vector with 16 `i32` lanes. +-); +-impl_u!([u32; 16]: u32x16, m32x16 | u32, u16 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: u8x16, u16x16 | +- /// A 512-bit vector with 16 `u32` lanes. +-); +-impl_f!([f32; 16]: f32x16, m32x16 | f32 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: i8x16, u8x16, i16x16, u16x16 | +- /// A 512-bit vector with 16 `f32` lanes. +-); +-impl_m!([m32; 16]: m32x16 | i32, u16 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15 | +- From: m8x16, m16x16 | +- /// A 512-bit vector mask with 16 `m32` lanes. +-); +- +-impl_i!([i64; 8]: i64x8, m64x8 | i64, u8 | test_v512 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: i8x8, u8x8, i16x8, u16x8, i32x8, u32x8 | +- /// A 512-bit vector with 8 `i64` lanes. +-); +-impl_u!([u64; 8]: u64x8, m64x8 | u64, u8 | test_v512 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: u8x8, u16x8, u32x8 | +- /// A 512-bit vector with 8 `u64` lanes. +-); +-impl_f!([f64; 8]: f64x8, m64x8 | f64 | test_v512 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: i8x8, u8x8, i16x8, u16x8, i32x8, u32x8, f32x8 | +- /// A 512-bit vector with 8 `f64` lanes. +-); +-impl_m!([m64; 8]: m64x8 | i64, u8 | test_v512 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: m8x8, m16x8, m32x8 | +- /// A 512-bit vector mask with 8 `m64` lanes. +-); +- +-impl_i!([i128; 4]: i128x4, m128x4 | i128, u8 | test_v512 | x0, x1, x2, x3 | +- From: i8x4, u8x4, i16x4, u16x4, i32x4, u32x4, i64x4, u64x4 | +- /// A 512-bit vector with 4 `i128` lanes. +-); +-impl_u!([u128; 4]: u128x4, m128x4 | u128, u8 | test_v512 | x0, x1, x2, x3 | +- From: u8x4, u16x4, u32x4, u64x4 | +- /// A 512-bit vector with 4 `u128` lanes. +-); +-impl_m!([m128; 4]: m128x4 | i128, u8 | test_v512 | x0, x1, x2, x3 | +- From: m8x4, m16x4, m32x4, m64x4 | +- /// A 512-bit vector mask with 4 `m128` lanes. +-); +diff --git a/third_party/rust/packed_simd/src/v64.rs b/third_party/rust/packed_simd/src/v64.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/v64.rs ++++ /dev/null +@@ -1,66 +0,0 @@ +-//! 64-bit wide vector types +-#[rustfmt::skip] +- +-use super::*; +- +-impl_i!([i8; 8]: i8x8, m8x8 | i8, u8 | test_v64 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: | +- /// A 64-bit vector with 8 `i8` lanes. +-); +-impl_u!([u8; 8]: u8x8, m8x8 | u8, u8 | test_v64 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: | +- /// A 64-bit vector with 8 `u8` lanes. +-); +-impl_m!([m8; 8]: m8x8 | i8, u8 | test_v64 | x0, x1, x2, x3, x4, x5, x6, x7 | +- From: m16x8, m32x8 | +- /// A 64-bit vector mask with 8 `m8` lanes. +-); +- +-impl_i!([i16; 4]: i16x4, m16x4 | i16, u8 | test_v64 | x0, x1, x2, x3 | +- From: i8x4, u8x4 | +- /// A 64-bit vector with 4 `i16` lanes. +-); +-impl_u!([u16; 4]: u16x4, m16x4 | u16, u8 | test_v64 | x0, x1, x2, x3 | +- From: u8x4 | +- /// A 64-bit vector with 4 `u16` lanes. +-); +-impl_m!([m16; 4]: m16x4 | i16, u8 | test_v64 | x0, x1, x2, x3 | +- From: m8x4, m32x4, m64x4 | +- /// A 64-bit vector mask with 4 `m16` lanes. +-); +- +-impl_i!([i32; 2]: i32x2, m32x2 | i32, u8 | test_v64 | x0, x1 | +- From: i8x2, u8x2, i16x2, u16x2 | +- /// A 64-bit vector with 2 `i32` lanes. +-); +-impl_u!([u32; 2]: u32x2, m32x2 | u32, u8 | test_v64 | x0, x1 | +- From: u8x2, u16x2 | +- /// A 64-bit vector with 2 `u32` lanes. +-); +-impl_m!([m32; 2]: m32x2 | i32, u8 | test_v64 | x0, x1 | +- From: m8x2, m16x2, m64x2, m128x2 | +- /// A 64-bit vector mask with 2 `m32` lanes. +-); +-impl_f!([f32; 2]: f32x2, m32x2 | f32 | test_v64 | x0, x1 | +- From: i8x2, u8x2, i16x2, u16x2 | +- /// A 64-bit vector with 2 `f32` lanes. +-); +- +-/* +-impl_i!([i64; 1]: i64x1, m64x1 | i64, u8 | test_v64 | x0 | +- From: /*i8x1, u8x1, i16x1, u16x1, i32x1, u32x1*/ | // FIXME: primitive to vector conversion +- /// A 64-bit vector with 1 `i64` lanes. +-); +-impl_u!([u64; 1]: u64x1, m64x1 | u64, u8 | test_v64 | x0 | +- From: /*u8x1, u16x1, u32x1*/ | // FIXME: primitive to vector conversion +- /// A 64-bit vector with 1 `u64` lanes. +-); +-impl_m!([m64; 1]: m64x1 | i64, u8 | test_v64 | x0 | +- From: /*m8x1, m16x1, m32x1, */ m128x1 | // FIXME: unary small vector types +- /// A 64-bit vector mask with 1 `m64` lanes. +-); +-impl_f!([f64; 1]: f64x1, m64x1 | f64 | test_v64 | x0 | +- From: /*i8x1, u8x1, i16x1, u16x1, i32x1, u32x1, f32x1*/ | // FIXME: unary small vector types +- /// A 64-bit vector with 1 `f64` lanes. +-); +-*/ +diff --git a/third_party/rust/packed_simd/src/vPtr.rs b/third_party/rust/packed_simd/src/vPtr.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/vPtr.rs ++++ /dev/null +@@ -1,34 +0,0 @@ +-//! Vectors of pointers +-#[rustfmt::skip] +- +-use crate::*; +- +-impl_const_p!( +- [*const T; 2]: cptrx2, msizex2, usizex2, isizex2 | test_v128 | x0, x1 | From: | +- /// A vector with 2 `*const T` lanes +-); +- +-impl_mut_p!( +- [*mut T; 2]: mptrx2, msizex2, usizex2, isizex2 | test_v128 | x0, x1 | From: | +- /// A vector with 2 `*mut T` lanes +-); +- +-impl_const_p!( +- [*const T; 4]: cptrx4, msizex4, usizex4, isizex4 | test_v256 | x0, x1, x2, x3 | From: | +- /// A vector with 4 `*const T` lanes +-); +- +-impl_mut_p!( +- [*mut T; 4]: mptrx4, msizex4, usizex4, isizex4 | test_v256 | x0, x1, x2, x3 | From: | +- /// A vector with 4 `*mut T` lanes +-); +- +-impl_const_p!( +- [*const T; 8]: cptrx8, msizex8, usizex8, isizex8 | test_v512 | x0, x1, x2, x3, x4, x5, x6, x7 | From: | +- /// A vector with 8 `*const T` lanes +-); +- +-impl_mut_p!( +- [*mut T; 8]: mptrx8, msizex8, usizex8, isizex8 | test_v512 | x0, x1, x2, x3, x4, x5, x6, x7 | From: | +- /// A vector with 8 `*mut T` lanes +-); +diff --git a/third_party/rust/packed_simd/src/vSize.rs b/third_party/rust/packed_simd/src/vSize.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/src/vSize.rs ++++ /dev/null +@@ -1,53 +0,0 @@ +-//! Vectors with pointer-sized elements +- +-use crate::codegen::pointer_sized_int::{isize_, usize_}; +-use crate::*; +- +-impl_i!([isize; 2]: isizex2, msizex2 | isize_, u8 | test_v128 | +- x0, x1| +- From: | +- /// A vector with 2 `isize` lanes. +-); +- +-impl_u!([usize; 2]: usizex2, msizex2 | usize_, u8 | test_v128 | +- x0, x1| +- From: | +- /// A vector with 2 `usize` lanes. +-); +-impl_m!([msize; 2]: msizex2 | isize_, u8 | test_v128 | +- x0, x1 | +- From: | +- /// A vector mask with 2 `msize` lanes. +-); +- +-impl_i!([isize; 4]: isizex4, msizex4 | isize_, u8 | test_v256 | +- x0, x1, x2, x3 | +- From: | +- /// A vector with 4 `isize` lanes. +-); +-impl_u!([usize; 4]: usizex4, msizex4 | usize_, u8 | test_v256 | +- x0, x1, x2, x3| +- From: | +- /// A vector with 4 `usize` lanes. +-); +-impl_m!([msize; 4]: msizex4 | isize_, u8 | test_v256 | +- x0, x1, x2, x3 | +- From: | +- /// A vector mask with 4 `msize` lanes. +-); +- +-impl_i!([isize; 8]: isizex8, msizex8 | isize_, u8 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7 | +- From: | +- /// A vector with 8 `isize` lanes. +-); +-impl_u!([usize; 8]: usizex8, msizex8 | usize_, u8 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7 | +- From: | +- /// A vector with 8 `usize` lanes. +-); +-impl_m!([msize; 8]: msizex8 | isize_, u8 | test_v512 | +- x0, x1, x2, x3, x4, x5, x6, x7 | +- From: | +- /// A vector mask with 8 `msize` lanes. +-); +diff --git a/third_party/rust/packed_simd/tests/endianness.rs b/third_party/rust/packed_simd/tests/endianness.rs +deleted file mode 100644 +--- a/third_party/rust/packed_simd/tests/endianness.rs ++++ /dev/null +@@ -1,268 +0,0 @@ +-#[cfg(target_arch = "wasm32")] +-use wasm_bindgen_test::*; +- +-use packed_simd::*; +-use std::{mem, slice}; +- +-#[cfg_attr(not(target_arch = "wasm32"), test)] +-#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +-fn endian_indexing() { +- let v = i32x4::new(0, 1, 2, 3); +- assert_eq!(v.extract(0), 0); +- assert_eq!(v.extract(1), 1); +- assert_eq!(v.extract(2), 2); +- assert_eq!(v.extract(3), 3); +-} +- +-#[cfg_attr(not(target_arch = "wasm32"), test)] +-#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +-fn endian_bitcasts() { +- #[rustfmt::skip] +- let x = i8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- let t: i16x8 = unsafe { mem::transmute(x) }; +- let e: i16x8 = if cfg!(target_endian = "little") { +- i16x8::new(256, 770, 1284, 1798, 2312, 2826, 3340, 3854) +- } else { +- i16x8::new(1, 515, 1029, 1543, 2057, 2571, 3085, 3599) +- }; +- assert_eq!(t, e); +-} +- +-#[cfg_attr(not(target_arch = "wasm32"), test)] +-#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +-fn endian_casts() { +- #[rustfmt::skip] +- let x = i8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- let t: i16x16 = x.into(); // simd_cast +- #[rustfmt::skip] +- let e = i16x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- assert_eq!(t, e); +-} +- +-#[cfg_attr(not(target_arch = "wasm32"), test)] +-#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +-fn endian_load_and_stores() { +- #[rustfmt::skip] +- let x = i8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- let mut y: [i16; 8] = [0; 8]; +- x.write_to_slice_unaligned(unsafe { slice::from_raw_parts_mut(&mut y as *mut _ as *mut i8, 16) }); +- +- let e: [i16; 8] = if cfg!(target_endian = "little") { +- [256, 770, 1284, 1798, 2312, 2826, 3340, 3854] +- } else { +- [1, 515, 1029, 1543, 2057, 2571, 3085, 3599] +- }; +- assert_eq!(y, e); +- +- let z = i8x16::from_slice_unaligned(unsafe { slice::from_raw_parts(&y as *const _ as *const i8, 16) }); +- assert_eq!(z, x); +-} +- +-#[cfg_attr(not(target_arch = "wasm32"), test)] +-#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +-fn endian_array_union() { +- union A { +- data: [f32; 4], +- vec: f32x4, +- } +- let x: [f32; 4] = unsafe { A { vec: f32x4::new(0., 1., 2., 3.) }.data }; +- // As all of these are integer values within the mantissa^1 range, it +- // would be very unusual for them to actually fail to compare. +- #[allow(clippy::float_cmp)] +- { +- assert_eq!(x[0], 0_f32); +- assert_eq!(x[1], 1_f32); +- assert_eq!(x[2], 2_f32); +- assert_eq!(x[3], 3_f32); +- } +- let y: f32x4 = unsafe { A { data: [3., 2., 1., 0.] }.vec }; +- assert_eq!(y, f32x4::new(3., 2., 1., 0.)); +- +- union B { +- data: [i8; 16], +- vec: i8x16, +- } +- #[rustfmt::skip] +- let x = i8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- let x: [i8; 16] = unsafe { B { vec: x }.data }; +- +- for (i, v) in x.iter().enumerate() { +- assert_eq!(i as i8, *v); +- } +- +- #[rustfmt::skip] +- let y = [ +- 15, 14, 13, 12, 11, 19, 9, 8, +- 7, 6, 5, 4, 3, 2, 1, 0 +- ]; +- #[rustfmt::skip] +- let e = i8x16::new( +- 15, 14, 13, 12, 11, 19, 9, 8, +- 7, 6, 5, 4, 3, 2, 1, 0 +- ); +- let z = unsafe { B { data: y }.vec }; +- assert_eq!(z, e); +- +- union C { +- data: [i16; 8], +- vec: i8x16, +- } +- #[rustfmt::skip] +- let x = i8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- let x: [i16; 8] = unsafe { C { vec: x }.data }; +- +- let e: [i16; 8] = if cfg!(target_endian = "little") { +- [256, 770, 1284, 1798, 2312, 2826, 3340, 3854] +- } else { +- [1, 515, 1029, 1543, 2057, 2571, 3085, 3599] +- }; +- assert_eq!(x, e); +-} +- +-#[cfg_attr(not(target_arch = "wasm32"), test)] +-#[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] +-fn endian_tuple_access() { +- type F32x4T = (f32, f32, f32, f32); +- union A { +- data: F32x4T, +- vec: f32x4, +- } +- let x: F32x4T = unsafe { A { vec: f32x4::new(0., 1., 2., 3.) }.data }; +- // As all of these are integer values within the mantissa^1 range, it +- // would be very unusual for them to actually fail to compare. +- #[allow(clippy::float_cmp)] +- { +- assert_eq!(x.0, 0_f32); +- assert_eq!(x.1, 1_f32); +- assert_eq!(x.2, 2_f32); +- assert_eq!(x.3, 3_f32); +- } +- let y: f32x4 = unsafe { A { data: (3., 2., 1., 0.) }.vec }; +- assert_eq!(y, f32x4::new(3., 2., 1., 0.)); +- +- #[rustfmt::skip] +- type I8x16T = (i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8, i8); +- union B { +- data: I8x16T, +- vec: i8x16, +- } +- +- #[rustfmt::skip] +- let x = i8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- let x: I8x16T = unsafe { B { vec: x }.data }; +- +- assert_eq!(x.0, 0); +- assert_eq!(x.1, 1); +- assert_eq!(x.2, 2); +- assert_eq!(x.3, 3); +- assert_eq!(x.4, 4); +- assert_eq!(x.5, 5); +- assert_eq!(x.6, 6); +- assert_eq!(x.7, 7); +- assert_eq!(x.8, 8); +- assert_eq!(x.9, 9); +- assert_eq!(x.10, 10); +- assert_eq!(x.11, 11); +- assert_eq!(x.12, 12); +- assert_eq!(x.13, 13); +- assert_eq!(x.14, 14); +- assert_eq!(x.15, 15); +- +- #[rustfmt::skip] +- let y = ( +- 15, 14, 13, 12, 11, 10, 9, 8, +- 7, 6, 5, 4, 3, 2, 1, 0 +- ); +- let z: i8x16 = unsafe { B { data: y }.vec }; +- #[rustfmt::skip] +- let e = i8x16::new( +- 15, 14, 13, 12, 11, 10, 9, 8, +- 7, 6, 5, 4, 3, 2, 1, 0 +- ); +- assert_eq!(e, z); +- +- #[rustfmt::skip] +- type I16x8T = (i16, i16, i16, i16, i16, i16, i16, i16); +- union C { +- data: I16x8T, +- vec: i8x16, +- } +- +- #[rustfmt::skip] +- let x = i8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- let x: I16x8T = unsafe { C { vec: x }.data }; +- +- let e: [i16; 8] = if cfg!(target_endian = "little") { +- [256, 770, 1284, 1798, 2312, 2826, 3340, 3854] +- } else { +- [1, 515, 1029, 1543, 2057, 2571, 3085, 3599] +- }; +- assert_eq!(x.0, e[0]); +- assert_eq!(x.1, e[1]); +- assert_eq!(x.2, e[2]); +- assert_eq!(x.3, e[3]); +- assert_eq!(x.4, e[4]); +- assert_eq!(x.5, e[5]); +- assert_eq!(x.6, e[6]); +- assert_eq!(x.7, e[7]); +- +- #[rustfmt::skip] +- #[repr(C)] +- #[derive(Copy ,Clone)] +- pub struct Tup(pub i8, pub i8, pub i16, pub i8, pub i8, pub i16, +- pub i8, pub i8, pub i16, pub i8, pub i8, pub i16); +- +- union D { +- data: Tup, +- vec: i8x16, +- } +- +- #[rustfmt::skip] +- let x = i8x16::new( +- 0, 1, 2, 3, 4, 5, 6, 7, +- 8, 9, 10, 11, 12, 13, 14, 15, +- ); +- let x: Tup = unsafe { D { vec: x }.data }; +- +- let e: [i16; 12] = if cfg!(target_endian = "little") { +- [0, 1, 770, 4, 5, 1798, 8, 9, 2826, 12, 13, 3854] +- } else { +- [0, 1, 515, 4, 5, 1543, 8, 9, 2571, 12, 13, 3599] +- }; +- assert_eq!(x.0 as i16, e[0]); +- assert_eq!(x.1 as i16, e[1]); +- assert_eq!(x.2 as i16, e[2]); +- assert_eq!(x.3 as i16, e[3]); +- assert_eq!(x.4 as i16, e[4]); +- assert_eq!(x.5 as i16, e[5]); +- assert_eq!(x.6 as i16, e[6]); +- assert_eq!(x.7 as i16, e[7]); +- assert_eq!(x.8 as i16, e[8]); +- assert_eq!(x.9 as i16, e[9]); +- assert_eq!(x.10 as i16, e[10]); +- assert_eq!(x.11 as i16, e[11]); +-} +diff --git a/third_party/rust/version_check/.cargo-checksum.json b/third_party/rust/version_check/.cargo-checksum.json +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/.cargo-checksum.json +@@ -0,0 +1,1 @@ ++{"files":{"Cargo.toml":"f25d88044914cb3466df43bc39a199e1589dda1aad3226c9c7e7ac4d2f8751d0","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"b7e650f3fce5c53249d1cdc608b54df156a97edd636cf9d23498d0cfe7aec63e","README.md":"ac2a0a360812436bd5798f5fe2affe7d6ed9eb7f15d6e4d73931e95b437560f2","src/channel.rs":"d2443d503d4cc469a171a51a26eca3ec0d2a58b5f7375a84542c36f1421766a8","src/date.rs":"09580a0a2008fad2ccbc43fb42a88f42221b98b01692702022a296dc9c86bf37","src/lib.rs":"760f0d29567ecaa61287088cf23cf74b3c0efbbcd3077cea5fb7c88359e96c7e","src/version.rs":"dba18a25983ec6e37b952f4cdc5219c9e5abba2c3a76cef87465e1fba6f8ac89"},"package":"49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"} +\ No newline at end of file +diff --git a/third_party/rust/version_check/Cargo.toml b/third_party/rust/version_check/Cargo.toml +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/Cargo.toml +@@ -0,0 +1,24 @@ ++# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO ++# ++# When uploading crates to the registry Cargo will automatically ++# "normalize" Cargo.toml files for maximal compatibility ++# with all versions of Cargo and also rewrite `path` dependencies ++# to registry (e.g., crates.io) dependencies. ++# ++# If you are reading this file be aware that the original Cargo.toml ++# will likely look very different (and much more reasonable). ++# See Cargo.toml.orig for the original contents. ++ ++[package] ++name = "version_check" ++version = "0.9.4" ++authors = ["Sergio Benitez "] ++exclude = ["static"] ++description = "Tiny crate to check the version of the installed/running rustc." ++documentation = "https://docs.rs/version_check/" ++readme = "README.md" ++keywords = ["version", "rustc", "minimum", "check"] ++license = "MIT/Apache-2.0" ++repository = "https://github.com/SergioBenitez/version_check" ++ ++[dependencies] +diff --git a/third_party/rust/version_check/LICENSE-APACHE b/third_party/rust/version_check/LICENSE-APACHE +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/LICENSE-APACHE +@@ -0,0 +1,201 @@ ++ Apache License ++ Version 2.0, January 2004 ++ http://www.apache.org/licenses/ ++ ++TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION ++ ++1. Definitions. ++ ++ "License" shall mean the terms and conditions for use, reproduction, ++ and distribution as defined by Sections 1 through 9 of this document. ++ ++ "Licensor" shall mean the copyright owner or entity authorized by ++ the copyright owner that is granting the License. ++ ++ "Legal Entity" shall mean the union of the acting entity and all ++ other entities that control, are controlled by, or are under common ++ control with that entity. For the purposes of this definition, ++ "control" means (i) the power, direct or indirect, to cause the ++ direction or management of such entity, whether by contract or ++ otherwise, or (ii) ownership of fifty percent (50%) or more of the ++ outstanding shares, or (iii) beneficial ownership of such entity. ++ ++ "You" (or "Your") shall mean an individual or Legal Entity ++ exercising permissions granted by this License. ++ ++ "Source" form shall mean the preferred form for making modifications, ++ including but not limited to software source code, documentation ++ source, and configuration files. ++ ++ "Object" form shall mean any form resulting from mechanical ++ transformation or translation of a Source form, including but ++ not limited to compiled object code, generated documentation, ++ and conversions to other media types. ++ ++ "Work" shall mean the work of authorship, whether in Source or ++ Object form, made available under the License, as indicated by a ++ copyright notice that is included in or attached to the work ++ (an example is provided in the Appendix below). ++ ++ "Derivative Works" shall mean any work, whether in Source or Object ++ form, that is based on (or derived from) the Work and for which the ++ editorial revisions, annotations, elaborations, or other modifications ++ represent, as a whole, an original work of authorship. For the purposes ++ of this License, Derivative Works shall not include works that remain ++ separable from, or merely link (or bind by name) to the interfaces of, ++ the Work and Derivative Works thereof. ++ ++ "Contribution" shall mean any work of authorship, including ++ the original version of the Work and any modifications or additions ++ to that Work or Derivative Works thereof, that is intentionally ++ submitted to Licensor for inclusion in the Work by the copyright owner ++ or by an individual or Legal Entity authorized to submit on behalf of ++ the copyright owner. For the purposes of this definition, "submitted" ++ means any form of electronic, verbal, or written communication sent ++ to the Licensor or its representatives, including but not limited to ++ communication on electronic mailing lists, source code control systems, ++ and issue tracking systems that are managed by, or on behalf of, the ++ Licensor for the purpose of discussing and improving the Work, but ++ excluding communication that is conspicuously marked or otherwise ++ designated in writing by the copyright owner as "Not a Contribution." ++ ++ "Contributor" shall mean Licensor and any individual or Legal Entity ++ on behalf of whom a Contribution has been received by Licensor and ++ subsequently incorporated within the Work. ++ ++2. Grant of Copyright License. Subject to the terms and conditions of ++ this License, each Contributor hereby grants to You a perpetual, ++ worldwide, non-exclusive, no-charge, royalty-free, irrevocable ++ copyright license to reproduce, prepare Derivative Works of, ++ publicly display, publicly perform, sublicense, and distribute the ++ Work and such Derivative Works in Source or Object form. ++ ++3. Grant of Patent License. Subject to the terms and conditions of ++ this License, each Contributor hereby grants to You a perpetual, ++ worldwide, non-exclusive, no-charge, royalty-free, irrevocable ++ (except as stated in this section) patent license to make, have made, ++ use, offer to sell, sell, import, and otherwise transfer the Work, ++ where such license applies only to those patent claims licensable ++ by such Contributor that are necessarily infringed by their ++ Contribution(s) alone or by combination of their Contribution(s) ++ with the Work to which such Contribution(s) was submitted. If You ++ institute patent litigation against any entity (including a ++ cross-claim or counterclaim in a lawsuit) alleging that the Work ++ or a Contribution incorporated within the Work constitutes direct ++ or contributory patent infringement, then any patent licenses ++ granted to You under this License for that Work shall terminate ++ as of the date such litigation is filed. ++ ++4. Redistribution. You may reproduce and distribute copies of the ++ Work or Derivative Works thereof in any medium, with or without ++ modifications, and in Source or Object form, provided that You ++ meet the following conditions: ++ ++ (a) You must give any other recipients of the Work or ++ Derivative Works a copy of this License; and ++ ++ (b) You must cause any modified files to carry prominent notices ++ stating that You changed the files; and ++ ++ (c) You must retain, in the Source form of any Derivative Works ++ that You distribute, all copyright, patent, trademark, and ++ attribution notices from the Source form of the Work, ++ excluding those notices that do not pertain to any part of ++ the Derivative Works; and ++ ++ (d) If the Work includes a "NOTICE" text file as part of its ++ distribution, then any Derivative Works that You distribute must ++ include a readable copy of the attribution notices contained ++ within such NOTICE file, excluding those notices that do not ++ pertain to any part of the Derivative Works, in at least one ++ of the following places: within a NOTICE text file distributed ++ as part of the Derivative Works; within the Source form or ++ documentation, if provided along with the Derivative Works; or, ++ within a display generated by the Derivative Works, if and ++ wherever such third-party notices normally appear. The contents ++ of the NOTICE file are for informational purposes only and ++ do not modify the License. You may add Your own attribution ++ notices within Derivative Works that You distribute, alongside ++ or as an addendum to the NOTICE text from the Work, provided ++ that such additional attribution notices cannot be construed ++ as modifying the License. ++ ++ You may add Your own copyright statement to Your modifications and ++ may provide additional or different license terms and conditions ++ for use, reproduction, or distribution of Your modifications, or ++ for any such Derivative Works as a whole, provided Your use, ++ reproduction, and distribution of the Work otherwise complies with ++ the conditions stated in this License. ++ ++5. Submission of Contributions. Unless You explicitly state otherwise, ++ any Contribution intentionally submitted for inclusion in the Work ++ by You to the Licensor shall be under the terms and conditions of ++ this License, without any additional terms or conditions. ++ Notwithstanding the above, nothing herein shall supersede or modify ++ the terms of any separate license agreement you may have executed ++ with Licensor regarding such Contributions. ++ ++6. Trademarks. This License does not grant permission to use the trade ++ names, trademarks, service marks, or product names of the Licensor, ++ except as required for reasonable and customary use in describing the ++ origin of the Work and reproducing the content of the NOTICE file. ++ ++7. Disclaimer of Warranty. Unless required by applicable law or ++ agreed to in writing, Licensor provides the Work (and each ++ Contributor provides its Contributions) on an "AS IS" BASIS, ++ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or ++ implied, including, without limitation, any warranties or conditions ++ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A ++ PARTICULAR PURPOSE. You are solely responsible for determining the ++ appropriateness of using or redistributing the Work and assume any ++ risks associated with Your exercise of permissions under this License. ++ ++8. Limitation of Liability. In no event and under no legal theory, ++ whether in tort (including negligence), contract, or otherwise, ++ unless required by applicable law (such as deliberate and grossly ++ negligent acts) or agreed to in writing, shall any Contributor be ++ liable to You for damages, including any direct, indirect, special, ++ incidental, or consequential damages of any character arising as a ++ result of this License or out of the use or inability to use the ++ Work (including but not limited to damages for loss of goodwill, ++ work stoppage, computer failure or malfunction, or any and all ++ other commercial damages or losses), even if such Contributor ++ has been advised of the possibility of such damages. ++ ++9. Accepting Warranty or Additional Liability. While redistributing ++ the Work or Derivative Works thereof, You may choose to offer, ++ and charge a fee for, acceptance of support, warranty, indemnity, ++ or other liability obligations and/or rights consistent with this ++ License. However, in accepting such obligations, You may act only ++ on Your own behalf and on Your sole responsibility, not on behalf ++ of any other Contributor, and only if You agree to indemnify, ++ defend, and hold each Contributor harmless for any liability ++ incurred by, or claims asserted against, such Contributor by reason ++ of your accepting any such warranty or additional liability. ++ ++END OF TERMS AND CONDITIONS ++ ++APPENDIX: How to apply the Apache License to your work. ++ ++ To apply the Apache License to your work, attach the following ++ boilerplate notice, with the fields enclosed by brackets "[]" ++ replaced with your own identifying information. (Don't include ++ the brackets!) The text should be enclosed in the appropriate ++ comment syntax for the file format. We also recommend that a ++ file or class name and description of purpose be included on the ++ same "printed page" as the copyright notice for easier ++ identification within third-party archives. ++ ++Copyright [yyyy] [name of copyright owner] ++ ++Licensed under the Apache License, Version 2.0 (the "License"); ++you may not use this file except in compliance with the License. ++You may obtain a copy of the License at ++ ++ http://www.apache.org/licenses/LICENSE-2.0 ++ ++Unless required by applicable law or agreed to in writing, software ++distributed under the License is distributed on an "AS IS" BASIS, ++WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ++See the License for the specific language governing permissions and ++limitations under the License. +diff --git a/third_party/rust/version_check/LICENSE-MIT b/third_party/rust/version_check/LICENSE-MIT +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/LICENSE-MIT +@@ -0,0 +1,19 @@ ++The MIT License (MIT) ++Copyright (c) 2017-2018 Sergio Benitez ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy of ++this software and associated documentation files (the "Software"), to deal in ++the Software without restriction, including without limitation the rights to ++use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of ++the Software, and to permit persons to whom the Software is furnished to do so, ++subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in all ++copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS ++FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR ++COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER ++IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +diff --git a/third_party/rust/version_check/README.md b/third_party/rust/version_check/README.md +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/README.md +@@ -0,0 +1,80 @@ ++# version\_check ++ ++[![Build Status](https://github.com/SergioBenitez/version_check/workflows/CI/badge.svg)](https://github.com/SergioBenitez/version_check/actions) ++[![Current Crates.io Version](https://img.shields.io/crates/v/version_check.svg)](https://crates.io/crates/version_check) ++[![rustdocs on docs.rs](https://docs.rs/version_check/badge.svg)](https://docs.rs/version_check) ++ ++This tiny crate checks that the running or installed `rustc` meets some version ++requirements. The version is queried by calling the Rust compiler with ++`--version`. The path to the compiler is determined first via the `RUSTC` ++environment variable. If it is not set, then `rustc` is used. If that fails, no ++determination is made, and calls return `None`. ++ ++## Usage ++ ++Add to your `Cargo.toml` file, typically as a build dependency: ++ ++```toml ++[build-dependencies] ++version_check = "0.9" ++``` ++ ++`version_check` is compatible and compiles with Rust 1.0.0 and beyond. ++ ++## Examples ++ ++Set a `cfg` flag in `build.rs` if the running compiler was determined to be ++at least version `1.13.0`: ++ ++```rust ++extern crate version_check as rustc; ++ ++if rustc::is_min_version("1.13.0").unwrap_or(false) { ++ println!("cargo:rustc-cfg=question_mark_operator"); ++} ++``` ++ ++Check that the running compiler was released on or after `2018-12-18`: ++ ++```rust ++extern crate version_check as rustc; ++ ++match rustc::is_min_date("2018-12-18") { ++ Some(true) => "Yep! It's recent!", ++ Some(false) => "No, it's older.", ++ None => "Couldn't determine the rustc version." ++}; ++``` ++ ++Check that the running compiler supports feature flags: ++ ++```rust ++extern crate version_check as rustc; ++ ++match rustc::is_feature_flaggable() { ++ Some(true) => "Yes! It's a dev or nightly release!", ++ Some(false) => "No, it's stable or beta.", ++ None => "Couldn't determine the rustc version." ++}; ++``` ++ ++See the [rustdocs](https://docs.rs/version_check) for more examples and complete ++documentation. ++ ++## Alternatives ++ ++This crate is dead simple with no dependencies. If you need something more and ++don't care about panicking if the version cannot be obtained, or if you don't ++mind adding dependencies, see [rustc_version]. If you'd instead prefer a feature ++detection library that works by dynamically invoking `rustc` with a ++representative code sample, see [autocfg]. ++ ++[rustc_version]: https://crates.io/crates/rustc_version ++[autocfg]: https://crates.io/crates/autocfg ++ ++## License ++ ++`version_check` is licensed under either of the following, at your option: ++ ++ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0) ++ * MIT License ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT) +diff --git a/third_party/rust/version_check/src/channel.rs b/third_party/rust/version_check/src/channel.rs +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/src/channel.rs +@@ -0,0 +1,193 @@ ++use std::fmt; ++ ++#[derive(Debug, PartialEq, Eq, Copy, Clone)] ++enum Kind { ++ Dev, ++ Nightly, ++ Beta, ++ Stable, ++} ++ ++/// Release channel: "dev", "nightly", "beta", or "stable". ++#[derive(Debug, PartialEq, Eq, Copy, Clone)] ++pub struct Channel(Kind); ++ ++impl Channel { ++ /// Reads the release channel of the running compiler. If it cannot be ++ /// determined (see the [top-level documentation](crate)), returns `None`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Channel; ++ /// ++ /// match Channel::read() { ++ /// Some(c) => format!("The channel is: {}", c), ++ /// None => format!("Failed to read the release channel.") ++ /// }; ++ /// ``` ++ pub fn read() -> Option { ++ ::get_version_and_date() ++ .and_then(|(version, _)| version) ++ .and_then(|version| Channel::parse(&version)) ++ } ++ ++ /// Parse a Rust release channel from a Rust release version string (of the ++ /// form `major[.minor[.patch[-channel]]]`). Returns `None` if `version` is ++ /// not a valid Rust version string. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Channel; ++ /// ++ /// let dev = Channel::parse("1.3.0-dev").unwrap(); ++ /// assert!(dev.is_dev()); ++ /// ++ /// let nightly = Channel::parse("1.42.2-nightly").unwrap(); ++ /// assert!(nightly.is_nightly()); ++ /// ++ /// let beta = Channel::parse("1.32.0-beta").unwrap(); ++ /// assert!(beta.is_beta()); ++ /// ++ /// let stable = Channel::parse("1.4.0").unwrap(); ++ /// assert!(stable.is_stable()); ++ /// ``` ++ pub fn parse(version: &str) -> Option { ++ let version = version.trim(); ++ if version.contains("-dev") || version == "dev" { ++ Some(Channel(Kind::Dev)) ++ } else if version.contains("-nightly") || version == "nightly" { ++ Some(Channel(Kind::Nightly)) ++ } else if version.contains("-beta") || version == "beta" { ++ Some(Channel(Kind::Beta)) ++ } else if !version.contains("-") { ++ Some(Channel(Kind::Stable)) ++ } else { ++ None ++ } ++ } ++ ++ /// Returns the name of the release channel. ++ fn as_str(&self) -> &'static str { ++ match self.0 { ++ Kind::Dev => "dev", ++ Kind::Beta => "beta", ++ Kind::Nightly => "nightly", ++ Kind::Stable => "stable", ++ } ++ } ++ ++ /// Returns `true` if this channel supports feature flags. In other words, ++ /// returns `true` if the channel is either `dev` or `nightly`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Channel; ++ /// ++ /// let dev = Channel::parse("1.3.0-dev").unwrap(); ++ /// assert!(dev.supports_features()); ++ /// ++ /// let nightly = Channel::parse("1.42.2-nightly").unwrap(); ++ /// assert!(nightly.supports_features()); ++ /// ++ /// let beta = Channel::parse("1.32.0-beta").unwrap(); ++ /// assert!(!beta.supports_features()); ++ /// ++ /// let stable = Channel::parse("1.4.0").unwrap(); ++ /// assert!(!stable.supports_features()); ++ /// ``` ++ pub fn supports_features(&self) -> bool { ++ match self.0 { ++ Kind::Dev | Kind::Nightly => true, ++ Kind::Beta | Kind::Stable => false ++ } ++ } ++ ++ /// Returns `true` if this channel is `dev` and `false` otherwise. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Channel; ++ /// ++ /// let dev = Channel::parse("1.3.0-dev").unwrap(); ++ /// assert!(dev.is_dev()); ++ /// ++ /// let stable = Channel::parse("1.0.0").unwrap(); ++ /// assert!(!stable.is_dev()); ++ /// ``` ++ pub fn is_dev(&self) -> bool { ++ match self.0 { ++ Kind::Dev => true, ++ _ => false ++ } ++ } ++ ++ /// Returns `true` if this channel is `nightly` and `false` otherwise. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Channel; ++ /// ++ /// let nightly = Channel::parse("1.3.0-nightly").unwrap(); ++ /// assert!(nightly.is_nightly()); ++ /// ++ /// let stable = Channel::parse("1.0.0").unwrap(); ++ /// assert!(!stable.is_nightly()); ++ /// ``` ++ pub fn is_nightly(&self) -> bool { ++ match self.0 { ++ Kind::Nightly => true, ++ _ => false ++ } ++ } ++ ++ /// Returns `true` if this channel is `beta` and `false` otherwise. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Channel; ++ /// ++ /// let beta = Channel::parse("1.3.0-beta").unwrap(); ++ /// assert!(beta.is_beta()); ++ /// ++ /// let stable = Channel::parse("1.0.0").unwrap(); ++ /// assert!(!stable.is_beta()); ++ /// ``` ++ pub fn is_beta(&self) -> bool { ++ match self.0 { ++ Kind::Beta => true, ++ _ => false ++ } ++ } ++ ++ /// Returns `true` if this channel is `stable` and `false` otherwise. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Channel; ++ /// ++ /// let stable = Channel::parse("1.0.0").unwrap(); ++ /// assert!(stable.is_stable()); ++ /// ++ /// let beta = Channel::parse("1.3.0-beta").unwrap(); ++ /// assert!(!beta.is_stable()); ++ /// ``` ++ pub fn is_stable(&self) -> bool { ++ match self.0 { ++ Kind::Stable => true, ++ _ => false ++ } ++ } ++} ++ ++impl fmt::Display for Channel { ++ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ++ write!(f, "{}", self.as_str()) ++ } ++} +diff --git a/third_party/rust/version_check/src/date.rs b/third_party/rust/version_check/src/date.rs +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/src/date.rs +@@ -0,0 +1,203 @@ ++use std::fmt; ++ ++/// Release date including year, month, and day. ++// Internal storage is: y[31..9] | m[8..5] | d[5...0]. ++#[derive(Debug, PartialEq, Eq, Copy, Clone, PartialOrd, Ord)] ++pub struct Date(u32); ++ ++impl Date { ++ /// Reads the release date of the running compiler. If it cannot be ++ /// determined (see the [top-level documentation](crate)), returns `None`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Date; ++ /// ++ /// match Date::read() { ++ /// Some(d) => format!("The release date is: {}", d), ++ /// None => format!("Failed to read the release date.") ++ /// }; ++ /// ``` ++ pub fn read() -> Option { ++ ::get_version_and_date() ++ .and_then(|(_, date)| date) ++ .and_then(|date| Date::parse(&date)) ++ } ++ ++ /// Parse a release date of the form `%Y-%m-%d`. Returns `None` if `date` is ++ /// not in `%Y-%m-%d` format. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Date; ++ /// ++ /// let date = Date::parse("2016-04-20").unwrap(); ++ /// ++ /// assert!(date.at_least("2016-01-10")); ++ /// assert!(date.at_most("2016-04-20")); ++ /// assert!(date.exactly("2016-04-20")); ++ /// ++ /// assert!(Date::parse("2021-12-31").unwrap().exactly("2021-12-31")); ++ /// ++ /// assert!(Date::parse("March 13, 2018").is_none()); ++ /// assert!(Date::parse("1-2-3-4-5").is_none()); ++ /// assert!(Date::parse("2020-300-23120").is_none()); ++ /// assert!(Date::parse("2020-12-12 1").is_none()); ++ /// assert!(Date::parse("2020-10").is_none()); ++ /// assert!(Date::parse("2020").is_none()); ++ /// ``` ++ pub fn parse(date: &str) -> Option { ++ let mut ymd = [0u16; 3]; ++ for (i, split) in date.split('-').map(|s| s.parse::()).enumerate() { ++ ymd[i] = match (i, split) { ++ (3, _) | (_, Err(_)) => return None, ++ (_, Ok(v)) => v, ++ }; ++ } ++ ++ let (year, month, day) = (ymd[0], ymd[1], ymd[2]); ++ if year == 0 || month == 0 || month > 12 || day == 0 || day > 31 { ++ return None; ++ } ++ ++ Some(Date::from_ymd(year, month as u8, day as u8)) ++ } ++ ++ /// Creates a `Date` from `(year, month, day)` date components. ++ /// ++ /// Does not check the validity of `year`, `month`, or `day`, but `year` is ++ /// truncated to 23 bits (% 8,388,608), `month` to 4 bits (% 16), and `day` ++ /// to 5 bits (% 32). ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Date; ++ /// ++ /// assert!(Date::from_ymd(2021, 7, 30).exactly("2021-07-30")); ++ /// assert!(Date::from_ymd(2010, 3, 23).exactly("2010-03-23")); ++ /// assert!(Date::from_ymd(2090, 1, 31).exactly("2090-01-31")); ++ /// ++ /// // Truncation: 33 % 32 == 0x21 & 0x1F == 1. ++ /// assert!(Date::from_ymd(2090, 1, 33).exactly("2090-01-01")); ++ /// ``` ++ pub fn from_ymd(year: u16, month: u8, day: u8) -> Date { ++ let year = (year as u32) << 9; ++ let month = ((month as u32) & 0xF) << 5; ++ let day = (day as u32) & 0x1F; ++ Date(year | month | day) ++ } ++ ++ /// Return the original (YYYY, MM, DD). ++ fn to_ymd(&self) -> (u16, u8, u8) { ++ let y = self.0 >> 9; ++ let m = (self.0 >> 5) & 0xF; ++ let d = self.0 & 0x1F; ++ (y as u16, m as u8, d as u8) ++ } ++ ++ /// Returns `true` if `self` occurs on or after `date`. ++ /// ++ /// If `date` occurs before `self`, or if `date` is not in `%Y-%m-%d` ++ /// format, returns `false`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Date; ++ /// ++ /// let date = Date::parse("2020-01-01").unwrap(); ++ /// ++ /// assert!(date.at_least("2019-12-31")); ++ /// assert!(date.at_least("2020-01-01")); ++ /// assert!(date.at_least("2014-04-31")); ++ /// ++ /// assert!(!date.at_least("2020-01-02")); ++ /// assert!(!date.at_least("2024-08-18")); ++ /// ``` ++ pub fn at_least(&self, date: &str) -> bool { ++ Date::parse(date) ++ .map(|date| self >= &date) ++ .unwrap_or(false) ++ } ++ ++ /// Returns `true` if `self` occurs on or before `date`. ++ /// ++ /// If `date` occurs after `self`, or if `date` is not in `%Y-%m-%d` ++ /// format, returns `false`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Date; ++ /// ++ /// let date = Date::parse("2020-01-01").unwrap(); ++ /// ++ /// assert!(date.at_most("2020-01-01")); ++ /// assert!(date.at_most("2020-01-02")); ++ /// assert!(date.at_most("2024-08-18")); ++ /// ++ /// assert!(!date.at_most("2019-12-31")); ++ /// assert!(!date.at_most("2014-04-31")); ++ /// ``` ++ pub fn at_most(&self, date: &str) -> bool { ++ Date::parse(date) ++ .map(|date| self <= &date) ++ .unwrap_or(false) ++ } ++ ++ /// Returns `true` if `self` occurs exactly on `date`. ++ /// ++ /// If `date` is not exactly `self`, or if `date` is not in `%Y-%m-%d` ++ /// format, returns `false`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Date; ++ /// ++ /// let date = Date::parse("2020-01-01").unwrap(); ++ /// ++ /// assert!(date.exactly("2020-01-01")); ++ /// ++ /// assert!(!date.exactly("2019-12-31")); ++ /// assert!(!date.exactly("2014-04-31")); ++ /// assert!(!date.exactly("2020-01-02")); ++ /// assert!(!date.exactly("2024-08-18")); ++ /// ``` ++ pub fn exactly(&self, date: &str) -> bool { ++ Date::parse(date) ++ .map(|date| self == &date) ++ .unwrap_or(false) ++ } ++} ++ ++impl fmt::Display for Date { ++ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ++ let (y, m, d) = self.to_ymd(); ++ write!(f, "{}-{:02}-{:02}", y, m, d) ++ } ++} ++ ++#[cfg(test)] ++mod tests { ++ use super::Date; ++ ++ macro_rules! reflexive_display { ++ ($string:expr) => ( ++ assert_eq!(Date::parse($string).unwrap().to_string(), $string); ++ ) ++ } ++ ++ #[test] ++ fn display() { ++ reflexive_display!("2019-05-08"); ++ reflexive_display!("2000-01-01"); ++ reflexive_display!("2000-12-31"); ++ reflexive_display!("2090-12-31"); ++ reflexive_display!("1999-02-19"); ++ reflexive_display!("9999-12-31"); ++ } ++} +diff --git a/third_party/rust/version_check/src/lib.rs b/third_party/rust/version_check/src/lib.rs +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/src/lib.rs +@@ -0,0 +1,493 @@ ++//! This tiny crate checks that the running or installed `rustc` meets some ++//! version requirements. The version is queried by calling the Rust compiler ++//! with `--version`. The path to the compiler is determined first via the ++//! `RUSTC` environment variable. If it is not set, then `rustc` is used. If ++//! that fails, no determination is made, and calls return `None`. ++//! ++//! # Examples ++//! ++//! * Set a `cfg` flag in `build.rs` if the running compiler was determined to ++//! be at least version `1.13.0`: ++//! ++//! ```rust ++//! extern crate version_check as rustc; ++//! ++//! if rustc::is_min_version("1.13.0").unwrap_or(false) { ++//! println!("cargo:rustc-cfg=question_mark_operator"); ++//! } ++//! ``` ++//! ++//! See [`is_max_version`] or [`is_exact_version`] to check if the compiler ++//! is _at most_ or _exactly_ a certain version. ++//! ++//! * Check that the running compiler was released on or after `2018-12-18`: ++//! ++//! ```rust ++//! extern crate version_check as rustc; ++//! ++//! match rustc::is_min_date("2018-12-18") { ++//! Some(true) => "Yep! It's recent!", ++//! Some(false) => "No, it's older.", ++//! None => "Couldn't determine the rustc version." ++//! }; ++//! ``` ++//! ++//! See [`is_max_date`] or [`is_exact_date`] to check if the compiler was ++//! released _prior to_ or _exactly on_ a certain date. ++//! ++//! * Check that the running compiler supports feature flags: ++//! ++//! ```rust ++//! extern crate version_check as rustc; ++//! ++//! match rustc::is_feature_flaggable() { ++//! Some(true) => "Yes! It's a dev or nightly release!", ++//! Some(false) => "No, it's stable or beta.", ++//! None => "Couldn't determine the rustc version." ++//! }; ++//! ``` ++//! ++//! * Check that the running compiler supports a specific feature: ++//! ++//! ```rust ++//! extern crate version_check as rustc; ++//! ++//! if let Some(true) = rustc::supports_feature("doc_cfg") { ++//! println!("cargo:rustc-cfg=has_doc_cfg"); ++//! } ++//! ``` ++//! ++//! * Check that the running compiler is on the stable channel: ++//! ++//! ```rust ++//! extern crate version_check as rustc; ++//! ++//! match rustc::Channel::read() { ++//! Some(c) if c.is_stable() => format!("Yes! It's stable."), ++//! Some(c) => format!("No, the channel {} is not stable.", c), ++//! None => format!("Couldn't determine the rustc version.") ++//! }; ++//! ``` ++//! ++//! To interact with the version, release date, and release channel as structs, ++//! use [`Version`], [`Date`], and [`Channel`], respectively. The [`triple()`] ++//! function returns all three values efficiently. ++//! ++//! # Alternatives ++//! ++//! This crate is dead simple with no dependencies. If you need something more ++//! and don't care about panicking if the version cannot be obtained, or if you ++//! don't mind adding dependencies, see ++//! [rustc_version](https://crates.io/crates/rustc_version). ++ ++#![allow(deprecated)] ++ ++mod version; ++mod channel; ++mod date; ++ ++use std::env; ++use std::process::Command; ++ ++#[doc(inline)] pub use version::*; ++#[doc(inline)] pub use channel::*; ++#[doc(inline)] pub use date::*; ++ ++/// Parses (version, date) as available from rustc version string. ++fn version_and_date_from_rustc_version(s: &str) -> (Option, Option) { ++ let last_line = s.lines().last().unwrap_or(s); ++ let mut components = last_line.trim().split(" "); ++ let version = components.nth(1); ++ let date = components.filter(|c| c.ends_with(')')).next() ++ .map(|s| s.trim_right().trim_right_matches(")").trim_left().trim_left_matches('(')); ++ (version.map(|s| s.to_string()), date.map(|s| s.to_string())) ++} ++ ++/// Parses (version, date) as available from rustc verbose version output. ++fn version_and_date_from_rustc_verbose_version(s: &str) -> (Option, Option) { ++ let (mut version, mut date) = (None, None); ++ for line in s.lines() { ++ let split = |s: &str| s.splitn(2, ":").nth(1).map(|s| s.trim().to_string()); ++ match line.trim().split(" ").nth(0) { ++ Some("rustc") => { ++ let (v, d) = version_and_date_from_rustc_version(line); ++ version = version.or(v); ++ date = date.or(d); ++ }, ++ Some("release:") => version = split(line), ++ Some("commit-date:") if line.ends_with("unknown") => date = None, ++ Some("commit-date:") => date = split(line), ++ _ => continue ++ } ++ } ++ ++ (version, date) ++} ++ ++/// Returns (version, date) as available from `rustc --version`. ++fn get_version_and_date() -> Option<(Option, Option)> { ++ let rustc = env::var("RUSTC").unwrap_or_else(|_| "rustc".to_string()); ++ Command::new(rustc).arg("--verbose").arg("--version").output().ok() ++ .and_then(|output| String::from_utf8(output.stdout).ok()) ++ .map(|s| version_and_date_from_rustc_verbose_version(&s)) ++} ++ ++/// Reads the triple of [`Version`], [`Channel`], and [`Date`] of the installed ++/// or running `rustc`. ++/// ++/// If any attribute cannot be determined (see the [top-level ++/// documentation](crate)), returns `None`. ++/// ++/// To obtain only one of three attributes, use [`Version::read()`], ++/// [`Channel::read()`], or [`Date::read()`]. ++pub fn triple() -> Option<(Version, Channel, Date)> { ++ let (version_str, date_str) = match get_version_and_date() { ++ Some((Some(version), Some(date))) => (version, date), ++ _ => return None ++ }; ++ ++ // Can't use `?` or `try!` for `Option` in 1.0.0. ++ match Version::parse(&version_str) { ++ Some(version) => match Channel::parse(&version_str) { ++ Some(channel) => match Date::parse(&date_str) { ++ Some(date) => Some((version, channel, date)), ++ _ => None, ++ }, ++ _ => None, ++ }, ++ _ => None ++ } ++} ++ ++/// Checks that the running or installed `rustc` was released **on or after** ++/// some date. ++/// ++/// The format of `min_date` must be YYYY-MM-DD. For instance: `2016-12-20` or ++/// `2017-01-09`. ++/// ++/// If the date cannot be retrieved or parsed, or if `min_date` could not be ++/// parsed, returns `None`. Otherwise returns `true` if the installed `rustc` ++/// was release on or after `min_date` and `false` otherwise. ++pub fn is_min_date(min_date: &str) -> Option { ++ match (Date::read(), Date::parse(min_date)) { ++ (Some(rustc_date), Some(min_date)) => Some(rustc_date >= min_date), ++ _ => None ++ } ++} ++ ++/// Checks that the running or installed `rustc` was released **on or before** ++/// some date. ++/// ++/// The format of `max_date` must be YYYY-MM-DD. For instance: `2016-12-20` or ++/// `2017-01-09`. ++/// ++/// If the date cannot be retrieved or parsed, or if `max_date` could not be ++/// parsed, returns `None`. Otherwise returns `true` if the installed `rustc` ++/// was release on or before `max_date` and `false` otherwise. ++pub fn is_max_date(max_date: &str) -> Option { ++ match (Date::read(), Date::parse(max_date)) { ++ (Some(rustc_date), Some(max_date)) => Some(rustc_date <= max_date), ++ _ => None ++ } ++} ++ ++/// Checks that the running or installed `rustc` was released **exactly** on ++/// some date. ++/// ++/// The format of `date` must be YYYY-MM-DD. For instance: `2016-12-20` or ++/// `2017-01-09`. ++/// ++/// If the date cannot be retrieved or parsed, or if `date` could not be parsed, ++/// returns `None`. Otherwise returns `true` if the installed `rustc` was ++/// release on `date` and `false` otherwise. ++pub fn is_exact_date(date: &str) -> Option { ++ match (Date::read(), Date::parse(date)) { ++ (Some(rustc_date), Some(date)) => Some(rustc_date == date), ++ _ => None ++ } ++} ++ ++/// Checks that the running or installed `rustc` is **at least** some minimum ++/// version. ++/// ++/// The format of `min_version` is a semantic version: `1.3.0`, `1.15.0-beta`, ++/// `1.14.0`, `1.16.0-nightly`, etc. ++/// ++/// If the version cannot be retrieved or parsed, or if `min_version` could not ++/// be parsed, returns `None`. Otherwise returns `true` if the installed `rustc` ++/// is at least `min_version` and `false` otherwise. ++pub fn is_min_version(min_version: &str) -> Option { ++ match (Version::read(), Version::parse(min_version)) { ++ (Some(rustc_ver), Some(min_ver)) => Some(rustc_ver >= min_ver), ++ _ => None ++ } ++} ++ ++/// Checks that the running or installed `rustc` is **at most** some maximum ++/// version. ++/// ++/// The format of `max_version` is a semantic version: `1.3.0`, `1.15.0-beta`, ++/// `1.14.0`, `1.16.0-nightly`, etc. ++/// ++/// If the version cannot be retrieved or parsed, or if `max_version` could not ++/// be parsed, returns `None`. Otherwise returns `true` if the installed `rustc` ++/// is at most `max_version` and `false` otherwise. ++pub fn is_max_version(max_version: &str) -> Option { ++ match (Version::read(), Version::parse(max_version)) { ++ (Some(rustc_ver), Some(max_ver)) => Some(rustc_ver <= max_ver), ++ _ => None ++ } ++} ++ ++/// Checks that the running or installed `rustc` is **exactly** some version. ++/// ++/// The format of `version` is a semantic version: `1.3.0`, `1.15.0-beta`, ++/// `1.14.0`, `1.16.0-nightly`, etc. ++/// ++/// If the version cannot be retrieved or parsed, or if `version` could not be ++/// parsed, returns `None`. Otherwise returns `true` if the installed `rustc` is ++/// exactly `version` and `false` otherwise. ++pub fn is_exact_version(version: &str) -> Option { ++ match (Version::read(), Version::parse(version)) { ++ (Some(rustc_ver), Some(version)) => Some(rustc_ver == version), ++ _ => None ++ } ++} ++ ++/// Checks whether the running or installed `rustc` supports feature flags. ++/// ++/// In other words, if the channel is either "nightly" or "dev". ++/// ++/// Note that support for specific `rustc` features can be enabled or disabled ++/// via the `allow-features` compiler flag, which this function _does not_ ++/// check. That is, this function _does not_ check whether a _specific_ feature ++/// is supported, but instead whether features are supported at all. To check ++/// for support for a specific feature, use [`supports_feature()`]. ++/// ++/// If the version could not be determined, returns `None`. Otherwise returns ++/// `true` if the running version supports feature flags and `false` otherwise. ++pub fn is_feature_flaggable() -> Option { ++ Channel::read().map(|c| c.supports_features()) ++} ++ ++/// Checks whether the running or installed `rustc` supports `feature`. ++/// ++/// Returns _true_ _iff_ [`is_feature_flaggable()`] returns `true` _and_ the ++/// feature is not disabled via exclusion in `allow-features` via `RUSTFLAGS` or ++/// `CARGO_ENCODED_RUSTFLAGS`. If the version could not be determined, returns ++/// `None`. ++/// ++/// # Example ++/// ++/// ```rust ++/// use version_check as rustc; ++/// ++/// if let Some(true) = rustc::supports_feature("doc_cfg") { ++/// println!("cargo:rustc-cfg=has_doc_cfg"); ++/// } ++/// ``` ++pub fn supports_feature(feature: &str) -> Option { ++ match is_feature_flaggable() { ++ Some(true) => { /* continue */ } ++ Some(false) => return Some(false), ++ None => return None, ++ } ++ ++ let env_flags = env::var_os("CARGO_ENCODED_RUSTFLAGS") ++ .map(|flags| (flags, '\x1f')) ++ .or_else(|| env::var_os("RUSTFLAGS").map(|flags| (flags, ' '))); ++ ++ if let Some((flags, delim)) = env_flags { ++ const ALLOW_FEATURES: &'static str = "allow-features="; ++ ++ let rustflags = flags.to_string_lossy(); ++ let allow_features = rustflags.split(delim) ++ .map(|flag| flag.trim_left_matches("-Z").trim()) ++ .filter(|flag| flag.starts_with(ALLOW_FEATURES)) ++ .map(|flag| &flag[ALLOW_FEATURES.len()..]); ++ ++ if let Some(allow_features) = allow_features.last() { ++ return Some(allow_features.split(',').any(|f| f.trim() == feature)); ++ } ++ } ++ ++ // If there are no `RUSTFLAGS` or `CARGO_ENCODED_RUSTFLAGS` or they don't ++ // contain an `allow-features` flag, assume compiler allows all features. ++ Some(true) ++} ++ ++#[cfg(test)] ++mod tests { ++ use std::{env, fs}; ++ ++ use super::version_and_date_from_rustc_version; ++ use super::version_and_date_from_rustc_verbose_version; ++ ++ macro_rules! check_parse { ++ (@ $f:expr, $s:expr => $v:expr, $d:expr) => ({ ++ if let (Some(v), d) = $f(&$s) { ++ let e_d: Option<&str> = $d.into(); ++ assert_eq!((v, d), ($v.to_string(), e_d.map(|s| s.into()))); ++ } else { ++ panic!("{:?} didn't parse for version testing.", $s); ++ } ++ }); ++ ($f:expr, $s:expr => $v:expr, $d:expr) => ({ ++ let warn = "warning: invalid logging spec 'warning', ignoring it"; ++ let warn2 = "warning: sorry, something went wrong :(sad)"; ++ check_parse!(@ $f, $s => $v, $d); ++ check_parse!(@ $f, &format!("{}\n{}", warn, $s) => $v, $d); ++ check_parse!(@ $f, &format!("{}\n{}", warn2, $s) => $v, $d); ++ check_parse!(@ $f, &format!("{}\n{}\n{}", warn, warn2, $s) => $v, $d); ++ check_parse!(@ $f, &format!("{}\n{}\n{}", warn2, warn, $s) => $v, $d); ++ }) ++ } ++ ++ macro_rules! check_terse_parse { ++ ($($s:expr => $v:expr, $d:expr,)+) => {$( ++ check_parse!(version_and_date_from_rustc_version, $s => $v, $d); ++ )+} ++ } ++ ++ macro_rules! check_verbose_parse { ++ ($($s:expr => $v:expr, $d:expr,)+) => {$( ++ check_parse!(version_and_date_from_rustc_verbose_version, $s => $v, $d); ++ )+} ++ } ++ ++ #[test] ++ fn test_version_parse() { ++ check_terse_parse! { ++ "rustc 1.18.0" => "1.18.0", None, ++ "rustc 1.8.0" => "1.8.0", None, ++ "rustc 1.20.0-nightly" => "1.20.0-nightly", None, ++ "rustc 1.20" => "1.20", None, ++ "rustc 1.3" => "1.3", None, ++ "rustc 1" => "1", None, ++ "rustc 1.5.1-beta" => "1.5.1-beta", None, ++ "rustc 1.20.0 (2017-07-09)" => "1.20.0", Some("2017-07-09"), ++ "rustc 1.20.0-dev (2017-07-09)" => "1.20.0-dev", Some("2017-07-09"), ++ "rustc 1.20.0-nightly (d84693b93 2017-07-09)" => "1.20.0-nightly", Some("2017-07-09"), ++ "rustc 1.20.0 (d84693b93 2017-07-09)" => "1.20.0", Some("2017-07-09"), ++ "rustc 1.30.0-nightly (3bc2ca7e4 2018-09-20)" => "1.30.0-nightly", Some("2018-09-20"), ++ }; ++ } ++ ++ #[test] ++ fn test_verbose_version_parse() { ++ check_verbose_parse! { ++ "rustc 1.0.0 (a59de37e9 2015-05-13) (built 2015-05-14)\n\ ++ binary: rustc\n\ ++ commit-hash: a59de37e99060162a2674e3ff45409ac73595c0e\n\ ++ commit-date: 2015-05-13\n\ ++ build-date: 2015-05-14\n\ ++ host: x86_64-unknown-linux-gnu\n\ ++ release: 1.0.0" => "1.0.0", Some("2015-05-13"), ++ ++ "rustc 1.0.0 (a59de37e9 2015-05-13) (built 2015-05-14)\n\ ++ commit-hash: a59de37e99060162a2674e3ff45409ac73595c0e\n\ ++ commit-date: 2015-05-13\n\ ++ build-date: 2015-05-14\n\ ++ host: x86_64-unknown-linux-gnu\n\ ++ release: 1.0.0" => "1.0.0", Some("2015-05-13"), ++ ++ "rustc 1.50.0 (cb75ad5db 2021-02-10)\n\ ++ binary: rustc\n\ ++ commit-hash: cb75ad5db02783e8b0222fee363c5f63f7e2cf5b\n\ ++ commit-date: 2021-02-10\n\ ++ host: x86_64-unknown-linux-gnu\n\ ++ release: 1.50.0" => "1.50.0", Some("2021-02-10"), ++ ++ "rustc 1.52.0-nightly (234781afe 2021-03-07)\n\ ++ binary: rustc\n\ ++ commit-hash: 234781afe33d3f339b002f85f948046d8476cfc9\n\ ++ commit-date: 2021-03-07\n\ ++ host: x86_64-unknown-linux-gnu\n\ ++ release: 1.52.0-nightly\n\ ++ LLVM version: 12.0.0" => "1.52.0-nightly", Some("2021-03-07"), ++ ++ "rustc 1.41.1\n\ ++ binary: rustc\n\ ++ commit-hash: unknown\n\ ++ commit-date: unknown\n\ ++ host: x86_64-unknown-linux-gnu\n\ ++ release: 1.41.1\n\ ++ LLVM version: 7.0" => "1.41.1", None, ++ ++ "rustc 1.49.0\n\ ++ binary: rustc\n\ ++ commit-hash: unknown\n\ ++ commit-date: unknown\n\ ++ host: x86_64-unknown-linux-gnu\n\ ++ release: 1.49.0" => "1.49.0", None, ++ ++ "rustc 1.50.0 (Fedora 1.50.0-1.fc33)\n\ ++ binary: rustc\n\ ++ commit-hash: unknown\n\ ++ commit-date: unknown\n\ ++ host: x86_64-unknown-linux-gnu\n\ ++ release: 1.50.0" => "1.50.0", None, ++ }; ++ } ++ ++ fn read_static(verbose: bool, channel: &str, minor: usize) -> String { ++ use std::fs::File; ++ use std::path::Path; ++ use std::io::{BufReader, Read}; ++ ++ let subdir = if verbose { "verbose" } else { "terse" }; ++ let path = Path::new(STATIC_PATH) ++ .join(channel) ++ .join(subdir) ++ .join(format!("rustc-1.{}.0", minor)); ++ ++ let file = File::open(path).unwrap(); ++ let mut buf_reader = BufReader::new(file); ++ let mut contents = String::new(); ++ buf_reader.read_to_string(&mut contents).unwrap(); ++ contents ++ } ++ ++ static STATIC_PATH: &'static str = concat!(env!("CARGO_MANIFEST_DIR"), "/static"); ++ ++ static DATES: [&'static str; 51] = [ ++ "2015-05-13", "2015-06-19", "2015-08-03", "2015-09-15", "2015-10-27", ++ "2015-12-04", "2016-01-19", "2016-02-29", "2016-04-11", "2016-05-18", ++ "2016-07-03", "2016-08-15", "2016-09-23", "2016-11-07", "2016-12-16", ++ "2017-01-19", "2017-03-10", "2017-04-24", "2017-06-06", "2017-07-17", ++ "2017-08-27", "2017-10-09", "2017-11-20", "2018-01-01", "2018-02-12", ++ "2018-03-25", "2018-05-07", "2018-06-19", "2018-07-30", "2018-09-11", ++ "2018-10-24", "2018-12-04", "2019-01-16", "2019-02-28", "2019-04-10", ++ "2019-05-20", "2019-07-03", "2019-08-13", "2019-09-23", "2019-11-04", ++ "2019-12-16", "2020-01-27", "2020-03-09", "2020-04-20", "2020-06-01", ++ "2020-07-13", "2020-08-24", "2020-10-07", "2020-11-16", "2020-12-29", ++ "2021-02-10", ++ ]; ++ ++ #[test] ++ fn test_stable_compatibility() { ++ if env::var_os("FORCE_STATIC").is_none() && fs::metadata(STATIC_PATH).is_err() { ++ // We exclude `/static` when we package `version_check`, so don't ++ // run if static files aren't present unless we know they should be. ++ return; ++ } ++ ++ // Ensure we can parse all output from all Linux stable releases. ++ for v in 0..DATES.len() { ++ let (version, date) = (&format!("1.{}.0", v), Some(DATES[v])); ++ check_terse_parse!(read_static(false, "stable", v) => version, date,); ++ check_verbose_parse!(read_static(true, "stable", v) => version, date,); ++ } ++ } ++ ++ #[test] ++ fn test_parse_current() { ++ let (version, channel) = (::Version::read(), ::Channel::read()); ++ assert!(version.is_some()); ++ assert!(channel.is_some()); ++ ++ if let Ok(known_channel) = env::var("KNOWN_CHANNEL") { ++ assert_eq!(channel, ::Channel::parse(&known_channel)); ++ } ++ } ++} +diff --git a/third_party/rust/version_check/src/version.rs b/third_party/rust/version_check/src/version.rs +new file mode 100644 +--- /dev/null ++++ b/third_party/rust/version_check/src/version.rs +@@ -0,0 +1,316 @@ ++use std::fmt; ++ ++/// Version number: `major.minor.patch`, ignoring release channel. ++#[derive(PartialEq, Eq, Copy, Clone, PartialOrd, Ord)] ++pub struct Version(u64); ++ ++impl Version { ++ /// Reads the version of the running compiler. If it cannot be determined ++ /// (see the [top-level documentation](crate)), returns `None`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Version; ++ /// ++ /// match Version::read() { ++ /// Some(d) => format!("Version is: {}", d), ++ /// None => format!("Failed to read the version.") ++ /// }; ++ /// ``` ++ pub fn read() -> Option { ++ ::get_version_and_date() ++ .and_then(|(version, _)| version) ++ .and_then(|version| Version::parse(&version)) ++ } ++ ++ ++ /// Parse a Rust release version (of the form ++ /// `major[.minor[.patch[-channel]]]`), ignoring the release channel, if ++ /// any. Returns `None` if `version` is not a valid Rust version string. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Version; ++ /// ++ /// let version = Version::parse("1.18.0").unwrap(); ++ /// assert!(version.exactly("1.18.0")); ++ /// ++ /// let version = Version::parse("1.20.0-nightly").unwrap(); ++ /// assert!(version.exactly("1.20.0")); ++ /// assert!(version.exactly("1.20.0-beta")); ++ /// ++ /// let version = Version::parse("1.3").unwrap(); ++ /// assert!(version.exactly("1.3.0")); ++ /// ++ /// let version = Version::parse("1").unwrap(); ++ /// assert!(version.exactly("1.0.0")); ++ /// ++ /// assert!(Version::parse("one.two.three").is_none()); ++ /// assert!(Version::parse("1.65536.2").is_none()); ++ /// assert!(Version::parse("1. 2").is_none()); ++ /// assert!(Version::parse("").is_none()); ++ /// assert!(Version::parse("1.").is_none()); ++ /// assert!(Version::parse("1.2.3.4").is_none()); ++ /// ``` ++ pub fn parse(version: &str) -> Option { ++ let splits = version.split('-') ++ .nth(0) ++ .unwrap_or("") ++ .split('.') ++ .map(|s| s.parse::()); ++ ++ let mut mmp = [0u16; 3]; ++ for (i, split) in splits.enumerate() { ++ mmp[i] = match (i, split) { ++ (3, _) | (_, Err(_)) => return None, ++ (_, Ok(v)) => v, ++ }; ++ } ++ ++ let (maj, min, patch) = (mmp[0], mmp[1], mmp[2]); ++ Some(Version::from_mmp(maj, min, patch)) ++ } ++ ++ /// Creates a `Version` from `(major, minor, patch)` version components. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Version; ++ /// ++ /// assert!(Version::from_mmp(1, 35, 0).exactly("1.35.0")); ++ /// assert!(Version::from_mmp(1, 33, 0).exactly("1.33.0")); ++ /// assert!(Version::from_mmp(1, 35, 1).exactly("1.35.1")); ++ /// assert!(Version::from_mmp(1, 13, 2).exactly("1.13.2")); ++ /// ``` ++ pub fn from_mmp(major: u16, minor: u16, patch: u16) -> Version { ++ Version(((major as u64) << 32) | ((minor as u64) << 16) | patch as u64) ++ } ++ ++ /// Returns the `(major, minor, patch)` version components of `self`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Version; ++ /// ++ /// assert_eq!(Version::parse("1.35.0").unwrap().to_mmp(), (1, 35, 0)); ++ /// assert_eq!(Version::parse("1.33.0").unwrap().to_mmp(), (1, 33, 0)); ++ /// assert_eq!(Version::parse("1.35.1").unwrap().to_mmp(), (1, 35, 1)); ++ /// assert_eq!(Version::parse("1.13.2").unwrap().to_mmp(), (1, 13, 2)); ++ /// ``` ++ pub fn to_mmp(&self) -> (u16, u16, u16) { ++ let major = self.0 >> 32; ++ let minor = self.0 >> 16; ++ let patch = self.0; ++ (major as u16, minor as u16, patch as u16) ++ } ++ ++ /// Returns `true` if `self` is greater than or equal to `version`. ++ /// ++ /// If `version` is greater than `self`, or if `version` is not a valid Rust ++ /// version string, returns `false`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Version; ++ /// ++ /// let version = Version::parse("1.35.0").unwrap(); ++ /// ++ /// assert!(version.at_least("1.33.0")); ++ /// assert!(version.at_least("1.35.0")); ++ /// assert!(version.at_least("1.13.2")); ++ /// ++ /// assert!(!version.at_least("1.35.1")); ++ /// assert!(!version.at_least("1.55.0")); ++ /// ++ /// let version = Version::parse("1.12.5").unwrap(); ++ /// ++ /// assert!(version.at_least("1.12.0")); ++ /// assert!(!version.at_least("1.35.0")); ++ /// ``` ++ pub fn at_least(&self, version: &str) -> bool { ++ Version::parse(version) ++ .map(|version| self >= &version) ++ .unwrap_or(false) ++ } ++ ++ /// Returns `true` if `self` is less than or equal to `version`. ++ /// ++ /// If `version` is less than `self`, or if `version` is not a valid Rust ++ /// version string, returns `false`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Version; ++ /// ++ /// let version = Version::parse("1.35.0").unwrap(); ++ /// ++ /// assert!(version.at_most("1.35.1")); ++ /// assert!(version.at_most("1.55.0")); ++ /// assert!(version.at_most("1.35.0")); ++ /// ++ /// assert!(!version.at_most("1.33.0")); ++ /// assert!(!version.at_most("1.13.2")); ++ /// ``` ++ pub fn at_most(&self, version: &str) -> bool { ++ Version::parse(version) ++ .map(|version| self <= &version) ++ .unwrap_or(false) ++ } ++ ++ /// Returns `true` if `self` is exactly equal to `version`. ++ /// ++ /// If `version` is not equal to `self`, or if `version` is not a valid Rust ++ /// version string, returns `false`. ++ /// ++ /// # Example ++ /// ++ /// ```rust ++ /// use version_check::Version; ++ /// ++ /// let version = Version::parse("1.35.0").unwrap(); ++ /// ++ /// assert!(version.exactly("1.35.0")); ++ /// ++ /// assert!(!version.exactly("1.33.0")); ++ /// assert!(!version.exactly("1.35.1")); ++ /// assert!(!version.exactly("1.13.2")); ++ /// ``` ++ pub fn exactly(&self, version: &str) -> bool { ++ Version::parse(version) ++ .map(|version| self == &version) ++ .unwrap_or(false) ++ } ++} ++ ++impl fmt::Display for Version { ++ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ++ let (major, minor, patch) = self.to_mmp(); ++ write!(f, "{}.{}.{}", major, minor, patch) ++ } ++} ++ ++impl fmt::Debug for Version { ++ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { ++ // We don't use `debug_*` because it's not available in `1.0.0`. ++ write!(f, "Version({:?}, {:?})", self.0, self.to_mmp()) ++ } ++} ++ ++#[cfg(test)] ++mod tests { ++ use super::Version; ++ ++ macro_rules! assert_to_mmp { ++ // We don't use `.into::>` because it's not available in 1.0. ++ // We don't use the message part of `assert!` for the same reason. ++ ($s:expr, None) => ( ++ assert_eq!(Version::parse($s), None); ++ ); ++ ($s:expr, $mmp:expr) => ( ++ assert_eq!(Version::parse($s).map(|v| v.to_mmp()), Some($mmp)); ++ ) ++ } ++ ++ macro_rules! assert_from_mmp { ++ (($x:expr, $y:expr, $z:expr) => $s:expr) => { ++ assert_eq!(Some(Version::from_mmp($x, $y, $z)), Version::parse($s)); ++ }; ++ } ++ ++ #[test] ++ fn test_str_to_mmp() { ++ assert_to_mmp!("1", (1, 0, 0)); ++ assert_to_mmp!("1.2", (1, 2, 0)); ++ assert_to_mmp!("1.18.0", (1, 18, 0)); ++ assert_to_mmp!("3.19.0", (3, 19, 0)); ++ assert_to_mmp!("1.19.0-nightly", (1, 19, 0)); ++ assert_to_mmp!("1.12.2349", (1, 12, 2349)); ++ assert_to_mmp!("0.12", (0, 12, 0)); ++ assert_to_mmp!("1.12.5", (1, 12, 5)); ++ assert_to_mmp!("1.12", (1, 12, 0)); ++ assert_to_mmp!("1", (1, 0, 0)); ++ assert_to_mmp!("1.4.4-nightly (d84693b93 2017-07-09))", (1, 4, 4)); ++ assert_to_mmp!("1.58879.4478-dev", (1, 58879, 4478)); ++ assert_to_mmp!("1.58879.4478-dev (d84693b93 2017-07-09))", (1, 58879, 4478)); ++ } ++ ++ #[test] ++ fn test_malformed() { ++ assert_to_mmp!("1.65536.2", None); ++ assert_to_mmp!("-1.2.3", None); ++ assert_to_mmp!("1. 2", None); ++ assert_to_mmp!("", None); ++ assert_to_mmp!(" ", None); ++ assert_to_mmp!(".", None); ++ assert_to_mmp!("one", None); ++ assert_to_mmp!("1.", None); ++ assert_to_mmp!("1.2.3.4.5.6", None); ++ } ++ ++ #[test] ++ fn test_from_mmp() { ++ assert_from_mmp!((1, 18, 0) => "1.18.0"); ++ assert_from_mmp!((3, 19, 0) => "3.19.0"); ++ assert_from_mmp!((1, 19, 0) => "1.19.0"); ++ assert_from_mmp!((1, 12, 2349) => "1.12.2349"); ++ assert_from_mmp!((0, 12, 0) => "0.12"); ++ assert_from_mmp!((1, 12, 5) => "1.12.5"); ++ assert_from_mmp!((1, 12, 0) => "1.12"); ++ assert_from_mmp!((1, 0, 0) => "1"); ++ assert_from_mmp!((1, 4, 4) => "1.4.4"); ++ assert_from_mmp!((1, 58879, 4478) => "1.58879.4478"); ++ } ++ ++ #[test] ++ fn test_comparisons() { ++ let version = Version::parse("1.18.0").unwrap(); ++ assert!(version.exactly("1.18.0")); ++ assert!(version.at_least("1.12.0")); ++ assert!(version.at_least("1.12")); ++ assert!(version.at_least("1")); ++ assert!(version.at_most("1.18.1")); ++ assert!(!version.exactly("1.19.0")); ++ assert!(!version.exactly("1.18.1")); ++ ++ let version = Version::parse("1.20.0-nightly").unwrap(); ++ assert!(version.exactly("1.20.0-beta")); ++ assert!(version.exactly("1.20.0-nightly")); ++ assert!(version.exactly("1.20.0")); ++ assert!(!version.exactly("1.19")); ++ ++ let version = Version::parse("1.3").unwrap(); ++ assert!(version.exactly("1.3.0")); ++ assert!(version.exactly("1.3.0-stable")); ++ assert!(version.exactly("1.3")); ++ assert!(!version.exactly("1.5.0-stable")); ++ ++ let version = Version::parse("1").unwrap(); ++ assert!(version.exactly("1.0.0")); ++ assert!(version.exactly("1.0")); ++ assert!(version.exactly("1")); ++ ++ assert!(Version::parse("one.two.three").is_none()); ++ } ++ ++ macro_rules! reflexive_display { ++ ($s:expr) => ( ++ assert_eq!(Version::parse($s).unwrap().to_string(), $s); ++ ) ++ } ++ ++ #[test] ++ fn display() { ++ reflexive_display!("1.0.0"); ++ reflexive_display!("1.2.3"); ++ reflexive_display!("1.12.1438"); ++ reflexive_display!("1.44.0"); ++ reflexive_display!("2.44.0"); ++ reflexive_display!("23459.28923.3483"); ++ } ++} diff --git a/mozilla-bmo531915.patch b/mozilla-bmo531915.patch new file mode 100644 index 0000000..b84209d --- /dev/null +++ b/mozilla-bmo531915.patch @@ -0,0 +1,33 @@ +# HG changeset patch +# User Wolfgang Rosenauer +# Parent fa8a5832a374ccd7af5db927b992b5d9f15273ef + +diff --git a/modules/fdlibm/src/math_private.h b/modules/fdlibm/src/math_private.h +--- a/modules/fdlibm/src/math_private.h ++++ b/modules/fdlibm/src/math_private.h +@@ -25,19 +25,24 @@ + + #include "fdlibm.h" + + /* + * Emulate FreeBSD internal double types. + * Adapted from https://github.com/freebsd/freebsd-src/search?q=__double_t + */ + ++#ifdef __i386__ ++typedef long double __double_t; ++typedef long double __float_t; ++#else + typedef double __double_t; ++typedef float __float_t; ++#endif + typedef __double_t double_t; +-typedef float __float_t; + + /* + * The original fdlibm code used statements like: + * n0 = ((*(int*)&one)>>29)^1; * index of high word * + * ix0 = *(n0+(int*)&x); * high word of x * + * ix1 = *((1-n0)+(int*)&x); * low word of x * + * to dig two 32 bit words out of the 64 bit IEEE floating point + * value. That is non-ANSI, and, moreover, the gcc instruction diff --git a/mozilla-nongnome-proxies.patch b/mozilla-nongnome-proxies.patch new file mode 100644 index 0000000..837200b --- /dev/null +++ b/mozilla-nongnome-proxies.patch @@ -0,0 +1,25 @@ +From: Wolfgang Rosenauer, Tristan Miller +Subject: Do not use gconf for proxy settings if not running within Gnome + +diff -ruN seamonkey-2.53.17b1.orig/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp seamonkey-2.53.17b1/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp +--- seamonkey-2.53.17b1.orig/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp 2023-06-10 12:41:26.000000000 +0200 ++++ seamonkey-2.53.17b1/toolkit/system/unixproxy/nsUnixSystemProxySettings.cpp 2023-07-12 09:41:08.047344985 +0200 +@@ -55,10 +55,14 @@ + nsresult + nsUnixSystemProxySettings::Init() + { +- mGSettings = do_GetService(NS_GSETTINGSSERVICE_CONTRACTID); +- if (mGSettings) { +- mGSettings->GetCollectionForSchema(NS_LITERAL_CSTRING("org.gnome.system.proxy"), +- getter_AddRefs(mProxySettings)); ++ // only use GSettings if that is a GNOME session ++ const char* sessionType = PR_GetEnv("DESKTOP_SESSION"); ++ if (sessionType && !strcmp(sessionType, "gnome")) { ++ mGSettings = do_GetService(NS_GSETTINGSSERVICE_CONTRACTID); ++ if (mGSettings) { ++ mGSettings->GetCollectionForSchema(NS_LITERAL_CSTRING("org.gnome.system.proxy"), ++ getter_AddRefs(mProxySettings)); ++ } + } + + return NS_OK; diff --git a/mozilla-ntlm-full-path.patch b/mozilla-ntlm-full-path.patch new file mode 100644 index 0000000..2e9f1a8 --- /dev/null +++ b/mozilla-ntlm-full-path.patch @@ -0,0 +1,18 @@ +# HG changeset patch +# User Petr Cerny +# Parent 7308e4a7c1f769f4bbbc90870b849cadd99495a6 +# Parent 03565086f1e230cf6f0f6c01bf9a792c732de50b +Bug 634334 - call to the ntlm_auth helper fails + +diff -ruN seamonkey/mozilla/extensions/auth/nsAuthSambaNTLM.cpp seamonkey.new/mozilla/extensions/auth/nsAuthSambaNTLM.cpp +--- seamonkey/mozilla/extensions/auth/nsAuthSambaNTLM.cpp 2020-02-18 00:37:50.000000000 +0100 ++++ seamonkey.new/mozilla/extensions/auth/nsAuthSambaNTLM.cpp 2020-03-02 12:53:27.147346423 +0100 +@@ -174,7 +174,7 @@ + return NS_ERROR_FAILURE; + + const char* const args[] = { +- "ntlm_auth", ++ "/usr/bin/ntlm_auth", + "--helper-protocol", "ntlmssp-client-1", + "--use-cached-creds", + "--username", username, diff --git a/mozilla.sh.in b/mozilla.sh.in new file mode 100644 index 0000000..6e11d0b --- /dev/null +++ b/mozilla.sh.in @@ -0,0 +1,143 @@ +#!/bin/sh +# +# ***** BEGIN LICENSE BLOCK ***** +# Version: MPL 1.1/GPL 2.0/LGPL 2.1 +# +# The contents of this file are subject to the Mozilla Public License Version +# 1.1 (the "License"); you may not use this file except in compliance with +# the License. You may obtain a copy of the License at +# http://www.mozilla.org/MPL/ +# +# Software distributed under the License is distributed on an "AS IS" basis, +# WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License +# for the specific language governing rights and limitations under the +# License. +# +# The Original Code is mozilla.org Code. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 1998 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Wolfgang Rosenauer +# +# +# Alternatively, the contents of this file may be used under the terms of +# either the GNU General Public License Version 2 or later (the "GPL"), or +# the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), +# in which case the provisions of the GPL or the LGPL are applicable instead +# of those above. If you wish to allow use of your version of this file only +# under the terms of either the GPL or the LGPL, and not to allow others to +# use your version of this file under the terms of the MPL, indicate your +# decision by deleting the provisions above and replace them with the notice +# and other provisions required by the GPL or the LGPL. If you do not delete +# the provisions above, a recipient may use your version of this file under +# the terms of any one of the MPL, the GPL or the LGPL. +# +# ***** END LICENSE BLOCK ***** + +## +## Usage: +## +## $ mozilla [args] +## +## This script is meant to run a mozilla program from the mozilla +## rpm installation. +## +## The script will setup all the environment voodoo needed to make +## mozilla work. + +cmdname=`basename $0` + +## +## Variables +## +MOZ_DIST_BIN="%PREFIX" +MOZ_DIST_LIB="%PROGDIR" +MOZ_APPNAME="%APPNAME" +MOZ_PROGRAM="$MOZ_DIST_LIB/$MOZ_APPNAME-bin" + +MOZ_APP_LAUNCHER="$MOZ_DIST_LIB/$MOZ_APPNAME.sh" +if [ "$0" = "$MOZ_APP_LAUNCHER" ]; then + [ -h "/usr/bin/$MOZ_APPNAME" ] && \ + _link=$(readlink -f "/usr/bin/$MOZ_APPNAME") + if [ "$_link" = "$MOZ_APP_LAUNCHER" ]; then + export MOZ_APP_LAUNCHER="/usr/bin/$MOZ_APPNAME" + fi +else + export MOZ_APP_LAUNCHER="/usr/bin/$MOZ_APPNAME" +fi + +mozilla_lib=`file $MOZ_PROGRAM` +LIB=lib +echo $mozilla_lib | grep -q -E 'ELF.64-bit.*(x86-64|S/390|PowerPC)' && LIB=lib64 + +BROWSER_PLUGIN_DIR=/usr/$LIB/browser-plugins +if [ ! -d $BROWSER_PLUGIN_DIR ]; then + BROWSER_PLUGIN_DIR=/opt/netscape/plugins +fi + +MOZILLA_FIVE_HOME="$MOZ_DIST_LIB" +export MOZILLA_FIVE_HOME +LD_LIBRARY_PATH=$MOZ_DIST_LIB${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH} +export LD_LIBRARY_PATH + +# needed for SUN Java under Xorg >= 7.2 +export LIBXCB_ALLOW_SLOPPY_LOCK=1 + +## +if [ -z "$MOZ_PLUGIN_PATH" ]; then + export MOZ_PLUGIN_PATH=$BROWSER_PLUGIN_DIR +else + # make sure that BROWSER_PLUGIN_DIR is in MOZ_PLUGIN_PATH + echo "$MOZ_PLUGIN_PATH" | grep "$BROWSER_PLUGIN_DIR" 2>&1 >/dev/null + _retval=$? + if [ ${_retval} -ne 0 ]; then + export MOZ_PLUGIN_PATH=$MOZ_PLUGIN_PATH:$BROWSER_PLUGIN_DIR + fi +fi + +# disable Gnome crash dialog (doesn't make sense anyway) +export GNOME_DISABLE_CRASH_DIALOG=1 + +moz_debug=0 +script_args="" +pass_arg_count=0 +while [ $# -gt $pass_arg_count ] +do + case "$1" in + -d | --debugger) + moz_debugger=$2; + if [ "${moz_debugger}" != "" ]; then + shift 2 + moz_debug=1 + else + echo "-d requires an argument" + exit 1 + fi + ;; + *) + # Move the unrecognized argument to the end of the list. + arg="$1" + shift + set -- "$@" "$arg" + pass_arg_count=`expr $pass_arg_count + 1` + ;; + esac +done + +if [ $moz_debug -eq 1 ]; then + tmpfile=`mktemp /tmp/mozargs.XXXXXX` || { echo "Cannot create temporary file" >&2; exit 1; } + trap " [ -f \"$tmpfile\" ] && /bin/rm -f -- \"$tmpfile\"" 0 1 2 3 13 15 + echo "set args ${1+"$@"}" > $tmpfile + echo "run" >> $tmpfile + echo "$moz_debugger $MOZ_PROGRAM -x $tmpfile" + $moz_debugger "$MOZ_PROGRAM" -x $tmpfile +else + $MOZ_PROGRAM "$@" +fi +exitcode=$? + +exit $exitcode diff --git a/reproducible.patch b/reproducible.patch new file mode 100644 index 0000000..4c85be1 --- /dev/null +++ b/reproducible.patch @@ -0,0 +1,63 @@ +https://github.com/mozilla/gecko-dev/commit/025982b6714051c747dcb9600d6e5c92d2dcaf7b + +From 025982b6714051c747dcb9600d6e5c92d2dcaf7b Mon Sep 17 00:00:00 2001 +From: Maxim Cournoyer +Date: Thu, 16 Mar 2023 14:01:58 +0000 +Subject: [PATCH] Bug 1817032 - Honor SOURCE_DATE_EPOCH to build langpacks + reproducibly. r=eemeli@mozilla.com + +Differential Revision: https://phabricator.services.mozilla.com/D169979 +--- + .../mozbuild/action/langpack_manifest.py | 17 +++++++++++++---- + 1 file changed, 13 insertions(+), 4 deletions(-) + +diff --git a/python/mozbuild/mozbuild/action/langpack_manifest.py b/python/mozbuild/mozbuild/action/langpack_manifest.py +index f82a329cc..10e42fe99 100644 +--- a/python/mozbuild/mozbuild/action/langpack_manifest.py ++++ b/python/mozbuild/mozbuild/action/langpack_manifest.py +@@ -16,6 +16,7 @@ import os + import json + import io + import datetime ++import time + import requests + import mozversioncontrol + import mozpack.path as mozpath +@@ -36,9 +37,17 @@ def write_file(path, content): + pushlog_api_url = "{0}/json-rev/{1}" + + ++def get_build_date(): ++ """Return the current date or SOURCE_DATE_EPOCH, if set.""" ++ return datetime.datetime.utcfromtimestamp( ++ int(os.environ.get("SOURCE_DATE_EPOCH", time.time())) ++ ) ++ ++ + ### +-# Retrievers a UTC datetime of the push for the current commit +-# from a mercurial clone directory. ++# Retrieves a UTC datetime of the push for the current commit from a ++# mercurial clone directory. The SOURCE_DATE_EPOCH environment ++# variable is honored, for reproducibility. + # + # Args: + # path (str) - path to a directory +@@ -54,7 +63,7 @@ def get_dt_from_hg(path): + with mozversioncontrol.get_repository_object(path=path) as repo: + phase = repo._run("log", "-r", ".", "-T" "{phase}") + if phase.strip() != "public": +- return datetime.datetime.utcnow() ++ return get_build_date() + repo_url = repo._run("paths", "default") + repo_url = repo_url.strip().replace("ssh://", "https://") + repo_url = repo_url.replace("hg://", "https://") +@@ -99,7 +108,7 @@ def get_timestamp_for_locale(path): + dt = get_dt_from_hg(path) + + if dt is None: +- dt = datetime.datetime.utcnow() ++ dt = get_build_date() + + dt = dt.replace(microsecond=0) + return dt.strftime("%Y%m%d%H%M%S") diff --git a/seamonkey-2.53.18.2.source-l10n.tar.xz b/seamonkey-2.53.18.2.source-l10n.tar.xz new file mode 100644 index 0000000..5e39e7f --- /dev/null +++ b/seamonkey-2.53.18.2.source-l10n.tar.xz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3d029110e7eddb895a70e0ee146e160ea2952005e18be71f49cdd7f3c04bbb79 +size 13419252 diff --git a/seamonkey-2.53.18.2.source.tar.xz b/seamonkey-2.53.18.2.source.tar.xz new file mode 100644 index 0000000..5b70d5f --- /dev/null +++ b/seamonkey-2.53.18.2.source.tar.xz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2422e824dbec0cb268d3741dcbf3f2b23a477437052300f181fa7b6c7c364fef +size 252310768 diff --git a/seamonkey-2.53.19.source-l10n.tar.xz b/seamonkey-2.53.19.source-l10n.tar.xz new file mode 100644 index 0000000..5349972 --- /dev/null +++ b/seamonkey-2.53.19.source-l10n.tar.xz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a9c7d6aff6cb0c084c14aa8c1261b80b2b32c7f03e8910658db037671b893e25 +size 13430044 diff --git a/seamonkey-2.53.19.source.tar.xz b/seamonkey-2.53.19.source.tar.xz new file mode 100644 index 0000000..b003fc2 --- /dev/null +++ b/seamonkey-2.53.19.source.tar.xz @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:a6c9a44d2a167f04fff5d4175ad61e934c6177852ab8ab56c319f242a73146e2 +size 249145892 diff --git a/seamonkey-GNUmakefile b/seamonkey-GNUmakefile new file mode 100644 index 0000000..173f2ed --- /dev/null +++ b/seamonkey-GNUmakefile @@ -0,0 +1,190 @@ +# +# Front-end based on GNU make, intended for a more friendly +# integration of the build system with Linux/UNIX distributions, +# as well as for those who still allergy using mach command. +# +# Place it as `mozilla/GNUmakefile' (instead of the existing stub), +# and work under `mozilla/' dir. +# + +# +# For build, just use +# +# make +# +# (If you want to separate config stage, use "make configure" and then "make", +# but normally it is done automatically). +# +# For install, use +# +# make install DESTDIR=where_you_want_to_install +# +# +# Additionally, before install you can use: +# +# make locales +# +# to provide all the shipped locales (will appear in a form of langpack extensions). +# If irc and/or calendar are built, their data will be included too. +# (See below for more details about locales target). +# + +# +# For clarity, some comparison with the other build methods +# (assume `-jN' is the option for parallel builds, ie. `-j4' for 4-cpu system): +# +# Build stage: +# +# client.mk: make -f client.mk build MOZ_MAKE_FLAGS=-jN +# mach: ./mach build -jN +# THIS: make -jN +# +# Install stage: +# +# client.mk: DESTDIR=where... make -f client.mk install +# mach: DESTDIR=where... make -C $OBJDIR... install +# THIS: make install DESTDIR=where... +# + + +ifeq (,$(wildcard .mozconfig)) +$(error Cannot find .mozconfig file in the current directory) +endif + +MACH_CMD = env MACH_USE_SYSTEM_PYTHON=1 ./mach --log-no-times +export MACH_USE_SYSTEM_PYTHON = 1 + +OBJDIR := $(shell $(MACH_CMD) environment --format=json | sed -e 's/.*"topobjdir": "//' -e 's/".*//') + +OBJDIR_TARGETS = install distribution source-package package clobber + + +.PHONY: all configure build clean distclean $(OBJDIR_TARGETS) + + +all: build + + +configure: $(OBJDIR)/Makefile + + +$(OBJDIR)/Makefile: .mozconfig + $(MACH_CMD) configure + + +build: $(OBJDIR)/Makefile + $(MAKE) -C $(OBJDIR) + + +$(OBJDIR_TARGETS): + $(MAKE) -C $(OBJDIR) $@ + + +clean: + $(MACH_CMD) clobber + +distclean: clean + rm -f configure js/src/configure + rm -rf $(OBJDIR) + + +# +# LOCALES +# +# +# The target `locales' creates all the needed langpacks. +# +# By default, all available locales will be used. You can change it +# by overriding SHIPPED_LOCALES variable on the command line. +# +# Additionally, you can use `make locale-LANG' to create one (or several) +# langpack separately. +# +# For example, to build `fr' and 'it' only, use: +# +# make locales SHIPPED_LOCALES="fr it" +# +# to create just `ru' langpack: +# +# make locale-ru +# +# Use `clear-locales' for clearing. +# +# +# NOTE! NOTE! NOTE! +# +# Do NOT use parallel builds (-jN) for locale targets! +# +# It is better to use `-j1' explicitly (`make -j1 locales') to avoid issues. +# + +.PHONY: locales clear-locales dictionaries clear-dictionaries + + +drop_extra := $(if $(or $(filter Windows_NT,$(OS)),$(filter-out Darwin,$(shell uname))),ja-JP-mac,ja) + +SHIPPED_LOCALES := $(shell while read loc rest; do echo $$loc; done >$(PACKAGE_MANIFEST) + + +clear-locales: + sed -i '/langpack-.*@seamonkey.mozilla.org.xpi/ d' $(PACKAGE_MANIFEST) + rm -f $(OBJDIR)/dist/bin/extensions/langpack-*@seamonkey.mozilla.org.xpi + + +# +# Dictionaries +# +# It is better to use system dictionaries, specifying directory path for them +# by "spellchecker.dictionary_path" preference (or even use symlink when possible). +# + +DICT_DEST := $(OBJDIR)/dist/bin/dictionaries + +dictionaries: $(SHIPPED_LOCALES:%=$(stage)-%) + cp -f -d $(wildcard $(foreach loc,$(SHIPPED_LOCALES),$(stage)-$(loc)/dictionaries/$(loc).aff $(stage)-$(loc)/dictionaries/$(loc).dic)) $(DICT_DEST) + +clear-dictionaries: + rm -f $(filter-out $(DICT_DEST)/en-US.%,$(wildcard $(DICT_DEST)/*.aff $(DICT_DEST)/*.dic)) + diff --git a/seamonkey-appdata.tar.bz2 b/seamonkey-appdata.tar.bz2 new file mode 100644 index 0000000..2f3cc46 --- /dev/null +++ b/seamonkey-appdata.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f3cb87e82e2f21d04417ed5313275f39c6d6c4164563560c3ce43f6e26306ede +size 3025 diff --git a/seamonkey-desktop.tar.bz2 b/seamonkey-desktop.tar.bz2 new file mode 100644 index 0000000..3548585 --- /dev/null +++ b/seamonkey-desktop.tar.bz2 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:992d36c915ac5362dfbd0f057c81937d3133fb97fbbea4b51f83bfc19e97696f +size 22975 diff --git a/seamonkey-lto.patch b/seamonkey-lto.patch new file mode 100644 index 0000000..4636c9a --- /dev/null +++ b/seamonkey-lto.patch @@ -0,0 +1,12 @@ +diff -ruN seamonkey-2.53.17b1.orig/security/sandbox/linux/moz.build seamonkey-2.53.17b1/security/sandbox/linux/moz.build +--- seamonkey-2.53.17b1.orig/security/sandbox/linux/moz.build 2023-06-10 12:41:21.000000000 +0200 ++++ seamonkey-2.53.17b1/security/sandbox/linux/moz.build 2023-07-12 09:48:50.099448143 +0200 +@@ -101,7 +101,7 @@ + # forcing there to be only one partition. + for f in CONFIG['OS_CXXFLAGS']: + if f.startswith('-flto') and CONFIG['CC_TYPE'] != 'clang': +- LDFLAGS += ['--param lto-partitions=1'] ++ LDFLAGS += ['--param=lto-partitions=1'] + + DEFINES['NS_NO_XPCOM'] = True + DisableStlWrapping() diff --git a/seamonkey-man-page.patch b/seamonkey-man-page.patch new file mode 100644 index 0000000..8f86230 --- /dev/null +++ b/seamonkey-man-page.patch @@ -0,0 +1,23 @@ +--- build/moz.configure/old.configure 2022-06-08 21:10:25.000000000 +0200 ++++ build/moz.configure/old.configure 2022-07-11 14:04:06.231167162 +0200 +@@ -246,6 +246,7 @@ + '--enable-zipwriter', + '--includedir', + '--libdir', ++ '--mandir', + '--prefix', + '--with-app-basename', + '--with-app-name', +--- comm/suite/installer/Makefile.in 2021-08-08 15:29:32.000000000 +0200 ++++ comm/suite/installer/Makefile.in 2022-07-11 14:04:44.710104711 +0200 +@@ -145,6 +145,10 @@ + + include $(topsrcdir)/toolkit/mozapps/installer/packager.mk + ++install:: ++ $(NSINSTALL) -D $(DESTDIR)$(mandir)/man1 ++ $(SYSINSTALL) $(IFLAGS1) $(DIST)/man/man1/$(MOZ_APP_NAME).1 $(DESTDIR)$(mandir)/man1 ++ + ifeq (Darwin, $(OS_ARCH)) + BINPATH = $(_BINPATH) + DEFINES += -DAPPNAME=$(_APPNAME) diff --git a/seamonkey-rpmlintrc b/seamonkey-rpmlintrc new file mode 100644 index 0000000..86c1048 --- /dev/null +++ b/seamonkey-rpmlintrc @@ -0,0 +1 @@ +addFilter("no-jar-manifest") diff --git a/seamonkey.changes b/seamonkey.changes new file mode 100644 index 0000000..0f68b14 --- /dev/null +++ b/seamonkey.changes @@ -0,0 +1,4873 @@ +------------------------------------------------------------------- +Wed Sep 04 20:04:01 UTC 2024 - Tristan Miller + +- update to SeaMonkey 2.53.19 + * Cancel button in SeaMonkey bookmarking star ui not working bug + 1872623. + * Remove OfflineAppCacheHelper.jsm copy from SeaMonkey and use the + one in toolkit bug 1896292. + * Remove obsolete registerFactoryLocation calls from cZ bug 1870930. + * Remove needless implements='nsIDOMEventListener' and QI bug + 1611010. + * Replace use of nsIStandardURL::Init bug 1864355. + * Switch SeaMonkey website from hg.mozilla.org to heptapod. bug + 1870934. + * Allow view-image to open a data: URI by setting a flag on the + loadinfo bug 1877001. + * Save-link-as feature should use the loading principal and context + menu using nsIContentPolicy.TYPE_SAVE_AS_DOWNLOAD bug 1879726. + * Use punycode in SeaMonkey JS bug 1864287. + * Font lists in preferences are no longer grouped by font type, port + asynchronous handling like Bug 1399206 bug 1437393. + * SeaMonkey broken tab after undo closed tab with invalid protocol + bug 1885748. + * SeaMonkey session restore is missing the checkboxes in the Classic + theme bug 1896174. + * Implement about:credits on seamonkey-project.org website bug + 1898467. + * Fix for the 0.0.0.0 day vulnerability oligo summary. + * Link in update notification does not open Browser bug 1888364. + * Update ReadExtensionPrefs in Preferences.cpp bug 1890196. + * Add about:seamonkey page to SeaMonkey bug 1897801. + * SeaMonkey 2.53.19 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.19 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 115.14 + and Thunderbird 115.14 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- Adapt seamonkey-man-page.patch for SeaMonkey 2.53.19 +- Adapt seamonkey-GNUmakefile to create mach environment +- Build with GCC 13 on Tumbleweed due to build failures with GCC 14: + https://bugzilla.mozilla.org/show_bug.cgi?id=1916827 + +------------------------------------------------------------------- +Thu Jun 07 00:42:26 UTC 2024 - Tristan Miller + +- add patch mozilla-bmo1896958.patch adapted from + https://bugzilla.mozilla.org/show_bug.cgi?id=1896958 to fix + compilation with rust >= 1.78 +- add patch mozilla-bmo1862601.patch adapted from + https://bugzilla.mozilla.org/show_bug.cgi?id=1862601 to fix + build failure using --system-icu on Tumbleweed + +------------------------------------------------------------------- +Thu Mar 28 15:00:02 UTC 2024 - Tristan Miller + +- update to SeaMonkey 2.53.18.2 + * Block set-cookie from multipart/x-mixed-replace with pref bug + 1864385. + * Check if WorkerRunnable::Run runs on top of + WorkerThreadPrimaryRunnable::Run in a worker thread bug 1867982. + * Process pairs in coord list in PolyArea bug 1878211. + * Cherry-pick update to dav1d bug 1881093. + * Land NSS NSS_3_90_2_RTM UPGRADE_NSS_RELEASE bug 1880562. + * Fix DSN for send later bug 815638. + * Catch webNavigation error during tab restore bug 1885748. + * SeaMonkey 2.53.18.2 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.18.2 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.8.0 release notes + for specific security fixes in this release. + * Additional important security fixes up to Current Firefox 115.9 + and Thunderbird 115.9 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- request inclusion in Leap 15.5 and 15.6: + https://bugzilla.opensuse.org/show_bug.cgi?id=1222137 + +------------------------------------------------------------------- +Mon Feb 26 13:22:25 UTC 2024 - Dominique Leuenberger + +- Use %patch -P N instead of deprecated %patchN. + +------------------------------------------------------------------- +Thu Feb 8 17:35:05 UTC 2024 - Dominique Leuenberger + +- Replace python-devel and python2-xml BuildRequires with + python3-base: the build log already contains + Creating Python 3 environment + i.e, python2 was not used anymore (boo#1219739). + +------------------------------------------------------------------- +Wed Jan 18 00:10:28 UTC 2024 - Tristan Miller + +- update to SeaMonkey 2.53.18.1 + * Update the NSS library to the latest esr 115 version for the final + 2.53.18.1 release. + * SeaMonkey 2.53.18.1 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.18.1 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.8.0 release notes + for specific security fixes in this release. + * Additional important security fixes up to Current Firefox 115.7 + and Thunderbird 115.7 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- request inclusion in Leap 15.5 and 15.6: + https://bugzilla.opensuse.org/show_bug.cgi?id=1218961 + +------------------------------------------------------------------- +Sun Dec 09 14:26:01 UTC 2023 - Tristan Miller + +- update to SeaMonkey 2.53.18 + * Update Branding info bug 1841167. + * Use BugSplat for SeaMonkey crash reporting bug 1835524. + * Unify notifications and permissions in SeaMonkey bug 1849526. + * SeaMonkey 2.53.18 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.18 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 115.5 + and Thunderbird 115.5 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- remove obsolete patch seamonkey-binutils.patch +- remove obsolete patches 1817900-13-112a1.patch, 1849874-11503.patch, + and TOP-NOBUG-revendor-253172.patch +- request inclusion in Leap 15.4, 15.5, and 15.6: + https://bugzilla.opensuse.org/show_bug.cgi?id=1217916 +- disable --with-system-nss on Leap 15.5 to work around build breakage + +------------------------------------------------------------------- +Wed Nov 01 17:37:55 UTC 2023 - Tristan Miller + +- add 1817900-13-112a1.patch, 1849874-11503.patch, and + TOP-NOBUG-revendor-253172.patch to allow building with rust >= 1.48 +- request inclusion in Leap 15.4 and 15.5: + https://bugzilla.opensuse.org/show_bug.cgi?id=1216797 + +------------------------------------------------------------------- +Wed Oct 04 08:21:55 UTC 2023 - Tristan Miller + +- add seamonkey-binutils.patch to allow building with binutils >= 2.41: + https://bugzilla.mozilla.org/show_bug.cgi?id=1856238 + https://bugzilla.mozilla.org/show_bug.cgi?id=1846703 +- add mozilla-bmo531915.patch to fix builds for x86: + https://bugzilla.mozilla.org/show_bug.cgi?id=531915 +- request inclusion in Leap 15.4 and 15.5: + https://bugzilla.opensuse.org/show_bug.cgi?id=1215944 + +------------------------------------------------------------------- +Thu Sep 28 20:29:03 UTC 2023 - Bernhard Wiedemann + +- Add reproducible.patch to override build date (boo#1047218) + +------------------------------------------------------------------- +Thu Sep 21 15:58:45 UTC 2023 - Tristan Miller + +- update to SeaMonkey 2.53.17.1 + * Upstream libwebp security fix bug 1852749. + * CVE-2023-4863: Heap buffer overflow in libwebp bug 1852649. + * Fix bad string encoded in ansi. l10n fr problem only bug 1847887. + * SeaMonkey 2.53.17 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.17 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 115.3 + and Thunderbird 115.3 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- request inclusion in Leap 15.4 and 15.5: + https://bugzilla.opensuse.org/show_bug.cgi?id=1215585 + +------------------------------------------------------------------- +Fri Aug 04 13:04:12 UTC 2023 - Tristan Miller + +- update to SeaMonkey 2.53.17 + * Fix macOS Contacts permission request bug 1826719. + * Remove SeaMonkey 2.57 links from debugQA bug 1829683. + * Treat opening urls from the library as external bug 1619108. + * Disable spam warning for autogenerated links in plaintext messages + bug 619031. + * Switch SeaMonkey build files to Python 3 bug 1635849. + * Remove empty overlays from Composer bug 1828533. + * Move xpfe autocomplete to comm-central suite bug 1418512. + * Remove nsIPrefBranch2 and nsIPrefBranchInternal bug 1374847. + * SeaMonkey 2.53.17 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.17 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 102.11 + and Thunderbird 102.11 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. + * Adapt mozilla-nongnome-proxies.patch for SeaMonkey 2.53.17 + * Adapt seamonkey-lto.patch for SeaMonkey 2.53.17 + * Remove obsolete %clean section from seamonkey.spec +- request inclusion in Leap 15.4 and 15.5: + https://bugzilla.opensuse.org/show_bug.cgi?id=1213986 + +------------------------------------------------------------------- +Wed Mar 31 07:22:42 UTC 2023 - Tristan Miller + +- update to SeaMonkey 2.53.16 + * No throbber in plaintext editor bug 85498. + * Remove unused gridlines class from EdAdvancedEdit bug 1806632. + * Remove ESR 91 links from debugQA bug 1804534. + * Rename devtools/shim to devtools/startup bug 1812367. + * Remove unused seltype=text|cell css bug 1806653. + * Implement new shared tree styling bug 1807802. + * Use `win.focus()` in macWindowMenu.js bug 1807817. + * Remove WCAP provider bug 1579020. + * Remove ftp/file tree view support bug 1239239. + * Change calendar list tree to a list bug 1561530. + * Various other updates to the calendar code. + * Continue the switch from Python 2 to Python 3 in the build system. + * Verified compatibility with Rust 1.66.1. + * SeaMonkey 2.53.16 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.16 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 102.9 + and Thunderbird 102.9 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- update seamonkey-GNUmakefile patch per + https://bugzilla.mozilla.org/show_bug.cgi?id=1692516#c11 to reflect + changes in the new way of packing langpacks +- remove obsolete patch mozilla-language.patch +- remove obsolete patch seamonkey-spellcheck.patch +- remove --enable-system-hunspell from .mozconfig per + https://bugzilla.mozilla.org/show_bug.cgi?id=1820413 +- add build dependency on clang +- request inclusion in Leap 15.4: + https://bugzilla.opensuse.org/show_bug.cgi?id=1209994 + +------------------------------------------------------------------- +Fri Jan 20 10:12:30 UTC 2023 - Tristan Miller + +- update to SeaMonkey 2.53.15 + * Microtasks and promises bug 1193394. + * Implement queueMicrotask()bug 1480236. + * Remove old synchronous contentPrefService from the tree bug 886907 + and bug 1392929. + * Remove remaining uses of 'general.useragent.locale' bug 1410736 + and bug 1410738. + * Migrate to intl.locale.requested.locale list from + 'general.useragent.locale' bug 1441016. + * Introduce a pref to store BCP47 locale list bug 1414390, bug + 1423532 and bug 1441026. + * Remove synchronous certificate verification APIs from + nsIX509CertDB bug 1453741 and bug 1453778. + * Taskbar preview's favicon appears blank bug 1475524. + * Call Imagelibs decodeImageAsyncWindows using a callback bug + 1790695. + * Remove PermissionsService from process Windows sandboxing code bug + 1788233, bug 1789782 and bug 1794394. + * Security info dialog doesn't show cert status anymore bug 1293378. + * Replace nsIPlatfromCharset in mailnews bug 1381762. + * Replace use of nsMsgI18NFileSystemCharset() with + NS_CopyUnicodeToNative/NS_CopyNativeToUnicode() bug 1506422. + * Cater for Outlook's/Hotmail's 'Deleted' folder bug 1320191. + * Make some filter methods scriptable bug 1497513. + * Fix crash in nsMsgFilterAfterTheFact::ApplyFilter() caused by + async reset of 'm_curFolder' bug 537017. + * Localize messages from nsIMsgFolder.logRuleHitFail() bug 1352731. + * Add logging of message filter runs and actions bug 697522. + * Check that we got a non-null header before running a filter on it + (and crashing) bug 1563959. + * With CONDSTORE, eliminate unneeded flag fetches at startup bug + 1428097. + * Fix so custom tags (keywords) are visible to all users bug 583677. + * Improve handling of tags on shared folders bug 1596371. + * Allow setting/resetting junk marking by user for yahoo/aol to + stick bug 1260059. + * Don't check subject if spellchecker is not ready bug 1069787. + * Grammar issues in mailnews_account_settings.xhtml bug 1793291. + * Remove use of nsIMemory bug 1792578. + * Replace obsolete GetStringBundleService call in SeaMonkey bug + 1794400. + * SeaMonkey crashes on MacOS Ventura 13.0 bug 1797696. + * Continue the switch from Python 2 to Python 3 in the build system. + * Added support for clang 15 and macOS SDK 11.3. + * Verified compatibility with Rust 1.65. + * SeaMonkey 2.53.15 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.15 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 102.6 + and Thunderbird 102.5 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- update seamonkey-GNUmakefile patch per + https://bugzilla.mozilla.org/show_bug.cgi?id=1692516#c9 to remove + obsolete stuff and fix handling of Latam Spanish +- remove build dependency on obsolete rust-std-static +- request inclusion in Leap 15.4: + https://bugzilla.opensuse.org/show_bug.cgi?id=1207332 + +------------------------------------------------------------------- +Thu Sep 29 12:14:18 UTC 2022 - Tristan Miller + +- update to SeaMonkey 2.53.14 + * Updates to the following DOM HTML element interfaces: Embed, + Object, Anchor, Area, Button, Frame, Canvas, IFrame, Link, Image, + MenuItem, TextArea, Source, Select, Option, Script and + Html. Please test add-ons. + * Continue the switch from Python 2 to Python 3 in the build system. + * Add ESR 102 links to debugQA bug 1779028. + * Remove about plugins from help menu bug 1779031. + * Dead links in cs_nav_prefs_advanced.xhtml [en-US] bug 1783558. + * Dead links in cs_nav_prefs_advanced.xhtml bug 1786030. + * Remove obsolete chat services from SeaMonkey address book bug + 1779034. + * Address Book: "Get Map" button is not shown for home addresses bug + 1779319. + * Added compatibility for rust 1.63 + * SeaMonkey 2.53.14 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.14 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 91.11 + and Thunderbird 91.11 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- add seamonkey-spellcheck.patch to work around a circular dependency + issue when compiling with GCC 12 +- requested inclusion in Leap 15.4 and 15.3: + https://bugzilla.opensuse.org/show_bug.cgi?id=1203916 + +------------------------------------------------------------------- +Mon Jul 11 11:43:54 UTC 2022 - Tristan Miller + +- update to SeaMonkey 2.53.13 + * Updates to devtools. + * Updates to build configuration. + * Starting the switch from Python 2 to Python 3 in the build system. + * Removal of array comprehensions, legacy iterators and generators + bug 1414340 and bug 1098412. + * Adding initial optional chaining and Promise.allSettled() support. + * SeaMonkey 2.53.13 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.13 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 91.11 + and Thunderbird 91.11 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- adapt seamonkey-man-page.patch for SeaMonkey 2.53.13 +- disable LTO for Tumbleweed builds due to linker errors +- requested inclusion in Leap 15.4 and 15.3: + https://bugzilla.opensuse.org/show_bug.cgi?id=1201406 + +------------------------------------------------------------------- +Tue Jun 14 12:09:28 UTC 2022 - Guillaume GARDET + +- Add --disable-elf-hack for aarch64 to fix build + +------------------------------------------------------------------- +Fri May 04 09:25:16 UTC 2022 - Tristan Miller + +- update to SeaMonkey 2.53.12 + * Format Toolbar forgets its hidden status when switching to other + view modes bug 1719020. + * Remove obsolete plugin code from SeaMonkey bug 1762733. + * Fix a few strict warnings in SeaMonkey bug 1755553. + * Remove Run Flash from Site permissions and page info bug 1758289. + * Use fixIterator and replace use of removeItemAt in + FilterListDialog bug 1756359. + * Remove RDF usage in tabmail.js bug 1758282. + * Implement 'Edit Template' and 'New Message From Template' commands + and UI bug 1759376. + * [SM] Implement 'Edit Draft' command and hide it when not in a + draft folder (port Thunderbird bug 1106412) bug 1256716. + * Messages in Template folder need "Edit Template" button in header + (like for Drafts) bug 80280. + * Refactor and simplify the feed Subscribe dialog options updates + bug 1420473. + * Add system memory and disk size and placeDB page limit to + about:support bug 1753729. + * Remove warning about missing plugins in SeaMonkey 2.53 and 2.57 + bug 1755558. + * SeaMonkey 2.53.12 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.12 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.8.0 release notes for + specific security fixes in this release. + * Additional important security fixes up to Current Firefox 91.9 and + Thunderbird 91.9 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- remove/update references to obsolete gtk2 directory +- requested inclusion in Leap 15.3: + https://bugzilla.opensuse.org/show_bug.cgi?id=1199197 + +------------------------------------------------------------------- +Fri Mar 25 09:53:04 UTC 2022 - Tristan Miller + +- update to SeaMonkey 2.53.11.1 + * Fix edge case when setting IntersectionObserver threshold bug + 1758291. + * OAuth2 prefs should use realuserName instead of username bug + 1518126. + * SeaMonkey 2.53.11.1 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.11.1 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.8.0 release notes + for specific security fixes in this release. + * Additional important security fixes up to Current Firefox 91.7 and + Thunderbird 91.7 ESR plus many enhancements have been + backported. We will continue to enhance SeaMonkey security in + subsequent 2.53.x beta and release versions as fast as we are able + to. +- requested inclusion in Leap 15.3: + https://bugzilla.opensuse.org/show_bug.cgi?id=1197518 + +------------------------------------------------------------------- +Thu Mar 03 12:10:36 UTC 2022 - Tristan Miller + +- update to SeaMonkey 2.53.11 + * Remove obsolete MOZ_EXTENSIONS check in suite bug 1749146. + * Add connect button to cZ Networks Editor bug 1736443. + * Remove freenode remnants from ChatZilla in SeaMonkey bug 1741082. + * Prefer secure over insecure protocol in network list in ChatZilla + bug 1744440. + * Composer - Change tag textbox is not removed after use bug + 1755369. + * Clean up repo links in debugQA bug 1746790. + * Fix misspelled references to macOS in suite bug 1749144. + * Remove obsolete references to Java and Flash bug 1749141. + * Help button not working in delete cert dialog bug 1750386. + * Rearrange Message Filter Dialog to make room for new features bug + 1735053. + * Use Insert key as shortcut to create new message filters bug 1735055. + * Rename some variables used in SeaMonkey's FilterListDialog to + match Thunderbird's bug 1735056. + * Implement Copy to New message filter functionality bug 1735057. + * Add move to top / bottom buttons to message filters bug 1735059. + * Add preference to not prompt for message filter deletion bug + 1735061. + * Clean up folder handling in FilterListDialog bug 1736425. + * Add refresh function to Filter list dialog so that it can be + updated when already open and new filters are added externally bug + 1737450. + * Use listbox rather than tree in FilterListDialog bug 1746081. + * MsgFilterList(args) should take targetFilter and pass it to + FilterListDialog bug 1753891. + * Mail&News' start.xhtml: "We" link broken bug 1748178. + * Add search functionality to filter dialog bug 1749207. + * Move the taskbar refresh timer in SeaMonkey to idle dispatch bug + 1746788. + * Prevent subresource loads from showing the progress indicator on + the tab in SeaMonkey bug 1746787. + * SeaMonkey 2.53.11 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * Additional important security fixes up to Current Firefox 91.6 ESR + and a few enhancements have been backported. We will continue to + enhance SeaMonkey security in subsequent 2.53.x beta and release + versions as fast as we are able to. + * SeaMonkey 2.53.11 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. +- adapt seamonkey-man-page.patch for SeaMonkey 2.53.11 +- requested inclusion in Leap 15.3: + https://bugzilla.opensuse.org/show_bug.cgi?id=1196703 + +------------------------------------------------------------------- +Tue Feb 15 23:18:43 UTC 2022 - Bjørn Lie + +- Drop pkgconfig(gconf-2) BuildRequires and pass ac_add_options + --disable-gconf to mozconfig. As we already are using cairo-gtk3, + gconf support serves no purpose (gio/gsettings takes care). + +------------------------------------------------------------------- +Tue Dec 28 13:01:41 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.10.2 + * Obtain Windows code-signing certificate for SeaMonkey binary and + update signing bug 1438084. + * Support SHA-2 hashes in CertIDs in OCSP responses - port of bug + 1746221. + * Fix rust 1.57 Windows linking for SeaMonkey 2.53 bug 1746785. + * SeaMonkey 2.53.10.2 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * Additional important security fixes up to Current Firefox 91.4.1 + ESR and a few enhancements have been backported. We will continue + to enhance SeaMonkey security in subsequent 2.53.x beta and + release versions as fast as we are able to. + * SeaMonkey 2.53.10.2 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.0 release notes + for specific changes and security fixes in this release. +- requested inclusion in Leap 15.3: + https://bugzilla.opensuse.org/show_bug.cgi?id=1194114 + +------------------------------------------------------------------- +Mon Dec 13 10:38:44 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.10.1 + * Security fix for NSS code bug 1737470. + * Only use networks and servers in lower case in ChatZilla bug + 1742502. + * Change classic form icon in SeaMonkey composer bug 1710915. + * Addition fixes for SeaMonkey 32x32 default icons on Windows and + macOS bug 1729153. + * SeaMonkey 2.53.10.1 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.10.1 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.0 release notes + for specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 91.4 ESR + and a few enhancements have been backported. We will continue to + enhance SeaMonkey security in subsequent 2.53.x beta and release + versions as fast as we are able to. +- Remove unused build dependency on libidl-devel. +- requested inclusion in Leap 15.3: + https://bugzilla.opensuse.org/show_bug.cgi?id=1193668 + +------------------------------------------------------------------- +Tue Nov 16 08:40:32 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.10 + * Minor fixes for testdisplay command in ChatZilla bug 1727976. + * Show CTCP requests (excluding ACTION and DCC) bug 1722156. + * IRCv3: Add support for server-time bug 1724586. + * Add localization note for network editor dialog width in ChatZilla + bug 1727977. + * IRCv3: Add support for extended-join and account-notify bug + 1722159. + * Add ability to collapse message groups in ChatZilla bug 1724588. + * Fix JS strict warnings in unescapeTagValue in ChatZilla bug + 1727989. + * IRCv3: Add support for invite-notify bug 1722161. + * IRCv3: Add support for batch bug 1724589. + * Fix JS strict warning in addHistory in cZ static.js bug 1727992. + * IRCv3: Add support for cap-notify bug 1722162. + * Stop using canonical name as collection keys in ChatZilla bug + 1728025. + * IRCv3: Add support for TLS and STS bug 1722166. + * Helper function for renaming irc server properties in ChatZilla + bug 1728027. + * IRCv3: Add support for MONITOR bug 1722174. + * Remove use of msg.commasp in ChatZilla bug 1726965. + * Allow shiftKey to modify behaviour of link clicking in cZ bug + 1713458. + * IRCv3: Add support for echo-message bug 1722211. + * In ChatZilla make /commands return all matches starting with + pattern bug 1726966. + * Use SeaMonkey prefs to determine how links behave in cZ bug + 1713467. + * Allow parameters to be localised in ChatZilla bug 1724105. + * Add identify command to cZ and hook into password management bug + 1713470. + * IRCv3.1: Implement SASL with PLAIN mechanism bug 1717545. + * IRCv3: Add support for message tags bug 1724584. + * Add last read message divider to ChatZilla bug 1729159. + * IRCv3: Add support for account-tag bug 1724585. + * Missing option "text encoding Unicode/UTF-8" in preferences - + Mailnews bug 1679260. + * Detect Crashreporter using AppConstants in SeaMonkey bug 1735236. + * Link about LEGACY extensions in Add-ons Manager is broken bug + 1656797. + * Update help for clear private data preferences and dialog bug + 1728911. + * Fix typo in cs_nav_prefs_appearance bug 1737473. + * Drop leftover "Edit Menu" comment from messageWindow.xul and + addressbook.xul bug 1725121. + * Add dummy tab routines to SeaMonkey mailnews tab browser bug + 1735243. + * Folder pane and tab/window title not updated correctly when + opening in new tab bug 1726940. + * Allow mail tab bar to be controlled separately to browser tab bar + bug 1724515. + * Copy any user set values for new mail.tabs prefs bug 1729165. + * Merge Master Passwords and Passwords pref panes into a single pref + pane bug 1728099. + * Move warning about redirection pref from Content to Privacy & + Security pane bug 1728185. + * Move website icons prefs from content pref pane to browser pref + pane bug 1727425. + * Move browser / mailnews system integration prefs into advanced + pane bug 1727659. + * Have separate opentabfor.middleclick for mailnews bug 1727948. + * Add removeBrowser helper for tabbrowser bug 1730391. + * Put in a so it's easy to overlay bug 1730392. + * Allow browser focus to be avoided bug 1720003. + * SeaMonkey 32x32 default icon has light stripe at the bottom bug + 1729153. + * Support and in SeaMonkey bug + 1730408. + * Middleclick on browser tab handled twice (closes tab and loads URL + from primary or clipboard) bug 1734407. + * Unable to create a new "Saved Search Folder" using "Save View as a + Folder..." bug 1738669. + * Enable compression for standard http connections bug 1728996. + * Support VS2022 for compiling under Windows bug 1728988. + * SeaMonkey 2.53.10 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.10 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.0 release notes + for specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.15 + ESR and a few enhancements have been backported. We will continue + to enhance SeaMonkey security in subsequent 2.53.x beta and + release versions as fast as we are able to. +- requested inclusion in Leap 15.3 and Leap 15.2: + https://bugzilla.opensuse.org/show_bug.cgi?id=1192742 + +------------------------------------------------------------------- +Tue Sep 28 07:09:11 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.9.1 + * Fix the lazy loading of images from some websites bug 1727967. + * Move certain font family defaults from serif to sans serif bug + 1727982. + * SeaMonkey 2.53.9.1 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.9.1 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.0 release notes + for specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.14 + ESR and a few enhancements have been backported. We will continue + to enhance SeaMonkey security in subsequent 2.53.x beta and + release versions as fast as we are able to. +- requested inclusion in Leap 15.3 and Leap 15.2: + https://bugzilla.opensuse.org/show_bug.cgi?id=1191022 + +------------------------------------------------------------------- +Thu Aug 26 12:27:32 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.9 + * There is now an option to clear browser history during shutdown + bug 1621445. + * Uninstall plugin command for ChatZilla bug 541719. + * Update icons used in ChatZilla status bar bug 1710238 and bug + 1710249. + * Make ChatZilla understand mIRC color code 99 bug 1710298. + * Implement IRCv3 basic CAP negotiation bug 1717539 and CAP LIST and + update CAP ACK and CAP LS bug 1710313. + * Use Unicode instead of images for emojis in ChatZilla bug 1711375 + and add some extra emojis bug 1711376. + * Use SeaMonkey's configured web search rather than a separate one + in ChatZilla bug 1712498. + * Add a networks editor to ChatZilla bug 1716232. + * Implement IRCv3 away-notify bug 1717543, chghost and + userhost-in-names bug 1717544, self-messaging bug 1722212 and WHOX + bug 1722214. + * Link to SeaMonkey website in debugQA for verification sites and + development section bug 1685606. + * Send button should be disable until we have a recipient bug + 104973. + * Remove need to use a modifier for marking messages as unread bug + 1719216. + * SeaMonkey 2.53.9 uses the same backend as Firefox and contains the + relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.9 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.13 + ESR and a few enhancements have been backported. We will continue + to enhance SeaMonkey security in subsequent 2.53.x beta and + release versions as fast as we are able to. +- removed obsolete patch seamonkey-packed_simd.patch (integrated + upstream) +- update seamonkey-lto.patch to work with 2.53.9 +- requested inclusion in Leap 15.3 and Leap 15.2: + https://bugzilla.opensuse.org/show_bug.cgi?id=1189845 + +------------------------------------------------------------------- +Thu Aug 19 12:52:52 UTC 2021 - Tristan Miller + +- add upstream patch seamonkey-packed_simd.patch which allows + packed_simd to compile with Rust 1.54 + +------------------------------------------------------------------- +Tue Jul 27 06:57:05 UTC 2021 - Guillaume GARDET + +- Remove --disable-elf-hack when not available: aarch64 and ppc64* + +------------------------------------------------------------------- +Thu Jul 22 08:55:51 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.8.1 + * Archive message action does not work bug 1718839. + * Do not preserve offlineMsgSize parameter when moving/copying + emails between folders bug 1720202 and bug 1430480. + * Move thread code to threadPane.js and remove messengerdnd.js bug + 515675. + * SeaMonkey 2.53.8.1 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.8.1 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.0 release notes + for specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.12 + ESR and a few enhancements have been backported. We will continue + to enhance SeaMonkey security in subsequent 2.53.x beta and + release versions as fast as we are able to. +- requested inclusion in Leap 15.3 and Leap 15.2: + https://bugzilla.opensuse.org/show_bug.cgi?id=1188614 + +------------------------------------------------------------------- +Thu Jul 08 06:50:25 UTC 2021 - Tristan Miller + +- requested inclusion in Leap 15.3 and Leap 15.2: + https://bugzilla.opensuse.org/show_bug.cgi?id=1188100 + +------------------------------------------------------------------- +Wed Jul 07 13:50:05 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.8 + * Serious performance improvements and bug fixes tracked in bug + 1633339 and bug 1711050. + * Language attributes with country codes not recognized when + building the Website Navigation Bar link toolbar bug 134436 and + bug 1709443. + * Optimize SeaMonkey icons for speed and optional higher quality for + branding bug 1362210 and bug 1699322. + * Support from= option when opening email compose window from the + command line bug 1628671. + * Update subject handling and GenericSendMessage function in compose + window bug 1693994. + * All message windows should update when view preferences are + changed bug 1694765. + * Improve marking of multiple messages as read / unread bug 1700530. + * Show version numbers again in the add-on manager by the partial + backout of bug 1161183. + * Update available networks in chatZilla (including adding + libera.chat)bug 1704392 and bug 1712505. + * Change default port for IRC via TLS/SSL to 6697 bug 1704280. + * Remove chatZilla and Lightning extension language packs and + incorpate localisations within the main language pack bug 1604663. + * Fix address drag and drop handling in compose window bug 1712002 + and bug 1712227. + * Further fixes for legacy generators and the deprecated for each + statement in add-ons and the Add-on SDK bug 1702903. + * For developers, fork DOMi repo into main SeaMonkey one which means + no need to separately checkout the extension bug 1700003. + * SeaMonkey 2.53.8 uses the same backend as Firefox and contains the + relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.8 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.11 + ESR and a few enhancements have been backported. We will continue + to enhance SeaMonkey security in subsequent 2.53.x beta and + release versions as fast as we are able to. +- removed obsolete seamonkey-websocketloop.patch and + seamonkey-rustc-bootstrap.patch (now integrated upstream) + +------------------------------------------------------------------- +Tue May 18 07:04:59 UTC 2021 - Tristan Miller + +- add patch seamonkey-rustc-bootstrap.patch adapted from + https://bugzilla.mozilla.org/show_bug.cgi?id=1710154 to enable + compilation with rust >= 1.50.0 + +------------------------------------------------------------------- +Tue May 05 18:36:24 UTC 2021 - Tristan Miller + +- update GNU Makefile from upstream + https://bugzilla.mozilla.org/show_bug.cgi?id=1692516#c8 -- besides + some general improvements, this Makefile now allows the language + packs for the bundled extensions to be split off again if desired + (though our spec file does not yet take advantage of this) + +------------------------------------------------------------------- +Tue May 04 08:19:42 UTC 2021 - Tristan Miller + +- use system libraries for bz2, webp, and icu to reduce package size + and because this is probably more secure (since our own libraries + are probably updated more often than the ones bundled with + SeaMonkey) + +------------------------------------------------------------------- +Wed Apr 28 07:59:04 UTC 2021 - Tristan Miller + +- add upstream patch seamonkey-websocketloop.patch from + https://bugzilla.mozilla.org/attachment.cgi?id=9218795&action=diff + to solve critical performance issue + https://bugzilla.mozilla.org/show_bug.cgi?id=1633339 + +------------------------------------------------------------------- +Tue Apr 27 11:54:30 UTC 2021 - Tristan Miller + +- requested inclusion in Leap 15.2: + https://bugzilla.opensuse.org/show_bug.cgi?id=1185349 + +------------------------------------------------------------------- +Tue Apr 20 15:28:04 UTC 2021 - Tristan Miller + +- remove check for .mkdir.done, as these files are no longer generated +- remove check for text files with the executable bit incorrectly set, + as the only remaining files in the source tree with this problem are + ones that don't get installed anyway: + https://bugzilla.mozilla.org/show_bug.cgi?id=1706019 +- revise/improve spec file comments +- update package description to clarify compatibility with Firefox + extensions +- update package description to reference bundled calendar + +------------------------------------------------------------------- +Tue Apr 20 06:52:31 UTC 2021 - Tristan Miller + +- re-enable elf-hack for x86_64 builds as this is no longer preventing + compilation: https://bugzilla.mozilla.org/show_bug.cgi?id=1619776 + +------------------------------------------------------------------- +Mon Apr 19 20:40:37 UTC 2021 - Tristan Miller + +- remove --disable-optimize flag (added on Sat Sep 20 14:53:01 UTC + 2014 as a result of bnc#896624) as compilation on ix86 with the + default optimizations seems to work fine now + +------------------------------------------------------------------- +Mon Apr 19 07:40:51 UTC 2021 - Tristan Miller + +- add patch to install SeaMonkey's new man page: + seamonkey-man-page.patch + +------------------------------------------------------------------- +Sun Apr 18 13:28:57 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.7.1 + * Fix for legacy generators and the deprecated for each statement in + add-ons and the Add-on SDK bug 1702903. + * Fix for handling of dead keys in text input fields in GTK 3.24.26+ + bug 1701288. + * SeaMonkey 2.53.7.1 uses the same backend as Firefox and contains + the relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.7.1 shares most parts of the mail and news code + with Thunderbird. Please read the Thunderbird 60.0 release notes + for specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.8 ESR + and a few enhancements have been backported. We will continue to + enhance SeaMonkey security in subsequent 2.53.x beta and release + versions as fast as we are able to. + +------------------------------------------------------------------- +Sun Apr 18 12:57:14 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.7 + * Remove Flash and NPAPI support bug 1688415. + * Switch packaged extensions to be global bug 1659298. + * Add Insert Forms to Composer bug 1684611. + * Fix an issue with copying to IMAP sent folder and some reference + count leaks in mailnews bug 1689890. + * Tailing to delay tracker requests and enhance performance has been + enabled bug 1358060. + * Fix an issue with favorite and recent folders not showing in macOS + bug 1695869. + * Various security and general platform fixes. + * The ChatZilla source has been integrated into SeaMonkey and no + longer needs to be checked out separately if you build your own + release bug 1551033. + * SeaMonkey 2.53.7 uses the same backend as Firefox and contains the + relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.7 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.8 ESR + and a few enhancements have been backported. We will continue to + enhance SeaMonkey security in subsequent 2.53.x beta and release + versions as fast as we are able to. +- update GNU Makefile per + https://bugzilla.mozilla.org/show_bug.cgi?id=1692516#c6 + * provide a way to auto-select es-AR locale on any Spanish one but + es-ES + +------------------------------------------------------------------- +Sun Apr 18 12:22:54 UTC 2021 - Tristan Miller + +- restore Chatzilla and DOM Inspector packages disabled in Revision + 333; these extensions were long since re-enabled upstream but + apparently we had forgotten to re-enable them in the spec file + +------------------------------------------------------------------- +Fri Apr 16 15:18:27 UTC 2021 - Tristan Miller + +- add --disable-install-strip to .mozconfig; fixes #1184851 + +------------------------------------------------------------------- +Fri Apr 16 07:20:09 UTC 2021 - Tristan Miller + +- update to SeaMonkey 2.53.6 + * Improve usability of multiple mailboxes/folders selectionbug + 1600103. + * Add Greek localisation (el). + * Remove more RDF from mailnews code. + * Switch to mozilla as topsrcdir and component for building is + comm/suite now. + * Rust support is now up to 1.48 and official build is now using + 1.47.0 + * Various security and general platform fixes. + * SeaMonkey 2.53.6 uses the same backend as Firefox and contains the + relevant Firefox 60.8 security fixes. + * SeaMonkey 2.53.6 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.6 ESR + and a few enhancements have been backported. We will continue to + enhance SeaMonkey security in subsequent 2.53.x beta and release + versions as fast as we are able to. +- rewrote spec file to account for SeaMonkey's new build system, including + a new Makefile from Dmitry Butskoy: #1181525#c3 +- merged the translations-common and translations-other subpackages into + the main package; it is no longer convenient/consistent to keep these + separate because localizations for the integrated IRC and Calendar + clients are already merged in the source. This also solves #1181525. +- enabled and bundled Calendar (Lightning) extension +- cleaned up spec file to remove conditions targeting long-obsolete + openSUSE versions +- disabled elf-hack on i586 builds, as it was preventing compilation + +------------------------------------------------------------------- +Tue Apr 13 07:58:48 UTC 2021 - Tristan Miller + +- add patch to enable builds with Rust >= 1.48 on Tumbleweed + https://bugzilla.mozilla.org/show_bug.cgi?id=1617782#c22 + +------------------------------------------------------------------- +Fri Nov 20 09:49:51 UTC 2020 - Tristan Miller + +- requested inclusion in Leap 15.1 and 15.2: + https://bugzilla.opensuse.org/show_bug.cgi?id=1179010 + +------------------------------------------------------------------- +Thu Nov 19 09:44:58 UTC 2020 - Tristan Miller + +- update to SeaMonkey 2.53.5.1 + * Fix advertising of av1 support bug 1490877. + * Fix some issues found with supporting new macOS. + * Various security and general platform fixes. + +------------------------------------------------------------------- +Sat Nov 14 20:17:43 UTC 2020 - Tristan Miller + +- update to SeaMonkey 2.53.5 + * Provide WebP support bug 1653869. + * Add startpage.com as a search engine available to all locales bug + 1655283. + * Added av1 support. + * Included latest version of freetype2. + * Added support for the resizeObserver web API. + * Support for rust 1.47.0 on Linux and macOS platforms. + * Dropped support for use of system sqlite. + * Various security and general platform fixes. + * SeaMonkey 2.53.5 uses the same backend as Firefox and contains the + relevant Firefox 60.8 security fixes + * SeaMonkey 2.53.5 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.4 ESR + and a few enhancements have been backported. We will continue to + enhance SeaMonkey security in subsequent 2.53.x beta and release + versions as fast as we are able to. + +------------------------------------------------------------------- +Wed Sep 23 08:19:00 UTC 2020 - Tristan Miller + +- update to SeaMonkey 2.53.4 + * This version makes changes to your profile that can't be reverted + in case you want to go back to a previous version of + SeaMonkey. You MUST absolutely do a full backup of your profile + before trying SeaMonkey 2.53.4. + * Added translation for Bokmål (nb_NO) + * Upgraded NSS to 3.53.1 bug 1643859. + * Updated to Unicode 11 for SpiderMonkey bug 1466471. + * Updated bundled Twemoji Mozilla font to v0.5.1 to support newer + emojis bug 1644346. + * Updated how photos are handled in the addressbook bug 1641705. + * Removed outdated RSS feed handlers bug 1643716. + * Fix initialisation of TodayPane mini-day, to show the right day + bug 1479628. + * Fixed sizing issue of HTML mail question (askSendFormat) dialog + bug 1583415. + * Update of help page content and links. + * Various security and general platform fixes. + * SeaMonkey 2.53.4 uses the same backend as Firefox and contains the + relevant Firefox 60.6 security fixes. + * SeaMonkey 2.53.4 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 78.1 ESR + and a few enhancements have been backported. We will continue to + enhance SeaMonkey security in subsequent 2.53.x beta and release + versions as fast as we are able to. +- Added patch seamonkey-lto.patch which corrects the LTO syntax + when compiling with GCC + +------------------------------------------------------------------- +Mon Jul 20 09:35:49 UTC 2020 - Tristan Miller + +- requested inclusion in Leap 15.1 and 15.2: + https://bugzilla.opensuse.org/show_bug.cgi?id=1174300 + +------------------------------------------------------------------- +Sat Jul 18 20:49:18 UTC 2020 - Tristan Miller + +- update appdata files (Bug 1174192): + * correct metadata licensing information (most of the application + descriptions had been taken from + https://www.seamonkey-project.org/doc/features which according to + the page footer is licensed under CC-BY-SA-3.0) + * update the metadata summary and the introduction in the metadata + description to more accurately reflect what SeaMonkey is, giving + less prominence to the long-discontinued Mozilla Application Suite + that many users may no longer be familiar with + * update the metadata name to more accurately reflect the name + or purpose of the application + * update the metadata URL with the current SeaMonkey website + +------------------------------------------------------------------- +Wed Jul 15 12:09:03 UTC 2020 - Tristan Miller + +- update to SeaMonkey 2.53.3 + * The LaTex tool TexZilla, used for inserting Math, has been + upgraded to 1.0.2. + * It is now possible to customize the toolbars in Composer and the + formatting toolbar in Mailnews composition. + * All folders of an account can now be marked as read. + * There is now an option for not advertizing SeaMonkey at all in the + user agent. + * The preference for hiding the toolbar and menubar grippies can now + be changed from "Preferences->Appearance". + * The preference "browser.tabs.autoHide" which autohides the tab bar + when there is only one tab in a browser window open has been + flipped in bug 1634879. SeaMonkey will now show the tab bar as the + default. You can change it back by checking "Hide the tab bar when + only one tab is open" in "Preferences->Browser->Tabbed Browsing" + * Update of help page content and links. + * SeaMonkey language packs are now version specific and will be + disabled as part of the profile upgrade following the installation + of a later version. + * Search Engines have been centralized and updated in bug 1300198. + * Address book now has updated IM fields, improved layout for card + view pane, improved multi-word search, ability to search across + multiple address books, more granular prompts when deleting items, + print on the context menus and print button on the toolbar. + * Multimedia support has been updated in preparation of supporting + more audio video formats in the next releases. For enhanced + security the Rust multimedia parser is now used for this and the + libstagefright package has been removed. + * SeaMonkey 2.53.3 uses the same backend as Firefox and contains the + relevant Firefox 60.4 security fixes. + * SeaMonkey 2.53.3 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. + * Additional important security fixes up to Current Firefox 77 and a + few enhancements have been backported. +- Fix exclusion list syntax in create-tars.sh script +- Disable LTO on i586 builds as these are once again failing due to + memory issues + +------------------------------------------------------------------- +Tue Jun 02 13:00:57 UTC 2020 - Tristan Miller + +- Re-enable LTO on Tumbleweed builds after increasing available + memory in _constraints + +------------------------------------------------------------------- +Sun May 10 20:24:22 UTC 2020 - Tristan Miller + +- Disable LTO on Tumbleweed builds to work around issues on + build.opensuse.org: + https://bugzilla.opensuse.org/show_bug.cgi?id=1171414 + +------------------------------------------------------------------- +Thu May 08 09:55:00 UTC 2020 - Tristan Miller + +- Update create-tars.sh script to more precisely exclude unwanted + VCS files; the previous exclusion list would have eventually + triggered the bug at + https://bugzilla.mozilla.org/show_bug.cgi?id=1621564 + +------------------------------------------------------------------- +Thu May 07 14:21:31 UTC 2020 - Tristan Miller + +- update to SeaMonkey 2.53.2 + https://www.seamonkey-project.org/releases/seamonkey2.53.2/ + * Scrollbars have been switched over to the native gtk3 theme in bug + 1625754. If your theme does not show scrollbar buttons and you + would like to see them try editing ~/.config/gtk-3.0/gtk.css and + adding the following: + { + -GtkScrollbar-has-backward-stepper: 1; + -GtkScrollbar-has-forward-stepper: 1; + } + * The download progress dialog has been fixed and is now showing the + correct status for downloads. Some downloads may not show the + transferred count. This problem is under investigation. + * SeaMonkey is now translated and available in Finnish and Georgian. + * Because of website compatibility issues and privacy concerns the + Lightning version is no longer appended to the user agent string + and has been removed from the preferences dialog. + * Advanced Layers has been activated on Windows. This should boost + performance on some websites. If you experience graphics problems + please disable it by setting the pref "layers.mlgpu.enabled" to + false. + * Whether the native app chooser is used in Linux is now controlled + via a preference setting in the Helper Applications preference + pane. + * In the Modern theme, popup notifications have improved styling and + column headers now display sort direction arrows. + * The column picker and folder view have been reinstated for the + bookmarks panel. + * Introduced the ability to close all tabs to the right of the + current tab. + * Whether mailnews tabs open in the background is controlled by a + separate preference to browser tabs via General Settings section + of main Mail & Newsgroups preference pane. + * Fixed an issue with the recipient being missing when using Reply + to Sender and Group button in Newsgroup discussions. + * SeaMonkey now prevents address books from having duplicate names. + * SeaMonkey 2.53.2 uses the same backend as Firefox and contains + the relevant Firefox 60.3 security fixes. + * SeaMonkey 2.53.2 shares most parts of the mail and news code with + Thunderbird. Please read the Thunderbird 60.0 release notes for + specific changes and security fixes in this release. + * SeaMonkey now uses gtk3 on Linux. If you experience a problem + because of this please file a bug and link it to bug + 1367257. Please try another OS theme first. Some of them are buggy + and cause problems with SeaMonkey, Thunderbird and Firefox. +- Remove obsolete upstream and local patches + +------------------------------------------------------------------- +Thu Mar 05 12:37:11 UTC 2020 - Tristan Miller + +- update to SeaMonkey 2.53.1 + https://www.seamonkey-project.org/releases/seamonkey2.53.1/ + * The Bookmarks Manager has switched its name to Library, and now + also includes the History list. When invoking History, the Library + will be shown with the History list selected. The extensive + modifications were needed because of Mozilla Gecko platform API + changes. + * Download Manager has been migrated to a new API. Although it looks + pretty much the same as before, the search option is missing and + some other minor details work differently. The previous downloads + history is removed during the upgrade. + * Added Layout panel to CSS Grid tools. + * TLS 1.3 is the default version now. + * Among the general platform and mail fixes this release contains + backported fixes from Thunderbird for the EFAIL security + vulnerability. + * SeaMonkey now uses gtk3 on Linux. If you experience a problem + because of this please file a bug and link it to Switch Linux + builds to GTK3 with SeaMonkey 2.49. Please try another OS theme + first. Some of them are buggy and cause problems with SeaMonkey, + Thunderbird and Firefox. + * The Lightning extension is now included. +- apply upstream patches for building with rust >= 1.40 +- remove mozilla-systems-nss.patch (since merged upstream) +- remove mozilla-no-stdcxx-check.patch (no longer applicable as + build checks have been moved to a Python script) +- adapt mozilla-nongnome-proxies.patch, mozilla-language.patch, + and mozilla-ntlm-full-path.patch for SeaMonkey 2.53.1 +- add upstream patch for better LTO detection +- disable elf-hacking on x86_64 builds to prevent build errors: + https://bugzilla.mozilla.org/show_bug.cgi?id=1619776 +- rewrite the create-tars.sh script according to the new source code + checkout instructions: + https://bugzilla.opensuse.org/show_bug.cgi?id=1165427 + https://bugzilla.mozilla.org/show_bug.cgi?id=1618806 + +------------------------------------------------------------------- +Fri Jan 24 10:59:33 UTC 2020 - Tristan Miller + +- remove obsolete locale patches mozilla-ua-locale.patch and + seamonkey-ua-locale.patch, and update default preferences per + https://bugzilla.mozilla.org/show_bug.cgi?id=542999#c23 + +------------------------------------------------------------------- +Mon Jan 20 12:22:30 UTC 2020 - Tristan Miller + +- remove obsolete and unused custom search add-ons + +------------------------------------------------------------------- +Tue Jan 14 13:28:47 UTC 2020 - Tristan Miller + +- disable Rust, as it caused build errors and was apparently unused +- add patch unifying gettid() declarations to avoid GCC build errors +- add patch correcting the syntax of the linker flags + +------------------------------------------------------------------- +Mon Jan 13 10:52:54 UTC 2020 - Wolfgang Rosenauer + +- remove mozilla-reduce-files-per-UnifiedBindings.patch since it + creates build errors in certain situations +- introduce limit_build instead + +------------------------------------------------------------------- +Mon Oct 21 09:29:14 UTC 2019 - Wolfgang Rosenauer + +- update to Seamonkey 2.49.5 + * https://www.seamonkey-project.org/releases/seamonkey2.49.5/ +- removed obsolete patch + mozilla-bmo1338655.patch +- fix build with system NSS (mozilla-system-nss.patch) + +------------------------------------------------------------------- +Fri Jul 13 05:13:13 UTC 2018 - wr@rosenauer.org + +- update to Seamonkey 2.49.4 + * Gecko 52.9.1esr (bsc#1098998) + MFSA 2018-16 (bsc#1098998) + * CVE-2018-12359 (bmo#1459162) + Buffer overflow using computed size of canvas element + * CVE-2018-12360 (bmo#1459693) + Use-after-free when using focus() + * CVE-2018-12362 (bmo#1452375) + Integer overflow in SSSE3 scaler + * CVE-2018-5156 (bmo#1453127) + Media recorder segmentation fault when track type is changed during capture + * CVE-2018-12363 (bmo#1464784) + Use-after-free when appending DOM nodes + * CVE-2018-12364 (bmo#1436241) + CSRF attacks through 307 redirects and NPAPI plugins + * CVE-2018-12365 (bmo#1459206) + Compromised IPC child process can list local filenames + * CVE-2018-12366 (bmo#1464039) + Invalid data handling during QCMS transformations + * CVE-2018-5188 (bmo#1456189,bmo#1456975,bmo#1465898,bmo#1392739, + bmo#1451297,bmo#1464063,bmo#1437842,bmo#1442722,bmo#1452576, + bmo#1450688,bmo#1458264,bmo#1458270,bmo#1465108,bmo#1464829, + bmo#1464079,bmo#1463494,bmo#1458048) + Memory safety bugs fixed in Firefox 60, Firefox ESR 60.1, and Firefox ESR 52.9 +- localizations finally included again (boo#1062195) + +------------------------------------------------------------------- +Thu Jun 7 00:07:03 UTC 2018 - bjorn.lie@gmail.com + +- Add conditional for pkgconfig(gconf-2.0) BuildRequires, and pass + conditional --disable-gconf to configure: no longer pull in + obsolete gconf2 for Tumbleweed. + +------------------------------------------------------------------- +Tue Jun 5 12:09:11 UTC 2018 - psychonaut@nothingisreal.com + +- update spec file summary and description to more accurately + reflect what SeaMonkey is, giving less prominence to the long- + discontinued Mozilla Application Suite that many users may no + longer be familiar with +- update project URL in spec file + +------------------------------------------------------------------- +Sat Mar 3 16:57:24 UTC 2018 - wr@rosenauer.org + +- update to Seamonkey 2.49.2 + * Gecko 52.6esr (including security relevant fixes) (bsc#1077291) + * fix issue in Composer + * With some themes, the menulist- and history-dropmarker didn't show + * Scrollbars didn't show the buttons + * WebRTC has been disabled by default. It needs an add-on to enable it per site + * The active title bar was not visually emphasized +- correct requires and provides handling (boo#1076907) + +------------------------------------------------------------------- +Tue Jan 9 07:53:08 UTC 2018 - wr@rosenauer.org + +- Explicitly buildrequires python2-xml: The build system relies on + it. We wrongly relied on other packages pulling it in for us. +- use parallel compression in create-tar if available +- use XZ instead of BZ2 for source archives +- import upstream patch mozilla-bmo1338655.patch to fix failing + build + +------------------------------------------------------------------- +Thu Dec 7 11:19:39 UTC 2017 - dimstar@opensuse.org + +- Escape the usage of %{VERSION} when calling out to rpm. + RPM 4.14 has %{VERSION} defined as 'the main packages version'. + +------------------------------------------------------------------- +Fri Nov 10 22:30:10 UTC 2017 - zaitor@opensuse.org + +- Drop obsolete libgnomeui-devel BuildRequires: No longer needed. +- Following the above, add explicit pkgconfig(gconf-2.0), + pkgconfig(gobject-2.0)pkgconfig(gdk-x11-2.0), pkgconfig(gtk+-2.0) + and pkgconfig(gtk+-unix-print-2.0) BuildRequires: previously + pulled in by libgnomeui-devel, and is what configure really + checks for. + +------------------------------------------------------------------- +Fri Aug 4 15:02:38 UTC 2017 - wr@rosenauer.org + +- update to Seamonkey 2.48 + * based on Gecko 51.0.3 + * requires NSPR 4.13.1 and NSS 3.28.5 (aligned with 52ESR) +- removed obsolete (upstreamed) patches + * mozilla-http2-ecdh-keybits.patch + * mozilla-sed43.patch + * mozilla-flex_buffer_overrun.patch + * mozilla-shared-nss-db.patch (feature dropped from SM due to + maintenance costs vs. usefulness) + * mozilla-binutils-visibility.patch + * mozilla-check_return.patch + * mozilla-skia-overflow.patch +- rebased patches + +------------------------------------------------------------------- +Sun Feb 12 13:03:49 UTC 2017 - wr@rosenauer.org + +- fix configure with for sed >= 4.3 (boo#1020631) (mozilla-sed43.patch) + +------------------------------------------------------------------- +Tue Jan 24 21:08:19 UTC 2017 - wr@rosenauer.org + +- improve recognition of LANGUAGE env variable (boo#1017174) +- update minimum keybits in H2 so it allows a smaller value + (e.g. for curve25519 as supported with NSS 3.28) (bmo#1290037) + (boo#1021636) (mozilla-http2-ecdh-keybits.patch) + +------------------------------------------------------------------- +Fri Dec 23 22:13:00 UTC 2016 - wr@rosenauer.org + +- update to Seamonkey 2.46 + * based on Gecko 49.0.2 + * Chatzilla and DOM Inspector were removed/disabled and therefore + those subpackages are not available at this moment +- requires NSPR 4.12 and NSS 3.25 +- removed obsolete patches + * mozilla-libproxy.patch + * mozilla-gcc6.patch + * mozilla-openaes-decl.patch +- rebased patches +- added patches imported from Firefox 49: + * mozilla-check_return.patch + * mozilla-flex_buffer_overrun.patch + * mozilla-skia-overflow.patch + +------------------------------------------------------------------- +Mon Oct 17 11:30:39 UTC 2016 - wr@rosenauer.org + +- mozilla-binutils-visibility.patch to fix build issues with + gcc/binutils combination used in Leap 42.2 (boo#984637) + +------------------------------------------------------------------- +Sun Aug 21 14:05:26 UTC 2016 - antoine.belvire@laposte.net + +- Build also with fno-lifetime-dse and fno-schedule-insns2 for GCC6 + (still boo#991027) +- Check compiler version instead of openSUSE version for this + +------------------------------------------------------------------- +Mon Aug 8 09:19:46 UTC 2016 - wr@rosenauer.org + +- build with -fno-delete-null-pointer-checks for Tumbleweed/gcc6 + as long as underlying issues have been addressed upstream + (boo#991027) + +------------------------------------------------------------------- +Fri Aug 5 13:47:12 UTC 2016 - pcerny@suse.com + +- Fix for possible buffer overrun (bsc#990856) + CVE-2016-6354 (bmo#1292534) + [mozilla-flex_buffer_overrun.patch] + +------------------------------------------------------------------- +Tue Jul 26 04:44:49 UTC 2016 - badshah400@gmail.com + +- Add appstream metainfo files as a tar.bz2 source + (seamonkey-appdata.tar.bz2) and install these appdata.xml files + to the appdata dir (/usr/share/appdata); with these appdata + files installed, seamonkey shows up in appstores like GNOME + software and KDE Discover. + +------------------------------------------------------------------- +Sun Jul 17 02:55:00 UTC 2016 - badshah400@gmail.com + +- Add mozilla-gcc6.patch to fix building with gcc >= 6.0. + +------------------------------------------------------------------- +Sat Mar 5 09:20:24 UTC 2016 - wr@rosenauer.org + +- fix build problems on i586, caused by too large unified compile + units - adding mozilla-reduce-files-per-UnifiedBindings.patch +- increased _constraints as required + +------------------------------------------------------------------- +Tue Jan 19 16:15:28 UTC 2016 - wr@rosenauer.org + +- update to Seamonkey 2.40 (bnc#959277) + * requires NSS 3.20.2 to fix + MFSA 2015-150/CVE-2015-7575 (bmo#1158489) + MD5 signatures accepted within TLS 1.2 ServerKeyExchange in + server signature + * MFSA 2015-134/CVE-2015-7201/CVE-2015-7202 + Miscellaneous memory safety hazards + * MFSA 2015-135/CVE-2015-7204 (bmo#1216130) + Crash with JavaScript variable assignment with unboxed objects + * MFSA 2015-136/CVE-2015-7207 (bmo#1185256) + Same-origin policy violation using perfomance.getEntries and + history navigation + * MFSA 2015-137/CVE-2015-7208 (bmo#1191423) + Firefox allows for control characters to be set in cookies + * MFSA 2015-138/CVE-2015-7210 (bmo#1218326) + Use-after-free in WebRTC when datachannel is used after being + destroyed + * MFSA 2015-139/CVE-2015-7212 (bmo#1222809) + Integer overflow allocating extremely large textures + * MFSA 2015-140/CVE-2015-7215 (bmo#1160890) + Cross-origin information leak through web workers error events + * MFSA 2015-141/CVE-2015-7211 (bmo#1221444) + Hash in data URI is incorrectly parsed + * MFSA 2015-142/CVE-2015-7218/CVE-2015-7219 (bmo#1194818, bmo#1194820) + DOS due to malformed frames in HTTP/2 + * MFSA 2015-143/CVE-2015-7216/CVE-2015-7217 (bmo#1197059, bmo#1203078) + Linux file chooser crashes on malformed images due to flaws in + Jasper library + * MFSA 2015-144/CVE-2015-7203/CVE-2015-7220/CVE-2015-7221 + (bmo#1201183, bmo#1178033, bmo#1199400) + Buffer overflows found through code inspection + * MFSA 2015-145/CVE-2015-7205 (bmo#1220493) + Underflow through code inspection + * MFSA 2015-146/CVE-2015-7213 (bmo#1206211) + Integer overflow in MP4 playback in 64-bit versions + * MFSA 2015-147/CVE-2015-7222 (bmo#1216748) + Integer underflow and buffer overflow processing MP4 metadata in + libstagefright + * MFSA 2015-148/CVE-2015-7223 (bmo#1226423) + Privilege escalation vulnerabilities in WebExtension APIs + * MFSA 2015-149/CVE-2015-7214 (bmo#1228950) + Cross-site reading attack through data and view-source URIs +- rebased patches +- buildrequire xcomposite now explicitely + +------------------------------------------------------------------- +Thu Nov 5 08:01:22 UTC 2015 - wr@rosenauer.org + +- update to Seamonkey 2.39 (bnc#952810) + * MFSA 2015-116/CVE-2015-4513/CVE-2015-4514 + Miscellaneous memory safety hazards + * MFSA 2015-117/CVE-2015-4515 (bmo#1046421) + Information disclosure through NTLM authentication + * MFSA 2015-118/CVE-2015-4518 (bmo#1182778, bmo#1136692) + CSP bypass due to permissive Reader mode whitelist + * MFSA 2015-119/CVE-2015-7185 (bmo#1149000) (Android only) + Firefox for Android addressbar can be removed after fullscreen mode + * MFSA 2015-120/CVE-2015-7186 (bmo#1193027) (Android only) + Reading sensitive profile files through local HTML file on Android + * MFSA 2015-121/CVE-2015-7187 (bmo#1195735) + disabling scripts in Add-on SDK panels has no effect + * MFSA 2015-122/CVE-2015-7188 (bmo#1199430) + Trailing whitespace in IP address hostnames can bypass same-origin policy + * MFSA 2015-123/CVE-2015-7189 (bmo#1205900) + Buffer overflow during image interactions in canvas + * MFSA 2015-124/CVE-2015-7190 (bmo#1208520) (Android only) + Android intents can be used on Firefox for Android to open privileged files + * MFSA 2015-125/CVE-2015-7191 (bmo#1208956) (Android only) + XSS attack through intents on Firefox for Android + * MFSA 2015-126/CVE-2015-7192 (bmo#1210023) (OS X only) + Crash when accessing HTML tables with accessibility tools on OS X + * MFSA 2015-127/CVE-2015-7193 (bmo#1210302) + CORS preflight is bypassed when non-standard Content-Type headers + are received + * MFSA 2015-128/CVE-2015-7194 (bmo#1211262) + Memory corruption in libjar through zip files + * MFSA 2015-129/CVE-2015-7195 (bmo#1211871) + Certain escaped characters in host of Location-header are being + treated as non-escaped + * MFSA 2015-130/CVE-2015-7196 (bmo#1140616) + JavaScript garbage collection crash with Java applet + * MFSA 2015-131/CVE-2015-7198/CVE-2015-7199/CVE-2015-7200 + (bmo#1188010, bmo#1204061, bmo#1204155) + Vulnerabilities found through code inspection + * MFSA 2015-132/CVE-2015-7197 (bmo#1204269) + Mixed content WebSocket policy bypass through workers + * MFSA 2015-133/CVE-2015-7181/CVE-2015-7182/CVE-2015-7183 + (bmo#1202868, bmo#1205157) + NSS and NSPR memory corruption issues + (fixed in mozilla-nspr and mozilla-nss packages) +- requires NSPR >= 4.10.10 and NSS >= 3.19.4 +- removed obsolete patches + * mozilla-icu-strncat.patch +- fixed build with enable-libproxy (bmo#1220399) + * mozilla-libproxy.patch + +------------------------------------------------------------------- +Thu Oct 1 09:42:28 UTC 2015 - wr@rosenauer.org + +- update to SeaMonkey 2.38 (bnc#947003) + * based on 41.0.1 + * MFSA 2015-96/CVE-2015-4500/CVE-2015-4501 + Miscellaneous memory safety hazards + * MFSA 2015-97/CVE-2015-4503 (bmo#994337) + Memory leak in mozTCPSocket to servers + * MFSA 2015-98/CVE-2015-4504 (bmo#1132467) + Out of bounds read in QCMS library with ICC V4 profile attributes + * MFSA 2015-100/CVE-2015-4505 (bmo#1177861) (Windows only) + Arbitrary file manipulation by local user through Mozilla updater + * MFSA 2015-101/CVE-2015-4506 (bmo#1192226) + Buffer overflow in libvpx while parsing vp9 format video + * MFSA 2015-102/CVE-2015-4507 (bmo#1192401) + Crash when using debugger with SavedStacks in JavaScript + * MFSA 2015-104/CVE-2015-4510 (bmo#1200004) + Use-after-free with shared workers and IndexedDB + * MFSA 2015-105/CVE-2015-4511 (bmo#1200148) + Buffer overflow while decoding WebM video + * MFSA 2015-106/CVE-2015-4509 (bmo#1198435) + Use-after-free while manipulating HTML media content + * MFSA 2015-107/CVE-2015-4512 (bmo#1170390) + Out-of-bounds read during 2D canvas display on Linux 16-bit + color depth systems + * MFSA 2015-108/CVE-2015-4502 (bmo#1105045) + Scripted proxies can access inner window + * MFSA 2015-109/CVE-2015-4516 (bmo#904886) + JavaScript immutable property enforcement can be bypassed + * MFSA 2015-110/CVE-2015-4519 (bmo#1189814) + Dragging and dropping images exposes final URL after redirects + * MFSA 2015-111/CVE-2015-4520 (bmo#1200856, bmo#1200869) + Errors in the handling of CORS preflight request headers + * MFSA 2015-112/CVE-2015-4517/CVE-2015-4521/CVE-2015-4522/ + CVE-2015-7174/CVE-2015-7175/CVE-2015-7176/CVE-2015-7177/ + CVE-2015-7180 + Vulnerabilities found through code inspection + * MFSA 2015-113/CVE-2015-7178/CVE-2015-7179 (bmo#1189860, + bmo#1190526) (Windows only) + Memory safety errors in libGLES in the ANGLE graphics library + * MFSA 2015-114 (bmo#1167498, bmo#1153672) (Windows only) + Information disclosure via the High Resolution Time API +- removed obsolete patch + * mozilla-add-glibcxx_use_cxx11_abi.patch +- added mozilla-no-stdcxx-check.patch + +------------------------------------------------------------------- +Sat Aug 29 20:09:34 UTC 2015 - wr@rosenauer.org + +- update to SeaMonkey 2.35 (bnc#935979) + * based on 38.1.1esr + * requires NSPR 4.10.8 and NSS 3.19.2 +- removed obsolete patches + * mozilla-visitSubstr.patch + * mozilla-undef-CONST.patch + * mozilla-reintroduce-pixman-code-path.patch + * mozilla-fix-prototype.patch + * mozilla-disable-JEMALLOC_STATIC_SIZES-on-ppc.patch +- renamed mozilla-add-D_GLIBCXX_USE_CXX11_ABI-0-to-CXXFLAG.patch + to mozilla-add-glibcxx_use_cxx11_abi.patch (sync with Firefox) +- dropped mozilla-prefer_plugin_pref.patch as this feature is + likely not worth maintaining further + +------------------------------------------------------------------- +Sat Jun 27 08:13:54 UTC 2015 - antoine.belvire@laposte.net + +- Fix compilation issues: + * Add mozilla-add-D_GLIBCXX_USE_CXX11_ABI-0-to-CXXFLAG.patch (bmo#1153109) + * Add mozilla-reintroduce-pixman-code-path.patch (bmo#1136958) + * Add mozilla-visitSubstr.patch (bmo#1108834) + * Add mozilla-undef-CONST.patch (bmo#1111395) + * Add mozilla-disable-JEMALLOC_STATIC_SIZES-on-ppc.patch + +------------------------------------------------------------------- +Sun Mar 22 09:11:17 UTC 2015 - wr@rosenauer.org + +- update to SeaMonkey 2.33.1 (bnc#923534) + * MFSA 2015-28/CVE-2015-0818 (bmo#1144988) + Privilege escalation through SVG navigation + * MFSA 2015-29/CVE-2015-0817 (bmo#1145255) + Code execution through incorrect JavaScript bounds checking + elimination + +------------------------------------------------------------------- +Mon Mar 16 08:48:08 UTC 2015 - wr@rosenauer.org + +- update to SeaMonkey 2.33 (bnc#917597) + * MFSA 2015-11/CVE-2015-0835/CVE-2015-0836 + Miscellaneous memory safety hazards + * MFSA 2015-12/CVE-2015-0833 (bmo#945192) + Invoking Mozilla updater will load locally stored DLL files + (Windows only) + * MFSA 2015-13/CVE-2015-0832 (bmo#1065909) + Appended period to hostnames can bypass HPKP and HSTS protections + * MFSA 2015-14/CVE-2015-0830 (bmo#1110488) + Malicious WebGL content crash when writing strings + * MFSA 2015-15/CVE-2015-0834 (bmo#1098314) + TLS TURN and STUN connections silently fail to simple TCP connections + * MFSA 2015-16/CVE-2015-0831 (bmo#1130514) + Use-after-free in IndexedDB + * MFSA 2015-17/CVE-2015-0829 (bmo#1128939) + Buffer overflow in libstagefright during MP4 video playback + * MFSA 2015-18/CVE-2015-0828 (bmo#1030667, bmo#988675) + Double-free when using non-default memory allocators with a + zero-length XHR + * MFSA 2015-19/CVE-2015-0827 (bmo#1117304) + Out-of-bounds read and write while rendering SVG content + * MFSA 2015-20/CVE-2015-0826 (bmo#1092363) + Buffer overflow during CSS restyling + * MFSA 2015-21/CVE-2015-0825 (bmo#1092370) + Buffer underflow during MP3 playback + * MFSA 2015-22/CVE-2015-0824 (bmo#1095925) + Crash using DrawTarget in Cairo graphics library + * MFSA 2015-23/CVE-2015-0823 (bmo#1098497) + Use-after-free in Developer Console date with OpenType Sanitiser + * MFSA 2015-24/CVE-2015-0822 (bmo#1110557) + Reading of local files through manipulation of form autocomplete + * MFSA 2015-25/CVE-2015-0821 (bmo#1111960) + Local files or privileged URLs in pages can be opened into new tabs + * MFSA 2015-26/CVE-2015-0819 (bmo#1079554) + UI Tour whitelisted sites in background tab can spoof foreground + tabs + * MFSA 2015-27CVE-2015-0820 (bmo#1125398) + Caja Compiler JavaScript sandbox bypass +- rebased patches +- requires NSS 3.17.4 +- removed obsolete seamonkey-fix-signed-char.patch +- mozilla-xremote-client was removed upstream + +------------------------------------------------------------------- +Sat Feb 7 09:52:07 UTC 2015 - wr@rosenauer.org + +- update to SeaMonkey 2.32.1 + * fixed MailNews feeds not updating + * fixed selected profile in Profile Manager not remembered + * fixed opening a bookmark folder in tabs on Linux + * fixed Troubleshooting Information (about:support) with the + Modern theme + +------------------------------------------------------------------- +Sat Jan 17 17:59:50 UTC 2015 - wr@rosenauer.org + +- update to SeaMonkey 2.32 (bnc#910669) + * MFSA 2015-01/CVE-2014-8634/CVE-2014-8635 + Miscellaneous memory safety hazards + * MFSA 2015-02/CVE-2014-8637 (bmo#1094536) + Uninitialized memory use during bitmap rendering + * MFSA 2015-03/CVE-2014-8638 (bmo#1080987) + sendBeacon requests lack an Origin header + * MFSA 2015-04/CVE-2014-8639 (bmo#1095859) + Cookie injection through Proxy Authenticate responses + * MFSA 2015-05/CVE-2014-8640 (bmo#1100409) + Read of uninitialized memory in Web Audio + * MFSA 2015-06/CVE-2014-8641 (bmo#1108455) + Read-after-free in WebRTC + * MFSA 2015-07/CVE-2014-8643 (bmo#1114170) (Windows-only) + Gecko Media Plugin sandbox escape + * MFSA 2015-08/CVE-2014-8642 (bmo#1079658) + Delegated OCSP responder certificates failure with + id-pkix-ocsp-nocheck extension + * MFSA 2015-09/CVE-2014-8636 (bmo#987794) + XrayWrapper bypass through DOM objects +- rebased patches +- removed obsolete mozilla-seamonkey-sdk.patch +- added mozilla-openaes-decl.patch to fix implicit declarations + +------------------------------------------------------------------- +Thu Jan 1 22:53:33 UTC 2015 - wr@rosenauer.org + +- use GStreamer 1.0 from 13.2 on +- removed package support for distributions older than 12.3 + * removed mozilla-sle11.patch + +------------------------------------------------------------------- +Mon Dec 8 10:49:06 UTC 2014 - meissner@suse.com + +- seamonkey-fix-signed-char.patch: fix build on platforms + where char is unsigned (power/arm). (bmo#1085151) +- mozilla-fix-prototype.patch: add string.h includes + for memcpy prototype (as used on bigendian architectures). + +------------------------------------------------------------------- +Thu Dec 4 23:52:37 UTC 2014 - pcerny@suse.com + +- enable some extensions using the addons sdk (e.g. Ghostery) + (mozilla-seamonkey-sdk.patch) (bmo#1071048) + +------------------------------------------------------------------- +Wed Dec 3 06:53:08 UTC 2014 - wr@rosenauer.org + +- update to SeaMonkey 2.31 (bnc#908009) + * requires NSS 3.17.2 + * MFSA 2014-83/CVE-2014-1587/CVE-2014-1588 + Miscellaneous memory safety hazards + * MFSA 2014-84/CVE-2014-1589 (bmo#1043787) + XBL bindings accessible via improper CSS declarations + * MFSA 2014-85/CVE-2014-1590 (bmo#1087633) + XMLHttpRequest crashes with some input streams + * MFSA 2014-86/CVE-2014-1591 (bmo#1069762) + CSP leaks redirect data via violation reports + * MFSA 2014-87/CVE-2014-1592 (bmo#1088635) + Use-after-free during HTML5 parsing + * MFSA 2014-88/CVE-2014-1593 (bmo#1085175) + Buffer overflow while parsing media content + * MFSA 2014-89/CVE-2014-1594 (bmo#1074280) + Bad casting from the BasicThebesLayer to BasicContainerLayer +- rebased patches + +------------------------------------------------------------------- +Fri Nov 21 10:43:11 UTC 2014 - wr@rosenauer.org + +- use platform specific build flags as in Firefox + (including _constraints) +- define /usr/share/myspell as additional dictionary location + and remove add-plugins.sh finally (bnc#900639) + +------------------------------------------------------------------- +Wed Nov 19 22:13:00 UTC 2014 - Led + +- fix bashisms in mozilla.sh and add-plugins.sh scripts + +------------------------------------------------------------------- +Tue Oct 14 21:06:22 UTC 2014 - wr@rosenauer.org + +- update to SeaMonkey 2.30 (bnc#900941) + * venkman debugger removed from application and therefore + obsolete package seamonkey-venkman + * MFSA 2014-74/CVE-2014-1574/CVE-2014-1575 + Miscellaneous memory safety hazards + * MFSA 2014-75/CVE-2014-1576 (bmo#1041512) + Buffer overflow during CSS manipulation + * MFSA 2014-76/CVE-2014-1577 (bmo#1012609) + Web Audio memory corruption issues with custom waveforms + * MFSA 2014-77/CVE-2014-1578 (bmo#1063327) + Out-of-bounds write with WebM video + * MFSA 2014-78/CVE-2014-1580 (bmo#1063733) + Further uninitialized memory use during GIF rendering + * MFSA 2014-79/CVE-2014-1581 (bmo#1068218) + Use-after-free interacting with text directionality + * MFSA 2014-80/CVE-2014-1582/CVE-2014-1584 (bmo#1049095, bmo#1066190) + Key pinning bypasses + * MFSA 2014-81/CVE-2014-1585/CVE-2014-1586 (bmo#1062876, bmo#1062981) + Inconsistent video sharing within iframe + * MFSA 2014-82/CVE-2014-1583 (bmo#1015540) + Accessing cross-origin objects via the Alarms API + (only relevant for installed web apps) +- requires NSPR 4.10.7 +- requires NSS 3.17.1 +- removed obsolete patches: + * mozilla-ppc.patch + * mozilla-libproxy-compat.patch + +------------------------------------------------------------------- +Sat Sep 20 14:53:01 UTC 2014 - wr@rosenauer.org + +- update to SeaMonkey 2.29 (bnc#894370) + * based on Gecko 32.0 including all security fixes outlined here + https://www.mozilla.org/security/known-vulnerabilities/ + * removed obsolete patches + mozilla-aarch64-bmo-810631.patch, mozilla-aarch64-bmo-962488.patch, + mozilla-aarch64-bmo-963023.patch, mozilla-aarch64-bmo-963024.patch, + mozilla-aarch64-bmo-963027.patch + mozilla-ppc64le-build.patch, mozilla-ppc64le-javascript.patch, + mozilla-ppc64le-libffi.patch, mozilla-ppc64le-mfbt.patch, + mozilla-ppc64le-webrtc.patch, mozilla-ppc64le-xpcom.patch + * rebased patches +- requires NSS 3.16.4 +- build with --disable-optimize for 13.1 and above for i586 to + workaround miscompilations (bnc#896624) + +------------------------------------------------------------------- +Mon Jun 16 09:04:38 UTC 2014 - wr@rosenauer.org + +- update to SeaMonkey 2.26.1 (bnc#881874) + * MFSA 2014-48/CVE-2014-1533/CVE-2014-1534 + (bmo#921622, bmo#967354, bmo#969517, bmo#969549, bmo#973874, + bmo#978652, bmo#978811, bmo#988719, bmo#990868, bmo#991981, + bmo#992274, bmo#994907, bmo#995679, bmo#995816, bmo#995817, + bmo#996536, bmo#996715, bmo#999651, bmo#1000598, + bmo#1000960, bmo#1002340, bmo#1005578, bmo#1007223, + bmo#1009952, bmo#1011007) + Miscellaneous memory safety hazards (rv:30.0) + * MFSA 2014-49/CVE-2014-1536/CVE-2014-1537/CVE-2014-1538 + (bmo#989994, bmo#999274, bmo#1005584) + Use-after-free and out of bounds issues found using Address + Sanitizer + * MFSA 2014-50/CVE-2014-1539 (bmo#995603) + Clickjacking through cursor invisability after Flash interaction + * MFSA 2014-51/CVE-2014-1540 (bmo#978862) + Use-after-free in Event Listener Manager + * MFSA 2014-52/CVE-2014-1541 (bmo#1000185) + Use-after-free with SMIL Animation Controller + * MFSA 2014-53/CVE-2014-1542 (bmo#991533) + Buffer overflow in Web Audio Speex resampler + * MFSA 2014-54/CVE-2014-1543 (bmo#1011859) + Buffer overflow in Gamepad API + * MFSA 2014-55/CVE-2014-1545 (bmo#1018783) + Out of bounds write in NSPR +- requires NSPR 4.10.6 +- build require makeinfo + +------------------------------------------------------------------- +Tue May 13 09:05:18 UTC 2014 - wr@rosenauer.org + +- fix translations packaging (bnc#877263) + +------------------------------------------------------------------- +Tue Apr 29 06:43:16 UTC 2014 - wr@rosenauer.org + +- update to SeaMonkey 2.26 (bnc#875378) + * MFSA 2014-34/CVE-2014-1518/CVE-2014-1519 + Miscellaneous memory safety hazards + * MFSA 2014-36/CVE-2014-1522 (bmo#995289) + Web Audio memory corruption issues + * MFSA 2014-37/CVE-2014-1523 (bmo#969226) + Out of bounds read while decoding JPG images + * MFSA 2014-38/CVE-2014-1524 (bmo#989183) + Buffer overflow when using non-XBL object as XBL + * MFSA 2014-39/CVE-2014-1525 (bmo#989210) + Use-after-free in the Text Track Manager for HTML video + * MFSA 2014-41/CVE-2014-1528 (bmo#963962) + Out-of-bounds write in Cairo + * MFSA 2014-42/CVE-2014-1529 (bmo#987003) + Privilege escalation through Web Notification API + * MFSA 2014-43/CVE-2014-1530 (bmo#895557) + Cross-site scripting (XSS) using history navigations + * MFSA 2014-44/CVE-2014-1531 (bmo#987140) + Use-after-free in imgLoader while resizing images + * MFSA 2014-45/CVE-2014-1492 (bmo#903885) + Incorrect IDNA domain name matching for wildcard certificates + (fixed by NSS 3.16) + * MFSA 2014-46/CVE-2014-1532 (bmo#966006) + Use-after-free in nsHostResolver + * MFSA 2014-47/CVE-2014-1526 (bmo#988106) + Debugger can bypass XrayWrappers with JavaScript +- rebased patches +- added aarch64 porting patches + * mozilla-aarch64-bmo-810631.patch + * mozilla-aarch64-bmo-962488.patch + * mozilla-aarch64-bmo-963023.patch + * mozilla-aarch64-bmo-963024.patch + * mozilla-aarch64-bmo-963027.patch +- requires NSPR 4.10.3 and NSS 3.16 +- added mozilla-icu-strncat.patch to fix post build checks + +------------------------------------------------------------------- +Wed Mar 19 13:31:58 UTC 2014 - wr@rosenauer.org + +- update to SeaMonkey 2.25 (bnc#868603) + * MFSA 2014-15/CVE-2014-1493/CVE-2014-1494 + Miscellaneous memory safety hazards + * MFSA 2014-17/CVE-2014-1497 (bmo#966311) + Out of bounds read during WAV file decoding + * MFSA 2014-18/CVE-2014-1498 (bmo#935618) + crypto.generateCRMFRequest does not validate type of key + * MFSA 2014-19/CVE-2014-1499 (bmo#961512) + Spoofing attack on WebRTC permission prompt + * MFSA 2014-20/CVE-2014-1500 (bmo#956524) + onbeforeunload and Javascript navigation DOS + * MFSA 2014-22/CVE-2014-1502 (bmo#972622) + WebGL content injection from one domain to rendering in another + * MFSA 2014-23/CVE-2014-1504 (bmo#911547) + Content Security Policy for data: documents not preserved by + session restore + * MFSA 2014-26/CVE-2014-1508 (bmo#963198) + Information disclosure through polygon rendering in MathML + * MFSA 2014-27/CVE-2014-1509 (bmo#966021) + Memory corruption in Cairo during PDF font rendering + * MFSA 2014-28/CVE-2014-1505 (bmo#941887) + SVG filters information disclosure through feDisplacementMap + * MFSA 2014-29/CVE-2014-1510/CVE-2014-1511 (bmo#982906, bmo#982909) + Privilege escalation using WebIDL-implemented APIs + * MFSA 2014-30/CVE-2014-1512 (bmo#982957) + Use-after-free in TypeObject + * MFSA 2014-31/CVE-2014-1513 (bmo#982974) + Out-of-bounds read/write through neutering ArrayBuffer objects + * MFSA 2014-32/CVE-2014-1514 (bmo#983344) + Out-of-bounds write through TypedArrayObject after neutering +- requires NSPR 4.10.3 and NSS 3.15.5 +- new build dependency (and recommends): + * libpulse +- update of PowerPC 64 patches (bmo#976648) (pcerny@suse.com) +- rebased patches + +------------------------------------------------------------------- +Sat Feb 8 08:21:01 UTC 2014 - wr@rosenauer.org + +- replaced locale source archive because the old one was broken + by wrong upstream tagging (bnc#862831) + +------------------------------------------------------------------- +Tue Feb 4 10:18:33 UTC 2014 - wr@rosenauer.org + +- update to SeaMonkey 2.24 (bnc#861847) + * MFSA 2014-01/CVE-2014-1477/CVE-2014-1478 + Miscellaneous memory safety hazards (rv:27.0 / rv:24.3) + * MFSA 2014-02/CVE-2014-1479 (bmo#911864) + Clone protected content with XBL scopes + * MFSA 2014-03/CVE-2014-1480 (bmo#916726) + UI selection timeout missing on download prompts + * MFSA 2014-04/CVE-2014-1482 (bmo#943803) + Incorrect use of discarded images by RasterImage + * MFSA 2014-05/CVE-2014-1483 (bmo#950427) + Information disclosure with *FromPoint on iframes + * MFSA 2014-07/CVE-2014-1485 (bmo#910139) + XSLT stylesheets treated as styles in Content Security Policy + * MFSA 2014-08/CVE-2014-1486 (bmo#942164) + Use-after-free with imgRequestProxy and image proccessing + * MFSA 2014-09/CVE-2014-1487 (bmo#947592) + Cross-origin information leak through web workers + * MFSA 2014-11/CVE-2014-1488 (bmo#950604) + Crash when using web workers with asm.js + * MFSA 2014-12/CVE-2014-1490/CVE-2014-1491 + (bmo#934545, bmo#930874, bmo#930857) + NSS ticket handling issues + * MFSA 2014-13/CVE-2014-1481(bmo#936056) + Inconsistent JavaScript handling of access to Window objects +- requires NSS 3.15.4 +- removed obsolete mozilla-bug929439.patch + +------------------------------------------------------------------- +Fri Dec 13 21:30:38 UTC 2013 - uweigand@de.ibm.com + +- Add support for powerpc64le-linux. + * ppc64le-support.patch: general support + * libffi-ppc64le.patch: libffi backport + * xpcom-ppc64le.patch: port xpcom +- Add build fix from mainline. + * mozilla-bug929439.patch + +------------------------------------------------------------------- +Wed Dec 11 11:13:16 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.23 (bnc#854367, bnc#854370)) + * requires NSPR 4.10.2 and NSS 3.15.3.1 + * MFSA 2013-104/CVE-2013-5609/CVE-2013-5610 + Miscellaneous memory safety hazards + * MFSA 2013-105/CVE-2013-5611 (bmo#771294) + Application Installation doorhanger persists on navigation + * MFSA 2013-106/CVE-2013-5612 (bmo#871161) + Character encoding cross-origin XSS attack + * MFSA 2013-107/CVE-2013-5614 (bmo#886262) + Sandbox restrictions not applied to nested object elements + * MFSA 2013-108/CVE-2013-5616 (bmo#938341) + Use-after-free in event listeners + * MFSA 2013-109/CVE-2013-5618 (bmo#926361) + Use-after-free during Table Editing + * MFSA 2013-110/CVE-2013-5619 (bmo#917841) + Potential overflow in JavaScript binary search algorithms + * MFSA 2013-111/CVE-2013-6671 (bmo#930281) + Segmentation violation when replacing ordered list elements + * MFSA 2013-112/CVE-2013-6672 (bmo#894736) + Linux clipboard information disclosure though selection paste + * MFSA 2013-113/CVE-2013-6673 (bmo#970380) + Trust settings for built-in roots ignored during EV certificate + validation + * MFSA 2013-114/CVE-2013-5613 (bmo#930381, bmo#932449) + Use-after-free in synthetic mouse movement + * MFSA 2013-115/CVE-2013-5615 (bmo#929261) + GetElementIC typed array stubs can be generated outside observed + typesets + * MFSA 2013-116/CVE-2013-6629/CVE-2013-6630 (bmo#891693) + JPEG information leak + * MFSA 2013-117 (bmo#946351) + Mis-issued ANSSI/DCSSI certificate + (fixed via NSS 3.15.3.1) +- rebased patches: + * mozilla-nongnome-proxies.patch + * mozilla-shared-nss-db.patch + +------------------------------------------------------------------- +Wed Oct 30 18:07:33 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.22 (bnc#847708) + * rebased patches + * requires NSS 3.15.2 or higher + * MFSA 2013-93/CVE-2013-5590/CVE-2013-5591/CVE-2013-5592 + Miscellaneous memory safety hazards + * MFSA 2013-94/CVE-2013-5593 (bmo#868327) + Spoofing addressbar through SELECT element + * MFSA 2013-95/CVE-2013-5604 (bmo#914017) + Access violation with XSLT and uninitialized data + * MFSA 2013-96/CVE-2013-5595 (bmo#916580) + Improperly initialized memory and overflows in some JavaScript + functions + * MFSA 2013-97/CVE-2013-5596 (bmo#910881) + Writing to cycle collected object during image decoding + * MFSA 2013-98/CVE-2013-5597 (bmo#918864) + Use-after-free when updating offline cache + * MFSA 2013-99/CVE-2013-5598 (bmo#920515) + Security bypass of PDF.js checks using iframes + * MFSA 2013-100/CVE-2013-5599/CVE-2013-5600/CVE-2013-5601 + (bmo#915210, bmo#915576, bmo#916685) + Miscellaneous use-after-free issues found through ASAN fuzzing + * MFSA 2013-101/CVE-2013-5602 (bmo#897678) + Memory corruption in workers + * MFSA 2013-102/CVE-2013-5603 (bmo#916404) + Use-after-free in HTML document templates + +------------------------------------------------------------------- +Tue Sep 17 15:51:02 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.21 (bnc#840485) + * MFSA 2013-76/CVE-2013-1718/CVE-2013-1719 + Miscellaneous memory safety hazards + * MFSA 2013-77/CVE-2013-1720 (bmo#888820) + Improper state in HTML5 Tree Builder with templates + * MFSA 2013-78/CVE-2013-1721 (bmo#890277) + Integer overflow in ANGLE library + * MFSA 2013-79/CVE-2013-1722 (bmo#893308) + Use-after-free in Animation Manager during stylesheet cloning + * MFSA 2013-80/CVE-2013-1723 (bmo#891292) + NativeKey continues handling key messages after widget is destroyed + * MFSA 2013-81/CVE-2013-1724 (bmo#894137) + Use-after-free with select element + * MFSA 2013-82/CVE-2013-1725 (bmo#876762) + Calling scope for new Javascript objects can lead to memory corruption + * MFSA 2013-85/CVE-2013-1728 (bmo#883686) + Uninitialized data in IonMonkey + * MFSA 2013-88/CVE-2013-1730 (bmo#851353) + Compartment mismatch re-attaching XBL-backed nodes + * MFSA 2013-89/CVE-2013-1732 (bmo#883514) + Buffer overflow with multi-column, lists, and floats + * MFSA 2013-90/CVE-2013-1735/CVE-2013-1736 (bmo#898871, bmo#906301) + Memory corruption involving scrolling + * MFSA 2013-91/CVE-2013-1737 (bmo#907727) + User-defined properties on DOM proxies get the wrong "this" object + * MFSA 2013-92/CVE-2013-1738 (bmo#887334, bmo#882897) + GC hazard with default compartments and frame chain restoration +- requires NSS 3.15.1 + +------------------------------------------------------------------- +Mon Aug 5 17:26:03 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.20 (bnc#833389) + * MFSA 2013-63/CVE-2013-1701/CVE-2013-1702 + Miscellaneous memory safety hazards + * MFSA 2013-64/CVE-2013-1704 (bmo#883313) + Use after free mutating DOM during SetBody + * MFSA 2013-65/CVE-2013-1705 (bmo#882865) + Buffer underflow when generating CRMF requests + * MFSA 2013-67/CVE-2013-1708 (bmo#879924) + Crash during WAV audio file decoding + * MFSA 2013-68/CVE-2013-1709 (bmo#838253) + Document URI misrepresentation and masquerading + * MFSA 2013-69/CVE-2013-1710 (bmo#871368) + CRMF requests allow for code execution and XSS attacks + * MFSA 2013-70/CVE-2013-1711 (bmo#843829) + Bypass of XrayWrappers using XBL Scopes + * MFSA 2013-72/CVE-2013-1713 (bmo#887098) + Wrong principal used for validating URI for some Javascript + components + * MFSA 2013-73/CVE-2013-1714 (bmo#879787) + Same-origin bypass with web workers and XMLHttpRequest + * MFSA 2013-75/CVE-2013-1717 (bmo#406541, bmo#738397) + Local Java applets may read contents of local file system +- requires NSPR 4.10 and NSS 3.15 +- removed obsolete seamonkey-shared-nss-db.patch + +------------------------------------------------------------------- +Sat Jun 29 14:22:45 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.19 (bnc#825935) + * removed obsolete patches + + mozilla-gstreamer-760140.patch + * GStreamer support does not build on 12.1 anymore (build only + on 12.2 and later) + * MFSA 2013-49/CVE-2013-1682/CVE-2013-1683 + Miscellaneous memory safety hazards + * MFSA 2013-50/CVE-2013-1684/CVE-2013-1685/CVE-2013-1686 + Memory corruption found using Address Sanitizer + * MFSA 2013-51/CVE-2013-1687 (bmo#863933, bmo#866823) + Privileged content access and execution via XBL + * MFSA 2013-52/CVE-2013-1688 (bmo#873966) + Arbitrary code execution within Profiler + * MFSA 2013-53/CVE-2013-1690 (bmo#857883) + Execution of unmapped memory through onreadystatechange event + * MFSA 2013-54/CVE-2013-1692 (bmo#866915) + Data in the body of XHR HEAD requests leads to CSRF attacks + * MFSA 2013-55/CVE-2013-1693 (bmo#711043) + SVG filters can lead to information disclosure + * MFSA 2013-56/CVE-2013-1694 (bmo#848535) + PreserveWrapper has inconsistent behavior + * MFSA 2013-57/CVE-2013-1695 (bmo#849791) + Sandbox restrictions not applied to nested frame elements + * MFSA 2013-58/CVE-2013-1696 (bmo#761667) + X-Frame-Options ignored when using server push with multi-part + responses + * MFSA 2013-59/CVE-2013-1697 (bmo#858101) + XrayWrappers can be bypassed to run user defined methods in a + privileged context + * MFSA 2013-60/CVE-2013-1698 (bmo#876044) + getUserMedia permission dialog incorrectly displays location + * MFSA 2013-61/CVE-2013-1699 (bmo#840882) + Homograph domain spoofing in .com, .net and .name + +------------------------------------------------------------------- +Tue May 28 20:52:21 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.17.1 + +------------------------------------------------------------------- +Tue Apr 9 06:45:05 UTC 2013 - wr@rosenauer.org + +- revert to use GStreamer 0.10 on 12.3 (bnc#814101) + +------------------------------------------------------------------- +Tue Apr 2 14:18:30 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.17 (bnc#813026) + * requires NSPR 4.9.5 and NSS 3.14.3 + * mozilla-webrtc-ppc.patch included upstream + * MFSA 2013-30/CVE-2013-0788/CVE-2013-0789 + Miscellaneous memory safety hazards + * MFSA 2013-31/CVE-2013-0800 (bmo#825721) + Out-of-bounds write in Cairo library + * MFSA 2013-35/CVE-2013-0796 (bmo#827106) + WebGL crash with Mesa graphics driver on Linux + * MFSA 2013-36/CVE-2013-0795 (bmo#825697) + Bypass of SOW protections allows cloning of protected nodes + * MFSA 2013-37/CVE-2013-0794 (bmo#626775) + Bypass of tab-modal dialog origin disclosure + * MFSA 2013-38/CVE-2013-0793 (bmo#803870) + Cross-site scripting (XSS) using timed history navigations + * MFSA 2013-39/CVE-2013-0792 (bmo#722831) + Memory corruption while rendering grayscale PNG images +- use GStreamer 1.0 starting with 12.3 (mozilla-gstreamer-1.patch) + +------------------------------------------------------------------- +Fri Mar 15 17:34:54 UTC 2013 - pcerny@suse.com + +- update to SeaMonkey 2.16.2 + +------------------------------------------------------------------- +Sat Mar 9 09:15:53 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.16.1 (bnc#808243) + * MFSA 2013-29/CVE-2013-0787 (bmo#848644) + Use-after-free in HTML Editor + +------------------------------------------------------------------- +Mon Feb 18 07:41:44 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.16 (bnc#804248) + * MFSA 2013-21/CVE-2013-0783/2013-0784 + Miscellaneous memory safety hazards + * MFSA 2013-22/CVE-2013-0772 (bmo#801366) + Out-of-bounds read in image rendering + * MFSA 2013-23/CVE-2013-0765 (bmo#830614) + Wrapped WebIDL objects can be wrapped again + * MFSA 2013-24/CVE-2013-0773 (bmo#809652) + Web content bypass of COW and SOW security wrappers + * MFSA 2013-25/CVE-2013-0774 (bmo#827193) + Privacy leak in JavaScript Workers + * MFSA 2013-26/CVE-2013-0775 (bmo#831095) + Use-after-free in nsImageLoadingContent + * MFSA 2013-27/CVE-2013-0776 (bmo#796475) + Phishing on HTTPS connection through malicious proxy + * MFSA 2013-28/CVE-2013-0780/CVE-2013-0782/CVE-2013-0777/ + CVE-2013-0778/CVE-2013-0779/CVE-2013-0781 + Use-after-free, out of bounds read, and buffer overflow issues + found using Address Sanitizer +- removed obsolete patches + * mozilla-webrtc.patch + * mozilla-gstreamer-803287.patch + +------------------------------------------------------------------- +Mon Feb 4 12:27:38 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.15.2 + * Applications could not be removed from the "Application details" + dialog under Preferences, Helper Applications (bmo#826771). + * View / Message Body As could show menu items out of context + (bmo#831348) + +------------------------------------------------------------------- +Sun Jan 20 09:15:53 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.15.1 + * backed out bmo#677092 (removed patch) + * fixed problems involving HTTP proxy transactions + +------------------------------------------------------------------- +Sun Jan 13 16:38:35 UTC 2013 - wr@rosenauer.org + +- backed out restartless language packs as it broke multi-locale + setup (bmo#677092, bmo#818468) + +------------------------------------------------------------------- +Tue Jan 8 18:32:43 UTC 2013 - wr@rosenauer.org + +- update to SeaMonkey 2.15 (bnc#796895) + * MFSA 2013-01/CVE-2013-0749/CVE-2013-0769/CVE-2013-0770 + Miscellaneous memory safety hazards + * MFSA 2013-02/CVE-2013-0760/CVE-2013-0762/CVE-2013-0766/CVE-2013-0767 + CVE-2013-0761/CVE-2013-0763/CVE-2013-0771/CVE-2012-5829 + Use-after-free and buffer overflow issues found using Address Sanitizer + * MFSA 2013-03/CVE-2013-0768 (bmo#815795) + Buffer Overflow in Canvas + * MFSA 2013-04/CVE-2012-0759 (bmo#802026) + URL spoofing in addressbar during page loads + * MFSA 2013-05/CVE-2013-0744 (bmo#814713) + Use-after-free when displaying table with many columns and column groups + * MFSA 2013-06/CVE-2013-0751 (bmo#790454) + Touch events are shared across iframes + * MFSA 2013-07/CVE-2013-0764 (bmo#804237) + Crash due to handling of SSL on threads + * MFSA 2013-08/CVE-2013-0745 (bmo#794158) + AutoWrapperChanger fails to keep objects alive during garbage collection + * MFSA 2013-09/CVE-2013-0746 (bmo#816842) + Compartment mismatch with quickstubs returned values + * MFSA 2013-10/CVE-2013-0747 (bmo#733305) + Event manipulation in plugin handler to bypass same-origin policy + * MFSA 2013-11/CVE-2013-0748 (bmo#806031) + Address space layout leaked in XBL objects + * MFSA 2013-12/CVE-2013-0750 (bmo#805121) + Buffer overflow in Javascript string concatenation + * MFSA 2013-13/CVE-2013-0752 (bmo#805024) + Memory corruption in XBL with XML bindings containing SVG + * MFSA 2013-14/CVE-2013-0757 (bmo#813901) + Chrome Object Wrapper (COW) bypass through changing prototype + * MFSA 2013-15/CVE-2013-0758 (bmo#813906) + Privilege escalation through plugin objects + * MFSA 2013-16/CVE-2013-0753 (bmo#814001) + Use-after-free in serializeToStream + * MFSA 2013-17/CVE-2013-0754 (bmo#814026) + Use-after-free in ListenerManager + * MFSA 2013-18/CVE-2013-0755 (bmo#814027) + Use-after-free in Vibrate + * MFSA 2013-19/CVE-2013-0756 (bmo#814029) + Use-after-free in Javascript Proxy objects +- requires NSS 3.14.1 (MFSA 2013-20, CVE-2013-0743) +- reenable WebRTC +- added mozilla-libproxy-compat.patch for libproxy API compat + on openSUSE 11.2 and earlier + +------------------------------------------------------------------- +Tue Dec 18 13:08:40 UTC 2012 - wr@rosenauer.org + +- update to SeaMonkey 2.14.1 + * fix regressions from 2.14 release + +------------------------------------------------------------------- +Tue Nov 20 20:44:06 UTC 2012 - wr@rosenauer.org + +- update to SeaMonkey 2.14 (bnc#790140) + * MFSA 2012-91/CVE-2012-5842/CVE-2012-5843 + Miscellaneous memory safety hazards + * MFSA 2012-92/CVE-2012-4202 (bmo#758200) + Buffer overflow while rendering GIF images + * MFSA 2012-93/CVE-2012-4201 (bmo#747607) + evalInSanbox location context incorrectly applied + * MFSA 2012-94/CVE-2012-5836 (bmo#792857) + Crash when combining SVG text on path with CSS + * MFSA 2012-96/CVE-2012-4204 (bmo#778603) + Memory corruption in str_unescape + * MFSA 2012-97/CVE-2012-4205 (bmo#779821) + XMLHttpRequest inherits incorrect principal within sandbox + * MFSA 2012-99/CVE-2012-4208 (bmo#798264) + XrayWrappers exposes chrome-only properties when not in chrome + compartment + * MFSA 2012-100/CVE-2012-5841 (bmo#805807) + Improper security filtering for cross-origin wrappers + * MFSA 2012-101/CVE-2012-4207 (bmo#801681) + Improper character decoding in HZ-GB-2312 charset + * MFSA 2012-103/CVE-2012-4209 (bmo#792405) + Frames can shadow top.location + * MFSA 2012-105/CVE-2012-4214/CVE-2012-4215/CVE-2012-4216/ + CVE-2012-5829/CVE-2012-5839/CVE-2012-5840/CVE-2012-4212/ + CVE-2012-4213/CVE-2012-4217/CVE-2012-4218 + Use-after-free and buffer overflow issues found using Address + Sanitizer + * MFSA 2012-106/CVE-2012-5830/CVE-2012-5833/CVE-2012-5835/CVE-2012-5838 + Use-after-free, buffer overflow, and memory corruption issues + found using Address Sanitizer +- rebased patches +- disabled WebRTC since build is broken (bmo#776877) + +------------------------------------------------------------------- +Sat Oct 27 08:59:58 UTC 2012 - wr@rosenauer.org + +- update to SeaMonkey 2.13.2 (bnc#786522) + * MFSA 2012-90/CVE-2012-4194/CVE-2012-4195/CVE-2012-4196 + (bmo#800666, bmo#793121, bmo#802557) + Fixes for Location object issues + +------------------------------------------------------------------- +Fri Oct 12 07:33:18 UTC 2012 - wr@rosenauer.org + +- update to SeaMonkey 2.13.1 (bnc#783533) + * MFSA 2012-88/CVE-2012-4191 (bmo#798045) + Miscellaneous memory safety hazards + * MFSA 2012-89/CVE-2012-4192/CVE-2012-4193 (bmo#799952, bmo#720619) + defaultValue security checks not applied + +------------------------------------------------------------------- +Mon Oct 8 20:32:50 UTC 2012 - wr@rosenauer.org + +- update to SeaMonkey 2.13 (bnc#783533) + * MFSA 2012-74/CVE-2012-3982/CVE-2012-3983 + Miscellaneous memory safety hazards + * MFSA 2012-75/CVE-2012-3984 (bmo#575294) + select element persistance allows for attacks + * MFSA 2012-76/CVE-2012-3985 (bmo#655649) + Continued access to initial origin after setting document.domain + * MFSA 2012-77/CVE-2012-3986 (bmo#775868) + Some DOMWindowUtils methods bypass security checks + * MFSA 2012-79/CVE-2012-3988 (bmo#725770) + DOS and crash with full screen and history navigation + * MFSA 2012-80/CVE-2012-3989 (bmo#783867) + Crash with invalid cast when using instanceof operator + * MFSA 2012-81/CVE-2012-3991 (bmo#783260) + GetProperty function can bypass security checks + * MFSA 2012-82/CVE-2012-3994 (bmo#765527) + top object and location property accessible by plugins + * MFSA 2012-83/CVE-2012-3993/CVE-2012-4184 (bmo#768101, bmo#780370) + Chrome Object Wrapper (COW) does not disallow acces to privileged + functions or properties + * MFSA 2012-84/CVE-2012-3992 (bmo#775009) + Spoofing and script injection through location.hash + * MFSA 2012-85/CVE-2012-3995/CVE-2012-4179/CVE-2012-4180/ + CVE-2012-4181/CVE-2012-4182/CVE-2012-4183 + Use-after-free, buffer overflow, and out of bounds read issues + found using Address Sanitizer + * MFSA 2012-86/CVE-2012-4185/CVE-2012-4186/CVE-2012-4187/ + CVE-2012-4188 + Heap memory corruption issues found using Address Sanitizer + * MFSA 2012-87/CVE-2012-3990 (bmo#787704) + Use-after-free in the IME State Manager +- requires NSPR 4.9.2 +- improve GStreamer integration (bmo#760140) + +------------------------------------------------------------------- +Mon Sep 10 20:18:35 UTC 2012 - wr@rosenauer.org + +- update to SeaMonkey 2.12.1 (bnc#779936) + * Sites visited while in Private Browsing mode could be found + through manual browser cache inspection (bmo#787743) + +------------------------------------------------------------------- +Mon Aug 27 12:26:38 UTC 2012 - wr@rosenauer.org + +- update to SeaMonkey 2.12 (bnc#777588) + * MFSA 2012-57/CVE-2012-1970 + Miscellaneous memory safety hazards + * MFSA 2012-58/CVE-2012-1972/CVE-2012-1973/CVE-2012-1974/CVE-2012-1975 + CVE-2012-1976/CVE-2012-3956/CVE-2012-3957/CVE-2012-3958/CVE-2012-3959 + CVE-2012-3960/CVE-2012-3961/CVE-2012-3962/CVE-2012-3963/CVE-2012-3964 + Use-after-free issues found using Address Sanitizer + * MFSA 2012-59/CVE-2012-1956 (bmo#756719) + Location object can be shadowed using Object.defineProperty + * MFSA 2012-61/CVE-2012-3966 (bmo#775794, bmo#775793) + Memory corruption with bitmap format images with negative height + * MFSA 2012-62/CVE-2012-3967/CVE-2012-3968 + WebGL use-after-free and memory corruption + * MFSA 2012-63/CVE-2012-3969/CVE-2012-3970 + SVG buffer overflow and use-after-free issues + * MFSA 2012-64/CVE-2012-3971 + Graphite 2 memory corruption + * MFSA 2012-65/CVE-2012-3972 (bmo#746855) + Out-of-bounds read in format-number in XSLT + * MFSA 2012-68/CVE-2012-3975 (bmo#770684) + DOMParser loads linked resources in extensions when parsing + text/html + * MFSA 2012-69/CVE-2012-3976 (bmo#768568) + Incorrect site SSL certificate data display + * MFSA 2012-70/CVE-2012-3978 (bmo#770429) + Location object security checks bypassed by chrome code +- enable GStreamer for 12.1 and higher +- use internal libjpeg + +------------------------------------------------------------------- +Sun Jul 29 16:59:17 UTC 2012 - wr@rosenauer.org + +- import PPC patch from Firefox: + * add patches for bmo#750620 and bmo#746112 + * fix xpcshell segfault on ppc + +------------------------------------------------------------------- +Mon Jul 16 09:35:54 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.11 (bnc#771583) + * MFSA 2012-42/CVE-2012-1949/CVE-2012-1948 + Miscellaneous memory safety hazards + * MFSA 2012-44/CVE-2012-1951/CVE-2012-1954/CVE-2012-1953/CVE-2012-1952 + Gecko memory corruption + * MFSA 2012-45/CVE-2012-1955 (bmo#757376) + Spoofing issue with location + * MFSA 2012-47/CVE-2012-1957 (bmo#750096) + Improper filtering of javascript in HTML feed-view + * MFSA 2012-48/CVE-2012-1958 (bmo#750820) + use-after-free in nsGlobalWindow::PageHidden + * MFSA 2012-49/CVE-2012-1959 (bmo#754044, bmo#737559) + Same-compartment Security Wrappers can be bypassed + * MFSA 2012-50/CVE-2012-1960 (bmo#761014) + Out of bounds read in QCMS + * MFSA 2012-51/CVE-2012-1961 (bmo#761655) + X-Frame-Options header ignored when duplicated + * MFSA 2012-52/CVE-2012-1962 (bmo#764296) + JSDependentString::undepend string conversion results in memory + corruption + * MFSA 2012-53/CVE-2012-1963 (bmo#767778) + Content Security Policy 1.0 implementation errors cause data + leakage + * MFSA 2012-56/CVE-2012-1967 (bmo#758344) + Code execution through javascript: URLs + * relicensed to MPL-2.0 +- updated/removed patches +- requires NSS 3.13.5 + +------------------------------------------------------------------- +Fri Jun 15 07:50:18 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.10.1 + +------------------------------------------------------------------- +Mon Jun 4 06:03:00 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.10 (bnc#765204) + * MFSA 2012-34/CVE-2012-1938/CVE-2012-1937/CVE-2011-3101 + Miscellaneous memory safety hazards + * MFSA 2012-36/CVE-2012-1944 (bmo#751422) + Content Security Policy inline-script bypass + * MFSA 2012-37/CVE-2012-1945 (bmo#670514) + Information disclosure though Windows file shares and shortcut + files + * MFSA 2012-38/CVE-2012-1946 (bmo#750109) + Use-after-free while replacing/inserting a node in a document + * MFSA 2012-40/CVE-2012-1947/CVE-2012-1940/CVE-2012-1941 + Buffer overflow and use-after-free issues found using Address + Sanitizer +- requires NSS 3.13.4 + * MFSA 2012-39/CVE-2012-0441 (bmo#715073) + +------------------------------------------------------------------- +Mon Apr 30 07:30:14 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.9.1 + * fix regressions + - POP3 filters (bmo#748090) + - Message Body not loaded when using "Fetch Headers Only" + (bmo#748865) + - Received messages contain parts of other messages with + movemail account (bmo#748726) + - New mail notification issue (bmo#748997) + - crash in nsMsgDatabase::MatchDbName (bmo#748432) + +------------------------------------------------------------------- +Fri Apr 27 10:21:24 UTC 2012 - wr@rosenauer.org + +- fixed build with gcc 4.7 + +------------------------------------------------------------------- +Mon Apr 23 14:28:50 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.9 (bnc#758408) + * MFSA 2012-20/CVE-2012-0467/CVE-2012-0468 + Miscellaneous memory safety hazards + * MFSA 2012-22/CVE-2012-0469 (bmo#738985) + use-after-free in IDBKeyRange + * MFSA 2012-23/CVE-2012-0470 (bmo#734288) + Invalid frees causes heap corruption in gfxImageSurface + * MFSA 2012-24/CVE-2012-0471 (bmo#715319) + Potential XSS via multibyte content processing errors + * MFSA 2012-25/CVE-2012-0472 (bmo#744480) + Potential memory corruption during font rendering using cairo-dwrite + * MFSA 2012-26/CVE-2012-0473 (bmo#743475) + WebGL.drawElements may read illegal video memory due to + FindMaxUshortElement error + * MFSA 2012-27/CVE-2012-0474 (bmo#687745, bmo#737307) + Page load short-circuit can lead to XSS + * MFSA 2012-28/CVE-2012-0475 (bmo#694576) + Ambiguous IPv6 in Origin headers may bypass webserver access + restrictions + * MFSA 2012-29/CVE-2012-0477 (bmo#718573) + Potential XSS through ISO-2022-KR/ISO-2022-CN decoding issues + * MFSA 2012-30/CVE-2012-0478 (bmo#727547) + Crash with WebGL content using textImage2D + * MFSA 2012-31/CVE-2011-3062 (bmo#739925) + Off-by-one error in OpenType Sanitizer + * MFSA 2012-32/CVE-2011-1187 (bmo#624621) + HTTP Redirections and remote content can be read by javascript errors + * MFSA 2012-33/CVE-2012-0479 (bmo#714631) + Potential site identity spoofing when loading RSS and Atom feeds + +------------------------------------------------------------------- +Sat Apr 21 12:29:55 UTC 2012 - wr@rosenauer.org + +- update to 2.9b4 +- added mozilla-sle11.patch and add exceptions to be able to build + for SLE11/11.1 +- exclude broken gl locale from build +- fixed build on 11.2-x86_64 by adding mozilla-revert_621446.patch +- added mozilla-gcc47.patch and mailnews-literals.patch to fix + compilation issues with recent gcc 4.7 + +------------------------------------------------------------------- +Tue Mar 13 15:19:56 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.8 (bnc#750044) + * MFSA 2012-13/CVE-2012-0455 (bmo#704354) + XSS with Drag and Drop and Javascript: URL + * MFSA 2012-14/CVE-2012-0456/CVE-2012-0457 (bmo#711653, #720103) + SVG issues found with Address Sanitizer + * MFSA 2012-15/CVE-2012-0451 (bmo#717511) + XSS with multiple Content Security Policy headers + * MFSA 2012-16/CVE-2012-0458 + Escalation of privilege with Javascript: URL as home page + * MFSA 2012-17/CVE-2012-0459 (bmo#723446) + Crash when accessing keyframe cssText after dynamic modification + * MFSA 2012-18/CVE-2012-0460 (bmo#727303) + window.fullScreen writeable by untrusted content + * MFSA 2012-19/CVE-2012-0461/CVE-2012-0462/CVE-2012-0464/ + CVE-2012-0463 + Miscellaneous memory safety hazards +- explicitely build-require X libs + +------------------------------------------------------------------- +Thu Feb 16 15:55:03 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.7.2 (bnc#747328) + * CVE-2011-3026 (bmo#727401) + libpng: integer overflow leading to heap-buffer overflow + +------------------------------------------------------------------- +Thu Feb 9 12:36:02 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.7.1 (bnc#746616) + * MFSA 2012-10/CVE-2012-0452 (bmo#724284) + use after free in nsXBLDocumentInfo::ReadPrototypeBindings +- Use YARR interpreter instead of PCRE on platforms where YARR JIT + is not supported, since PCRE doesnt build (bmo#691898) +- fix ppc64 build (bmo#703534) + +------------------------------------------------------------------- +Tue Jan 31 22:16:33 UTC 2012 - wr@rosenauer.org + +- update to Seamonkey 2.7 (bnc#744275) + * MFSA 2012-01/CVE-2012-0442/CVE-2012-0443 + Miscellaneous memory safety hazards + * MFSA 2012-03/CVE-2012-0445 (bmo#701071) +