diff --git a/library/stdarch/src/x86/avx.rs b/library/stdarch/src/x86/avx.rs
index 919609e3e182..8829985da9dc 100644
--- a/library/stdarch/src/x86/avx.rs
+++ b/library/stdarch/src/x86/avx.rs
@@ -120,33 +120,23 @@ pub unsafe fn _mm256_floor_pd(a: f64x4) -> f64x4 {
 /// https://github.com/llvm-mirror/clang/blob/dcd8d797b20291f1a6b3e0ddda085aa2bbb382a8/lib/Headers/avxintrin.h#L382
 #[inline(always)]
 #[target_feature = "+avx"]
-// #[cfg_attr(test, assert_instr(vroundps))]
-// TODO: Replace with assert_expanded_instr https://github.com/rust-lang-nursery/stdsimd/issues/49
-pub fn _mm256_round_ps(a: f32x8, b: i32) -> f32x8 {
+#[cfg_attr(test, assert_instr(vroundps, b = 0x00))]
+pub unsafe fn _mm256_round_ps(a: f32x8, b: i32) -> f32x8 {
     macro_rules! call {
         ($imm8:expr) => {
-            unsafe { roundps256(a, $imm8) }
+            roundps256(a, $imm8)
         }
     }
     constify_imm8!(b, call)
 }
 
-// TODO: Remove once a macro is ipmlemented to automate these tests
-// https://github.com/rust-lang-nursery/stdsimd/issues/49
-#[cfg(test)]
-#[target_feature = "+avx"]
-#[cfg_attr(test, assert_instr(vroundps))]
-fn test_mm256_round_ps(a: f32x8) -> f32x8 {
-    _mm256_round_ps(a, 0x00)
-}
-
 /// Round packed single-precision (32-bit) floating point elements in `a` toward
 /// positive infinity.
 #[inline(always)]
 #[target_feature = "+avx"]
 #[cfg_attr(test, assert_instr(vroundps))]
-pub fn _mm256_ceil_ps(a: f32x8) -> f32x8 {
-    unsafe { roundps256(a, 0x02) }
+pub unsafe fn _mm256_ceil_ps(a: f32x8) -> f32x8 {
+    roundps256(a, 0x02)
 }
 
 /// Round packed single-precision (32-bit) floating point elements in `a` toward
@@ -154,8 +144,8 @@ pub fn _mm256_ceil_ps(a: f32x8) -> f32x8 {
 #[inline(always)]
 #[target_feature = "+avx"]
 #[cfg_attr(test, assert_instr(vroundps))]
-pub fn _mm256_floor_ps(a: f32x8) -> f32x8 {
-    unsafe { roundps256(a, 0x01) }
+pub unsafe fn _mm256_floor_ps(a: f32x8) -> f32x8 {
+    roundps256(a, 0x01)
 }
 
 /// Return the square root of packed single-precision (32-bit) floating point
@@ -163,8 +153,8 @@ pub fn _mm256_floor_ps(a: f32x8) -> f32x8 {
 #[inline(always)]
 #[target_feature = "+avx"]
 #[cfg_attr(test, assert_instr(vsqrtps))]
-pub fn _mm256_sqrt_ps(a: f32x8) -> f32x8 {
-    unsafe { sqrtps256(a) }
+pub unsafe fn _mm256_sqrt_ps(a: f32x8) -> f32x8 {
+    sqrtps256(a)
 }
 
 /// Return the square root of packed double-precision (64-bit) floating point
@@ -172,8 +162,8 @@ pub fn _mm256_sqrt_ps(a: f32x8) -> f32x8 {
 #[inline(always)]
 #[target_feature = "+avx"]
 #[cfg_attr(test, assert_instr(vsqrtpd))]
-pub fn _mm256_sqrt_pd(a: f64x4) -> f64x4 {
-    unsafe { sqrtpd256(a) }
+pub unsafe fn _mm256_sqrt_pd(a: f64x4) -> f64x4 {
+    sqrtpd256(a)
 }
 
 /// LLVM intrinsics used in the above functions
@@ -193,7 +183,7 @@ extern "C" {
     fn sqrtps256(a: f32x8) -> f32x8;
 }
 
-#[cfg(all(test, target_feature = "avx", any(target_arch = "x86", target_arch = "x86_64")))]
+#[cfg(test)]
 mod tests {
     use stdsimd_test::simd_test;
 
@@ -303,7 +293,7 @@ mod tests {
     }
 
     #[simd_test = "avx"]
-    fn _mm256_round_ps() {
+    unsafe fn _mm256_round_ps() {
         let a = f32x8::new(1.55, 2.2, 3.99, -1.2, 1.55, 2.2, 3.99, -1.2);
         let result_closest = avx::_mm256_round_ps(a, 0b00000000);
         let result_down = avx::_mm256_round_ps(a, 0b00000001);
@@ -317,7 +307,7 @@ mod tests {
     }
 
     #[simd_test = "avx"]
-    fn _mm256_floor_ps() {
+    unsafe fn _mm256_floor_ps() {
         let a = f32x8::new(1.55, 2.2, 3.99, -1.2, 1.55, 2.2, 3.99, -1.2);
         let result_down = avx::_mm256_floor_ps(a);
         let expected_down = f32x8::new(1.0, 2.0, 3.0, -2.0, 1.0, 2.0, 3.0, -2.0);
@@ -325,7 +315,7 @@ mod tests {
     }
 
     #[simd_test = "avx"]
-    fn _mm256_ceil_ps() {
+    unsafe fn _mm256_ceil_ps() {
         let a = f32x8::new(1.55, 2.2, 3.99, -1.2, 1.55, 2.2, 3.99, -1.2);
         let result_up = avx::_mm256_ceil_ps(a);
         let expected_up = f32x8::new(2.0, 3.0, 4.0, -1.0, 2.0, 3.0, 4.0, -1.0);
@@ -333,7 +323,7 @@ mod tests {
     }
 
     #[simd_test = "avx"]
-    fn _mm256_sqrt_pd() {
+    unsafe fn _mm256_sqrt_pd() {
         let a = f64x4::new(4.0, 9.0, 16.0, 25.0);
         let r = avx::_mm256_sqrt_pd(a, );
         let e = f64x4::new(2.0, 3.0, 4.0, 5.0);
@@ -341,11 +331,10 @@ mod tests {
     }
 
     #[simd_test = "avx"]
-    fn _mm256_sqrt_ps() {
+    unsafe fn _mm256_sqrt_ps() {
         let a = f32x8::new(4.0, 9.0, 16.0, 25.0, 4.0, 9.0, 16.0, 25.0);
         let r = avx::_mm256_sqrt_ps(a);
         let e = f32x8::new(2.0, 3.0, 4.0, 5.0, 2.0, 3.0, 4.0, 5.0);
         assert_eq!(r, e);
     }
-
 }