diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 896e56a9a1e3a6410d128cb6fccccad337e47464..f823792fabe63767e9e82580e478f3235f910193 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -261,7 +261,7 @@ fn unreachable(&mut self) {
     fn fadd_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMBuildFAdd(self.llbuilder, lhs, rhs, UNNAMED);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
@@ -269,7 +269,7 @@ fn fadd_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
     fn fsub_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMBuildFSub(self.llbuilder, lhs, rhs, UNNAMED);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
@@ -277,7 +277,7 @@ fn fsub_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
     fn fmul_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMBuildFMul(self.llbuilder, lhs, rhs, UNNAMED);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
@@ -285,7 +285,7 @@ fn fmul_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
     fn fdiv_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMBuildFDiv(self.llbuilder, lhs, rhs, UNNAMED);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
@@ -293,7 +293,7 @@ fn fdiv_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
     fn frem_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMBuildFRem(self.llbuilder, lhs, rhs, UNNAMED);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
@@ -1242,14 +1242,14 @@ pub fn vector_reduce_fmul(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll V
     pub fn vector_reduce_fadd_fast(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMRustBuildVectorReduceFAdd(self.llbuilder, acc, src);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
     pub fn vector_reduce_fmul_fast(&mut self, acc: &'ll Value, src: &'ll Value) -> &'ll Value {
         unsafe {
             let instr = llvm::LLVMRustBuildVectorReduceFMul(self.llbuilder, acc, src);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
@@ -1282,7 +1282,7 @@ pub fn vector_reduce_fmin_fast(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe {
             let instr =
                 llvm::LLVMRustBuildVectorReduceFMin(self.llbuilder, src, /*NoNaNs:*/ true);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
@@ -1290,7 +1290,7 @@ pub fn vector_reduce_fmax_fast(&mut self, src: &'ll Value) -> &'ll Value {
         unsafe {
             let instr =
                 llvm::LLVMRustBuildVectorReduceFMax(self.llbuilder, src, /*NoNaNs:*/ true);
-            llvm::LLVMRustSetHasUnsafeAlgebra(instr);
+            llvm::LLVMRustSetFastMath(instr);
             instr
         }
     }
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index 52fab2ea17d8d7800194e32b6dbe47bdca0dcae8..fc6c1abf4af5639ca8604399be1666419cbdead9 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -1053,50 +1053,48 @@ fn simd_simple_float_intrinsic(
         let vec_ty = bx.type_vector(elem_ty, in_len);
 
         let (intr_name, fn_ty) = match name {
-            sym::simd_fsqrt => ("sqrt", bx.type_func(&[vec_ty], vec_ty)),
-            sym::simd_fsin => ("sin", bx.type_func(&[vec_ty], vec_ty)),
-            sym::simd_fcos => ("cos", bx.type_func(&[vec_ty], vec_ty)),
-            sym::simd_fabs => ("fabs", bx.type_func(&[vec_ty], vec_ty)),
             sym::simd_ceil => ("ceil", bx.type_func(&[vec_ty], vec_ty)),
-            sym::simd_floor => ("floor", bx.type_func(&[vec_ty], vec_ty)),
-            sym::simd_round => ("round", bx.type_func(&[vec_ty], vec_ty)),
-            sym::simd_trunc => ("trunc", bx.type_func(&[vec_ty], vec_ty)),
-            sym::simd_fexp => ("exp", bx.type_func(&[vec_ty], vec_ty)),
+            sym::simd_fabs => ("fabs", bx.type_func(&[vec_ty], vec_ty)),
+            sym::simd_fcos => ("cos", bx.type_func(&[vec_ty], vec_ty)),
             sym::simd_fexp2 => ("exp2", bx.type_func(&[vec_ty], vec_ty)),
+            sym::simd_fexp => ("exp", bx.type_func(&[vec_ty], vec_ty)),
             sym::simd_flog10 => ("log10", bx.type_func(&[vec_ty], vec_ty)),
             sym::simd_flog2 => ("log2", bx.type_func(&[vec_ty], vec_ty)),
             sym::simd_flog => ("log", bx.type_func(&[vec_ty], vec_ty)),
+            sym::simd_floor => ("floor", bx.type_func(&[vec_ty], vec_ty)),
+            sym::simd_fma => ("fma", bx.type_func(&[vec_ty, vec_ty, vec_ty], vec_ty)),
             sym::simd_fpowi => ("powi", bx.type_func(&[vec_ty, bx.type_i32()], vec_ty)),
             sym::simd_fpow => ("pow", bx.type_func(&[vec_ty, vec_ty], vec_ty)),
-            sym::simd_fma => ("fma", bx.type_func(&[vec_ty, vec_ty, vec_ty], vec_ty)),
+            sym::simd_fsin => ("sin", bx.type_func(&[vec_ty], vec_ty)),
+            sym::simd_fsqrt => ("sqrt", bx.type_func(&[vec_ty], vec_ty)),
+            sym::simd_round => ("round", bx.type_func(&[vec_ty], vec_ty)),
+            sym::simd_trunc => ("trunc", bx.type_func(&[vec_ty], vec_ty)),
             _ => return_error!("unrecognized intrinsic `{}`", name),
         };
-
         let llvm_name = &format!("llvm.{0}.v{1}{2}", intr_name, in_len, elem_ty_str);
         let f = bx.declare_cfn(&llvm_name, llvm::UnnamedAddr::No, fn_ty);
         let c = bx.call(f, &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(), None);
-        unsafe { llvm::LLVMRustSetHasUnsafeAlgebra(c) };
         Ok(c)
     }
 
     if std::matches!(
         name,
-        sym::simd_fsqrt
-            | sym::simd_fsin
-            | sym::simd_fcos
+        sym::simd_ceil
             | sym::simd_fabs
-            | sym::simd_ceil
-            | sym::simd_floor
-            | sym::simd_round
-            | sym::simd_trunc
-            | sym::simd_fexp
+            | sym::simd_fcos
             | sym::simd_fexp2
+            | sym::simd_fexp
             | sym::simd_flog10
             | sym::simd_flog2
             | sym::simd_flog
-            | sym::simd_fpowi
-            | sym::simd_fpow
+            | sym::simd_floor
             | sym::simd_fma
+            | sym::simd_fpow
+            | sym::simd_fpowi
+            | sym::simd_fsin
+            | sym::simd_fsqrt
+            | sym::simd_round
+            | sym::simd_trunc
     ) {
         return simd_simple_float_intrinsic(name, in_elem, in_ty, in_len, bx, span, args);
     }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index 54a8249b175b01f6a898b29c746994599bb918c4..32b1526f6e44c3463440a0e3abfad1ea6f3b70cf 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -1354,7 +1354,7 @@ pub fn LLVMBuildXor(
     pub fn LLVMBuildNeg(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
     pub fn LLVMBuildFNeg(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
     pub fn LLVMBuildNot(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
-    pub fn LLVMRustSetHasUnsafeAlgebra(Instr: &Value);
+    pub fn LLVMRustSetFastMath(Instr: &Value);
 
     // Memory
     pub fn LLVMBuildAlloca(B: &Builder<'a>, Ty: &'a Type, Name: *const c_char) -> &'a Value;
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
index d6db69c748fb568aaa339ae8e01046920d3156b0..ef27f04ae218bca54846e115942faa51851df64e 100644
--- a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -349,8 +349,10 @@ extern "C" void LLVMRustRemoveFunctionAttributes(LLVMValueRef Fn,
   F->setAttributes(PALNew);
 }
 
-// enable fpmath flag UnsafeAlgebra
-extern "C" void LLVMRustSetHasUnsafeAlgebra(LLVMValueRef V) {
+// Enable a fast-math flag
+//
+// https://llvm.org/docs/LangRef.html#fast-math-flags
+extern "C" void LLVMRustSetFastMath(LLVMValueRef V) {
   if (auto I = dyn_cast<Instruction>(unwrap<Value>(V))) {
     I->setFast(true);
   }
diff --git a/src/test/codegen/issue-84268.rs b/src/test/codegen/issue-84268.rs
new file mode 100644
index 0000000000000000000000000000000000000000..7ca1954470075ded1d98c43ee52b523624c4364b
--- /dev/null
+++ b/src/test/codegen/issue-84268.rs
@@ -0,0 +1,23 @@
+// compile-flags: -O --crate-type=rlib
+#![feature(platform_intrinsics, repr_simd)]
+
+extern "platform-intrinsic" {
+    fn simd_fabs<T>(x: T) -> T;
+    fn simd_eq<T, U>(x: T, y: T) -> U;
+}
+
+#[repr(simd)]
+pub struct V([f32; 4]);
+
+#[repr(simd)]
+pub struct M([i32; 4]);
+
+#[no_mangle]
+// CHECK-LABEL: @is_infinite
+pub fn is_infinite(v: V) -> M {
+    // CHECK: fabs
+    // CHECK: cmp oeq
+    unsafe {
+        simd_eq(simd_fabs(v), V([f32::INFINITY; 4]))
+    }
+}
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
index 0a687078cd8eb3c7c05063fe368c447ab6b600b6..e7bb2327a6e03b807fe5480736358d47ec9263ad 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @fabs_32x2
 #[no_mangle]
 pub unsafe fn fabs_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.fabs.v2f32
+    // CHECK: call <2 x float> @llvm.fabs.v2f32
     simd_fabs(a)
 }
 
 // CHECK-LABEL: @fabs_32x4
 #[no_mangle]
 pub unsafe fn fabs_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.fabs.v4f32
+    // CHECK: call <4 x float> @llvm.fabs.v4f32
     simd_fabs(a)
 }
 
 // CHECK-LABEL: @fabs_32x8
 #[no_mangle]
 pub unsafe fn fabs_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.fabs.v8f32
+    // CHECK: call <8 x float> @llvm.fabs.v8f32
     simd_fabs(a)
 }
 
 // CHECK-LABEL: @fabs_32x16
 #[no_mangle]
 pub unsafe fn fabs_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.fabs.v16f32
+    // CHECK: call <16 x float> @llvm.fabs.v16f32
     simd_fabs(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @fabs_64x4
 #[no_mangle]
 pub unsafe fn fabs_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.fabs.v4f64
+    // CHECK: call <4 x double> @llvm.fabs.v4f64
     simd_fabs(a)
 }
 
 // CHECK-LABEL: @fabs_64x2
 #[no_mangle]
 pub unsafe fn fabs_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.fabs.v2f64
+    // CHECK: call <2 x double> @llvm.fabs.v2f64
     simd_fabs(a)
 }
 
 // CHECK-LABEL: @fabs_64x8
 #[no_mangle]
 pub unsafe fn fabs_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.fabs.v8f64
+    // CHECK: call <8 x double> @llvm.fabs.v8f64
     simd_fabs(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
index 9d47339d163cc362f45e59a1be1ff06801e87b6f..e33482d7556265705422b66307f880d26928734c 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @ceil_32x2
 #[no_mangle]
 pub unsafe fn ceil_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.ceil.v2f32
+    // CHECK: call <2 x float> @llvm.ceil.v2f32
     simd_ceil(a)
 }
 
 // CHECK-LABEL: @ceil_32x4
 #[no_mangle]
 pub unsafe fn ceil_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.ceil.v4f32
+    // CHECK: call <4 x float> @llvm.ceil.v4f32
     simd_ceil(a)
 }
 
 // CHECK-LABEL: @ceil_32x8
 #[no_mangle]
 pub unsafe fn ceil_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.ceil.v8f32
+    // CHECK: call <8 x float> @llvm.ceil.v8f32
     simd_ceil(a)
 }
 
 // CHECK-LABEL: @ceil_32x16
 #[no_mangle]
 pub unsafe fn ceil_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.ceil.v16f32
+    // CHECK: call <16 x float> @llvm.ceil.v16f32
     simd_ceil(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @ceil_64x4
 #[no_mangle]
 pub unsafe fn ceil_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.ceil.v4f64
+    // CHECK: call <4 x double> @llvm.ceil.v4f64
     simd_ceil(a)
 }
 
 // CHECK-LABEL: @ceil_64x2
 #[no_mangle]
 pub unsafe fn ceil_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.ceil.v2f64
+    // CHECK: call <2 x double> @llvm.ceil.v2f64
     simd_ceil(a)
 }
 
 // CHECK-LABEL: @ceil_64x8
 #[no_mangle]
 pub unsafe fn ceil_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.ceil.v8f64
+    // CHECK: call <8 x double> @llvm.ceil.v8f64
     simd_ceil(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
index 770b2a730377b6be40f1e4f505d2aa8497beacb1..0f52952bc0c9cbc6e71992fb59dad7fe2fb1f910 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @fcos_32x2
 #[no_mangle]
 pub unsafe fn fcos_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.cos.v2f32
+    // CHECK: call <2 x float> @llvm.cos.v2f32
     simd_fcos(a)
 }
 
 // CHECK-LABEL: @fcos_32x4
 #[no_mangle]
 pub unsafe fn fcos_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.cos.v4f32
+    // CHECK: call <4 x float> @llvm.cos.v4f32
     simd_fcos(a)
 }
 
 // CHECK-LABEL: @fcos_32x8
 #[no_mangle]
 pub unsafe fn fcos_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.cos.v8f32
+    // CHECK: call <8 x float> @llvm.cos.v8f32
     simd_fcos(a)
 }
 
 // CHECK-LABEL: @fcos_32x16
 #[no_mangle]
 pub unsafe fn fcos_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.cos.v16f32
+    // CHECK: call <16 x float> @llvm.cos.v16f32
     simd_fcos(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @fcos_64x4
 #[no_mangle]
 pub unsafe fn fcos_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.cos.v4f64
+    // CHECK: call <4 x double> @llvm.cos.v4f64
     simd_fcos(a)
 }
 
 // CHECK-LABEL: @fcos_64x2
 #[no_mangle]
 pub unsafe fn fcos_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.cos.v2f64
+    // CHECK: call <2 x double> @llvm.cos.v2f64
     simd_fcos(a)
 }
 
 // CHECK-LABEL: @fcos_64x8
 #[no_mangle]
 pub unsafe fn fcos_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.cos.v8f64
+    // CHECK: call <8 x double> @llvm.cos.v8f64
     simd_fcos(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
index 33c8605066686f028d971a22de2e1e63562cee45..1154acf6924a07eac5db8fd2a082744cca980422 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @exp_32x2
 #[no_mangle]
 pub unsafe fn exp_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.exp.v2f32
+    // CHECK: call <2 x float> @llvm.exp.v2f32
     simd_fexp(a)
 }
 
 // CHECK-LABEL: @exp_32x4
 #[no_mangle]
 pub unsafe fn exp_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.exp.v4f32
+    // CHECK: call <4 x float> @llvm.exp.v4f32
     simd_fexp(a)
 }
 
 // CHECK-LABEL: @exp_32x8
 #[no_mangle]
 pub unsafe fn exp_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.exp.v8f32
+    // CHECK: call <8 x float> @llvm.exp.v8f32
     simd_fexp(a)
 }
 
 // CHECK-LABEL: @exp_32x16
 #[no_mangle]
 pub unsafe fn exp_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.exp.v16f32
+    // CHECK: call <16 x float> @llvm.exp.v16f32
     simd_fexp(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @exp_64x4
 #[no_mangle]
 pub unsafe fn exp_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.exp.v4f64
+    // CHECK: call <4 x double> @llvm.exp.v4f64
     simd_fexp(a)
 }
 
 // CHECK-LABEL: @exp_64x2
 #[no_mangle]
 pub unsafe fn exp_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.exp.v2f64
+    // CHECK: call <2 x double> @llvm.exp.v2f64
     simd_fexp(a)
 }
 
 // CHECK-LABEL: @exp_64x8
 #[no_mangle]
 pub unsafe fn exp_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.exp.v8f64
+    // CHECK: call <8 x double> @llvm.exp.v8f64
     simd_fexp(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
index f7a8986242d17e80608cc43e9cc2d6b4c61e6697..929dc9ac8dfead5d4ae6018676141def6e366f19 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @exp2_32x2
 #[no_mangle]
 pub unsafe fn exp2_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.exp2.v2f32
+    // CHECK: call <2 x float> @llvm.exp2.v2f32
     simd_fexp2(a)
 }
 
 // CHECK-LABEL: @exp2_32x4
 #[no_mangle]
 pub unsafe fn exp2_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.exp2.v4f32
+    // CHECK: call <4 x float> @llvm.exp2.v4f32
     simd_fexp2(a)
 }
 
 // CHECK-LABEL: @exp2_32x8
 #[no_mangle]
 pub unsafe fn exp2_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.exp2.v8f32
+    // CHECK: call <8 x float> @llvm.exp2.v8f32
     simd_fexp2(a)
 }
 
 // CHECK-LABEL: @exp2_32x16
 #[no_mangle]
 pub unsafe fn exp2_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.exp2.v16f32
+    // CHECK: call <16 x float> @llvm.exp2.v16f32
     simd_fexp2(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @exp2_64x4
 #[no_mangle]
 pub unsafe fn exp2_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.exp2.v4f64
+    // CHECK: call <4 x double> @llvm.exp2.v4f64
     simd_fexp2(a)
 }
 
 // CHECK-LABEL: @exp2_64x2
 #[no_mangle]
 pub unsafe fn exp2_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.exp2.v2f64
+    // CHECK: call <2 x double> @llvm.exp2.v2f64
     simd_fexp2(a)
 }
 
 // CHECK-LABEL: @exp2_64x8
 #[no_mangle]
 pub unsafe fn exp2_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.exp2.v8f64
+    // CHECK: call <8 x double> @llvm.exp2.v8f64
     simd_fexp2(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
index a4070317a62bb8cf4f4f5dfcaa07c0b3ef0d85f7..56ca644f6bd91cce00d679d54eadf0289bcf47b4 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @floor_32x2
 #[no_mangle]
 pub unsafe fn floor_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.floor.v2f32
+    // CHECK: call <2 x float> @llvm.floor.v2f32
     simd_floor(a)
 }
 
 // CHECK-LABEL: @floor_32x4
 #[no_mangle]
 pub unsafe fn floor_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.floor.v4f32
+    // CHECK: call <4 x float> @llvm.floor.v4f32
     simd_floor(a)
 }
 
 // CHECK-LABEL: @floor_32x8
 #[no_mangle]
 pub unsafe fn floor_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.floor.v8f32
+    // CHECK: call <8 x float> @llvm.floor.v8f32
     simd_floor(a)
 }
 
 // CHECK-LABEL: @floor_32x16
 #[no_mangle]
 pub unsafe fn floor_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.floor.v16f32
+    // CHECK: call <16 x float> @llvm.floor.v16f32
     simd_floor(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @floor_64x4
 #[no_mangle]
 pub unsafe fn floor_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.floor.v4f64
+    // CHECK: call <4 x double> @llvm.floor.v4f64
     simd_floor(a)
 }
 
 // CHECK-LABEL: @floor_64x2
 #[no_mangle]
 pub unsafe fn floor_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.floor.v2f64
+    // CHECK: call <2 x double> @llvm.floor.v2f64
     simd_floor(a)
 }
 
 // CHECK-LABEL: @floor_64x8
 #[no_mangle]
 pub unsafe fn floor_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.floor.v8f64
+    // CHECK: call <8 x double> @llvm.floor.v8f64
     simd_floor(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
index 0800a498cb718f74661e7ba22d3a57df5f05bd2d..fd65cb72baa4c146bc24293336391c7f11f957eb 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @fma_32x2
 #[no_mangle]
 pub unsafe fn fma_32x2(a: f32x2, b: f32x2, c: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.fma.v2f32
+    // CHECK: call <2 x float> @llvm.fma.v2f32
     simd_fma(a, b, c)
 }
 
 // CHECK-LABEL: @fma_32x4
 #[no_mangle]
 pub unsafe fn fma_32x4(a: f32x4, b: f32x4, c: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.fma.v4f32
+    // CHECK: call <4 x float> @llvm.fma.v4f32
     simd_fma(a, b, c)
 }
 
 // CHECK-LABEL: @fma_32x8
 #[no_mangle]
 pub unsafe fn fma_32x8(a: f32x8, b: f32x8, c: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.fma.v8f32
+    // CHECK: call <8 x float> @llvm.fma.v8f32
     simd_fma(a, b, c)
 }
 
 // CHECK-LABEL: @fma_32x16
 #[no_mangle]
 pub unsafe fn fma_32x16(a: f32x16, b: f32x16, c: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.fma.v16f32
+    // CHECK: call <16 x float> @llvm.fma.v16f32
     simd_fma(a, b, c)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @fma_64x4
 #[no_mangle]
 pub unsafe fn fma_64x4(a: f64x4, b: f64x4, c: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.fma.v4f64
+    // CHECK: call <4 x double> @llvm.fma.v4f64
     simd_fma(a, b, c)
 }
 
 // CHECK-LABEL: @fma_64x2
 #[no_mangle]
 pub unsafe fn fma_64x2(a: f64x2, b: f64x2, c: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.fma.v2f64
+    // CHECK: call <2 x double> @llvm.fma.v2f64
     simd_fma(a, b, c)
 }
 
 // CHECK-LABEL: @fma_64x8
 #[no_mangle]
 pub unsafe fn fma_64x8(a: f64x8, b: f64x8, c: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.fma.v8f64
+    // CHECK: call <8 x double> @llvm.fma.v8f64
     simd_fma(a, b, c)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
index adc44ffd811758a49eacb72ee52974097b5ddaac..adc1919256e76ac88d93e6c4f87c925d7b87d374 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @fsqrt_32x2
 #[no_mangle]
 pub unsafe fn fsqrt_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.sqrt.v2f32
+    // CHECK: call <2 x float> @llvm.sqrt.v2f32
     simd_fsqrt(a)
 }
 
 // CHECK-LABEL: @fsqrt_32x4
 #[no_mangle]
 pub unsafe fn fsqrt_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.sqrt.v4f32
+    // CHECK: call <4 x float> @llvm.sqrt.v4f32
     simd_fsqrt(a)
 }
 
 // CHECK-LABEL: @fsqrt_32x8
 #[no_mangle]
 pub unsafe fn fsqrt_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.sqrt.v8f32
+    // CHECK: call <8 x float> @llvm.sqrt.v8f32
     simd_fsqrt(a)
 }
 
 // CHECK-LABEL: @fsqrt_32x16
 #[no_mangle]
 pub unsafe fn fsqrt_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.sqrt.v16f32
+    // CHECK: call <16 x float> @llvm.sqrt.v16f32
     simd_fsqrt(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @fsqrt_64x4
 #[no_mangle]
 pub unsafe fn fsqrt_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.sqrt.v4f64
+    // CHECK: call <4 x double> @llvm.sqrt.v4f64
     simd_fsqrt(a)
 }
 
 // CHECK-LABEL: @fsqrt_64x2
 #[no_mangle]
 pub unsafe fn fsqrt_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.sqrt.v2f64
+    // CHECK: call <2 x double> @llvm.sqrt.v2f64
     simd_fsqrt(a)
 }
 
 // CHECK-LABEL: @fsqrt_64x8
 #[no_mangle]
 pub unsafe fn fsqrt_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.sqrt.v8f64
+    // CHECK: call <8 x double> @llvm.sqrt.v8f64
     simd_fsqrt(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
index 9c236f196362ec6276509d829e18c2b8bf5a7ae7..c072519c0d65dfaa0a0044924c4c5a01dbc23b35 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @log_32x2
 #[no_mangle]
 pub unsafe fn log_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.log.v2f32
+    // CHECK: call <2 x float> @llvm.log.v2f32
     simd_flog(a)
 }
 
 // CHECK-LABEL: @log_32x4
 #[no_mangle]
 pub unsafe fn log_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.log.v4f32
+    // CHECK: call <4 x float> @llvm.log.v4f32
     simd_flog(a)
 }
 
 // CHECK-LABEL: @log_32x8
 #[no_mangle]
 pub unsafe fn log_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.log.v8f32
+    // CHECK: call <8 x float> @llvm.log.v8f32
     simd_flog(a)
 }
 
 // CHECK-LABEL: @log_32x16
 #[no_mangle]
 pub unsafe fn log_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.log.v16f32
+    // CHECK: call <16 x float> @llvm.log.v16f32
     simd_flog(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @log_64x4
 #[no_mangle]
 pub unsafe fn log_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.log.v4f64
+    // CHECK: call <4 x double> @llvm.log.v4f64
     simd_flog(a)
 }
 
 // CHECK-LABEL: @log_64x2
 #[no_mangle]
 pub unsafe fn log_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.log.v2f64
+    // CHECK: call <2 x double> @llvm.log.v2f64
     simd_flog(a)
 }
 
 // CHECK-LABEL: @log_64x8
 #[no_mangle]
 pub unsafe fn log_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.log.v8f64
+    // CHECK: call <8 x double> @llvm.log.v8f64
     simd_flog(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
index a922161affab600411039669e036f796b35eeb89..5fd64899507822b3c0c6c6bd9932b92edb652cdf 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @log10_32x2
 #[no_mangle]
 pub unsafe fn log10_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.log10.v2f32
+    // CHECK: call <2 x float> @llvm.log10.v2f32
     simd_flog10(a)
 }
 
 // CHECK-LABEL: @log10_32x4
 #[no_mangle]
 pub unsafe fn log10_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.log10.v4f32
+    // CHECK: call <4 x float> @llvm.log10.v4f32
     simd_flog10(a)
 }
 
 // CHECK-LABEL: @log10_32x8
 #[no_mangle]
 pub unsafe fn log10_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.log10.v8f32
+    // CHECK: call <8 x float> @llvm.log10.v8f32
     simd_flog10(a)
 }
 
 // CHECK-LABEL: @log10_32x16
 #[no_mangle]
 pub unsafe fn log10_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.log10.v16f32
+    // CHECK: call <16 x float> @llvm.log10.v16f32
     simd_flog10(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @log10_64x4
 #[no_mangle]
 pub unsafe fn log10_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.log10.v4f64
+    // CHECK: call <4 x double> @llvm.log10.v4f64
     simd_flog10(a)
 }
 
 // CHECK-LABEL: @log10_64x2
 #[no_mangle]
 pub unsafe fn log10_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.log10.v2f64
+    // CHECK: call <2 x double> @llvm.log10.v2f64
     simd_flog10(a)
 }
 
 // CHECK-LABEL: @log10_64x8
 #[no_mangle]
 pub unsafe fn log10_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.log10.v8f64
+    // CHECK: call <8 x double> @llvm.log10.v8f64
     simd_flog10(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
index 9624acb383fbd17f42bd34c1fd36aab833bd98e7..35175f0ca572be5aa5d38c91bf9445a1893b5ea8 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @log2_32x2
 #[no_mangle]
 pub unsafe fn log2_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.log2.v2f32
+    // CHECK: call <2 x float> @llvm.log2.v2f32
     simd_flog2(a)
 }
 
 // CHECK-LABEL: @log2_32x4
 #[no_mangle]
 pub unsafe fn log2_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.log2.v4f32
+    // CHECK: call <4 x float> @llvm.log2.v4f32
     simd_flog2(a)
 }
 
 // CHECK-LABEL: @log2_32x8
 #[no_mangle]
 pub unsafe fn log2_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.log2.v8f32
+    // CHECK: call <8 x float> @llvm.log2.v8f32
     simd_flog2(a)
 }
 
 // CHECK-LABEL: @log2_32x16
 #[no_mangle]
 pub unsafe fn log2_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.log2.v16f32
+    // CHECK: call <16 x float> @llvm.log2.v16f32
     simd_flog2(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @log2_64x4
 #[no_mangle]
 pub unsafe fn log2_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.log2.v4f64
+    // CHECK: call <4 x double> @llvm.log2.v4f64
     simd_flog2(a)
 }
 
 // CHECK-LABEL: @log2_64x2
 #[no_mangle]
 pub unsafe fn log2_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.log2.v2f64
+    // CHECK: call <2 x double> @llvm.log2.v2f64
     simd_flog2(a)
 }
 
 // CHECK-LABEL: @log2_64x8
 #[no_mangle]
 pub unsafe fn log2_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.log2.v8f64
+    // CHECK: call <8 x double> @llvm.log2.v8f64
     simd_flog2(a)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-pow.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-pow.rs
index 6639e5d652b04be215b89d43e2c65e4926cdadd6..3b8d611ab675bf4e9f0008800e2bb05aec4f20f8 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-pow.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-pow.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @fpow_32x2
 #[no_mangle]
 pub unsafe fn fpow_32x2(a: f32x2, b: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.pow.v2f32
+    // CHECK: call <2 x float> @llvm.pow.v2f32
     simd_fpow(a, b)
 }
 
 // CHECK-LABEL: @fpow_32x4
 #[no_mangle]
 pub unsafe fn fpow_32x4(a: f32x4, b: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.pow.v4f32
+    // CHECK: call <4 x float> @llvm.pow.v4f32
     simd_fpow(a, b)
 }
 
 // CHECK-LABEL: @fpow_32x8
 #[no_mangle]
 pub unsafe fn fpow_32x8(a: f32x8, b: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.pow.v8f32
+    // CHECK: call <8 x float> @llvm.pow.v8f32
     simd_fpow(a, b)
 }
 
 // CHECK-LABEL: @fpow_32x16
 #[no_mangle]
 pub unsafe fn fpow_32x16(a: f32x16, b: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.pow.v16f32
+    // CHECK: call <16 x float> @llvm.pow.v16f32
     simd_fpow(a, b)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @fpow_64x4
 #[no_mangle]
 pub unsafe fn fpow_64x4(a: f64x4, b: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.pow.v4f64
+    // CHECK: call <4 x double> @llvm.pow.v4f64
     simd_fpow(a, b)
 }
 
 // CHECK-LABEL: @fpow_64x2
 #[no_mangle]
 pub unsafe fn fpow_64x2(a: f64x2, b: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.pow.v2f64
+    // CHECK: call <2 x double> @llvm.pow.v2f64
     simd_fpow(a, b)
 }
 
 // CHECK-LABEL: @fpow_64x8
 #[no_mangle]
 pub unsafe fn fpow_64x8(a: f64x8, b: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.pow.v8f64
+    // CHECK: call <8 x double> @llvm.pow.v8f64
     simd_fpow(a, b)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-powi.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-powi.rs
index 5e82ea023d8e094070734651abdf6938a1e4ca11..e80c50c1076741b87813a386ea090a0d33e723bd 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-powi.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-powi.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @fpowi_32x2
 #[no_mangle]
 pub unsafe fn fpowi_32x2(a: f32x2, b: i32) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.powi.v2f32
+    // CHECK: call <2 x float> @llvm.powi.v2f32
     simd_fpowi(a, b)
 }
 
 // CHECK-LABEL: @fpowi_32x4
 #[no_mangle]
 pub unsafe fn fpowi_32x4(a: f32x4, b: i32) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.powi.v4f32
+    // CHECK: call <4 x float> @llvm.powi.v4f32
     simd_fpowi(a, b)
 }
 
 // CHECK-LABEL: @fpowi_32x8
 #[no_mangle]
 pub unsafe fn fpowi_32x8(a: f32x8, b: i32) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.powi.v8f32
+    // CHECK: call <8 x float> @llvm.powi.v8f32
     simd_fpowi(a, b)
 }
 
 // CHECK-LABEL: @fpowi_32x16
 #[no_mangle]
 pub unsafe fn fpowi_32x16(a: f32x16, b: i32) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.powi.v16f32
+    // CHECK: call <16 x float> @llvm.powi.v16f32
     simd_fpowi(a, b)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @fpowi_64x4
 #[no_mangle]
 pub unsafe fn fpowi_64x4(a: f64x4, b: i32) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.powi.v4f64
+    // CHECK: call <4 x double> @llvm.powi.v4f64
     simd_fpowi(a, b)
 }
 
 // CHECK-LABEL: @fpowi_64x2
 #[no_mangle]
 pub unsafe fn fpowi_64x2(a: f64x2, b: i32) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.powi.v2f64
+    // CHECK: call <2 x double> @llvm.powi.v2f64
     simd_fpowi(a, b)
 }
 
 // CHECK-LABEL: @fpowi_64x8
 #[no_mangle]
 pub unsafe fn fpowi_64x8(a: f64x8, b: i32) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.powi.v8f64
+    // CHECK: call <8 x double> @llvm.powi.v8f64
     simd_fpowi(a, b)
 }
diff --git a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
index 8ca2ca86076492709a79d971b7b2fa26c871768c..9e3fab49aff63fb9ea14c54916383b7b8dda420c 100644
--- a/src/test/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
+++ b/src/test/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
@@ -32,28 +32,28 @@ pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
 // CHECK-LABEL: @fsin_32x2
 #[no_mangle]
 pub unsafe fn fsin_32x2(a: f32x2) -> f32x2 {
-    // CHECK: call fast <2 x float> @llvm.sin.v2f32
+    // CHECK: call <2 x float> @llvm.sin.v2f32
     simd_fsin(a)
 }
 
 // CHECK-LABEL: @fsin_32x4
 #[no_mangle]
 pub unsafe fn fsin_32x4(a: f32x4) -> f32x4 {
-    // CHECK: call fast <4 x float> @llvm.sin.v4f32
+    // CHECK: call <4 x float> @llvm.sin.v4f32
     simd_fsin(a)
 }
 
 // CHECK-LABEL: @fsin_32x8
 #[no_mangle]
 pub unsafe fn fsin_32x8(a: f32x8) -> f32x8 {
-    // CHECK: call fast <8 x float> @llvm.sin.v8f32
+    // CHECK: call <8 x float> @llvm.sin.v8f32
     simd_fsin(a)
 }
 
 // CHECK-LABEL: @fsin_32x16
 #[no_mangle]
 pub unsafe fn fsin_32x16(a: f32x16) -> f32x16 {
-    // CHECK: call fast <16 x float> @llvm.sin.v16f32
+    // CHECK: call <16 x float> @llvm.sin.v16f32
     simd_fsin(a)
 }
 
@@ -73,20 +73,20 @@ pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
 // CHECK-LABEL: @fsin_64x4
 #[no_mangle]
 pub unsafe fn fsin_64x4(a: f64x4) -> f64x4 {
-    // CHECK: call fast <4 x double> @llvm.sin.v4f64
+    // CHECK: call <4 x double> @llvm.sin.v4f64
     simd_fsin(a)
 }
 
 // CHECK-LABEL: @fsin_64x2
 #[no_mangle]
 pub unsafe fn fsin_64x2(a: f64x2) -> f64x2 {
-    // CHECK: call fast <2 x double> @llvm.sin.v2f64
+    // CHECK: call <2 x double> @llvm.sin.v2f64
     simd_fsin(a)
 }
 
 // CHECK-LABEL: @fsin_64x8
 #[no_mangle]
 pub unsafe fn fsin_64x8(a: f64x8) -> f64x8 {
-    // CHECK: call fast <8 x double> @llvm.sin.v8f64
+    // CHECK: call <8 x double> @llvm.sin.v8f64
     simd_fsin(a)
 }