diff --git a/ci/all.sh b/ci/all.sh
index 273562d4a..55a1fa2ef 100755
--- a/ci/all.sh
+++ b/ci/all.sh
@@ -21,7 +21,7 @@ cargo_fmt() {
 }
 
 cargo_clippy() {
-    cargo clippy --all -- -D clippy::pedantic
+    cargo clippy --all -- -D clippy::perf
 }
 
 CMD="-1"
diff --git a/examples/aobench/benches/ambient_occlusion.rs b/examples/aobench/benches/ambient_occlusion.rs
index f0cbe0366..903bd97a5 100644
--- a/examples/aobench/benches/ambient_occlusion.rs
+++ b/examples/aobench/benches/ambient_occlusion.rs
@@ -4,10 +4,10 @@
 use aobench_lib::*;
 use criterion::*;
 use intersection::Isect;
-use scene::Test;
+use aobench_lib::scene::Test;
 
 fn hit_scalar(c: &mut Criterion) {
-    let mut scene = Test::new();
+    let mut scene = Test::default();
     c.bench(
         "scalar",
         Benchmark::new("ao_hit", move |b| {
@@ -24,7 +24,7 @@ fn hit_scalar(c: &mut Criterion) {
 }
 
 fn hit_vector(c: &mut Criterion) {
-    let mut scene = Test::new();
+    let mut scene = Test::default();
 
     c.bench(
         "vector",
diff --git a/examples/aobench/benches/isec_plane.rs b/examples/aobench/benches/isec_plane.rs
index a79058701..aadff808c 100644
--- a/examples/aobench/benches/isec_plane.rs
+++ b/examples/aobench/benches/isec_plane.rs
@@ -132,7 +132,7 @@ fn hit_vector(c: &mut Criterion) {
                 assert_eq!(v.hit.all(), true);
             })
         })
-        .throughput(Throughput::Elements(f32xN::lanes() as u32)),
+        .throughput(Throughput::Elements(f32xN::lanes() as u64)),
     );
 }
 
@@ -175,7 +175,7 @@ fn miss_vector(c: &mut Criterion) {
                 assert_eq!(v.hit.any(), false);
             })
         })
-        .throughput(Throughput::Elements(f32xN::lanes() as u32)),
+        .throughput(Throughput::Elements(f32xN::lanes() as u64)),
     );
 }
 
diff --git a/examples/aobench/benches/isec_sphere.rs b/examples/aobench/benches/isec_sphere.rs
index da281a121..17f72486c 100644
--- a/examples/aobench/benches/isec_sphere.rs
+++ b/examples/aobench/benches/isec_sphere.rs
@@ -5,7 +5,6 @@ use crate::geometry::{f32xN, Ray, RayxN, Sphere, V3DxN, V3D};
 use crate::intersection::{Intersect, Isect, IsectxN};
 use aobench_lib::*;
 use criterion::*;
-use test::*;
 
 fn hit_scalar(c: &mut Criterion) {
     let mut s = Sphere {
@@ -121,7 +120,7 @@ fn hit_vector(c: &mut Criterion) {
                 assert_eq!(v.hit.all(), true);
             })
         })
-        .throughput(Throughput::Elements(f32xN::lanes() as u32)),
+        .throughput(Throughput::Elements(f32xN::lanes() as u64)),
     );
 }
 
@@ -160,7 +159,7 @@ fn miss_vector(c: &mut Criterion) {
                 assert_eq!(v.hit.any(), false);
             })
         })
-        .throughput(Throughput::Elements(f32xN::lanes() as u32)),
+        .throughput(Throughput::Elements(f32xN::lanes() as u64)),
     );
 }
 
diff --git a/examples/aobench/benches/random.rs b/examples/aobench/benches/random.rs
index 6402bc4a9..551d03594 100644
--- a/examples/aobench/benches/random.rs
+++ b/examples/aobench/benches/random.rs
@@ -27,7 +27,7 @@ fn random_vector(c: &mut Criterion) {
                 black_box(rng.gen());
             })
         })
-        .throughput(Throughput::Elements(f32xN::lanes() as u32)),
+        .throughput(Throughput::Elements(f32xN::lanes() as u64)),
     );
 }
 
diff --git a/examples/aobench/src/image.rs b/examples/aobench/src/image.rs
index e1b43b2fc..44352e954 100644
--- a/examples/aobench/src/image.rs
+++ b/examples/aobench/src/image.rs
@@ -1,7 +1,8 @@
 //! Image utilities
 
 use failure::Error;
-use png;
+#[allow(unused)]
+use png::{BitDepth, ColorType, Encoder};
 use std::path::Path;
 
 /// PNG image in RGB format
@@ -53,14 +54,14 @@ impl Image {
 
         let file = File::create(output)?;
         let buf_writer = &mut BufWriter::new(file);
-        let mut encoder = png::Encoder::new(
+        let mut encoder = Encoder::new(
             buf_writer,
             self.width as u32,
             self.height as u32,
         );
 
-        encoder.set_color(png::ColorType::RGB);
-        encoder.set_depth(png::BitDepth::Eight);
+        encoder.set_color(ColorType::RGB);
+        encoder.set_depth(BitDepth::Eight);
         let mut writer = encoder.write_header().unwrap();
 
         if soa {
diff --git a/examples/aobench/src/intersection/ray_plane.rs b/examples/aobench/src/intersection/ray_plane.rs
index 5751c29e1..71893b92b 100644
--- a/examples/aobench/src/intersection/ray_plane.rs
+++ b/examples/aobench/src/intersection/ray_plane.rs
@@ -38,7 +38,7 @@ impl Intersect<Plane> for RayxN {
         let d = -plane.p.dot(plane.n);
         let v = ray.dir.dot(plane.n);
 
-        let old_isect = isect;
+        let _old_isect = isect;
 
         let m = v.abs().ge(f32xN::splat(1e-17));
         if m.any() {
@@ -58,10 +58,10 @@ impl Intersect<Plane> for RayxN {
             // Check that the vector and the scalar version produce the same results
             // for the same inputs in debug builds
             for i in 0..f32xN::lanes() {
-                let old_isect_i = old_isect.get(i);
+                let old_isect_i = _old_isect.get(i);
                 let ray_i = self.get(i);
                 let isect_i = ray_i.intersect(plane, old_isect_i);
-                assert!(isect_i.almost_eq(&isect.get(i)), "{:?} !~= {:?}\n\nplane: {:?}\n\nold_isect: {:?}\n\nrays: {:?}\n\ni: {:?}\nold_isect_i: {:?}\nray_i: {:?}\n\n", isect_i, isect.get(i), plane, old_isect, self, i, old_isect_i, ray_i);
+                assert!(isect_i.almost_eq(&isect.get(i)), "{:?} !~= {:?}\n\nplane: {:?}\n\nold_isect: {:?}\n\nrays: {:?}\n\ni: {:?}\nold_isect_i: {:?}\nray_i: {:?}\n\n", isect_i, isect.get(i), plane, _old_isect, self, i, old_isect_i, ray_i);
             }
         }
 
diff --git a/examples/aobench/src/intersection/ray_sphere.rs b/examples/aobench/src/intersection/ray_sphere.rs
index 205f81c01..2c0dcfc49 100644
--- a/examples/aobench/src/intersection/ray_sphere.rs
+++ b/examples/aobench/src/intersection/ray_sphere.rs
@@ -43,7 +43,7 @@ impl Intersect<Sphere> for RayxN {
         let c = radius.mul_adde(-radius, rs.dot(rs));
         let d = b.mul_adde(b, -c);
 
-        let old_isect = isect;
+        let _old_isect = isect;
 
         let m = d.gt(f32xN::splat(0.));
         if m.any() {
@@ -64,10 +64,10 @@ impl Intersect<Sphere> for RayxN {
             // Check that the vector and the scalar version produce the same results
             // for the same inputs in debug builds
             for i in 0..f32xN::lanes() {
-                let old_isect_i = old_isect.get(i);
+                let old_isect_i = _old_isect.get(i);
                 let ray_i = self.get(i);
                 let isect_i = ray_i.intersect(sphere, old_isect_i);
-                assert!(isect_i.almost_eq(&isect.get(i)), "{:?} !~= {:?}\n\nsphere: {:?}\n\nold_isect: {:?}\n\nrays: {:?}\n\ni: {:?}\nold_isect_i: {:?}\nray_i: {:?}\n\n", isect_i, isect.get(i), sphere, old_isect, self, i, old_isect_i, ray_i);
+                assert!(isect_i.almost_eq(&isect.get(i)), "{:?} !~= {:?}\n\nsphere: {:?}\n\nold_isect: {:?}\n\nrays: {:?}\n\ni: {:?}\nold_isect_i: {:?}\nray_i: {:?}\n\n", isect_i, isect.get(i), sphere, _old_isect, self, i, old_isect_i, ray_i);
             }
         }
 
diff --git a/examples/aobench/src/lib.rs b/examples/aobench/src/lib.rs
index 7c7993107..7fc7f9bda 100644
--- a/examples/aobench/src/lib.rs
+++ b/examples/aobench/src/lib.rs
@@ -13,7 +13,8 @@
     clippy::cast_sign_loss,
     clippy::identity_op,
     clippy::erasing_op,
-    clippy::must_use_candidate
+    clippy::must_use_candidate,
+    clippy::float_cmp
 )]
 
 pub mod ambient_occlusion;
diff --git a/examples/dot_product/src/lib.rs b/examples/dot_product/src/lib.rs
index fae2ec3bd..7f053a8f3 100644
--- a/examples/dot_product/src/lib.rs
+++ b/examples/dot_product/src/lib.rs
@@ -1,7 +1,7 @@
 //! Vector dot product
 #![deny(warnings, rust_2018_idioms)]
 #![feature(custom_inner_attributes)]
-#![allow(clippy::must_use_candidate)]
+#![allow(clippy::must_use_candidate, clippy::float_cmp)]
 
 pub mod scalar;
 pub mod simd;
diff --git a/examples/fannkuch_redux/src/lib.rs b/examples/fannkuch_redux/src/lib.rs
index 63b862e14..22c155eb7 100644
--- a/examples/fannkuch_redux/src/lib.rs
+++ b/examples/fannkuch_redux/src/lib.rs
@@ -7,7 +7,8 @@
     clippy::cast_possible_truncation,
     clippy::cast_sign_loss,
     clippy::cast_possible_wrap,
-    clippy::must_use_candidate
+    clippy::must_use_candidate,
+    clippy::float_cmp
 )]
 
 pub mod scalar;
diff --git a/examples/fannkuch_redux/src/main.rs b/examples/fannkuch_redux/src/main.rs
index 29661e149..bab26da4c 100644
--- a/examples/fannkuch_redux/src/main.rs
+++ b/examples/fannkuch_redux/src/main.rs
@@ -23,7 +23,7 @@ fn main() {
 #[cfg(test)]
 mod tests {
     use super::*;
-    static OUTPUT: &'static [u8] = include_bytes!("fannkuchredux-output.txt");
+    static OUTPUT: &[u8] = include_bytes!("fannkuchredux-output.txt");
     #[test]
     fn verify_output_simd() {
         let mut out: Vec<u8> = Vec::new();
diff --git a/examples/mandelbrot/src/lib.rs b/examples/mandelbrot/src/lib.rs
index 2760ba44c..581fd02ca 100644
--- a/examples/mandelbrot/src/lib.rs
+++ b/examples/mandelbrot/src/lib.rs
@@ -215,7 +215,7 @@ mod tests {
     }
 
     fn verify_algo(algo: Algorithm) {
-        static OUTPUT: &'static [u8] = include_bytes!("mandelbrot-output.txt");
+        static OUTPUT: &[u8] = include_bytes!("mandelbrot-output.txt");
 
         let (width, height) = (200, 200);
 
@@ -231,7 +231,7 @@ mod tests {
         assert_eq!(out.len(), OUTPUT.len());
 
         if out != OUTPUT {
-            out.into_iter().zip(OUTPUT.into_iter()).enumerate().for_each(
+            out.into_iter().zip(OUTPUT.iter()).enumerate().for_each(
                 |(i, (a, &b))| {
                     assert_eq!(
                         a, b,
diff --git a/examples/matrix_inverse/src/scalar.rs b/examples/matrix_inverse/src/scalar.rs
index 8a9409c65..992144415 100644
--- a/examples/matrix_inverse/src/scalar.rs
+++ b/examples/matrix_inverse/src/scalar.rs
@@ -1,5 +1,5 @@
 //! Scalar implementation
-#![rustfmt::skip]
+#[rustfmt::skip]
 use crate::*;
 
 #[allow(clippy::too_many_lines)]
diff --git a/examples/nbody/src/main.rs b/examples/nbody/src/main.rs
index c79bb94c2..3f53b2fe5 100644
--- a/examples/nbody/src/main.rs
+++ b/examples/nbody/src/main.rs
@@ -29,7 +29,7 @@ fn main() {
 #[cfg(test)]
 mod tests {
     use super::*;
-    static OUTPUT: &'static [u8] = include_bytes!("nbody-output.txt");
+    static OUTPUT: &[u8] = include_bytes!("nbody-output.txt");
     #[test]
     fn verify_output_simd() {
         let mut out: Vec<u8> = Vec::new();
diff --git a/examples/options_pricing/src/lib.rs b/examples/options_pricing/src/lib.rs
index 677109bd1..138249909 100644
--- a/examples/options_pricing/src/lib.rs
+++ b/examples/options_pricing/src/lib.rs
@@ -7,7 +7,8 @@
     clippy::cast_possible_truncation,
     clippy::cast_possible_wrap,
     clippy::must_use_candidate,
-    clippy::too_many_arguments
+    clippy::too_many_arguments,
+    clippy::float_cmp
 )]
 
 use packed_simd::f32x8 as f32s;
diff --git a/examples/spectral_norm/src/main.rs b/examples/spectral_norm/src/main.rs
index 0fa38402c..d16e6de99 100644
--- a/examples/spectral_norm/src/main.rs
+++ b/examples/spectral_norm/src/main.rs
@@ -24,7 +24,7 @@ fn main() {
 #[cfg(test)]
 mod tests {
     use super::*;
-    static OUTPUT: &'static [u8] = include_bytes!("spectralnorm-output.txt");
+    static OUTPUT: &[u8] = include_bytes!("spectralnorm-output.txt");
     #[test]
     fn verify_output_simd() {
         let mut out: Vec<u8> = Vec::new();
diff --git a/examples/stencil/src/lib.rs b/examples/stencil/src/lib.rs
index 2ff408e59..b922bc14f 100644
--- a/examples/stencil/src/lib.rs
+++ b/examples/stencil/src/lib.rs
@@ -97,7 +97,7 @@ impl Data {
     pub fn exec<F>(&mut self, f: F)
     where
         F: Fn(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,
-            &[f32; 4], &[f32], &mut [f32], &mut [f32]) -> (),
+            &[f32; 4], &[f32], &mut [f32], &mut [f32]),
     {
         f(
             self.t.0, self.t.1,
diff --git a/examples/stencil/src/main.rs b/examples/stencil/src/main.rs
index 2471ea34a..adb2f3cfc 100644
--- a/examples/stencil/src/main.rs
+++ b/examples/stencil/src/main.rs
@@ -8,7 +8,7 @@ use std::env;
 fn run<F>(name: &str, f: F)
 where
     F: Fn(i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32,
-        &[f32; 4], &[f32], &mut [f32], &mut [f32]) -> (),
+        &[f32; 4], &[f32], &mut [f32], &mut [f32]),
 {
     let mut d = Data::benchmark();
     let t = time::Duration::span(move || d.exec(f));
diff --git a/examples/stencil/src/simd.rs b/examples/stencil/src/simd.rs
index cf1505547..bb702f7a7 100644
--- a/examples/stencil/src/simd.rs
+++ b/examples/stencil/src/simd.rs
@@ -36,12 +36,12 @@ pub(crate) fn step_x8(
 
                         let sum = {
                             let i = i as i32;
-                            (a_cur!(i, 0, 0)
+                            a_cur!(i, 0, 0)
                                 + a_cur!(-i, 0, 0)
                                 + a_cur!(0, i, 0)
                                 + a_cur!(0, -i, 0)
                                 + a_cur!(0, 0, i)
-                                + a_cur!(0, 0, -i))
+                                + a_cur!(0, 0, -i)
                         };
 
                         div = coef.mul_adde(sum, div);
diff --git a/examples/triangle_xform/src/lib.rs b/examples/triangle_xform/src/lib.rs
index 7ecdb011a..4993b68df 100644
--- a/examples/triangle_xform/src/lib.rs
+++ b/examples/triangle_xform/src/lib.rs
@@ -70,9 +70,9 @@ mod tests {
             scalar_xformed.into_iter().zip(simd_xformed.into_iter()).for_each(
                 |(a, b)| {
                     if a != b {
-                        a.0.into_iter().zip(b.0.into_iter()).for_each(
+                        a.0.iter().zip(b.0.iter()).for_each(
                             |(v1, v2)| {
-                                v1.into_iter().zip(v2.into_iter()).for_each(
+                                v1.iter().zip(v2.iter()).for_each(
                                     |(a, b)| {
                                         assert!(
                                             (a - b).abs() <= EPSILON,
diff --git a/src/api/bit_manip.rs b/src/api/bit_manip.rs
index 3d3c4eb88..6d8865706 100644
--- a/src/api/bit_manip.rs
+++ b/src/api/bit_manip.rs
@@ -37,6 +37,7 @@ macro_rules! impl_bit_manip {
             paste::item_with_macros! {
                 #[allow(overflowing_literals)]
                 pub mod [<$id _bit_manip>] {
+                    #![allow(const_item_mutation)]
                     use super::*;
 
                     const LANE_WIDTH: usize = mem::size_of::<$elem_ty>() * 8;
diff --git a/src/api/cast/v128.rs b/src/api/cast/v128.rs
index 78c07f3a5..ab47ddc00 100644
--- a/src/api/cast/v128.rs
+++ b/src/api/cast/v128.rs
@@ -1,5 +1,5 @@
 //! `FromCast` and `IntoCast` implementations for portable 128-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/api/cast/v16.rs b/src/api/cast/v16.rs
index d292936ba..cf974bb08 100644
--- a/src/api/cast/v16.rs
+++ b/src/api/cast/v16.rs
@@ -1,5 +1,5 @@
 //! `FromCast` and `IntoCast` implementations for portable 16-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/api/cast/v256.rs b/src/api/cast/v256.rs
index 0a669e0be..9389dcb4c 100644
--- a/src/api/cast/v256.rs
+++ b/src/api/cast/v256.rs
@@ -1,5 +1,5 @@
 //! `FromCast` and `IntoCast` implementations for portable 256-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/api/cast/v32.rs b/src/api/cast/v32.rs
index 65050cdac..2b254ba0c 100644
--- a/src/api/cast/v32.rs
+++ b/src/api/cast/v32.rs
@@ -1,5 +1,5 @@
 //! `FromCast` and `IntoCast` implementations for portable 32-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/api/cast/v512.rs b/src/api/cast/v512.rs
index 9ae1caed3..5a10ab066 100644
--- a/src/api/cast/v512.rs
+++ b/src/api/cast/v512.rs
@@ -1,5 +1,5 @@
 //! `FromCast` and `IntoCast` implementations for portable 512-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/api/cast/v64.rs b/src/api/cast/v64.rs
index 0e2f78f73..192a4638a 100644
--- a/src/api/cast/v64.rs
+++ b/src/api/cast/v64.rs
@@ -1,5 +1,5 @@
 //! `FromCast` and `IntoCast` implementations for portable 64-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/api/default.rs b/src/api/default.rs
index 843d51bcc..7af55ea77 100644
--- a/src/api/default.rs
+++ b/src/api/default.rs
@@ -12,6 +12,8 @@ macro_rules! impl_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)]
diff --git a/src/api/from/from_array.rs b/src/api/from/from_array.rs
index 964d1501d..b83f93816 100644
--- a/src/api/from/from_array.rs
+++ b/src/api/from/from_array.rs
@@ -56,6 +56,8 @@ macro_rules! impl_from_array {
         test_if! {
             $test_tt:
             paste::item! {
+                // Comparisons use integer casts within mantissa^1 range.
+                #[allow(clippy::float_cmp)]
                 mod [<$id _from>] {
                     use super::*;
                     #[test]
diff --git a/src/api/hash.rs b/src/api/hash.rs
index 08d42496e..ee80eff93 100644
--- a/src/api/hash.rs
+++ b/src/api/hash.rs
@@ -36,6 +36,8 @@ macro_rules! impl_hash {
                         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/src/api/into_bits/arch_specific.rs b/src/api/into_bits/arch_specific.rs
index 6cc2fa37b..fee614005 100644
--- a/src/api/into_bits/arch_specific.rs
+++ b/src/api/into_bits/arch_specific.rs
@@ -1,6 +1,6 @@
 //! `FromBits` and `IntoBits` between portable vector types and the
 //! architecture-specific vector types.
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 // FIXME: MIPS FromBits/IntoBits
 
@@ -84,7 +84,6 @@ macro_rules! impl_arch {
 // FIXME: 64-bit single element types
 // FIXME: arm/aarch float16x4_t missing
 impl_arch!(
-    [x86["x86"]: __m64], [x86_64["x86_64"]: __m64],
     [arm["arm"]: int8x8_t, uint8x8_t, poly8x8_t, int16x4_t, uint16x4_t,
      poly16x4_t, int32x2_t, uint32x2_t, float32x2_t, int64x1_t,
      uint64x1_t],
diff --git a/src/api/into_bits/v128.rs b/src/api/into_bits/v128.rs
index 804dbf282..e32cd7f9f 100644
--- a/src/api/into_bits/v128.rs
+++ b/src/api/into_bits/v128.rs
@@ -1,5 +1,5 @@
 //! `FromBits` and `IntoBits` implementations for portable 128-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 #[allow(unused)]  // wasm_bindgen_test
 use crate::*;
diff --git a/src/api/into_bits/v16.rs b/src/api/into_bits/v16.rs
index 1162a62e5..e44d0e7f9 100644
--- a/src/api/into_bits/v16.rs
+++ b/src/api/into_bits/v16.rs
@@ -1,5 +1,5 @@
 //! `FromBits` and `IntoBits` implementations for portable 16-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 #[allow(unused)]  // wasm_bindgen_test
 use crate::*;
diff --git a/src/api/into_bits/v256.rs b/src/api/into_bits/v256.rs
index cc7a6646b..c4c373e0d 100644
--- a/src/api/into_bits/v256.rs
+++ b/src/api/into_bits/v256.rs
@@ -1,5 +1,5 @@
 //! `FromBits` and `IntoBits` implementations for portable 256-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 #[allow(unused)]  // wasm_bindgen_test
 use crate::*;
diff --git a/src/api/into_bits/v32.rs b/src/api/into_bits/v32.rs
index 2c183ecf1..5dba38a17 100644
--- a/src/api/into_bits/v32.rs
+++ b/src/api/into_bits/v32.rs
@@ -1,5 +1,5 @@
 //! `FromBits` and `IntoBits` implementations for portable 32-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 #[allow(unused)]  // wasm_bindgen_test
 use crate::*;
diff --git a/src/api/into_bits/v512.rs b/src/api/into_bits/v512.rs
index 8dec6a7f6..4a771962c 100644
--- a/src/api/into_bits/v512.rs
+++ b/src/api/into_bits/v512.rs
@@ -1,5 +1,5 @@
 //! `FromBits` and `IntoBits` implementations for portable 512-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 #[allow(unused)]  // wasm_bindgen_test
 use crate::*;
diff --git a/src/api/into_bits/v64.rs b/src/api/into_bits/v64.rs
index 8999d98e1..5b065f1bd 100644
--- a/src/api/into_bits/v64.rs
+++ b/src/api/into_bits/v64.rs
@@ -1,5 +1,5 @@
 //! `FromBits` and `IntoBits` implementations for portable 64-bit wide vectors
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 #[allow(unused)]  // wasm_bindgen_test
 use crate::*;
diff --git a/src/api/minimal/iuf.rs b/src/api/minimal/iuf.rs
index 58ffabab9..a155ac178 100644
--- a/src/api/minimal/iuf.rs
+++ b/src/api/minimal/iuf.rs
@@ -53,7 +53,7 @@ macro_rules! impl_minimal_iuf {
 
             /// Extracts the value at `index`.
             ///
-            /// # Precondition
+            /// # Safety
             ///
             /// If `index >= Self::lanes()` the behavior is undefined.
             #[inline]
@@ -80,7 +80,7 @@ macro_rules! impl_minimal_iuf {
 
             /// Returns a new vector where the value at `index` is replaced by `new_value`.
             ///
-            /// # Precondition
+            /// # Safety
             ///
             /// If `index >= Self::lanes()` the behavior is undefined.
             #[inline]
@@ -101,6 +101,8 @@ macro_rules! impl_minimal_iuf {
         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)]
diff --git a/src/api/minimal/mask.rs b/src/api/minimal/mask.rs
index e65be95db..a420060b4 100644
--- a/src/api/minimal/mask.rs
+++ b/src/api/minimal/mask.rs
@@ -58,6 +58,8 @@ macro_rules! impl_minimal_mask {
 
             /// Extracts the value at `index`.
             ///
+            /// # Safety
+            ///
             /// If `index >= Self::lanes()` the behavior is undefined.
             #[inline]
             pub unsafe fn extract_unchecked(self, index: usize) -> bool {
@@ -85,9 +87,9 @@ macro_rules! impl_minimal_mask {
             /// Returns a new vector where the value at `index` is replaced by
             /// `new_value`.
             ///
-            /// # Panics
+            /// # Safety
             ///
-            /// If `index >= Self::lanes()`.
+            /// 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` \
diff --git a/src/api/minimal/ptr.rs b/src/api/minimal/ptr.rs
index 8b42b6959..c3d61fbf6 100644
--- a/src/api/minimal/ptr.rs
+++ b/src/api/minimal/ptr.rs
@@ -550,11 +550,7 @@ macro_rules! impl_minimal_p {
                         ];
 
                         for i in 0..$elem_count {
-                            let ptr = unsafe {
-                                crate::mem::transmute(
-                                    &values[i] as *const i32
-                                )
-                            };
+                            let ptr = &values[i] as *const i32 as *mut i32;
                             vec = vec.replace(i, ptr);
                             array[i] = ptr;
                         }
@@ -1025,11 +1021,7 @@ macro_rules! impl_minimal_p {
                         ];
 
                         for i in 0..$elem_count {
-                            let ptr = unsafe {
-                                crate::mem::transmute(
-                                    &values[i] as *const i32
-                                )
-                            };
+                            let ptr = &values[i] as *const i32 as *mut i32;
                             vec = vec.replace(i, ptr);
                             array[i] = ptr;
                         }
diff --git a/src/api/ptr/gather_scatter.rs b/src/api/ptr/gather_scatter.rs
index 981543852..430435620 100644
--- a/src/api/ptr/gather_scatter.rs
+++ b/src/api/ptr/gather_scatter.rs
@@ -49,9 +49,9 @@ macro_rules! impl_ptr_read {
                         let mut ptr = $id::<i32>::null();
 
                         for i in 0..$elem_count {
-                            ptr = ptr.replace(i, unsafe {
-                                crate::mem::transmute(&v[i] as *const i32)
-                            });
+                            ptr = ptr.replace(i,
+                                &v[i] as *const i32 as *mut i32
+                            );
                         }
 
                         // all mask elements are true:
@@ -161,7 +161,7 @@ macro_rules! impl_ptr_write {
                         let mut ptr = $id::<i32>::null();
                         for i in 0..$elem_count {
                             ptr = ptr.replace(i, unsafe {
-                                crate::mem::transmute(arr.as_ptr().add(i))
+                                arr.as_ptr().add(i) as *mut i32
                             });
                         }
                         // ptr = [&arr[0], &arr[1], ...]
diff --git a/src/api/reductions/float_arithmetic.rs b/src/api/reductions/float_arithmetic.rs
index dd722ae25..4a47452e5 100644
--- a/src/api/reductions/float_arithmetic.rs
+++ b/src/api/reductions/float_arithmetic.rs
@@ -93,6 +93,8 @@ macro_rules! impl_reduction_float_arithmetic {
         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 {
@@ -225,7 +227,7 @@ macro_rules! impl_reduction_float_arithmetic {
                         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 *= 3.14 * c;
+                            start *= ::core::$elem_ty::consts::PI * c;
                             scalar_reduction += start;
                             v = v.replace(i, start);
                         }
@@ -257,6 +259,7 @@ macro_rules! impl_reduction_float_arithmetic {
                     #[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());
@@ -278,7 +281,7 @@ macro_rules! impl_reduction_float_arithmetic {
                         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 *= 3.14 * c;
+                            start *= ::core::$elem_ty::consts::PI * c;
                             scalar_reduction *= start;
                             v = v.replace(i, start);
                         }
@@ -288,7 +291,9 @@ macro_rules! impl_reduction_float_arithmetic {
                         v.write_to_slice_unaligned(&mut a);
                         let tree_reduction = tree_reduce_product(&a);
 
-                        // tolerate 1 ULP difference:
+                        // 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!(
@@ -296,7 +301,7 @@ macro_rules! impl_reduction_float_arithmetic {
                                 red_bits - tree_bits
                             } else {
                                 tree_bits - red_bits
-                            } < 2,
+                            } < ulp_limit.try_into().unwrap(),
                             "vector: {:?} | simd_reduction: {:?} | \
                              tree_reduction: {} | scalar_reduction: {}",
                             v,
diff --git a/src/api/reductions/min_max.rs b/src/api/reductions/min_max.rs
index c4d3aa10f..c4c1400a8 100644
--- a/src/api/reductions/min_max.rs
+++ b/src/api/reductions/min_max.rs
@@ -76,6 +76,8 @@ macro_rules! impl_reduction_min_max {
         }
         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)]
@@ -124,6 +126,8 @@ macro_rules! test_reduction_float_min_max {
         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)]
diff --git a/src/api/slice/from_slice.rs b/src/api/slice/from_slice.rs
index 109cd1f10..25082d1e6 100644
--- a/src/api/slice/from_slice.rs
+++ b/src/api/slice/from_slice.rs
@@ -38,7 +38,7 @@ macro_rules! impl_slice_from_slice {
 
             /// Instantiates a new vector with the values of the `slice`.
             ///
-            /// # Precondition
+            /// # Safety
             ///
             /// If `slice.len() < Self::lanes()` or `&slice[0]` is not aligned
             /// to an `align_of::<Self>()` boundary, the behavior is undefined.
@@ -59,7 +59,7 @@ macro_rules! impl_slice_from_slice {
 
             /// Instantiates a new vector with the values of the `slice`.
             ///
-            /// # Precondition
+            /// # Safety
             ///
             /// If `slice.len() < Self::lanes()` the behavior is undefined.
             #[inline]
@@ -84,6 +84,8 @@ macro_rules! impl_slice_from_slice {
         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;
diff --git a/src/api/slice/write_to_slice.rs b/src/api/slice/write_to_slice.rs
index fcb288da7..b634d98b9 100644
--- a/src/api/slice/write_to_slice.rs
+++ b/src/api/slice/write_to_slice.rs
@@ -39,7 +39,7 @@ macro_rules! impl_slice_write_to_slice {
 
             /// Writes the values of the vector to the `slice`.
             ///
-            /// # Precondition
+            /// # Safety
             ///
             /// If `slice.len() < Self::lanes()` or `&slice[0]` is not
             /// aligned to an `align_of::<Self>()` boundary, the behavior is
@@ -64,7 +64,7 @@ macro_rules! impl_slice_write_to_slice {
 
             /// Writes the values of the vector to the `slice`.
             ///
-            /// # Precondition
+            /// # Safety
             ///
             /// If `slice.len() < Self::lanes()` the behavior is undefined.
             #[inline]
@@ -86,6 +86,8 @@ macro_rules! impl_slice_write_to_slice {
         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;
diff --git a/src/codegen/bit_manip.rs b/src/codegen/bit_manip.rs
index 947266f5b..83c7d1987 100644
--- a/src/codegen/bit_manip.rs
+++ b/src/codegen/bit_manip.rs
@@ -1,5 +1,5 @@
 //! LLVM bit manipulation intrinsics.
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/codegen/shuffle1_dyn.rs b/src/codegen/shuffle1_dyn.rs
index 1e9f58163..4037a5eba 100644
--- a/src/codegen/shuffle1_dyn.rs
+++ b/src/codegen/shuffle1_dyn.rs
@@ -28,28 +28,7 @@ macro_rules! impl_fallback {
 macro_rules! impl_shuffle1_dyn {
     (u8x8) => {
         cfg_if! {
-            if #[cfg(all(any(target_arch = "x86", target_arch = "x86_64"),
-                         target_feature = "ssse3"))] {
-                impl Shuffle1Dyn for u8x8 {
-                    type Indices = Self;
-                    #[inline]
-                    fn shuffle1_dyn(self, indices: Self::Indices) -> Self {
-                        #[cfg(target_arch = "x86")]
-                        use crate::arch::x86::_mm_shuffle_pi8;
-                        #[cfg(target_arch = "x86_64")]
-                        use crate::arch::x86_64::_mm_shuffle_pi8;
-
-                        unsafe {
-                            crate::mem::transmute(
-                                _mm_shuffle_pi8(
-                                    crate::mem::transmute(self.0),
-                                    crate::mem::transmute(indices.0)
-                                )
-                            )
-                        }
-                    }
-                }
-            } else if #[cfg(all(
+            if #[cfg(all(
                 any(
                     all(target_aarch = "aarch64", target_feature = "neon"),
                     all(target_aarch = "arm", target_feature = "v7",
diff --git a/src/lib.rs b/src/lib.rs
index c715210a8..257996336 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -210,7 +210,8 @@
     core_intrinsics,
     stmt_expr_attributes,
     crate_visibility_modifier,
-    custom_inner_attributes
+    custom_inner_attributes,
+    llvm_asm
 )]
 #![allow(non_camel_case_types, non_snake_case,
          clippy::cast_possible_truncation,
diff --git a/src/testing/utils.rs b/src/testing/utils.rs
index 7b8f21ac1..21f27aae5 100644
--- a/src/testing/utils.rs
+++ b/src/testing/utils.rs
@@ -1,6 +1,8 @@
 //! 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};
 
@@ -19,14 +21,19 @@ pub fn test_lt<T>(
     assert!(a <= b, "{:?}, {:?}", a, b);
     assert!(b >= a, "{:?}, {:?}", a, b);
 
-    // Irreflexivity
-    assert!(!(a < a), "{:?}, {:?}", a, b);
-    assert!(!(b < b), "{:?}, {:?}", a, b);
-    assert!(!(a > a), "{:?}, {:?}", a, b);
-    assert!(!(b > b), "{:?}, {:?}", 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);
+        assert!(a <= a, "{:?}, {:?}", a, b);
+        assert!(b <= b, "{:?}, {:?}", a, b);
+    }
 }
 
 /// Tests PartialOrd for `a` and `b` where `a <= b` is true.
@@ -38,8 +45,8 @@ pub fn test_le<T>(
     assert!(a <= b, "{:?}, {:?}", a, b);
     assert!(b >= a, "{:?}, {:?}", a, b);
 
-    assert!(a == b || a < b, "{:?}, {:?}", a, b);
-    assert!(a == b || b > a, "{:?}, {:?}", a, b);
+    assert!(a <= b, "{:?}, {:?}", a, b);
+    assert!(b >= a, "{:?}, {:?}", a, b);
 
     if a == b {
         assert!(!(a < b), "{:?}, {:?}", a, b);
diff --git a/src/v128.rs b/src/v128.rs
index 03dc246cd..7949f6619 100644
--- a/src/v128.rs
+++ b/src/v128.rs
@@ -1,5 +1,5 @@
 //! 128-bit wide vector types
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/v256.rs b/src/v256.rs
index 78523a5ba..f0c3bc281 100644
--- a/src/v256.rs
+++ b/src/v256.rs
@@ -1,5 +1,5 @@
 //! 256-bit wide vector types
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/v512.rs b/src/v512.rs
index 8fe4d8351..4c8c71338 100644
--- a/src/v512.rs
+++ b/src/v512.rs
@@ -1,5 +1,5 @@
 //! 512-bit wide vector types
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/src/v64.rs b/src/v64.rs
index 92c2d103e..bf6b9de61 100644
--- a/src/v64.rs
+++ b/src/v64.rs
@@ -1,5 +1,5 @@
 //! 64-bit wide vector types
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use super::*;
 
diff --git a/src/vPtr.rs b/src/vPtr.rs
index fe9fb28ff..e34cb170e 100644
--- a/src/vPtr.rs
+++ b/src/vPtr.rs
@@ -1,5 +1,5 @@
 //! Vectors of pointers
-#![rustfmt::skip]
+#[rustfmt::skip]
 
 use crate::*;
 
diff --git a/tests/endianness.rs b/tests/endianness.rs
index 1e6b4f354..31fb7073a 100644
--- a/tests/endianness.rs
+++ b/tests/endianness.rs
@@ -17,7 +17,7 @@ fn endian_indexing() {
 #[cfg_attr(not(target_arch = "wasm32"), test)]
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn endian_bitcasts() {
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let x = i8x16::new(
         0, 1, 2, 3, 4, 5, 6, 7,
         8, 9, 10, 11, 12, 13, 14, 15,
@@ -34,13 +34,13 @@ fn endian_bitcasts() {
 #[cfg_attr(not(target_arch = "wasm32"), test)]
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn endian_casts() {
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[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
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let e = i16x16::new(
         0, 1, 2, 3, 4, 5, 6, 7,
         8, 9, 10, 11, 12, 13, 14, 15,
@@ -51,7 +51,7 @@ fn endian_casts() {
 #[cfg_attr(not(target_arch = "wasm32"), test)]
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
 fn endian_load_and_stores() {
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let x = i8x16::new(
         0, 1, 2, 3, 4, 5, 6, 7,
         8, 9, 10, 11, 12, 13, 14, 15,
@@ -82,10 +82,15 @@ fn endian_array_union() {
         vec: f32x4,
     }
     let x: [f32; 4] = unsafe { A { vec: f32x4::new(0., 1., 2., 3.) }.data };
-    assert_eq!(x[0], 0_f32);
-    assert_eq!(x[1], 1_f32);
-    assert_eq!(x[2], 2_f32);
-    assert_eq!(x[3], 3_f32);
+    // 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.));
 
@@ -93,23 +98,23 @@ fn endian_array_union() {
         data: [i8; 16],
         vec: i8x16,
     }
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[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 in 0..16 {
-        assert_eq!(x[i], i as i8);
+    for (i, v) in x.iter().enumerate() {
+        assert_eq!(i as i8, *v);
     }
 
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let y = [
         15, 14, 13, 12, 11, 19, 9, 8,
         7, 6, 5, 4, 3, 2, 1, 0
     ];
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let e = i8x16::new(
         15, 14, 13, 12, 11, 19, 9, 8,
         7, 6, 5, 4, 3, 2, 1, 0
@@ -121,7 +126,7 @@ fn endian_array_union() {
         data: [i16; 8],
         vec: i8x16,
     }
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let x = i8x16::new(
         0, 1, 2, 3, 4, 5, 6, 7,
         8, 9, 10, 11, 12, 13, 14, 15,
@@ -145,21 +150,26 @@ fn endian_tuple_access() {
         vec: f32x4,
     }
     let x: F32x4T = unsafe { A { vec: f32x4::new(0., 1., 2., 3.) }.data };
-    assert_eq!(x.0, 0_f32);
-    assert_eq!(x.1, 1_f32);
-    assert_eq!(x.2, 2_f32);
-    assert_eq!(x.3, 3_f32);
+    // 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.));
 
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[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,
     }
 
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let x = i8x16::new(
         0, 1, 2, 3, 4, 5, 6, 7,
         8, 9, 10, 11, 12, 13, 14, 15,
@@ -183,27 +193,27 @@ fn endian_tuple_access() {
     assert_eq!(x.14, 14);
     assert_eq!(x.15, 15);
 
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[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 };
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[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);
 
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     type I16x8T = (i16, i16, i16, i16, i16, i16, i16, i16);
     union C {
         data: I16x8T,
         vec: i8x16,
     }
 
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let x = i8x16::new(
         0, 1, 2, 3, 4, 5, 6, 7,
         8, 9, 10, 11, 12, 13, 14, 15,
@@ -224,7 +234,7 @@ fn endian_tuple_access() {
     assert_eq!(x.6, e[6]);
     assert_eq!(x.7, e[7]);
 
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     #[repr(C)]
     #[derive(Copy ,Clone)]
     pub struct Tup(pub i8, pub i8, pub i16, pub i8, pub i8, pub i16,
@@ -235,7 +245,7 @@ fn endian_tuple_access() {
         vec: i8x16,
     }
 
-    #[cfg_attr(rustfmt, rustfmt_skip)]
+    #[rustfmt::skip]
     let x = i8x16::new(
         0, 1, 2, 3, 4, 5, 6, 7,
         8, 9, 10, 11, 12, 13, 14, 15,
diff --git a/verify/verify/src/lib.rs b/verify/verify/src/lib.rs
index aaa5e2de0..df041582d 100644
--- a/verify/verify/src/lib.rs
+++ b/verify/verify/src/lib.rs
@@ -1,5 +1,5 @@
 #![deny(warnings, rust_2018_idioms)]
-#![cfg_attr(test, feature(avx512_target_feature, abi_vectorcall, asm))]
+#![cfg_attr(test, feature(avx512_target_feature, abi_vectorcall, llvm_asm))]
 
 #[cfg(test)]
 mod api;