ret i64 %result
}
-define i64 @f26(float %x) {
+define i64 @f26(float %x) #0 {
; X87-LABEL: f26:
; X87: # %bb.0: # %entry
; X87-NEXT: subl $12, %esp
; X87-NEXT: .cfi_def_cfa_offset 16
; X87-NEXT: flds {{[0-9]+}}(%esp)
; X87-NEXT: fstps (%esp)
+; X87-NEXT: wait
; X87-NEXT: calll llrintf
; X87-NEXT: addl $12, %esp
; X87-NEXT: .cfi_def_cfa_offset 4
br i1 %3, label %4, label %5
4: ; preds = %2
- tail call void @bar()
+ tail call void @bar() #0
br label %5
5: ; preds = %4, %2
; AVX-X64-NEXT: vroundss $10, %xmm0, %xmm0, %xmm0
; AVX-X64-NEXT: retq
%res = call float @llvm.experimental.constrained.ceil.f32(
- float %f, metadata !"fpexcept.strict")
+ float %f, metadata !"fpexcept.strict") #0
ret float %res
}
; AVX-X64-NEXT: vroundsd $10, %xmm0, %xmm0, %xmm0
; AVX-X64-NEXT: retq
%res = call double @llvm.experimental.constrained.ceil.f64(
- double %f, metadata !"fpexcept.strict")
+ double %f, metadata !"fpexcept.strict") #0
ret double %res
}
; AVX-X64-NEXT: vroundss $9, %xmm0, %xmm0, %xmm0
; AVX-X64-NEXT: retq
%res = call float @llvm.experimental.constrained.floor.f32(
- float %f, metadata !"fpexcept.strict")
+ float %f, metadata !"fpexcept.strict") #0
ret float %res
}
; AVX-X64-NEXT: vroundsd $9, %xmm0, %xmm0, %xmm0
; AVX-X64-NEXT: retq
%res = call double @llvm.experimental.constrained.floor.f64(
- double %f, metadata !"fpexcept.strict")
+ double %f, metadata !"fpexcept.strict") #0
ret double %res
}
; AVX-X64-NEXT: vroundss $11, %xmm0, %xmm0, %xmm0
; AVX-X64-NEXT: retq
%res = call float @llvm.experimental.constrained.trunc.f32(
- float %f, metadata !"fpexcept.strict")
+ float %f, metadata !"fpexcept.strict") #0
ret float %res
}
; AVX-X64-NEXT: vroundsd $11, %xmm0, %xmm0, %xmm0
; AVX-X64-NEXT: retq
%res = call double @llvm.experimental.constrained.trunc.f64(
- double %f, metadata !"fpexcept.strict")
+ double %f, metadata !"fpexcept.strict") #0
ret double %res
}
; AVX-X64-NEXT: retq
%res = call float @llvm.experimental.constrained.rint.f32(
float %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret float %res
}
; AVX-X64-NEXT: retq
%res = call double @llvm.experimental.constrained.rint.f64(
double %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret double %res
}
; AVX-X64-NEXT: retq
%res = call float @llvm.experimental.constrained.nearbyint.f32(
float %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret float %res
}
; AVX-X64-NEXT: retq
%res = call double @llvm.experimental.constrained.nearbyint.f64(
double %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret double %res
}
%ext = extractelement <2 x double> %a0, i32 0
%cvt = call float @llvm.experimental.constrained.fptrunc.f32.f64(double %ext,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%res = insertelement <4 x float> %a1, float %cvt, i32 0
ret <4 x float> %res
}
; CHECK-NEXT: vroundps $10, %ymm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <8 x float> @llvm.experimental.constrained.ceil.v8f32(
- <8 x float> %f, metadata !"fpexcept.strict")
+ <8 x float> %f, metadata !"fpexcept.strict") #0
ret <8 x float> %res
}
; CHECK-NEXT: vroundpd $10, %ymm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <4 x double> @llvm.experimental.constrained.ceil.v4f64(
- <4 x double> %f, metadata !"fpexcept.strict")
+ <4 x double> %f, metadata !"fpexcept.strict") #0
ret <4 x double> %res
}
; CHECK-NEXT: vroundps $9, %ymm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <8 x float> @llvm.experimental.constrained.floor.v8f32(
- <8 x float> %f, metadata !"fpexcept.strict")
+ <8 x float> %f, metadata !"fpexcept.strict") #0
ret <8 x float> %res
}
; CHECK-NEXT: vroundpd $9, %ymm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <4 x double> @llvm.experimental.constrained.floor.v4f64(
- <4 x double> %f, metadata !"fpexcept.strict")
+ <4 x double> %f, metadata !"fpexcept.strict") #0
ret <4 x double> %res
}
; CHECK-NEXT: vroundps $11, %ymm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <8 x float> @llvm.experimental.constrained.trunc.v8f32(
- <8 x float> %f, metadata !"fpexcept.strict")
+ <8 x float> %f, metadata !"fpexcept.strict") #0
ret <8 x float> %res
}
; CHECK-NEXT: vroundpd $11, %ymm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <4 x double> @llvm.experimental.constrained.trunc.v4f64(
- <4 x double> %f, metadata !"fpexcept.strict")
+ <4 x double> %f, metadata !"fpexcept.strict") #0
ret <4 x double> %res
}
; CHECK-NEXT: ret{{[l|q]}}
%res = call <8 x float> @llvm.experimental.constrained.rint.v8f32(
<8 x float> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <8 x float> %res
}
; CHECK-NEXT: ret{{[l|q]}}
%res = call <4 x double> @llvm.experimental.constrained.rint.v4f64(
<4 x double> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <4 x double> %res
}
; CHECK-NEXT: ret{{[l|q]}}
%res = call <8 x float> @llvm.experimental.constrained.nearbyint.v8f32(
<8 x float> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <8 x float> %res
}
; CHECK-NEXT: ret{{[l|q]}}
%res = call <4 x double> @llvm.experimental.constrained.nearbyint.v4f64(
<4 x double> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <4 x double> %res
}
; CHECK: # %bb.0:
; CHECK-NEXT: vrndscaleps $10, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
- %res = call <16 x float> @llvm.experimental.constrained.ceil.v16f32(<16 x float> %f, metadata !"fpexcept.strict")
+ %res = call <16 x float> @llvm.experimental.constrained.ceil.v16f32(<16 x float> %f, metadata !"fpexcept.strict") #0
ret <16 x float> %res
}
; CHECK: # %bb.0:
; CHECK-NEXT: vrndscalepd $10, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
- %res = call <8 x double> @llvm.experimental.constrained.ceil.v8f64(<8 x double> %f, metadata !"fpexcept.strict")
+ %res = call <8 x double> @llvm.experimental.constrained.ceil.v8f64(<8 x double> %f, metadata !"fpexcept.strict") #0
ret <8 x double> %res
}
; CHECK: # %bb.0:
; CHECK-NEXT: vrndscaleps $9, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
- %res = call <16 x float> @llvm.experimental.constrained.floor.v16f32(<16 x float> %f, metadata !"fpexcept.strict")
+ %res = call <16 x float> @llvm.experimental.constrained.floor.v16f32(<16 x float> %f, metadata !"fpexcept.strict") #0
ret <16 x float> %res
}
; CHECK: # %bb.0:
; CHECK-NEXT: vrndscalepd $9, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
- %res = call <8 x double> @llvm.experimental.constrained.floor.v8f64(<8 x double> %f, metadata !"fpexcept.strict")
+ %res = call <8 x double> @llvm.experimental.constrained.floor.v8f64(<8 x double> %f, metadata !"fpexcept.strict") #0
ret <8 x double> %res
}
; CHECK: # %bb.0:
; CHECK-NEXT: vrndscaleps $11, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
- %res = call <16 x float> @llvm.experimental.constrained.trunc.v16f32(<16 x float> %f, metadata !"fpexcept.strict")
+ %res = call <16 x float> @llvm.experimental.constrained.trunc.v16f32(<16 x float> %f, metadata !"fpexcept.strict") #0
ret <16 x float> %res
}
; CHECK: # %bb.0:
; CHECK-NEXT: vrndscalepd $11, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
- %res = call <8 x double> @llvm.experimental.constrained.trunc.v8f64(<8 x double> %f, metadata !"fpexcept.strict")
+ %res = call <8 x double> @llvm.experimental.constrained.trunc.v8f64(<8 x double> %f, metadata !"fpexcept.strict") #0
ret <8 x double> %res
}
; CHECK-NEXT: vrndscaleps $4, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <16 x float> @llvm.experimental.constrained.rint.v16f32(<16 x float> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <16 x float> %res
}
; CHECK-NEXT: vrndscalepd $4, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <8 x double> @llvm.experimental.constrained.rint.v8f64(<8 x double> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <8 x double> %res
}
; CHECK-NEXT: vrndscaleps $12, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <16 x float> @llvm.experimental.constrained.nearbyint.v16f32(<16 x float> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <16 x float> %res
}
; CHECK-NEXT: vrndscalepd $12, %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
%res = call <8 x double> @llvm.experimental.constrained.nearbyint.v8f64(<8 x double> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <8 x double> %res
}
; AVX512VLDQ-NEXT: vcvttpd2qq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %ret
}
; AVX512VLDQ-NEXT: vcvttpd2uqq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %ret
}
; AVX512VLDQ-NEXT: vcvttps2qq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %ret
}
; AVX512VLDQ-NEXT: vcvttps2uqq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %ret
}
; AVX512VLDQ-NEXT: vcvttpd2dq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i32> %ret
}
; AVX512VLDQ-NEXT: vcvttpd2udq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i32> %ret
}
; AVX512VLDQ-NEXT: vcvttps2dq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i32> %ret
}
; AVX512VLDQ-NEXT: vcvttps2udq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i32> %ret
}
; AVX512VLDQ-NEXT: vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i16> @llvm.experimental.constrained.fptosi.v2i16.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i16> %ret
}
; AVX512VLDQ-NEXT: vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i16> @llvm.experimental.constrained.fptoui.v2i16.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i16> %ret
}
; AVX512VLDQ-NEXT: vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i16> @llvm.experimental.constrained.fptosi.v2i16.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i16> %ret
}
; AVX512VLDQ-NEXT: vpshuflw {{.*#+}} xmm0 = xmm0[0,2,2,3,4,5,6,7]
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i16> @llvm.experimental.constrained.fptoui.v2i16.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i16> %ret
}
; AVX512VLDQ-NEXT: vpmovdb %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i8> @llvm.experimental.constrained.fptosi.v2i8.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i8> %ret
}
; AVX512VLDQ-NEXT: vpmovdb %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i8> @llvm.experimental.constrained.fptoui.v2i8.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i8> %ret
}
; AVX512VLDQ-NEXT: vpmovdb %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i8> @llvm.experimental.constrained.fptosi.v2i8.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i8> %ret
}
; AVX512VLDQ-NEXT: vpmovdb %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i8> @llvm.experimental.constrained.fptoui.v2i8.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i8> %ret
}
; AVX512VLDQ-NEXT: vpmovm2q %k0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i1> @llvm.experimental.constrained.fptosi.v2i1.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i1> %ret
}
; AVX512VLDQ-NEXT: vpmovm2q %k0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i1> @llvm.experimental.constrained.fptoui.v2i1.v2f64(<2 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i1> %ret
}
; AVX512VLDQ-NEXT: vpmovm2q %k0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i1> @llvm.experimental.constrained.fptosi.v2i1.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i1> %ret
}
; AVX512VLDQ-NEXT: vpmovm2q %k0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <2 x i1> @llvm.experimental.constrained.fptoui.v2i1.v2f32(<2 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i1> %ret
}
; AVX512VLDQ-NEXT: vcvttps2dq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f32(<4 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %ret
}
; AVX512VLDQ-NEXT: vcvttps2udq %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f32(<4 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %ret
}
; AVX512VLDQ-NEXT: vpmovdb %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <4 x i8> @llvm.experimental.constrained.fptosi.v4i8.v4f32(<4 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i8> %ret
}
; AVX512VLDQ-NEXT: vpmovdb %xmm0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <4 x i8> @llvm.experimental.constrained.fptoui.v4i8.v4f32(<4 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i8> %ret
}
; AVX512VLDQ-NEXT: vpmovm2d %k0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <4 x i1> @llvm.experimental.constrained.fptosi.v4i1.v4f32(<4 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i1> %ret
}
; AVX512VLDQ-NEXT: vpmovm2d %k0, %xmm0
; AVX512VLDQ-NEXT: ret{{[l|q]}}
%ret = call <4 x i1> @llvm.experimental.constrained.fptoui.v4i1.v4f32(<4 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i1> %ret
}
; AVX512DQVL-NEXT: vcvttpd2qq %ymm0, %ymm0
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i64> @llvm.experimental.constrained.fptosi.v4i64.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i64> %ret
}
; AVX512DQVL-NEXT: vcvttpd2uqq %ymm0, %ymm0
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i64> @llvm.experimental.constrained.fptoui.v4i64.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i64> %ret
}
; AVX512DQVL-NEXT: vcvttps2qq %xmm0, %ymm0
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i64> @llvm.experimental.constrained.fptosi.v4i64.v4f32(<4 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i64> %ret
}
; AVX512DQVL-NEXT: vcvttps2uqq %xmm0, %ymm0
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i64> @llvm.experimental.constrained.fptoui.v4i64.v4f32(<4 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i64> %ret
}
; CHECK-NEXT: vzeroupper
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %ret
}
; CHECK-NEXT: vzeroupper
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <4 x i16> @llvm.experimental.constrained.fptosi.v4i16.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i16> %ret
}
; CHECK-NEXT: vzeroupper
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <4 x i16> @llvm.experimental.constrained.fptoui.v4i16.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i16> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i8> @llvm.experimental.constrained.fptosi.v4i8.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i8> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i8> @llvm.experimental.constrained.fptoui.v4i8.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i8> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i1> @llvm.experimental.constrained.fptosi.v4i1.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i1> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <4 x i1> @llvm.experimental.constrained.fptoui.v4i1.v4f64(<4 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i1> %ret
}
; CHECK-NEXT: vcvttps2dq %ymm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <8 x i32> @llvm.experimental.constrained.fptosi.v8i32.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i32> %ret
}
; AVX512DQVL-NEXT: vcvttps2udq %ymm0, %ymm0
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <8 x i32> @llvm.experimental.constrained.fptoui.v8i32.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i32> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <8 x i16> @llvm.experimental.constrained.fptosi.v8i16.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i16> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <8 x i16> @llvm.experimental.constrained.fptoui.v8i16.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i16> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <8 x i8> @llvm.experimental.constrained.fptosi.v8i8.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i8> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <8 x i8> @llvm.experimental.constrained.fptoui.v8i8.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i8> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <8 x i1> @llvm.experimental.constrained.fptosi.v8i1.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i1> %ret
}
; AVX512DQVL-NEXT: vzeroupper
; AVX512DQVL-NEXT: ret{{[l|q]}}
%ret = call <8 x i1> @llvm.experimental.constrained.fptoui.v8i1.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i1> %ret
}
; AVX512DQ-NEXT: vcvttpd2qq %zmm0, %zmm0
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i64> @llvm.experimental.constrained.fptosi.v8i64.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i64> %ret
}
; AVX512DQ-NEXT: vcvttpd2uqq %zmm0, %zmm0
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i64> @llvm.experimental.constrained.fptoui.v8i64.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i64> %ret
}
; AVX512DQ-NEXT: vcvttps2qq %ymm0, %zmm0
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i64> @llvm.experimental.constrained.fptosi.v8i64.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i64> %ret
}
; AVX512DQ-NEXT: vcvttps2uqq %ymm0, %zmm0
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i64> @llvm.experimental.constrained.fptoui.v8i64.v8f32(<8 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i64> %ret
}
; CHECK-NEXT: vcvttpd2dq %zmm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <8 x i32> @llvm.experimental.constrained.fptosi.v8i32.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i32> %ret
}
; CHECK-NEXT: vcvttpd2udq %zmm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <8 x i32> @llvm.experimental.constrained.fptoui.v8i32.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i32> %ret
}
; AVX512DQ-NEXT: vzeroupper
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i16> @llvm.experimental.constrained.fptosi.v8i16.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i16> %ret
}
; AVX512DQ-NEXT: vzeroupper
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i16> @llvm.experimental.constrained.fptoui.v8i16.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i16> %ret
}
; AVX512DQ-NEXT: vzeroupper
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i8> @llvm.experimental.constrained.fptosi.v8i8.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i8> %ret
}
; AVX512DQ-NEXT: vzeroupper
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i8> @llvm.experimental.constrained.fptoui.v8i8.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i8> %ret
}
; AVX512DQ-NEXT: vzeroupper
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i1> @llvm.experimental.constrained.fptosi.v8i1.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i1> %ret
}
; AVX512DQ-NEXT: vzeroupper
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <8 x i1> @llvm.experimental.constrained.fptoui.v8i1.v8f64(<8 x double> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x i1> %ret
}
; CHECK-NEXT: vcvttps2dq %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <16 x i32> @llvm.experimental.constrained.fptosi.v16i32.v16f32(<16 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <16 x i32> %ret
}
; CHECK-NEXT: vcvttps2udq %zmm0, %zmm0
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <16 x i32> @llvm.experimental.constrained.fptoui.v16i32.v16f32(<16 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <16 x i32> %ret
}
; CHECK-NEXT: vpmovdw %zmm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <16 x i16> @llvm.experimental.constrained.fptosi.v16i16.v16f32(<16 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <16 x i16> %ret
}
; CHECK-NEXT: vpmovdw %zmm0, %ymm0
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <16 x i16> @llvm.experimental.constrained.fptoui.v16i16.v16f32(<16 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <16 x i16> %ret
}
; CHECK-NEXT: vzeroupper
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <16 x i8> @llvm.experimental.constrained.fptosi.v16i8.v16f32(<16 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <16 x i8> %ret
}
; CHECK-NEXT: vzeroupper
; CHECK-NEXT: ret{{[l|q]}}
%ret = call <16 x i8> @llvm.experimental.constrained.fptoui.v16i8.v16f32(<16 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <16 x i8> %ret
}
; AVX512DQ-NEXT: vzeroupper
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <16 x i1> @llvm.experimental.constrained.fptosi.v16i1.v16f32(<16 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <16 x i1> %ret
}
; AVX512DQ-NEXT: vzeroupper
; AVX512DQ-NEXT: ret{{[l|q]}}
%ret = call <16 x i1> @llvm.experimental.constrained.fptoui.v16i1.v16f32(<16 x float> %a,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <16 x i1> %ret
}
; AVX-NEXT: vroundps $10, %xmm0, %xmm0
; AVX-NEXT: ret{{[l|q]}}
%res = call <4 x float> @llvm.experimental.constrained.ceil.v4f32(
- <4 x float> %f, metadata !"fpexcept.strict")
+ <4 x float> %f, metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
; AVX-NEXT: vroundpd $10, %xmm0, %xmm0
; AVX-NEXT: ret{{[l|q]}}
%res = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
- <2 x double> %f, metadata !"fpexcept.strict")
+ <2 x double> %f, metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
; AVX-NEXT: vroundps $9, %xmm0, %xmm0
; AVX-NEXT: ret{{[l|q]}}
%res = call <4 x float> @llvm.experimental.constrained.floor.v4f32(
- <4 x float> %f, metadata !"fpexcept.strict")
+ <4 x float> %f, metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
; AVX-NEXT: vroundpd $9, %xmm0, %xmm0
; AVX-NEXT: ret{{[l|q]}}
%res = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
- <2 x double> %f, metadata !"fpexcept.strict")
+ <2 x double> %f, metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
; AVX-NEXT: vroundps $11, %xmm0, %xmm0
; AVX-NEXT: ret{{[l|q]}}
%res = call <4 x float> @llvm.experimental.constrained.trunc.v4f32(
- <4 x float> %f, metadata !"fpexcept.strict")
+ <4 x float> %f, metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
; AVX-NEXT: vroundpd $11, %xmm0, %xmm0
; AVX-NEXT: ret{{[l|q]}}
%res = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
- <2 x double> %f, metadata !"fpexcept.strict")
+ <2 x double> %f, metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
; AVX-NEXT: ret{{[l|q]}}
%res = call <4 x float> @llvm.experimental.constrained.rint.v4f32(
<4 x float> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
; AVX-NEXT: ret{{[l|q]}}
%res = call <2 x double> @llvm.experimental.constrained.rint.v2f64(
<2 x double> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
; AVX-NEXT: ret{{[l|q]}}
%res = call <4 x float> @llvm.experimental.constrained.nearbyint.v4f32(
<4 x float> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
; AVX-NEXT: ret{{[l|q]}}
%res = call <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(
<2 x double> %f,
- metadata !"round.dynamic", metadata !"fpexcept.strict")
+ metadata !"round.dynamic", metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
ret <4 x double> %add
}
+attributes #0 = { strictfp }
+
declare <1 x float> @llvm.experimental.constrained.fadd.v1f32(<1 x float>, <1 x float>, metadata, metadata)
declare <3 x float> @llvm.experimental.constrained.fadd.v3f32(<3 x float>, <3 x float>, metadata, metadata)
declare <4 x double> @llvm.experimental.constrained.fadd.v4f64(<4 x double>, <4 x double>, metadata, metadata)
ret <4 x float> %3
}
-define <4 x float> @load_cvt_8i16_to_4f32_constrained(<8 x i16>* %a0) nounwind {
+define <4 x float> @load_cvt_8i16_to_4f32_constrained(<8 x i16>* %a0) nounwind strictfp {
; ALL-LABEL: load_cvt_8i16_to_4f32_constrained:
; ALL: # %bb.0:
; ALL-NEXT: vcvtph2ps (%rdi), %xmm0