; Verify that no gross errors happen.
; CHECK-LABEL: @f20
; COMMON: cfdctsiz
-define i32 @f20(double %a) {
+define i32 @f20(double %a) strictfp {
entry:
%result = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double 42.1,
metadata !"fpexcept.strict")
+ strictfp
ret i32 %result
}
; RUN: llc -O3 -mtriple=powerpc64le-linux-gnu < %s | FileCheck --check-prefix=PC64LE %s
; RUN: llc -O3 -mtriple=powerpc64le-linux-gnu -mcpu=pwr9 < %s | FileCheck --check-prefix=PC64LE9 %s
-define <1 x float> @constrained_vector_fdiv_v1f32() nounwind {
+define <1 x float> @constrained_vector_fdiv_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_fdiv_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI0_0@toc@ha
<1 x float> <float 1.000000e+00>,
<1 x float> <float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %div
}
-define <2 x double> @constrained_vector_fdiv_v2f64() nounwind {
+define <2 x double> @constrained_vector_fdiv_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_fdiv_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI1_0@toc@ha
<2 x double> <double 1.000000e+00, double 2.000000e+00>,
<2 x double> <double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %div
}
-define <3 x float> @constrained_vector_fdiv_v3f32() nounwind {
+define <3 x float> @constrained_vector_fdiv_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_fdiv_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI2_0@toc@ha
<3 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>,
<3 x float> <float 1.000000e+01, float 1.000000e+01, float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %div
}
-define <3 x double> @constrained_vector_fdiv_v3f64() nounwind {
+define <3 x double> @constrained_vector_fdiv_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_fdiv_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI3_2@toc@ha
<3 x double> <double 1.000000e+00, double 2.000000e+00, double 3.000000e+00>,
<3 x double> <double 1.000000e+01, double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %div
}
-define <4 x double> @constrained_vector_fdiv_v4f64() nounwind {
+define <4 x double> @constrained_vector_fdiv_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_fdiv_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI4_0@toc@ha
<4 x double> <double 1.000000e+01, double 1.000000e+01,
double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %div
}
-define <1 x float> @constrained_vector_frem_v1f32() nounwind {
+define <1 x float> @constrained_vector_frem_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_frem_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<1 x float> <float 1.000000e+00>,
<1 x float> <float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %rem
}
-define <2 x double> @constrained_vector_frem_v2f64() nounwind {
+define <2 x double> @constrained_vector_frem_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_frem_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<2 x double> <double 1.000000e+00, double 2.000000e+00>,
<2 x double> <double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %rem
}
-define <3 x float> @constrained_vector_frem_v3f32() nounwind {
+define <3 x float> @constrained_vector_frem_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_frem_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>,
<3 x float> <float 1.000000e+01, float 1.000000e+01, float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %rem
}
-define <3 x double> @constrained_vector_frem_v3f64() nounwind {
+define <3 x double> @constrained_vector_frem_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_frem_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x double> <double 1.000000e+00, double 2.000000e+00, double 3.000000e+00>,
<3 x double> <double 1.000000e+01, double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %rem
}
-define <4 x double> @constrained_vector_frem_v4f64() nounwind {
+define <4 x double> @constrained_vector_frem_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_frem_v4f64:
; PC64LE: # %bb.0:
; PC64LE-NEXT: mflr 0
<4 x double> <double 1.000000e+01, double 1.000000e+01,
double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %rem
}
-define <1 x float> @constrained_vector_fmul_v1f32() nounwind {
+define <1 x float> @constrained_vector_fmul_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_fmul_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI10_0@toc@ha
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 2.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %mul
}
-define <2 x double> @constrained_vector_fmul_v2f64() nounwind {
+define <2 x double> @constrained_vector_fmul_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_fmul_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI11_0@toc@ha
<2 x double> <double 0x7FEFFFFFFFFFFFFF, double 0x7FEFFFFFFFFFFFFF>,
<2 x double> <double 2.000000e+00, double 3.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %mul
}
-define <3 x float> @constrained_vector_fmul_v3f32() nounwind {
+define <3 x float> @constrained_vector_fmul_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_fmul_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI12_1@toc@ha
float 0x7FF0000000000000>,
<3 x float> <float 1.000000e+00, float 1.000000e+01, float 1.000000e+02>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %mul
}
-define <3 x double> @constrained_vector_fmul_v3f64() nounwind {
+define <3 x double> @constrained_vector_fmul_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_fmul_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI13_2@toc@ha
double 0x7FEFFFFFFFFFFFFF>,
<3 x double> <double 1.000000e+00, double 1.000000e+01, double 1.000000e+02>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %mul
}
-define <4 x double> @constrained_vector_fmul_v4f64() nounwind {
+define <4 x double> @constrained_vector_fmul_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_fmul_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI14_0@toc@ha
<4 x double> <double 2.000000e+00, double 3.000000e+00,
double 4.000000e+00, double 5.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %mul
}
-define <1 x float> @constrained_vector_fadd_v1f32() nounwind {
+define <1 x float> @constrained_vector_fadd_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_fadd_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI15_0@toc@ha
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 1.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %add
}
-define <2 x double> @constrained_vector_fadd_v2f64() nounwind {
+define <2 x double> @constrained_vector_fadd_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_fadd_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI16_0@toc@ha
<2 x double> <double 0x7FEFFFFFFFFFFFFF, double 0x7FEFFFFFFFFFFFFF>,
<2 x double> <double 1.000000e+00, double 1.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %add
}
-define <3 x float> @constrained_vector_fadd_v3f32() nounwind {
+define <3 x float> @constrained_vector_fadd_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_fadd_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI17_0@toc@ha
float 0xFFFFFFFFE0000000>,
<3 x float> <float 2.0, float 1.0, float 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %add
}
-define <3 x double> @constrained_vector_fadd_v3f64() nounwind {
+define <3 x double> @constrained_vector_fadd_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_fadd_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI18_1@toc@ha
double 0x7FEFFFFFFFFFFFFF>,
<3 x double> <double 2.0, double 1.0, double 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %add
}
-define <4 x double> @constrained_vector_fadd_v4f64() nounwind {
+define <4 x double> @constrained_vector_fadd_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_fadd_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI19_0@toc@ha
<4 x double> <double 1.000000e+00, double 1.000000e-01,
double 2.000000e+00, double 2.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %add
}
-define <1 x float> @constrained_vector_fsub_v1f32() nounwind {
+define <1 x float> @constrained_vector_fsub_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_fsub_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI20_0@toc@ha
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 1.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %sub
}
-define <2 x double> @constrained_vector_fsub_v2f64() nounwind {
+define <2 x double> @constrained_vector_fsub_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_fsub_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI21_0@toc@ha
<2 x double> <double 0xFFEFFFFFFFFFFFFF, double 0xFFEFFFFFFFFFFFFF>,
<2 x double> <double 1.000000e+00, double 1.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %sub
}
-define <3 x float> @constrained_vector_fsub_v3f32() nounwind {
+define <3 x float> @constrained_vector_fsub_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_fsub_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI22_0@toc@ha
float 0xFFFFFFFFE0000000>,
<3 x float> <float 2.0, float 1.0, float 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %sub
}
-define <3 x double> @constrained_vector_fsub_v3f64() nounwind {
+define <3 x double> @constrained_vector_fsub_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_fsub_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI23_1@toc@ha
double 0xFFEFFFFFFFFFFFFF>,
<3 x double> <double 2.0, double 1.0, double 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %sub
}
-define <4 x double> @constrained_vector_fsub_v4f64() nounwind {
+define <4 x double> @constrained_vector_fsub_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_fsub_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI24_0@toc@ha
<4 x double> <double 1.000000e+00, double 1.000000e-01,
double 2.000000e+00, double 2.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %sub
}
-define <1 x float> @constrained_vector_sqrt_v1f32() nounwind {
+define <1 x float> @constrained_vector_sqrt_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_sqrt_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI25_0@toc@ha
%sqrt = call <1 x float> @llvm.experimental.constrained.sqrt.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %sqrt
}
-define <2 x double> @constrained_vector_sqrt_v2f64() nounwind {
+define <2 x double> @constrained_vector_sqrt_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_sqrt_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI26_0@toc@ha
%sqrt = call <2 x double> @llvm.experimental.constrained.sqrt.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %sqrt
}
-define <3 x float> @constrained_vector_sqrt_v3f32() nounwind {
+define <3 x float> @constrained_vector_sqrt_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_sqrt_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI27_2@toc@ha
%sqrt = call <3 x float> @llvm.experimental.constrained.sqrt.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %sqrt
}
-define <3 x double> @constrained_vector_sqrt_v3f64() nounwind {
+define <3 x double> @constrained_vector_sqrt_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_sqrt_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI28_1@toc@ha
%sqrt = call <3 x double> @llvm.experimental.constrained.sqrt.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %sqrt
}
-define <4 x double> @constrained_vector_sqrt_v4f64() nounwind {
+define <4 x double> @constrained_vector_sqrt_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_sqrt_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI29_0@toc@ha
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %sqrt
}
-define <1 x float> @constrained_vector_pow_v1f32() nounwind {
+define <1 x float> @constrained_vector_pow_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_pow_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<1 x float> <float 42.0>,
<1 x float> <float 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %pow
}
-define <2 x double> @constrained_vector_pow_v2f64() nounwind {
+define <2 x double> @constrained_vector_pow_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_pow_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<2 x double> <double 42.1, double 42.2>,
<2 x double> <double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %pow
}
-define <3 x float> @constrained_vector_pow_v3f32() nounwind {
+define <3 x float> @constrained_vector_pow_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_pow_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x float> <float 42.0, float 43.0, float 44.0>,
<3 x float> <float 3.0, float 3.0, float 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %pow
}
-define <3 x double> @constrained_vector_pow_v3f64() nounwind {
+define <3 x double> @constrained_vector_pow_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_pow_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x double> <double 42.0, double 42.1, double 42.2>,
<3 x double> <double 3.0, double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %pow
}
-define <4 x double> @constrained_vector_pow_v4f64() nounwind {
+define <4 x double> @constrained_vector_pow_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_pow_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 3.0, double 3.0,
double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %pow
}
-define <1 x float> @constrained_vector_powi_v1f32() nounwind {
+define <1 x float> @constrained_vector_powi_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_powi_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<1 x float> <float 42.0>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %powi
}
-define <2 x double> @constrained_vector_powi_v2f64() nounwind {
+define <2 x double> @constrained_vector_powi_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_powi_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<2 x double> <double 42.1, double 42.2>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %powi
}
-define <3 x float> @constrained_vector_powi_v3f32() nounwind {
+define <3 x float> @constrained_vector_powi_v3f32() #0 {
;
;
; PC64LE-LABEL: constrained_vector_powi_v3f32:
<3 x float> <float 42.0, float 43.0, float 44.0>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %powi
}
-define <3 x double> @constrained_vector_powi_v3f64() nounwind {
+define <3 x double> @constrained_vector_powi_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_powi_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x double> <double 42.0, double 42.1, double 42.2>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %powi
}
-define <4 x double> @constrained_vector_powi_v4f64() nounwind {
+define <4 x double> @constrained_vector_powi_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_powi_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
double 42.3, double 42.4>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %powi
}
-define <1 x float> @constrained_vector_sin_v1f32() nounwind {
+define <1 x float> @constrained_vector_sin_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_sin_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%sin = call <1 x float> @llvm.experimental.constrained.sin.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %sin
}
-define <2 x double> @constrained_vector_sin_v2f64() nounwind {
+define <2 x double> @constrained_vector_sin_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_sin_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%sin = call <2 x double> @llvm.experimental.constrained.sin.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %sin
}
-define <3 x float> @constrained_vector_sin_v3f32() nounwind {
+define <3 x float> @constrained_vector_sin_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_sin_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%sin = call <3 x float> @llvm.experimental.constrained.sin.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %sin
}
-define <3 x double> @constrained_vector_sin_v3f64() nounwind {
+define <3 x double> @constrained_vector_sin_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_sin_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%sin = call <3 x double> @llvm.experimental.constrained.sin.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %sin
}
-define <4 x double> @constrained_vector_sin_v4f64() nounwind {
+define <4 x double> @constrained_vector_sin_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_sin_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %sin
}
-define <1 x float> @constrained_vector_cos_v1f32() nounwind {
+define <1 x float> @constrained_vector_cos_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_cos_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%cos = call <1 x float> @llvm.experimental.constrained.cos.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %cos
}
-define <2 x double> @constrained_vector_cos_v2f64() nounwind {
+define <2 x double> @constrained_vector_cos_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_cos_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%cos = call <2 x double> @llvm.experimental.constrained.cos.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %cos
}
-define <3 x float> @constrained_vector_cos_v3f32() nounwind {
+define <3 x float> @constrained_vector_cos_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_cos_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%cos = call <3 x float> @llvm.experimental.constrained.cos.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %cos
}
-define <3 x double> @constrained_vector_cos_v3f64() nounwind {
+define <3 x double> @constrained_vector_cos_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_cos_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%cos = call <3 x double> @llvm.experimental.constrained.cos.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %cos
}
-define <4 x double> @constrained_vector_cos_v4f64() nounwind {
+define <4 x double> @constrained_vector_cos_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_cos_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %cos
}
-define <1 x float> @constrained_vector_exp_v1f32() nounwind {
+define <1 x float> @constrained_vector_exp_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_exp_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%exp = call <1 x float> @llvm.experimental.constrained.exp.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %exp
}
-define <2 x double> @constrained_vector_exp_v2f64() nounwind {
+define <2 x double> @constrained_vector_exp_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_exp_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%exp = call <2 x double> @llvm.experimental.constrained.exp.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %exp
}
-define <3 x float> @constrained_vector_exp_v3f32() nounwind {
+define <3 x float> @constrained_vector_exp_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_exp_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%exp = call <3 x float> @llvm.experimental.constrained.exp.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %exp
}
-define <3 x double> @constrained_vector_exp_v3f64() nounwind {
+define <3 x double> @constrained_vector_exp_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_exp_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%exp = call <3 x double> @llvm.experimental.constrained.exp.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %exp
}
-define <4 x double> @constrained_vector_exp_v4f64() nounwind {
+define <4 x double> @constrained_vector_exp_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_exp_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %exp
}
-define <1 x float> @constrained_vector_exp2_v1f32() nounwind {
+define <1 x float> @constrained_vector_exp2_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_exp2_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%exp2 = call <1 x float> @llvm.experimental.constrained.exp2.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %exp2
}
-define <2 x double> @constrained_vector_exp2_v2f64() nounwind {
+define <2 x double> @constrained_vector_exp2_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_exp2_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%exp2 = call <2 x double> @llvm.experimental.constrained.exp2.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %exp2
}
-define <3 x float> @constrained_vector_exp2_v3f32() nounwind {
+define <3 x float> @constrained_vector_exp2_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_exp2_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%exp2 = call <3 x float> @llvm.experimental.constrained.exp2.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %exp2
}
-define <3 x double> @constrained_vector_exp2_v3f64() nounwind {
+define <3 x double> @constrained_vector_exp2_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_exp2_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%exp2 = call <3 x double> @llvm.experimental.constrained.exp2.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %exp2
}
-define <4 x double> @constrained_vector_exp2_v4f64() nounwind {
+define <4 x double> @constrained_vector_exp2_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_exp2_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %exp2
}
-define <1 x float> @constrained_vector_log_v1f32() nounwind {
+define <1 x float> @constrained_vector_log_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_log_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log = call <1 x float> @llvm.experimental.constrained.log.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %log
}
-define <2 x double> @constrained_vector_log_v2f64() nounwind {
+define <2 x double> @constrained_vector_log_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_log_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log = call <2 x double> @llvm.experimental.constrained.log.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %log
}
-define <3 x float> @constrained_vector_log_v3f32() nounwind {
+define <3 x float> @constrained_vector_log_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_log_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log = call <3 x float> @llvm.experimental.constrained.log.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %log
}
-define <3 x double> @constrained_vector_log_v3f64() nounwind {
+define <3 x double> @constrained_vector_log_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_log_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log = call <3 x double> @llvm.experimental.constrained.log.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %log
}
-define <4 x double> @constrained_vector_log_v4f64() nounwind {
+define <4 x double> @constrained_vector_log_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_log_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %log
}
-define <1 x float> @constrained_vector_log10_v1f32() nounwind {
+define <1 x float> @constrained_vector_log10_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_log10_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log10 = call <1 x float> @llvm.experimental.constrained.log10.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %log10
}
-define <2 x double> @constrained_vector_log10_v2f64() nounwind {
+define <2 x double> @constrained_vector_log10_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_log10_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log10 = call <2 x double> @llvm.experimental.constrained.log10.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %log10
}
-define <3 x float> @constrained_vector_log10_v3f32() nounwind {
+define <3 x float> @constrained_vector_log10_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_log10_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log10 = call <3 x float> @llvm.experimental.constrained.log10.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %log10
}
-define <3 x double> @constrained_vector_log10_v3f64() nounwind {
+define <3 x double> @constrained_vector_log10_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_log10_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log10 = call <3 x double> @llvm.experimental.constrained.log10.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %log10
}
-define <4 x double> @constrained_vector_log10_v4f64() nounwind {
+define <4 x double> @constrained_vector_log10_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_log10_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %log10
}
-define <1 x float> @constrained_vector_log2_v1f32() nounwind {
+define <1 x float> @constrained_vector_log2_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_log2_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log2 = call <1 x float> @llvm.experimental.constrained.log2.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %log2
}
-define <2 x double> @constrained_vector_log2_v2f64() nounwind {
+define <2 x double> @constrained_vector_log2_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_log2_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log2 = call <2 x double> @llvm.experimental.constrained.log2.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %log2
}
-define <3 x float> @constrained_vector_log2_v3f32() nounwind {
+define <3 x float> @constrained_vector_log2_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_log2_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log2 = call <3 x float> @llvm.experimental.constrained.log2.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %log2
}
-define <3 x double> @constrained_vector_log2_v3f64() nounwind {
+define <3 x double> @constrained_vector_log2_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_log2_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%log2 = call <3 x double> @llvm.experimental.constrained.log2.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %log2
}
-define <4 x double> @constrained_vector_log2_v4f64() nounwind {
+define <4 x double> @constrained_vector_log2_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_log2_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %log2
}
-define <1 x float> @constrained_vector_rint_v1f32() nounwind {
+define <1 x float> @constrained_vector_rint_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_rint_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%rint = call <1 x float> @llvm.experimental.constrained.rint.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %rint
}
-define <2 x double> @constrained_vector_rint_v2f64() nounwind {
+define <2 x double> @constrained_vector_rint_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_rint_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%rint = call <2 x double> @llvm.experimental.constrained.rint.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %rint
}
-define <3 x float> @constrained_vector_rint_v3f32() nounwind {
+define <3 x float> @constrained_vector_rint_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_rint_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%rint = call <3 x float> @llvm.experimental.constrained.rint.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %rint
}
-define <3 x double> @constrained_vector_rint_v3f64() nounwind {
+define <3 x double> @constrained_vector_rint_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_rint_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%rint = call <3 x double> @llvm.experimental.constrained.rint.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %rint
}
-define <4 x double> @constrained_vector_rint_v4f64() nounwind {
+define <4 x double> @constrained_vector_rint_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_rint_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %rint
}
-define <1 x float> @constrained_vector_nearbyint_v1f32() nounwind {
+define <1 x float> @constrained_vector_nearbyint_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_nearbyint_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%nearby = call <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %nearby
}
-define <2 x double> @constrained_vector_nearbyint_v2f64() nounwind {
+define <2 x double> @constrained_vector_nearbyint_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_nearbyint_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%nearby = call <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %nearby
}
-define <3 x float> @constrained_vector_nearbyint_v3f32() nounwind {
+define <3 x float> @constrained_vector_nearbyint_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_nearbyint_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%nearby = call <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %nearby
}
-define <3 x double> @constrained_vector_nearby_v3f64() nounwind {
+define <3 x double> @constrained_vector_nearby_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_nearby_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%nearby = call <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %nearby
}
-define <4 x double> @constrained_vector_nearbyint_v4f64() nounwind {
+define <4 x double> @constrained_vector_nearbyint_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_nearbyint_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %nearby
}
-define <1 x float> @constrained_vector_maxnum_v1f32() nounwind {
+define <1 x float> @constrained_vector_maxnum_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_maxnum_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %max
}
-define <2 x double> @constrained_vector_maxnum_v2f64() nounwind {
+define <2 x double> @constrained_vector_maxnum_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_maxnum_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %max
}
-define <3 x float> @constrained_vector_maxnum_v3f32() nounwind {
+define <3 x float> @constrained_vector_maxnum_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_maxnum_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %max
}
-define <3 x double> @constrained_vector_max_v3f64() nounwind {
+define <3 x double> @constrained_vector_max_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_max_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x double> <double 43.0, double 44.0, double 45.0>,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %max
}
-define <4 x double> @constrained_vector_maxnum_v4f64() nounwind {
+define <4 x double> @constrained_vector_maxnum_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_maxnum_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %max
}
-define <1 x float> @constrained_vector_minnum_v1f32() nounwind {
+define <1 x float> @constrained_vector_minnum_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_minnum_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
%min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %min
}
-define <2 x double> @constrained_vector_minnum_v2f64() nounwind {
+define <2 x double> @constrained_vector_minnum_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_minnum_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %min
}
-define <3 x float> @constrained_vector_minnum_v3f32() nounwind {
+define <3 x float> @constrained_vector_minnum_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_minnum_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %min
}
-define <3 x double> @constrained_vector_min_v3f64() nounwind {
+define <3 x double> @constrained_vector_min_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_min_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<3 x double> <double 43.0, double 44.0, double 45.0>,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %min
}
-define <4 x double> @constrained_vector_minnum_v4f64() nounwind {
+define <4 x double> @constrained_vector_minnum_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_minnum_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: mflr 0
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %min
}
-define <1 x float> @constrained_vector_fptrunc_v1f64() nounwind {
+define <1 x float> @constrained_vector_fptrunc_v1f64() #0 {
; PC64LE-LABEL: constrained_vector_fptrunc_v1f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI95_0@toc@ha
%result = call <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(
<1 x double><double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %result
}
-define <2 x float> @constrained_vector_fptrunc_v2f64() nounwind {
+define <2 x float> @constrained_vector_fptrunc_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_fptrunc_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI96_0@toc@ha
%result = call <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(
<2 x double><double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x float> %result
}
-define <3 x float> @constrained_vector_fptrunc_v3f64() nounwind {
+define <3 x float> @constrained_vector_fptrunc_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_fptrunc_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI97_0@toc@ha
<3 x double><double 42.1, double 42.2,
double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %result
}
-define <4 x float> @constrained_vector_fptrunc_v4f64() nounwind {
+define <4 x float> @constrained_vector_fptrunc_v4f64() #0 {
; PC64LE-LABEL: constrained_vector_fptrunc_v4f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI98_0@toc@ha
<4 x double><double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x float> %result
}
-define <1 x double> @constrained_vector_fpext_v1f32() nounwind {
+define <1 x double> @constrained_vector_fpext_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_fpext_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI99_0@toc@ha
entry:
%result = call <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(
<1 x float><float 42.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x double> %result
}
-define <2 x double> @constrained_vector_fpext_v2f32() nounwind {
+define <2 x double> @constrained_vector_fpext_v2f32() #0 {
; PC64LE-LABEL: constrained_vector_fpext_v2f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI100_0@toc@ha
entry:
%result = call <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(
<2 x float><float 42.0, float 43.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %result
}
-define <3 x double> @constrained_vector_fpext_v3f32() nounwind {
+define <3 x double> @constrained_vector_fpext_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_fpext_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI101_0@toc@ha
%result = call <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(
<3 x float><float 42.0, float 43.0,
float 44.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %result
}
-define <4 x double> @constrained_vector_fpext_v4f32() nounwind {
+define <4 x double> @constrained_vector_fpext_v4f32() #0 {
; PC64LE-LABEL: constrained_vector_fpext_v4f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI102_0@toc@ha
%result = call <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(
<4 x float><float 42.0, float 43.0,
float 44.0, float 45.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <4 x double> %result
}
-define <1 x float> @constrained_vector_ceil_v1f32() nounwind {
+define <1 x float> @constrained_vector_ceil_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_ceil_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI103_0@toc@ha
%ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %ceil
}
-define <2 x double> @constrained_vector_ceil_v2f64() nounwind {
+define <2 x double> @constrained_vector_ceil_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_ceil_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI104_0@toc@ha
%ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %ceil
}
-define <3 x float> @constrained_vector_ceil_v3f32() nounwind {
+define <3 x float> @constrained_vector_ceil_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_ceil_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI105_2@toc@ha
%ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %ceil
}
-define <3 x double> @constrained_vector_ceil_v3f64() nounwind {
+define <3 x double> @constrained_vector_ceil_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_ceil_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI106_1@toc@ha
%ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %ceil
}
-define <1 x float> @constrained_vector_floor_v1f32() nounwind {
+define <1 x float> @constrained_vector_floor_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_floor_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI107_0@toc@ha
%floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %floor
}
-define <2 x double> @constrained_vector_floor_v2f64() nounwind {
+define <2 x double> @constrained_vector_floor_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_floor_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI108_0@toc@ha
%floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %floor
}
-define <3 x float> @constrained_vector_floor_v3f32() nounwind {
+define <3 x float> @constrained_vector_floor_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_floor_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI109_2@toc@ha
%floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %floor
}
-define <3 x double> @constrained_vector_floor_v3f64() nounwind {
+define <3 x double> @constrained_vector_floor_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_floor_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI110_1@toc@ha
%floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %floor
}
-define <1 x float> @constrained_vector_round_v1f32() nounwind {
+define <1 x float> @constrained_vector_round_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_round_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI111_0@toc@ha
%round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %round
}
-define <2 x double> @constrained_vector_round_v2f64() nounwind {
+define <2 x double> @constrained_vector_round_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_round_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI112_0@toc@ha
%round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %round
}
-define <3 x float> @constrained_vector_round_v3f32() nounwind {
+define <3 x float> @constrained_vector_round_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_round_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI113_2@toc@ha
%round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %round
}
-define <3 x double> @constrained_vector_round_v3f64() nounwind {
+define <3 x double> @constrained_vector_round_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_round_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI114_1@toc@ha
%round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %round
}
-define <1 x float> @constrained_vector_trunc_v1f32() nounwind {
+define <1 x float> @constrained_vector_trunc_v1f32() #0 {
; PC64LE-LABEL: constrained_vector_trunc_v1f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI115_0@toc@ha
%trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <1 x float> %trunc
}
-define <2 x double> @constrained_vector_trunc_v2f64() nounwind {
+define <2 x double> @constrained_vector_trunc_v2f64() #0 {
; PC64LE-LABEL: constrained_vector_trunc_v2f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI116_0@toc@ha
%trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <2 x double> %trunc
}
-define <3 x float> @constrained_vector_trunc_v3f32() nounwind {
+define <3 x float> @constrained_vector_trunc_v3f32() #0 {
; PC64LE-LABEL: constrained_vector_trunc_v3f32:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI117_2@toc@ha
%trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x float> %trunc
}
-define <3 x double> @constrained_vector_trunc_v3f64() nounwind {
+define <3 x double> @constrained_vector_trunc_v3f64() #0 {
; PC64LE-LABEL: constrained_vector_trunc_v3f64:
; PC64LE: # %bb.0: # %entry
; PC64LE-NEXT: addis 3, 2, .LCPI118_1@toc@ha
%trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #1
ret <3 x double> %trunc
}
+attributes #0 = { nounwind strictfp noimplicitfloat }
+attributes #1 = { strictfp }
; Single width declarations
declare <2 x double> @llvm.experimental.constrained.fadd.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare float @llvm.experimental.constrained.fadd.f32(float, float, metadata, metadata)
; Check register addition.
-define float @f1(float %f1, float %f2) {
+define float @f1(float %f1, float %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: aebr %f0, %f2
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fadd.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the low end of the AEB range.
-define float @f2(float %f1, float *%ptr) {
+define float @f2(float %f1, float *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: aeb %f0, 0(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fadd.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the high end of the aligned AEB range.
-define float @f3(float %f1, float *%base) {
+define float @f3(float %f1, float *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: aeb %f0, 4092(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fadd.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the next word up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define float @f4(float %f1, float *%base) {
+define float @f4(float %f1, float *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: aeb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.fadd.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check negative displacements, which also need separate address logic.
-define float @f5(float %f1, float *%base) {
+define float @f5(float %f1, float *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -4
; CHECK: aeb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.fadd.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that AEB allows indices.
-define float @f6(float %f1, float *%base, i64 %index) {
+define float @f6(float %f1, float *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: aeb %f0, 400(%r1,%r2)
%res = call float @llvm.experimental.constrained.fadd.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that additions of spilled values can use AEB rather than AEBR.
-define float @f7(float *%ptr0) {
+define float @f7(float *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK-SCALAR: aeb %f0, 16{{[04]}}(%r15)
%val9 = load float, float *%ptr9
%val10 = load float, float *%ptr10
- %ret = call float @foo()
+ %ret = call float @foo() #0
%add0 = call float @llvm.experimental.constrained.fadd.f32(
float %ret, float %val0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add1 = call float @llvm.experimental.constrained.fadd.f32(
float %add0, float %val1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add2 = call float @llvm.experimental.constrained.fadd.f32(
float %add1, float %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add3 = call float @llvm.experimental.constrained.fadd.f32(
float %add2, float %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add4 = call float @llvm.experimental.constrained.fadd.f32(
float %add3, float %val4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add5 = call float @llvm.experimental.constrained.fadd.f32(
float %add4, float %val5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add6 = call float @llvm.experimental.constrained.fadd.f32(
float %add5, float %val6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add7 = call float @llvm.experimental.constrained.fadd.f32(
float %add6, float %val7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add8 = call float @llvm.experimental.constrained.fadd.f32(
float %add7, float %val8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add9 = call float @llvm.experimental.constrained.fadd.f32(
float %add8, float %val9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add10 = call float @llvm.experimental.constrained.fadd.f32(
float %add9, float %val10,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %add10
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
; Check register addition.
-define double @f1(double %f1, double %f2) {
+define double @f1(double %f1, double %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: adbr %f0, %f2
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fadd.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the low end of the ADB range.
-define double @f2(double %f1, double *%ptr) {
+define double @f2(double %f1, double *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: adb %f0, 0(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fadd.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the high end of the aligned ADB range.
-define double @f3(double %f1, double *%base) {
+define double @f3(double %f1, double *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: adb %f0, 4088(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fadd.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the next doubleword up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define double @f4(double %f1, double *%base) {
+define double @f4(double %f1, double *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: adb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fadd.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check negative displacements, which also need separate address logic.
-define double @f5(double %f1, double *%base) {
+define double @f5(double %f1, double *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -8
; CHECK: adb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fadd.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that ADB allows indices.
-define double @f6(double %f1, double *%base, i64 %index) {
+define double @f6(double %f1, double *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 3
; CHECK: adb %f0, 800(%r1,%r2)
%res = call double @llvm.experimental.constrained.fadd.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that additions of spilled values can use ADB rather than ADBR.
-define double @f7(double *%ptr0) {
+define double @f7(double *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK-SCALAR: adb %f0, 160(%r15)
%val9 = load double, double *%ptr9
%val10 = load double, double *%ptr10
- %ret = call double @foo()
+ %ret = call double @foo() #0
%add0 = call double @llvm.experimental.constrained.fadd.f64(
double %ret, double %val0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add1 = call double @llvm.experimental.constrained.fadd.f64(
double %add0, double %val1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add2 = call double @llvm.experimental.constrained.fadd.f64(
double %add1, double %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add3 = call double @llvm.experimental.constrained.fadd.f64(
double %add2, double %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add4 = call double @llvm.experimental.constrained.fadd.f64(
double %add3, double %val4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add5 = call double @llvm.experimental.constrained.fadd.f64(
double %add4, double %val5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add6 = call double @llvm.experimental.constrained.fadd.f64(
double %add5, double %val6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add7 = call double @llvm.experimental.constrained.fadd.f64(
double %add6, double %val7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add8 = call double @llvm.experimental.constrained.fadd.f64(
double %add7, double %val8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add9 = call double @llvm.experimental.constrained.fadd.f64(
double %add8, double %val9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%add10 = call double @llvm.experimental.constrained.fadd.f64(
double %add9, double %val10,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %add10
}
+
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.fadd.f128(fp128, fp128, metadata, metadata)
; There is no memory form of 128-bit addition.
-define void @f1(fp128 *%ptr, float %f2) {
+define void @f1(fp128 *%ptr, float %f2) strictfp {
; CHECK-LABEL: f1:
; CHECK-DAG: lxebr %f0, %f0
; CHECK-DAG: ld %f1, 0(%r2)
%sum = call fp128 @llvm.experimental.constrained.fadd.f128(
fp128 %f1, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %sum, fp128 *%ptr
ret void
}
declare fp128 @llvm.experimental.constrained.fadd.f128(fp128, fp128, metadata, metadata)
-define void @f1(fp128 *%ptr1, fp128 *%ptr2) {
+define void @f1(fp128 *%ptr1, fp128 *%ptr2) strictfp {
; CHECK-LABEL: f1:
; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
%sum = call fp128 @llvm.experimental.constrained.fadd.f128(
fp128 %f1, fp128 %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %sum, fp128 *%ptr1
ret void
}
ret void
}
-define void @f2(float %f1, float %f2, float *%ptr1, float *%ptr2) {
+define void @f2(float %f1, float %f2, float *%ptr1, float *%ptr2) #0 {
; CHECK-LABEL: f2:
; CHECK: sqebr
; CHECK: ste
%sqrt1 = call float @llvm.experimental.constrained.sqrt.f32(
float %f1,
metadata !"round.dynamic",
- metadata !"fpexcept.ignore")
+ metadata !"fpexcept.ignore") #0
%sqrt2 = call float @llvm.experimental.constrained.sqrt.f32(
float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.ignore")
+ metadata !"fpexcept.ignore") #0
store float %sqrt1, float *%ptr1
store float %sqrt2, float *%ptr2
ret void
}
-define void @f3(float %f1, float %f2, float *%ptr1, float *%ptr2) {
+define void @f3(float %f1, float %f2, float *%ptr1, float *%ptr2) #0 {
; CHECK-LABEL: f3:
; CHECK: sqebr
; CHECK: ste
%sqrt1 = call float @llvm.experimental.constrained.sqrt.f32(
float %f1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sqrt2 = call float @llvm.experimental.constrained.sqrt.f32(
float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store float %sqrt1, float *%ptr1
store float %sqrt2, float *%ptr2
ret void
}
-define void @f5(float %f1, float %f2, float *%ptr1, float *%ptr2) {
+define void @f5(float %f1, float %f2, float *%ptr1, float *%ptr2) #0 {
; CHECK-LABEL: f5:
; CHECK: sqebr
; CHECK: ste
%sqrt1 = call float @llvm.experimental.constrained.sqrt.f32(
float %f1,
metadata !"round.dynamic",
- metadata !"fpexcept.ignore")
+ metadata !"fpexcept.ignore") #0
%sqrt2 = call float @llvm.experimental.constrained.sqrt.f32(
float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.ignore")
+ metadata !"fpexcept.ignore") #0
store volatile float %sqrt1, float *%ptr1
store volatile float %sqrt2, float *%ptr2
ret void
}
-define void @f6(float %f1, float %f2, float *%ptr1, float *%ptr2) {
+define void @f6(float %f1, float %f2, float *%ptr1, float *%ptr2) #0 {
; CHECK-LABEL: f6:
; CHECK: sqebr
; CHECK: sqebr
%sqrt1 = call float @llvm.experimental.constrained.sqrt.f32(
float %f1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sqrt2 = call float @llvm.experimental.constrained.sqrt.f32(
float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store volatile float %sqrt1, float *%ptr1
store volatile float %sqrt2, float *%ptr2
ret void
}
-define void @f8(float %f1, float %f2, float *%ptr1, float *%ptr2) {
+define void @f8(float %f1, float %f2, float *%ptr1, float *%ptr2) #0 {
; CHECK-LABEL: f8:
; CHECK: sqebr
; CHECK: sqebr
%sqrt1 = call float @llvm.experimental.constrained.sqrt.f32(
float %f1,
metadata !"round.dynamic",
- metadata !"fpexcept.ignore")
+ metadata !"fpexcept.ignore") #0
%sqrt2 = call float @llvm.experimental.constrained.sqrt.f32(
float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.ignore")
+ metadata !"fpexcept.ignore") #0
- call void @llvm.s390.sfpc(i32 0)
+ call void @llvm.s390.sfpc(i32 0) #0
store float %sqrt1, float *%ptr1
store float %sqrt2, float *%ptr2
ret void
}
-define void @f9(float %f1, float %f2, float *%ptr1, float *%ptr2) {
+define void @f9(float %f1, float %f2, float *%ptr1, float *%ptr2) #0 {
; CHECK-LABEL: f9:
; CHECK: sqebr
; CHECK: sqebr
%sqrt1 = call float @llvm.experimental.constrained.sqrt.f32(
float %f1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sqrt2 = call float @llvm.experimental.constrained.sqrt.f32(
float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
- call void @llvm.s390.sfpc(i32 0)
+ call void @llvm.s390.sfpc(i32 0) #0
store float %sqrt1, float *%ptr1
store float %sqrt2, float *%ptr2
ret void
}
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
; Test f64->f32.
-define float @f1(double %d1, double %d2) {
+define float @f1(double %d1, double %d2) #0 {
; CHECK-LABEL: f1:
; CHECK-SCALAR: ledbr %f0, %f2
; CHECK-VECTOR: ledbra %f0, 0, %f2, 0
%res = call float @llvm.experimental.constrained.fptrunc.f32.f64(
double %d2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test f128->f32.
-define float @f2(fp128 *%ptr) {
+define float @f2(fp128 *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: lexbr %f0, %f0
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fptrunc.f32.f128(
fp128 %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Make sure that we don't use %f0 as the destination of LEXBR when %f2
; is still live.
-define void @f3(float *%dst, fp128 *%ptr, float %d1, float %d2) {
+define void @f3(float *%dst, fp128 *%ptr, float %d1, float %d2) #0 {
; CHECK-LABEL: f3:
; CHECK: lexbr %f1, %f1
; CHECK: aebr %f1, %f2
%conv = call float @llvm.experimental.constrained.fptrunc.f32.f128(
fp128 %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%res = call float @llvm.experimental.constrained.fadd.f32(
float %conv, float %d2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store float %res, float *%dst
ret void
}
; Test f128->f64.
-define double @f4(fp128 *%ptr) {
+define double @f4(fp128 *%ptr) #0 {
; CHECK-LABEL: f4:
; CHECK: ldxbr %f0, %f0
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fptrunc.f64.f128(
fp128 %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Like f3, but for f128->f64.
-define void @f5(double *%dst, fp128 *%ptr, double %d1, double %d2) {
+define void @f5(double *%dst, fp128 *%ptr, double %d1, double %d2) #0 {
; CHECK-LABEL: f5:
; CHECK: ldxbr %f1, %f1
; CHECK-SCALAR: adbr %f1, %f2
%conv = call double @llvm.experimental.constrained.fptrunc.f64.f128(
fp128 %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%res = call double @llvm.experimental.constrained.fadd.f64(
double %conv, double %d2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store double %res, double *%dst
ret void
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)
; Check register extension.
-define double @f1(float %val) {
+define double @f1(float %val) #0 {
; CHECK-LABEL: f1:
; CHECK: ldebr %f0, %f0
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fpext.f64.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the low end of the LDEB range.
-define double @f2(float *%ptr) {
+define double @f2(float *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: ldeb %f0, 0(%r2)
; CHECK: br %r14
%val = load float, float *%ptr
%res = call double @llvm.experimental.constrained.fpext.f64.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the high end of the aligned LDEB range.
-define double @f3(float *%base) {
+define double @f3(float *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: ldeb %f0, 4092(%r2)
; CHECK: br %r14
%ptr = getelementptr float, float *%base, i64 1023
%val = load float, float *%ptr
%res = call double @llvm.experimental.constrained.fpext.f64.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the next word up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define double @f4(float *%base) {
+define double @f4(float *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: ldeb %f0, 0(%r2)
%ptr = getelementptr float, float *%base, i64 1024
%val = load float, float *%ptr
%res = call double @llvm.experimental.constrained.fpext.f64.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check negative displacements, which also need separate address logic.
-define double @f5(float *%base) {
+define double @f5(float *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -4
; CHECK: ldeb %f0, 0(%r2)
%ptr = getelementptr float, float *%base, i64 -1
%val = load float, float *%ptr
%res = call double @llvm.experimental.constrained.fpext.f64.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that LDEB allows indices.
-define double @f6(float *%base, i64 %index) {
+define double @f6(float *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: ldeb %f0, 400(%r1,%r2)
%ptr2 = getelementptr float, float *%ptr1, i64 100
%val = load float, float *%ptr2
%res = call double @llvm.experimental.constrained.fpext.f64.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.fpext.f128.f32(float, metadata)
; Check register extension.
-define void @f1(fp128 *%dst, float %val) {
+define void @f1(fp128 *%dst, float %val) #0 {
; CHECK-LABEL: f1:
; CHECK: lxebr %f0, %f0
; CHECK: std %f0, 0(%r2)
; CHECK: std %f2, 8(%r2)
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the low end of the LXEB range.
-define void @f2(fp128 *%dst, float *%ptr) {
+define void @f2(fp128 *%dst, float *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: lxeb %f0, 0(%r3)
; CHECK: std %f0, 0(%r2)
; CHECK: br %r14
%val = load float, float *%ptr
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the high end of the aligned LXEB range.
-define void @f3(fp128 *%dst, float *%base) {
+define void @f3(fp128 *%dst, float *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: lxeb %f0, 4092(%r3)
; CHECK: std %f0, 0(%r2)
%ptr = getelementptr float, float *%base, i64 1023
%val = load float, float *%ptr
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the next word up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define void @f4(fp128 *%dst, float *%base) {
+define void @f4(fp128 *%dst, float *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r3, 4096
; CHECK: lxeb %f0, 0(%r3)
%ptr = getelementptr float, float *%base, i64 1024
%val = load float, float *%ptr
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check negative displacements, which also need separate address logic.
-define void @f5(fp128 *%dst, float *%base) {
+define void @f5(fp128 *%dst, float *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r3, -4
; CHECK: lxeb %f0, 0(%r3)
%ptr = getelementptr float, float *%base, i64 -1
%val = load float, float *%ptr
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check that LXEB allows indices.
-define void @f6(fp128 *%dst, float *%base, i64 %index) {
+define void @f6(fp128 *%dst, float *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r4, 2
; CHECK: lxeb %f0, 400(%r1,%r3)
%ptr2 = getelementptr float, float *%ptr1, i64 100
%val = load float, float *%ptr2
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.fpext.f128.f64(double, metadata)
; Check register extension.
-define void @f1(fp128 *%dst, double %val) {
+define void @f1(fp128 *%dst, double %val) #0 {
; CHECK-LABEL: f1:
; CHECK: lxdbr %f0, %f0
; CHECK: std %f0, 0(%r2)
; CHECK: std %f2, 8(%r2)
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f64(double %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the low end of the LXDB range.
-define void @f2(fp128 *%dst, double *%ptr) {
+define void @f2(fp128 *%dst, double *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: lxdb %f0, 0(%r3)
; CHECK: std %f0, 0(%r2)
; CHECK: br %r14
%val = load double, double *%ptr
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f64(double %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the high end of the aligned LXDB range.
-define void @f3(fp128 *%dst, double *%base) {
+define void @f3(fp128 *%dst, double *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: lxdb %f0, 4088(%r3)
; CHECK: std %f0, 0(%r2)
%ptr = getelementptr double, double *%base, i64 511
%val = load double, double *%ptr
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f64(double %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the next doubleword up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define void @f4(fp128 *%dst, double *%base) {
+define void @f4(fp128 *%dst, double *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r3, 4096
; CHECK: lxdb %f0, 0(%r3)
%ptr = getelementptr double, double *%base, i64 512
%val = load double, double *%ptr
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f64(double %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check negative displacements, which also need separate address logic.
-define void @f5(fp128 *%dst, double *%base) {
+define void @f5(fp128 *%dst, double *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r3, -8
; CHECK: lxdb %f0, 0(%r3)
%ptr = getelementptr double, double *%base, i64 -1
%val = load double, double *%ptr
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f64(double %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check that LXDB allows indices.
-define void @f6(fp128 *%dst, double *%base, i64 %index) {
+define void @f6(fp128 *%dst, double *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r4, 3
; CHECK: lxdb %f0, 800(%r1,%r3)
%ptr2 = getelementptr double, double *%ptr1, i64 100
%val = load double, double *%ptr2
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f64(double %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
+attributes #0 = { strictfp }
declare i32 @llvm.experimental.constrained.fptosi.i32.f128(fp128, metadata)
; Test f32->i32.
-define i32 @f1(float %f) {
+define i32 @f1(float %f) #0 {
; CHECK-LABEL: f1:
; CHECK: cfebr %r2, 5, %f0
; CHECK: br %r14
%conv = call i32 @llvm.experimental.constrained.fptosi.i32.f32(float %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test f64->i32.
-define i32 @f2(double %f) {
+define i32 @f2(double %f) #0 {
; CHECK-LABEL: f2:
; CHECK: cfdbr %r2, 5, %f0
; CHECK: br %r14
%conv = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test f128->i32.
-define i32 @f3(fp128 *%src) {
+define i32 @f3(fp128 *%src) #0 {
; CHECK-LABEL: f3:
; CHECK: ld %f0, 0(%r2)
; CHECK: ld %f2, 8(%r2)
; CHECK: br %r14
%f = load fp128, fp128 *%src
%conv = call i32 @llvm.experimental.constrained.fptosi.i32.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
+
+attributes #0 = { strictfp }
declare i32 @llvm.experimental.constrained.fptoui.i32.f128(fp128, metadata)
; Test f32->i32.
-define i32 @f1(float %f) {
+define i32 @f1(float %f) #0 {
; CHECK-LABEL: f1:
; CHECK: # %bb.0:
; CHECK-NEXT: larl %r1, .LCPI0_0
; CHECK-NEXT: xr %r2, %r0
; CHECK-NEXT: br %r14
%conv = call i32 @llvm.experimental.constrained.fptoui.i32.f32(float %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test f64->i32.
-define i32 @f2(double %f) {
+define i32 @f2(double %f) #0 {
; CHECK-LABEL: f2:
; CHECK: # %bb.0:
; CHECK-NEXT: larl %r1, .LCPI1_0
; CHECK-NEXT: xr %r2, %r0
; CHECK-NEXT: br %r14
%conv = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test f128->i32.
-define i32 @f3(fp128 *%src) {
+define i32 @f3(fp128 *%src) #0 {
; CHECK-LABEL: f3:
; CHECK: # %bb.0:
; CHECK-NEXT: ld %f0, 0(%r2)
; CHECK-NEXT: br %r14
%f = load fp128, fp128 *%src
%conv = call i32 @llvm.experimental.constrained.fptoui.i32.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
+
+attributes #0 = { strictfp }
declare i64 @llvm.experimental.constrained.fptosi.i64.f128(fp128, metadata)
; Test f32->i64.
-define i64 @f1(float %f) {
+define i64 @f1(float %f) #0 {
; CHECK-LABEL: f1:
; CHECK: cgebr %r2, 5, %f0
; CHECK: br %r14
%conv = call i64 @llvm.experimental.constrained.fptosi.i64.f32(float %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
; Test f64->i64.
-define i64 @f2(double %f) {
+define i64 @f2(double %f) #0 {
; CHECK-LABEL: f2:
; CHECK: cgdbr %r2, 5, %f0
; CHECK: br %r14
%conv = call i64 @llvm.experimental.constrained.fptosi.i64.f64(double %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
; Test f128->i64.
-define i64 @f3(fp128 *%src) {
+define i64 @f3(fp128 *%src) #0 {
; CHECK-LABEL: f3:
; CHECK: ld %f0, 0(%r2)
; CHECK: ld %f2, 8(%r2)
; CHECK: br %r14
%f = load fp128, fp128 *%src
%conv = call i64 @llvm.experimental.constrained.fptosi.i64.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
+
+attributes #0 = { strictfp }
declare i64 @llvm.experimental.constrained.fptoui.i64.f128(fp128, metadata)
; Test f32->i64.
-define i64 @f1(float %f) {
+define i64 @f1(float %f) #0 {
; CHECK-LABEL: f1:
; CHECK: # %bb.0:
; CHECK-NEXT: larl %r1, .LCPI0_0
; CHECK-NEXT: xgr %r2, %r0
; CHECK-NEXT: br %r14
%conv = call i64 @llvm.experimental.constrained.fptoui.i64.f32(float %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
; Test f64->i64.
-define i64 @f2(double %f) {
+define i64 @f2(double %f) #0 {
; CHECK-LABEL: f2:
; CHECK: # %bb.0:
; CHECK-NEXT: larl %r1, .LCPI1_0
; CHECK-NEXT: xgr %r2, %r0
; CHECK-NEXT: br %r14
%conv = call i64 @llvm.experimental.constrained.fptoui.i64.f64(double %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
; Test f128->i64.
-define i64 @f3(fp128 *%src) {
+define i64 @f3(fp128 *%src) #0 {
; CHECK-LABEL: f3:
; CHECK: # %bb.0:
; CHECK-NEXT: ld %f0, 0(%r2)
; CHECK-NEXT: br %r14
%f = load fp128, fp128 *%src
%conv = call i64 @llvm.experimental.constrained.fptoui.i64.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
+
+attributes #0 = { strictfp }
declare i64 @llvm.experimental.constrained.fptoui.i64.f128(fp128, metadata)
; Test f32->i32.
-define i32 @f1(float %f) {
+define i32 @f1(float %f) #0 {
; CHECK-LABEL: f1:
; CHECK: clfebr %r2, 5, %f0, 0
; CHECK: br %r14
%conv = call i32 @llvm.experimental.constrained.fptoui.i32.f32(float %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test f64->i32.
-define i32 @f2(double %f) {
+define i32 @f2(double %f) #0 {
; CHECK-LABEL: f2:
; CHECK: clfdbr %r2, 5, %f0, 0
; CHECK: br %r14
%conv = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test f128->i32.
-define i32 @f3(fp128 *%src) {
+define i32 @f3(fp128 *%src) #0 {
; CHECK-LABEL: f3:
; CHECK-DAG: ld %f0, 0(%r2)
; CHECK-DAG: ld %f2, 8(%r2)
; CHECK: br %r14
%f = load fp128, fp128 *%src
%conv = call i32 @llvm.experimental.constrained.fptoui.i32.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test f32->i64.
-define i64 @f4(float %f) {
+define i64 @f4(float %f) #0 {
; CHECK-LABEL: f4:
; CHECK: clgebr %r2, 5, %f0, 0
; CHECK: br %r14
%conv = call i64 @llvm.experimental.constrained.fptoui.i64.f32(float %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
; Test f64->i64.
-define i64 @f5(double %f) {
+define i64 @f5(double %f) #0 {
; CHECK-LABEL: f5:
; CHECK: clgdbr %r2, 5, %f0, 0
; CHECK: br %r14
%conv = call i64 @llvm.experimental.constrained.fptoui.i64.f64(double %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
; Test f128->i64.
-define i64 @f6(fp128 *%src) {
+define i64 @f6(fp128 *%src) #0 {
; CHECK-LABEL: f6:
; CHECK-DAG: ld %f0, 0(%r2)
; CHECK-DAG: ld %f2, 8(%r2)
; CHECK: br %r14
%f = load fp128, fp128 *%src
%conv = call i64 @llvm.experimental.constrained.fptoui.i64.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
+
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.fpext.f128.f64(double, metadata)
; Test f128->f64.
-define double @f1(fp128 *%ptr) {
+define double @f1(fp128 *%ptr) #0 {
; CHECK-LABEL: f1:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wflrx %f0, [[REG]], 0, 0
%res = call double @llvm.experimental.constrained.fptrunc.f64.f128(
fp128 %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test f128->f32.
-define float @f2(fp128 *%ptr) {
+define float @f2(fp128 *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wflrx %f0, [[REG]], 0, 3
%res = call float @llvm.experimental.constrained.fptrunc.f32.f128(
fp128 %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test f64->f128.
-define void @f3(fp128 *%dst, double %val) {
+define void @f3(fp128 *%dst, double %val) #0 {
; CHECK-LABEL: f3:
; CHECK: wflld [[RES:%v[0-9]+]], %f0
; CHECK: vst [[RES]], 0(%r2)
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f64(double %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Test f32->f128.
-define void @f4(fp128 *%dst, float %val) {
+define void @f4(fp128 *%dst, float %val) #0 {
; CHECK-LABEL: f4:
; CHECK: ldebr %f0, %f0
; CHECK: wflld [[RES:%v[0-9]+]], %f0
; CHECK: vst [[RES]], 0(%r2)
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.fpext.f128.f32(float %val,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
+attributes #0 = { strictfp }
declare i64 @llvm.experimental.constrained.fptoui.i64.f128(fp128, metadata)
; Test signed f128->i32.
-define i32 @f5(fp128 *%src) {
+define i32 @f5(fp128 *%src) #0 {
; CHECK-LABEL: f5:
; CHECK: vl %v0, 0(%r2)
; CHECK: vrepg %v2, %v0, 1
; CHECK: br %r14
%f = load fp128, fp128 *%src
%conv = call i32 @llvm.experimental.constrained.fptosi.i32.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test signed f128->i64.
-define i64 @f6(fp128 *%src) {
+define i64 @f6(fp128 *%src) #0 {
; CHECK-LABEL: f6:
; CHECK: vl %v0, 0(%r2)
; CHECK: vrepg %v2, %v0, 1
; CHECK: br %r14
%f = load fp128, fp128 *%src
%conv = call i64 @llvm.experimental.constrained.fptosi.i64.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
; Test unsigned f128->i32.
-define i32 @f7(fp128 *%src) {
+define i32 @f7(fp128 *%src) #0 {
; CHECK-LABEL: f7:
; CHECK: vl %v0, 0(%r2)
; CHECK: vrepg %v2, %v0, 1
; CHECK: br %r14
%f = load fp128, fp128 *%src
%conv = call i32 @llvm.experimental.constrained.fptoui.i32.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %conv
}
; Test unsigned f128->i64.
-define i64 @f8(fp128 *%src) {
+define i64 @f8(fp128 *%src) #0 {
; CHECK-LABEL: f8:
; CHECK: vl %v0, 0(%r2)
; CHECK: vrepg %v2, %v0, 1
; CHECK: br %r14
%f = load fp128, fp128 *%src
%conv = call i64 @llvm.experimental.constrained.fptoui.i64.f128(fp128 %f,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i64 %conv
}
+
+attributes #0 = { strictfp }
declare float @llvm.experimental.constrained.fdiv.f32(float, float, metadata, metadata)
; Check register division.
-define float @f1(float %f1, float %f2) {
+define float @f1(float %f1, float %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: debr %f0, %f2
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fdiv.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the low end of the DEB range.
-define float @f2(float %f1, float *%ptr) {
+define float @f2(float %f1, float *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: deb %f0, 0(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fdiv.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the high end of the aligned DEB range.
-define float @f3(float %f1, float *%base) {
+define float @f3(float %f1, float *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: deb %f0, 4092(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fdiv.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the next word up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define float @f4(float %f1, float *%base) {
+define float @f4(float %f1, float *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: deb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.fdiv.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check negative displacements, which also need separate address logic.
-define float @f5(float %f1, float *%base) {
+define float @f5(float %f1, float *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -4
; CHECK: deb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.fdiv.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that DEB allows indices.
-define float @f6(float %f1, float *%base, i64 %index) {
+define float @f6(float %f1, float *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: deb %f0, 400(%r1,%r2)
%res = call float @llvm.experimental.constrained.fdiv.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that divisions of spilled values can use DEB rather than DEBR.
-define float @f7(float *%ptr0) {
+define float @f7(float *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK-SCALAR: deb %f0, 16{{[04]}}(%r15)
%val9 = load float, float *%ptr9
%val10 = load float, float *%ptr10
- %ret = call float @foo()
+ %ret = call float @foo() #0
%div0 = call float @llvm.experimental.constrained.fdiv.f32(
float %ret, float %val0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div1 = call float @llvm.experimental.constrained.fdiv.f32(
float %div0, float %val1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div2 = call float @llvm.experimental.constrained.fdiv.f32(
float %div1, float %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div3 = call float @llvm.experimental.constrained.fdiv.f32(
float %div2, float %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div4 = call float @llvm.experimental.constrained.fdiv.f32(
float %div3, float %val4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div5 = call float @llvm.experimental.constrained.fdiv.f32(
float %div4, float %val5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div6 = call float @llvm.experimental.constrained.fdiv.f32(
float %div5, float %val6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div7 = call float @llvm.experimental.constrained.fdiv.f32(
float %div6, float %val7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div8 = call float @llvm.experimental.constrained.fdiv.f32(
float %div7, float %val8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div9 = call float @llvm.experimental.constrained.fdiv.f32(
float %div8, float %val9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div10 = call float @llvm.experimental.constrained.fdiv.f32(
float %div9, float %val10,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %div10
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
; Check register division.
-define double @f1(double %f1, double %f2) {
+define double @f1(double %f1, double %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: ddbr %f0, %f2
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fdiv.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the low end of the DDB range.
-define double @f2(double %f1, double *%ptr) {
+define double @f2(double %f1, double *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: ddb %f0, 0(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fdiv.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the high end of the aligned DDB range.
-define double @f3(double %f1, double *%base) {
+define double @f3(double %f1, double *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: ddb %f0, 4088(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fdiv.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the next doubleword up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define double @f4(double %f1, double *%base) {
+define double @f4(double %f1, double *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: ddb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fdiv.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check negative displacements, which also need separate address logic.
-define double @f5(double %f1, double *%base) {
+define double @f5(double %f1, double *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -8
; CHECK: ddb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fdiv.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that DDB allows indices.
-define double @f6(double %f1, double *%base, i64 %index) {
+define double @f6(double %f1, double *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 3
; CHECK: ddb %f0, 800(%r1,%r2)
%res = call double @llvm.experimental.constrained.fdiv.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that divisions of spilled values can use DDB rather than DDBR.
-define double @f7(double *%ptr0) {
+define double @f7(double *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK-SCALAR: ddb %f0, 160(%r15)
%val9 = load double, double *%ptr9
%val10 = load double, double *%ptr10
- %ret = call double @foo()
+ %ret = call double @foo() #0
%div0 = call double @llvm.experimental.constrained.fdiv.f64(
double %ret, double %val0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div1 = call double @llvm.experimental.constrained.fdiv.f64(
double %div0, double %val1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div2 = call double @llvm.experimental.constrained.fdiv.f64(
double %div1, double %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div3 = call double @llvm.experimental.constrained.fdiv.f64(
double %div2, double %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div4 = call double @llvm.experimental.constrained.fdiv.f64(
double %div3, double %val4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div5 = call double @llvm.experimental.constrained.fdiv.f64(
double %div4, double %val5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div6 = call double @llvm.experimental.constrained.fdiv.f64(
double %div5, double %val6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div7 = call double @llvm.experimental.constrained.fdiv.f64(
double %div6, double %val7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div8 = call double @llvm.experimental.constrained.fdiv.f64(
double %div7, double %val8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div9 = call double @llvm.experimental.constrained.fdiv.f64(
double %div8, double %val9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%div10 = call double @llvm.experimental.constrained.fdiv.f64(
double %div9, double %val10,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %div10
}
+
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.fdiv.f128(fp128, fp128, metadata, metadata)
; There is no memory form of 128-bit division.
-define void @f1(fp128 *%ptr, float %f2) {
+define void @f1(fp128 *%ptr, float %f2) strictfp {
; CHECK-LABEL: f1:
; CHECK-DAG: lxebr %f0, %f0
; CHECK-DAG: ld %f1, 0(%r2)
%sum = call fp128 @llvm.experimental.constrained.fdiv.f128(
fp128 %f1, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %sum, fp128 *%ptr
ret void
}
declare fp128 @llvm.experimental.constrained.fdiv.f128(fp128, fp128, metadata, metadata)
-define void @f1(fp128 *%ptr1, fp128 *%ptr2) {
+define void @f1(fp128 *%ptr1, fp128 *%ptr2) strictfp {
; CHECK-LABEL: f1:
; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
%sum = call fp128 @llvm.experimental.constrained.fdiv.f128(
fp128 %f1, fp128 %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %sum, fp128 *%ptr1
ret void
}
declare float @llvm.experimental.constrained.fmul.f32(float, float, metadata, metadata)
; Check register multiplication.
-define float @f1(float %f1, float %f2) {
+define float @f1(float %f1, float %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: meebr %f0, %f2
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fmul.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the low end of the MEEB range.
-define float @f2(float %f1, float *%ptr) {
+define float @f2(float %f1, float *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: meeb %f0, 0(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fmul.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the high end of the aligned MEEB range.
-define float @f3(float %f1, float *%base) {
+define float @f3(float %f1, float *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: meeb %f0, 4092(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fmul.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the next word up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define float @f4(float %f1, float *%base) {
+define float @f4(float %f1, float *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: meeb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.fmul.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check negative displacements, which also need separate address logic.
-define float @f5(float %f1, float *%base) {
+define float @f5(float %f1, float *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -4
; CHECK: meeb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.fmul.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that MEEB allows indices.
-define float @f6(float %f1, float *%base, i64 %index) {
+define float @f6(float %f1, float *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: meeb %f0, 400(%r1,%r2)
%res = call float @llvm.experimental.constrained.fmul.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that multiplications of spilled values can use MEEB rather than MEEBR.
-define float @f7(float *%ptr0) {
+define float @f7(float *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK-SCALAR: meeb %f0, 16{{[04]}}(%r15)
%val9 = load float, float *%ptr9
%val10 = load float, float *%ptr10
- %ret = call float @foo()
+ %ret = call float @foo() #0
%mul0 = call float @llvm.experimental.constrained.fmul.f32(
float %ret, float %val0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul1 = call float @llvm.experimental.constrained.fmul.f32(
float %mul0, float %val1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul2 = call float @llvm.experimental.constrained.fmul.f32(
float %mul1, float %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul3 = call float @llvm.experimental.constrained.fmul.f32(
float %mul2, float %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul4 = call float @llvm.experimental.constrained.fmul.f32(
float %mul3, float %val4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul5 = call float @llvm.experimental.constrained.fmul.f32(
float %mul4, float %val5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul6 = call float @llvm.experimental.constrained.fmul.f32(
float %mul5, float %val6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul7 = call float @llvm.experimental.constrained.fmul.f32(
float %mul6, float %val7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul8 = call float @llvm.experimental.constrained.fmul.f32(
float %mul7, float %val8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul9 = call float @llvm.experimental.constrained.fmul.f32(
float %mul8, float %val9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul10 = call float @llvm.experimental.constrained.fmul.f32(
float %mul9, float %val10,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %mul10
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
; Check register multiplication.
-define double @f1(float %f1, float %f2) {
+define double @f1(float %f1, float %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: mdebr %f0, %f2
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the low end of the MDEB range.
-define double @f2(float %f1, float *%ptr) {
+define double @f2(float %f1, float *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: mdeb %f0, 0(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the high end of the aligned MDEB range.
-define double @f3(float %f1, float *%base) {
+define double @f3(float %f1, float *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: mdeb %f0, 4092(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the next word up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define double @f4(float %f1, float *%base) {
+define double @f4(float %f1, float *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: mdeb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check negative displacements, which also need separate address logic.
-define double @f5(float %f1, float *%base) {
+define double @f5(float %f1, float *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -4
; CHECK: mdeb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that MDEB allows indices.
-define double @f6(float %f1, float *%base, i64 %index) {
+define double @f6(float %f1, float *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: mdeb %f0, 400(%r1,%r2)
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1x, double %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that multiplications of spilled values can use MDEB rather than MDEBR.
-define float @f7(float *%ptr0) {
+define float @f7(float *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK: mdeb %f0, 16{{[04]}}(%r15)
store float %frob9, float *%ptr9
store float %frob10, float *%ptr10
- %ret = call float @foo()
+ %ret = call float @foo() #0
%accext0 = fpext float %ret to double
%ext0 = fpext float %frob0 to double
%mul0 = call double @llvm.experimental.constrained.fmul.f64(
double %accext0, double %ext0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra0 = call double @llvm.experimental.constrained.fmul.f64(
double %mul0, double 1.01,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc0 = fptrunc double %extra0 to float
%accext1 = fpext float %trunc0 to double
%mul1 = call double @llvm.experimental.constrained.fmul.f64(
double %accext1, double %ext1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra1 = call double @llvm.experimental.constrained.fmul.f64(
double %mul1, double 1.11,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc1 = fptrunc double %extra1 to float
%accext2 = fpext float %trunc1 to double
%mul2 = call double @llvm.experimental.constrained.fmul.f64(
double %accext2, double %ext2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra2 = call double @llvm.experimental.constrained.fmul.f64(
double %mul2, double 1.21,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc2 = fptrunc double %extra2 to float
%accext3 = fpext float %trunc2 to double
%mul3 = call double @llvm.experimental.constrained.fmul.f64(
double %accext3, double %ext3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra3 = call double @llvm.experimental.constrained.fmul.f64(
double %mul3, double 1.31,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc3 = fptrunc double %extra3 to float
%accext4 = fpext float %trunc3 to double
%mul4 = call double @llvm.experimental.constrained.fmul.f64(
double %accext4, double %ext4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra4 = call double @llvm.experimental.constrained.fmul.f64(
double %mul4, double 1.41,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc4 = fptrunc double %extra4 to float
%accext5 = fpext float %trunc4 to double
%mul5 = call double @llvm.experimental.constrained.fmul.f64(
double %accext5, double %ext5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra5 = call double @llvm.experimental.constrained.fmul.f64(
double %mul5, double 1.51,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc5 = fptrunc double %extra5 to float
%accext6 = fpext float %trunc5 to double
%mul6 = call double @llvm.experimental.constrained.fmul.f64(
double %accext6, double %ext6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra6 = call double @llvm.experimental.constrained.fmul.f64(
double %mul6, double 1.61,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc6 = fptrunc double %extra6 to float
%accext7 = fpext float %trunc6 to double
%mul7 = call double @llvm.experimental.constrained.fmul.f64(
double %accext7, double %ext7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra7 = call double @llvm.experimental.constrained.fmul.f64(
double %mul7, double 1.71,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc7 = fptrunc double %extra7 to float
%accext8 = fpext float %trunc7 to double
%mul8 = call double @llvm.experimental.constrained.fmul.f64(
double %accext8, double %ext8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra8 = call double @llvm.experimental.constrained.fmul.f64(
double %mul8, double 1.81,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc8 = fptrunc double %extra8 to float
%accext9 = fpext float %trunc8 to double
%mul9 = call double @llvm.experimental.constrained.fmul.f64(
double %accext9, double %ext9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%extra9 = call double @llvm.experimental.constrained.fmul.f64(
double %mul9, double 1.91,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc9 = fptrunc double %extra9 to float
ret float %trunc9
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
; Check register multiplication.
-define double @f1(double %f1, double %f2) {
+define double @f1(double %f1, double %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: mdbr %f0, %f2
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the low end of the MDB range.
-define double @f2(double %f1, double *%ptr) {
+define double @f2(double %f1, double *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: mdb %f0, 0(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the high end of the aligned MDB range.
-define double @f3(double %f1, double *%base) {
+define double @f3(double %f1, double *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: mdb %f0, 4088(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the next doubleword up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define double @f4(double %f1, double *%base) {
+define double @f4(double %f1, double *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: mdb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check negative displacements, which also need separate address logic.
-define double @f5(double %f1, double *%base) {
+define double @f5(double %f1, double *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -8
; CHECK: mdb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that MDB allows indices.
-define double @f6(double %f1, double *%base, i64 %index) {
+define double @f6(double %f1, double *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 3
; CHECK: mdb %f0, 800(%r1,%r2)
%res = call double @llvm.experimental.constrained.fmul.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that multiplications of spilled values can use MDB rather than MDBR.
-define double @f7(double *%ptr0) {
+define double @f7(double *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK-SCALAR: mdb %f0, 160(%r15)
%val9 = load double, double *%ptr9
%val10 = load double, double *%ptr10
- %ret = call double @foo()
+ %ret = call double @foo() #0
%mul0 = call double @llvm.experimental.constrained.fmul.f64(
double %ret, double %val0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul1 = call double @llvm.experimental.constrained.fmul.f64(
double %mul0, double %val1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul2 = call double @llvm.experimental.constrained.fmul.f64(
double %mul1, double %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul3 = call double @llvm.experimental.constrained.fmul.f64(
double %mul2, double %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul4 = call double @llvm.experimental.constrained.fmul.f64(
double %mul3, double %val4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul5 = call double @llvm.experimental.constrained.fmul.f64(
double %mul4, double %val5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul6 = call double @llvm.experimental.constrained.fmul.f64(
double %mul5, double %val6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul7 = call double @llvm.experimental.constrained.fmul.f64(
double %mul6, double %val7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul8 = call double @llvm.experimental.constrained.fmul.f64(
double %mul7, double %val8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul9 = call double @llvm.experimental.constrained.fmul.f64(
double %mul8, double %val9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul10 = call double @llvm.experimental.constrained.fmul.f64(
double %mul9, double %val10,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %mul10
}
+
+attributes #0 = { strictfp }
; Check register multiplication. "mxdbr %f0, %f2" is not valid from LLVM's
; point of view, because %f2 is the low register of the FP128 %f0. Pass the
; multiplier in %f4 instead.
-define void @f1(double %f1, double %dummy, double %f2, fp128 *%dst) {
+define void @f1(double %f1, double %dummy, double %f2, fp128 *%dst) #0 {
; CHECK-LABEL: f1:
; CHECK: mxdbr %f0, %f4
; CHECK: std %f0, 0(%r2)
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the low end of the MXDB range.
-define void @f2(double %f1, double *%ptr, fp128 *%dst) {
+define void @f2(double %f1, double *%ptr, fp128 *%dst) #0 {
; CHECK-LABEL: f2:
; CHECK: mxdb %f0, 0(%r2)
; CHECK: std %f0, 0(%r3)
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the high end of the aligned MXDB range.
-define void @f3(double %f1, double *%base, fp128 *%dst) {
+define void @f3(double %f1, double *%base, fp128 *%dst) #0 {
; CHECK-LABEL: f3:
; CHECK: mxdb %f0, 4088(%r2)
; CHECK: std %f0, 0(%r3)
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check the next doubleword up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define void @f4(double %f1, double *%base, fp128 *%dst) {
+define void @f4(double %f1, double *%base, fp128 *%dst) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: mxdb %f0, 0(%r2)
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check negative displacements, which also need separate address logic.
-define void @f5(double %f1, double *%base, fp128 *%dst) {
+define void @f5(double %f1, double *%base, fp128 *%dst) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -8
; CHECK: mxdb %f0, 0(%r2)
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check that MXDB allows indices.
-define void @f6(double %f1, double *%base, i64 %index, fp128 *%dst) {
+define void @f6(double %f1, double *%base, i64 %index, fp128 *%dst) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 3
; CHECK: mxdb %f0, 800(%r1,%r2)
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
; Check that multiplications of spilled values can use MXDB rather than MXDBR.
-define double @f7(double *%ptr0) {
+define double @f7(double *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK: mxdb %f0, 160(%r15)
store double %frob9, double *%ptr9
store double %frob10, double *%ptr10
- %ret = call double @foo()
+ %ret = call double @foo() #0
%accext0 = fpext double %ret to fp128
%ext0 = fpext double %frob0 to fp128
%mul0 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext0, fp128 %ext0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const0 = fpext double 1.01 to fp128
%extra0 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul0, fp128 %const0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc0 = fptrunc fp128 %extra0 to double
%accext1 = fpext double %trunc0 to fp128
%mul1 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext1, fp128 %ext1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const1 = fpext double 1.11 to fp128
%extra1 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul1, fp128 %const1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc1 = fptrunc fp128 %extra1 to double
%accext2 = fpext double %trunc1 to fp128
%mul2 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext2, fp128 %ext2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const2 = fpext double 1.21 to fp128
%extra2 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul2, fp128 %const2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc2 = fptrunc fp128 %extra2 to double
%accext3 = fpext double %trunc2 to fp128
%mul3 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext3, fp128 %ext3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const3 = fpext double 1.31 to fp128
%extra3 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul3, fp128 %const3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc3 = fptrunc fp128 %extra3 to double
%accext4 = fpext double %trunc3 to fp128
%mul4 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext4, fp128 %ext4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const4 = fpext double 1.41 to fp128
%extra4 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul4, fp128 %const4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc4 = fptrunc fp128 %extra4 to double
%accext5 = fpext double %trunc4 to fp128
%mul5 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext5, fp128 %ext5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const5 = fpext double 1.51 to fp128
%extra5 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul5, fp128 %const5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc5 = fptrunc fp128 %extra5 to double
%accext6 = fpext double %trunc5 to fp128
%mul6 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext6, fp128 %ext6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const6 = fpext double 1.61 to fp128
%extra6 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul6, fp128 %const6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc6 = fptrunc fp128 %extra6 to double
%accext7 = fpext double %trunc6 to fp128
%mul7 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext7, fp128 %ext7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const7 = fpext double 1.71 to fp128
%extra7 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul7, fp128 %const7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc7 = fptrunc fp128 %extra7 to double
%accext8 = fpext double %trunc7 to fp128
%mul8 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext8, fp128 %ext8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const8 = fpext double 1.81 to fp128
%extra8 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul8, fp128 %const8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc8 = fptrunc fp128 %extra8 to double
%accext9 = fpext double %trunc8 to fp128
%mul9 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %accext9, fp128 %ext9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%const9 = fpext double 1.91 to fp128
%extra9 = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %mul9, fp128 %const9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%trunc9 = fptrunc fp128 %extra9 to double
ret double %trunc9
}
+
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.fmul.f128(fp128, fp128, metadata, metadata)
; There is no memory form of 128-bit multiplication.
-define void @f1(fp128 *%ptr, float %f2) {
+define void @f1(fp128 *%ptr, float %f2) strictfp {
; CHECK-LABEL: f1:
; CHECK-DAG: lxebr %f0, %f0
; CHECK-DAG: ld %f1, 0(%r2)
%diff = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %diff, fp128 *%ptr
ret void
}
declare float @llvm.experimental.constrained.fma.f32(float, float, float, metadata, metadata)
-define float @f1(float %f1, float %f2, float %acc) {
+define float @f1(float %f1, float %f2, float %acc) #0 {
; CHECK-LABEL: f1:
; CHECK-SCALAR: maebr %f4, %f0, %f2
; CHECK-SCALAR: ler %f0, %f4
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f2(float %f1, float *%ptr, float %acc) {
+define float @f2(float %f1, float *%ptr, float %acc) #0 {
; CHECK-LABEL: f2:
; CHECK: maeb %f2, %f0, 0(%r2)
; CHECK-SCALAR: ler %f0, %f2
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f3(float %f1, float *%base, float %acc) {
+define float @f3(float %f1, float *%base, float %acc) #0 {
; CHECK-LABEL: f3:
; CHECK: maeb %f2, %f0, 4092(%r2)
; CHECK-SCALAR: ler %f0, %f2
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f4(float %f1, float *%base, float %acc) {
+define float @f4(float %f1, float *%base, float %acc) #0 {
; The important thing here is that we don't generate an out-of-range
; displacement. Other sequences besides this one would be OK.
;
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f5(float %f1, float *%base, float %acc) {
+define float @f5(float %f1, float *%base, float %acc) #0 {
; Here too the important thing is that we don't generate an out-of-range
; displacement. Other sequences besides this one would be OK.
;
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f6(float %f1, float *%base, i64 %index, float %acc) {
+define float @f6(float %f1, float *%base, i64 %index, float %acc) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: maeb %f2, %f0, 0(%r1,%r2)
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f7(float %f1, float *%base, i64 %index, float %acc) {
+define float @f7(float %f1, float *%base, i64 %index, float %acc) #0 {
; CHECK-LABEL: f7:
; CHECK: sllg %r1, %r3, 2
; CHECK: maeb %f2, %f0, 4092({{%r1,%r2|%r2,%r1}})
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f8(float %f1, float *%base, i64 %index, float %acc) {
+define float @f8(float %f1, float *%base, i64 %index, float %acc) #0 {
; CHECK-LABEL: f8:
; CHECK: sllg %r1, %r3, 2
; CHECK: lay %r1, 4096({{%r1,%r2|%r2,%r1}})
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fma.f64(double %f1, double %f2, double %f3, metadata, metadata)
-define double @f1(double %f1, double %f2, double %acc) {
+define double @f1(double %f1, double %f2, double %acc) #0 {
; CHECK-LABEL: f1:
; CHECK-SCALAR: madbr %f4, %f0, %f2
; CHECK-SCALAR: ldr %f0, %f4
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f2(double %f1, double *%ptr, double %acc) {
+define double @f2(double %f1, double *%ptr, double %acc) #0 {
; CHECK-LABEL: f2:
; CHECK: madb %f2, %f0, 0(%r2)
; CHECK: ldr %f0, %f2
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f3(double %f1, double *%base, double %acc) {
+define double @f3(double %f1, double *%base, double %acc) #0 {
; CHECK-LABEL: f3:
; CHECK: madb %f2, %f0, 4088(%r2)
; CHECK: ldr %f0, %f2
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f4(double %f1, double *%base, double %acc) {
+define double @f4(double %f1, double *%base, double %acc) #0 {
; The important thing here is that we don't generate an out-of-range
; displacement. Other sequences besides this one would be OK.
;
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f5(double %f1, double *%base, double %acc) {
+define double @f5(double %f1, double *%base, double %acc) #0 {
; Here too the important thing is that we don't generate an out-of-range
; displacement. Other sequences besides this one would be OK.
;
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f6(double %f1, double *%base, i64 %index, double %acc) {
+define double @f6(double %f1, double *%base, i64 %index, double %acc) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 3
; CHECK: madb %f2, %f0, 0(%r1,%r2)
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f7(double %f1, double *%base, i64 %index, double %acc) {
+define double @f7(double %f1, double *%base, i64 %index, double %acc) #0 {
; CHECK-LABEL: f7:
; CHECK: sllg %r1, %r3, 3
; CHECK: madb %f2, %f0, 4088({{%r1,%r2|%r2,%r1}})
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f8(double %f1, double *%base, i64 %index, double %acc) {
+define double @f8(double %f1, double *%base, i64 %index, double %acc) #0 {
; CHECK-LABEL: f8:
; CHECK: sllg %r1, %r3, 3
; CHECK: lay %r1, 4096({{%r1,%r2|%r2,%r1}})
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
+
+attributes #0 = { strictfp }
declare float @llvm.experimental.constrained.fma.f32(float %f1, float %f2, float %f3, metadata, metadata)
-define float @f1(float %f1, float %f2, float %acc) {
+define float @f1(float %f1, float %f2, float %acc) #0 {
; CHECK-LABEL: f1:
; CHECK-SCALAR: msebr %f4, %f0, %f2
; CHECK-SCALAR: ler %f0, %f4
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f2(float %f1, float *%ptr, float %acc) {
+define float @f2(float %f1, float *%ptr, float %acc) #0 {
; CHECK-LABEL: f2:
; CHECK: mseb %f2, %f0, 0(%r2)
; CHECK-SCALAR: ler %f0, %f2
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f3(float %f1, float *%base, float %acc) {
+define float @f3(float %f1, float *%base, float %acc) #0 {
; CHECK-LABEL: f3:
; CHECK: mseb %f2, %f0, 4092(%r2)
; CHECK-SCALAR: ler %f0, %f2
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f4(float %f1, float *%base, float %acc) {
+define float @f4(float %f1, float *%base, float %acc) #0 {
; The important thing here is that we don't generate an out-of-range
; displacement. Other sequences besides this one would be OK.
;
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f5(float %f1, float *%base, float %acc) {
+define float @f5(float %f1, float *%base, float %acc) #0 {
; Here too the important thing is that we don't generate an out-of-range
; displacement. Other sequences besides this one would be OK.
;
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f6(float %f1, float *%base, i64 %index, float %acc) {
+define float @f6(float %f1, float *%base, i64 %index, float %acc) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: mseb %f2, %f0, 0(%r1,%r2)
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f7(float %f1, float *%base, i64 %index, float %acc) {
+define float @f7(float %f1, float *%base, i64 %index, float %acc) #0 {
; CHECK-LABEL: f7:
; CHECK: sllg %r1, %r3, 2
; CHECK: mseb %f2, %f0, 4092({{%r1,%r2|%r2,%r1}})
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f8(float %f1, float *%base, i64 %index, float %acc) {
+define float @f8(float %f1, float *%base, i64 %index, float %acc) #0 {
; CHECK-LABEL: f8:
; CHECK: sllg %r1, %r3, 2
; CHECK: lay %r1, 4096({{%r1,%r2|%r2,%r1}})
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fma.f64(double %f1, double %f2, double %f3, metadata, metadata)
-define double @f1(double %f1, double %f2, double %acc) {
+define double @f1(double %f1, double %f2, double %acc) #0 {
; CHECK-LABEL: f1:
; CHECK-SCALAR: msdbr %f4, %f0, %f2
; CHECK-SCALAR: ldr %f0, %f4
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f2(double %f1, double *%ptr, double %acc) {
+define double @f2(double %f1, double *%ptr, double %acc) #0 {
; CHECK-LABEL: f2:
; CHECK: msdb %f2, %f0, 0(%r2)
; CHECK: ldr %f0, %f2
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f3(double %f1, double *%base, double %acc) {
+define double @f3(double %f1, double *%base, double %acc) #0 {
; CHECK-LABEL: f3:
; CHECK: msdb %f2, %f0, 4088(%r2)
; CHECK: ldr %f0, %f2
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f4(double %f1, double *%base, double %acc) {
+define double @f4(double %f1, double *%base, double %acc) #0 {
; The important thing here is that we don't generate an out-of-range
; displacement. Other sequences besides this one would be OK.
;
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f5(double %f1, double *%base, double %acc) {
+define double @f5(double %f1, double *%base, double %acc) #0 {
; Here too the important thing is that we don't generate an out-of-range
; displacement. Other sequences besides this one would be OK.
;
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f6(double %f1, double *%base, i64 %index, double %acc) {
+define double @f6(double %f1, double *%base, i64 %index, double %acc) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 3
; CHECK: msdb %f2, %f0, 0(%r1,%r2)
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f7(double %f1, double *%base, i64 %index, double %acc) {
+define double @f7(double %f1, double *%base, i64 %index, double %acc) #0 {
; CHECK-LABEL: f7:
; CHECK: sllg %r1, %r3, 3
; CHECK: msdb %f2, %f0, 4088({{%r1,%r2|%r2,%r1}})
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f8(double %f1, double *%base, i64 %index, double %acc) {
+define double @f8(double %f1, double *%base, i64 %index, double %acc) #0 {
; CHECK-LABEL: f8:
; CHECK: sllg %r1, %r3, 3
; CHECK: lay %r1, 4096({{%r1,%r2|%r2,%r1}})
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fma.f64(double %f1, double %f2, double %f3, metadata, metadata)
declare float @llvm.experimental.constrained.fma.f32(float %f1, float %f2, float %f3, metadata, metadata)
-define double @f1(double %f1, double %f2, double %acc) {
+define double @f1(double %f1, double %f2, double %acc) #0 {
; CHECK-LABEL: f1:
; CHECK: wfnmadb %f0, %f0, %f2, %f4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%negres = fsub double -0.0, %res
ret double %negres
}
-define double @f2(double %f1, double %f2, double %acc) {
+define double @f2(double %f1, double %f2, double %acc) #0 {
; CHECK-LABEL: f2:
; CHECK: wfnmsdb %f0, %f0, %f2, %f4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fma.f64 (
double %f1, double %f2, double %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%negres = fsub double -0.0, %res
ret double %negres
}
-define float @f3(float %f1, float %f2, float %acc) {
+define float @f3(float %f1, float %f2, float %acc) #0 {
; CHECK-LABEL: f3:
; CHECK: wfnmasb %f0, %f0, %f2, %f4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %acc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%negres = fsub float -0.0, %res
ret float %negres
}
-define float @f4(float %f1, float %f2, float %acc) {
+define float @f4(float %f1, float %f2, float %acc) #0 {
; CHECK-LABEL: f4:
; CHECK: wfnmssb %f0, %f0, %f2, %f4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fma.f32 (
float %f1, float %f2, float %negacc,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%negres = fsub float -0.0, %res
ret float %negres
}
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.fmul.f128(fp128, fp128, metadata, metadata)
-define void @f1(fp128 *%ptr1, fp128 *%ptr2) {
+define void @f1(fp128 *%ptr1, fp128 *%ptr2) #0 {
; CHECK-LABEL: f1:
; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
%sum = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1, fp128 %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %sum, fp128 *%ptr1
ret void
}
-define void @f2(double %f1, double %f2, fp128 *%dst) {
+define void @f2(double %f1, double %f2, fp128 *%dst) #0 {
; CHECK-LABEL: f2:
; CHECK-DAG: wflld [[REG1:%v[0-9]+]], %f0
; CHECK-DAG: wflld [[REG2:%v[0-9]+]], %f2
%res = call fp128 @llvm.experimental.constrained.fmul.f128(
fp128 %f1x, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%dst
ret void
}
+attributes #0 = { strictfp }
; Test rint for f32.
declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
-define float @f1(float %f) {
+define float @f1(float %f) #0 {
; CHECK-LABEL: f1:
; CHECK: fiebr %f0, 0, %f0
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.rint.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test rint for f64.
declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
-define double @f2(double %f) {
+define double @f2(double %f) #0 {
; CHECK-LABEL: f2:
; CHECK: fidbr %f0, 0, %f0
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.rint.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test rint for f128.
declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
-define void @f3(fp128 *%ptr) {
+define void @f3(fp128 *%ptr) #0 {
; CHECK-LABEL: f3:
; CHECK: fixbr %f0, 0, %f0
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.rint.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test nearbyint for f32.
declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
-define float @f4(float %f) {
+define float @f4(float %f) #0 {
; CHECK-LABEL: f4:
; CHECK: brasl %r14, nearbyintf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.nearbyint.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test nearbyint for f64.
declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
-define double @f5(double %f) {
+define double @f5(double %f) #0 {
; CHECK-LABEL: f5:
; CHECK: brasl %r14, nearbyint@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.nearbyint.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test nearbyint for f128.
declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
-define void @f6(fp128 *%ptr) {
+define void @f6(fp128 *%ptr) #0 {
; CHECK-LABEL: f6:
; CHECK: brasl %r14, nearbyintl@PLT
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.nearbyint.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test floor for f32.
declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
-define float @f7(float %f) {
+define float @f7(float %f) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, floorf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.floor.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test floor for f64.
declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
-define double @f8(double %f) {
+define double @f8(double %f) #0 {
; CHECK-LABEL: f8:
; CHECK: brasl %r14, floor@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.floor.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test floor for f128.
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
-define void @f9(fp128 *%ptr) {
+define void @f9(fp128 *%ptr) #0 {
; CHECK-LABEL: f9:
; CHECK: brasl %r14, floorl@PLT
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.floor.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test ceil for f32.
declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
-define float @f10(float %f) {
+define float @f10(float %f) #0 {
; CHECK-LABEL: f10:
; CHECK: brasl %r14, ceilf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.ceil.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test ceil for f64.
declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
-define double @f11(double %f) {
+define double @f11(double %f) #0 {
; CHECK-LABEL: f11:
; CHECK: brasl %r14, ceil@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.ceil.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test ceil for f128.
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
-define void @f12(fp128 *%ptr) {
+define void @f12(fp128 *%ptr) #0 {
; CHECK-LABEL: f12:
; CHECK: brasl %r14, ceill@PLT
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.ceil.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test trunc for f32.
declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
-define float @f13(float %f) {
+define float @f13(float %f) #0 {
; CHECK-LABEL: f13:
; CHECK: brasl %r14, truncf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.trunc.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test trunc for f64.
declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
-define double @f14(double %f) {
+define double @f14(double %f) #0 {
; CHECK-LABEL: f14:
; CHECK: brasl %r14, trunc@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.trunc.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test trunc for f128.
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
-define void @f15(fp128 *%ptr) {
+define void @f15(fp128 *%ptr) #0 {
; CHECK-LABEL: f15:
; CHECK: brasl %r14, truncl@PLT
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.trunc.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test round for f32.
declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
-define float @f16(float %f) {
+define float @f16(float %f) #0 {
; CHECK-LABEL: f16:
; CHECK: brasl %r14, roundf@PLT
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.round.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test round for f64.
declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
-define double @f17(double %f) {
+define double @f17(double %f) #0 {
; CHECK-LABEL: f17:
; CHECK: brasl %r14, round@PLT
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.round.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test round for f128.
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
-define void @f18(fp128 *%ptr) {
+define void @f18(fp128 *%ptr) #0 {
; CHECK-LABEL: f18:
; CHECK: brasl %r14, roundl@PLT
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.round.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
+attributes #0 = { strictfp }
; Test rint for f32.
declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
-define float @f1(float %f) {
+define float @f1(float %f) #0 {
; CHECK-LABEL: f1:
; CHECK: fiebr %f0, 0, %f0
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.rint.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test rint for f64.
declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
-define double @f2(double %f) {
+define double @f2(double %f) #0 {
; CHECK-LABEL: f2:
; CHECK-SCALAR: fidbr %f0, 0, %f0
; CHECK-VECTOR: fidbra %f0, 0, %f0, 0
%res = call double @llvm.experimental.constrained.rint.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test rint for f128.
declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
-define void @f3(fp128 *%ptr) {
+define void @f3(fp128 *%ptr) #0 {
; CHECK-LABEL: f3:
; CHECK: fixbr %f0, 0, %f0
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.rint.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test nearbyint for f32.
declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
-define float @f4(float %f) {
+define float @f4(float %f) #0 {
; CHECK-LABEL: f4:
; CHECK: fiebra %f0, 0, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.nearbyint.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test nearbyint for f64.
declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
-define double @f5(double %f) {
+define double @f5(double %f) #0 {
; CHECK-LABEL: f5:
; CHECK: fidbra %f0, 0, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.nearbyint.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test nearbyint for f128.
declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
-define void @f6(fp128 *%ptr) {
+define void @f6(fp128 *%ptr) #0 {
; CHECK-LABEL: f6:
; CHECK: fixbra %f0, 0, %f0, 4
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.nearbyint.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test floor for f32.
declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
-define float @f7(float %f) {
+define float @f7(float %f) #0 {
; CHECK-LABEL: f7:
; CHECK: fiebra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.floor.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test floor for f64.
declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
-define double @f8(double %f) {
+define double @f8(double %f) #0 {
; CHECK-LABEL: f8:
; CHECK: fidbra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.floor.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test floor for f128.
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
-define void @f9(fp128 *%ptr) {
+define void @f9(fp128 *%ptr) #0 {
; CHECK-LABEL: f9:
; CHECK: fixbra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.floor.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test ceil for f32.
declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
-define float @f10(float %f) {
+define float @f10(float %f) #0 {
; CHECK-LABEL: f10:
; CHECK: fiebra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.ceil.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test ceil for f64.
declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
-define double @f11(double %f) {
+define double @f11(double %f) #0 {
; CHECK-LABEL: f11:
; CHECK: fidbra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.ceil.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test ceil for f128.
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
-define void @f12(fp128 *%ptr) {
+define void @f12(fp128 *%ptr) #0 {
; CHECK-LABEL: f12:
; CHECK: fixbra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.ceil.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test trunc for f32.
declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
-define float @f13(float %f) {
+define float @f13(float %f) #0 {
; CHECK-LABEL: f13:
; CHECK: fiebra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.trunc.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test trunc for f64.
declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
-define double @f14(double %f) {
+define double @f14(double %f) #0 {
; CHECK-LABEL: f14:
; CHECK: fidbra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.trunc.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test trunc for f128.
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
-define void @f15(fp128 *%ptr) {
+define void @f15(fp128 *%ptr) #0 {
; CHECK-LABEL: f15:
; CHECK: fixbra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.trunc.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test round for f32.
declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
-define float @f16(float %f) {
+define float @f16(float %f) #0 {
; CHECK-LABEL: f16:
; CHECK: fiebra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.round.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test round for f64.
declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
-define double @f17(double %f) {
+define double @f17(double %f) #0 {
; CHECK-LABEL: f17:
; CHECK: fidbra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.round.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test round for f128.
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
-define void @f18(fp128 *%ptr) {
+define void @f18(fp128 *%ptr) #0 {
; CHECK-LABEL: f18:
; CHECK: fixbra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call fp128 @llvm.experimental.constrained.round.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
+attributes #0 = { strictfp }
; Test rint for f32.
declare float @llvm.experimental.constrained.rint.f32(float, metadata, metadata)
-define float @f1(float %f) {
+define float @f1(float %f) #0 {
; CHECK-LABEL: f1:
; CHECK: fiebra %f0, 0, %f0, 0
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.rint.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test rint for f64.
declare double @llvm.experimental.constrained.rint.f64(double, metadata, metadata)
-define double @f2(double %f) {
+define double @f2(double %f) #0 {
; CHECK-LABEL: f2:
; CHECK: fidbra %f0, 0, %f0, 0
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.rint.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test rint for f128.
declare fp128 @llvm.experimental.constrained.rint.f128(fp128, metadata, metadata)
-define void @f3(fp128 *%ptr) {
+define void @f3(fp128 *%ptr) #0 {
; CHECK-LABEL: f3:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 0, 0
%res = call fp128 @llvm.experimental.constrained.rint.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test nearbyint for f32.
declare float @llvm.experimental.constrained.nearbyint.f32(float, metadata, metadata)
-define float @f4(float %f) {
+define float @f4(float %f) #0 {
; CHECK-LABEL: f4:
; CHECK: fiebra %f0, 0, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.nearbyint.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test nearbyint for f64.
declare double @llvm.experimental.constrained.nearbyint.f64(double, metadata, metadata)
-define double @f5(double %f) {
+define double @f5(double %f) #0 {
; CHECK-LABEL: f5:
; CHECK: fidbra %f0, 0, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.nearbyint.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test nearbyint for f128.
declare fp128 @llvm.experimental.constrained.nearbyint.f128(fp128, metadata, metadata)
-define void @f6(fp128 *%ptr) {
+define void @f6(fp128 *%ptr) #0 {
; CHECK-LABEL: f6:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 0
%res = call fp128 @llvm.experimental.constrained.nearbyint.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test floor for f32.
declare float @llvm.experimental.constrained.floor.f32(float, metadata, metadata)
-define float @f7(float %f) {
+define float @f7(float %f) #0 {
; CHECK-LABEL: f7:
; CHECK: fiebra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.floor.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test floor for f64.
declare double @llvm.experimental.constrained.floor.f64(double, metadata, metadata)
-define double @f8(double %f) {
+define double @f8(double %f) #0 {
; CHECK-LABEL: f8:
; CHECK: fidbra %f0, 7, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.floor.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test floor for f128.
declare fp128 @llvm.experimental.constrained.floor.f128(fp128, metadata, metadata)
-define void @f9(fp128 *%ptr) {
+define void @f9(fp128 *%ptr) #0 {
; CHECK-LABEL: f9:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 7
%res = call fp128 @llvm.experimental.constrained.floor.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test ceil for f32.
declare float @llvm.experimental.constrained.ceil.f32(float, metadata, metadata)
-define float @f10(float %f) {
+define float @f10(float %f) #0 {
; CHECK-LABEL: f10:
; CHECK: fiebra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.ceil.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test ceil for f64.
declare double @llvm.experimental.constrained.ceil.f64(double, metadata, metadata)
-define double @f11(double %f) {
+define double @f11(double %f) #0 {
; CHECK-LABEL: f11:
; CHECK: fidbra %f0, 6, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.ceil.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test ceil for f128.
declare fp128 @llvm.experimental.constrained.ceil.f128(fp128, metadata, metadata)
-define void @f12(fp128 *%ptr) {
+define void @f12(fp128 *%ptr) #0 {
; CHECK-LABEL: f12:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 6
%res = call fp128 @llvm.experimental.constrained.ceil.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test trunc for f32.
declare float @llvm.experimental.constrained.trunc.f32(float, metadata, metadata)
-define float @f13(float %f) {
+define float @f13(float %f) #0 {
; CHECK-LABEL: f13:
; CHECK: fiebra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.trunc.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test trunc for f64.
declare double @llvm.experimental.constrained.trunc.f64(double, metadata, metadata)
-define double @f14(double %f) {
+define double @f14(double %f) #0 {
; CHECK-LABEL: f14:
; CHECK: fidbra %f0, 5, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.trunc.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test trunc for f128.
declare fp128 @llvm.experimental.constrained.trunc.f128(fp128, metadata, metadata)
-define void @f15(fp128 *%ptr) {
+define void @f15(fp128 *%ptr) #0 {
; CHECK-LABEL: f15:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 5
%res = call fp128 @llvm.experimental.constrained.trunc.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
; Test round for f32.
declare float @llvm.experimental.constrained.round.f32(float, metadata, metadata)
-define float @f16(float %f) {
+define float @f16(float %f) #0 {
; CHECK-LABEL: f16:
; CHECK: fiebra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.round.f32(
float %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Test round for f64.
declare double @llvm.experimental.constrained.round.f64(double, metadata, metadata)
-define double @f17(double %f) {
+define double @f17(double %f) #0 {
; CHECK-LABEL: f17:
; CHECK: fidbra %f0, 1, %f0, 4
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.round.f64(
double %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Test round for f128.
declare fp128 @llvm.experimental.constrained.round.f128(fp128, metadata, metadata)
-define void @f18(fp128 *%ptr) {
+define void @f18(fp128 *%ptr) #0 {
; CHECK-LABEL: f18:
; CHECK: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wfixb [[RES:%v[0-9]+]], [[REG]], 4, 1
%res = call fp128 @llvm.experimental.constrained.round.f128(
fp128 %src,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128 *%ptr
ret void
}
+attributes #0 = { strictfp }
declare float @llvm.experimental.constrained.sqrt.f32(float, metadata, metadata)
; Check register square root.
-define float @f1(float %val) {
+define float @f1(float %val) #0 {
; CHECK-LABEL: f1:
; CHECK: sqebr %f0, %f0
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.sqrt.f32(
float %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the low end of the SQEB range.
-define float @f2(float *%ptr) {
+define float @f2(float *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: sqeb %f0, 0(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.sqrt.f32(
float %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the high end of the aligned SQEB range.
-define float @f3(float *%base) {
+define float @f3(float *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: sqeb %f0, 4092(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.sqrt.f32(
float %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the next word up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define float @f4(float *%base) {
+define float @f4(float *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: sqeb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.sqrt.f32(
float %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check negative displacements, which also need separate address logic.
-define float @f5(float *%base) {
+define float @f5(float *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -4
; CHECK: sqeb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.sqrt.f32(
float %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that SQEB allows indices.
-define float @f6(float *%base, i64 %index) {
+define float @f6(float *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: sqeb %f0, 400(%r1,%r2)
%res = call float @llvm.experimental.constrained.sqrt.f32(
float %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
; Check register square root.
-define double @f1(double %val) {
+define double @f1(double %val) #0 {
; CHECK-LABEL: f1:
; CHECK: sqdbr %f0, %f0
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.sqrt.f64(
double %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the low end of the SQDB range.
-define double @f2(double *%ptr) {
+define double @f2(double *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: sqdb %f0, 0(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.sqrt.f64(
double %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the high end of the aligned SQDB range.
-define double @f3(double *%base) {
+define double @f3(double *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: sqdb %f0, 4088(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.sqrt.f64(
double %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the next doubleword up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define double @f4(double *%base) {
+define double @f4(double *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: sqdb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.sqrt.f64(
double %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check negative displacements, which also need separate address logic.
-define double @f5(double *%base) {
+define double @f5(double *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -8
; CHECK: sqdb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.sqrt.f64(
double %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that SQDB allows indices.
-define double @f6(double *%base, i64 %index) {
+define double @f6(double *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 3
; CHECK: sqdb %f0, 800(%r1,%r2)
%res = call double @llvm.experimental.constrained.sqrt.f64(
double %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.sqrt.f128(fp128, metadata, metadata)
; There's no memory form of SQXBR.
-define void @f1(fp128 *%ptr) {
+define void @f1(fp128 *%ptr) strictfp {
; CHECK-LABEL: f1:
; CHECK: ld %f0, 0(%r2)
; CHECK: ld %f2, 8(%r2)
%sqrt = call fp128 @llvm.experimental.constrained.sqrt.f128(
fp128 %orig,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %sqrt, fp128 *%ptr
ret void
}
declare fp128 @llvm.experimental.constrained.sqrt.f128(fp128, metadata, metadata)
-define void @f1(fp128 *%ptr) {
+define void @f1(fp128 *%ptr) strictfp {
; CHECK-LABEL: f1:
; CHECK-DAG: vl [[REG:%v[0-9]+]], 0(%r2)
; CHECK: wfsqxb [[RES:%v[0-9]+]], [[REG]]
%res = call fp128 @llvm.experimental.constrained.sqrt.f128(
fp128 %f,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %res, fp128 *%ptr
ret void
}
declare float @llvm.experimental.constrained.fsub.f32(float, float, metadata, metadata)
; Check register subtraction.
-define float @f1(float %f1, float %f2) {
+define float @f1(float %f1, float %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: sebr %f0, %f2
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fsub.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the low end of the SEB range.
-define float @f2(float %f1, float *%ptr) {
+define float @f2(float %f1, float *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: seb %f0, 0(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fsub.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the high end of the aligned SEB range.
-define float @f3(float %f1, float *%base) {
+define float @f3(float %f1, float *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: seb %f0, 4092(%r2)
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.fsub.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check the next word up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define float @f4(float %f1, float *%base) {
+define float @f4(float %f1, float *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: seb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.fsub.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check negative displacements, which also need separate address logic.
-define float @f5(float %f1, float *%base) {
+define float @f5(float %f1, float *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -4
; CHECK: seb %f0, 0(%r2)
%res = call float @llvm.experimental.constrained.fsub.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that SEB allows indices.
-define float @f6(float %f1, float *%base, i64 %index) {
+define float @f6(float %f1, float *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 2
; CHECK: seb %f0, 400(%r1,%r2)
%res = call float @llvm.experimental.constrained.fsub.f32(
float %f1, float %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
; Check that subtractions of spilled values can use SEB rather than SEBR.
-define float @f7(float *%ptr0) {
+define float @f7(float *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK-SCALAR: seb %f0, 16{{[04]}}(%r15)
%val9 = load float, float *%ptr9
%val10 = load float, float *%ptr10
- %ret = call float @foo()
+ %ret = call float @foo() #0
%sub0 = call float @llvm.experimental.constrained.fsub.f32(
float %ret, float %val0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub1 = call float @llvm.experimental.constrained.fsub.f32(
float %sub0, float %val1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub2 = call float @llvm.experimental.constrained.fsub.f32(
float %sub1, float %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub3 = call float @llvm.experimental.constrained.fsub.f32(
float %sub2, float %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub4 = call float @llvm.experimental.constrained.fsub.f32(
float %sub3, float %val4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub5 = call float @llvm.experimental.constrained.fsub.f32(
float %sub4, float %val5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub6 = call float @llvm.experimental.constrained.fsub.f32(
float %sub5, float %val6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub7 = call float @llvm.experimental.constrained.fsub.f32(
float %sub6, float %val7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub8 = call float @llvm.experimental.constrained.fsub.f32(
float %sub7, float %val8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub9 = call float @llvm.experimental.constrained.fsub.f32(
float %sub8, float %val9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub10 = call float @llvm.experimental.constrained.fsub.f32(
float %sub9, float %val10,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %sub10
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
; Check register subtraction.
-define double @f1(double %f1, double %f2) {
+define double @f1(double %f1, double %f2) #0 {
; CHECK-LABEL: f1:
; CHECK: sdbr %f0, %f2
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fsub.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the low end of the SDB range.
-define double @f2(double %f1, double *%ptr) {
+define double @f2(double %f1, double *%ptr) #0 {
; CHECK-LABEL: f2:
; CHECK: sdb %f0, 0(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fsub.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the high end of the aligned SDB range.
-define double @f3(double %f1, double *%base) {
+define double @f3(double %f1, double *%base) #0 {
; CHECK-LABEL: f3:
; CHECK: sdb %f0, 4088(%r2)
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.fsub.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check the next doubleword up, which needs separate address logic.
; Other sequences besides this one would be OK.
-define double @f4(double %f1, double *%base) {
+define double @f4(double %f1, double *%base) #0 {
; CHECK-LABEL: f4:
; CHECK: aghi %r2, 4096
; CHECK: sdb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fsub.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check negative displacements, which also need separate address logic.
-define double @f5(double %f1, double *%base) {
+define double @f5(double %f1, double *%base) #0 {
; CHECK-LABEL: f5:
; CHECK: aghi %r2, -8
; CHECK: sdb %f0, 0(%r2)
%res = call double @llvm.experimental.constrained.fsub.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that SDB allows indices.
-define double @f6(double %f1, double *%base, i64 %index) {
+define double @f6(double %f1, double *%base, i64 %index) #0 {
; CHECK-LABEL: f6:
; CHECK: sllg %r1, %r3, 3
; CHECK: sdb %f0, 800(%r1,%r2)
%res = call double @llvm.experimental.constrained.fsub.f64(
double %f1, double %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
; Check that subtractions of spilled values can use SDB rather than SDBR.
-define double @f7(double *%ptr0) {
+define double @f7(double *%ptr0) #0 {
; CHECK-LABEL: f7:
; CHECK: brasl %r14, foo@PLT
; CHECK-SCALAR: sdb %f0, 16{{[04]}}(%r15)
%val9 = load double, double *%ptr9
%val10 = load double, double *%ptr10
- %ret = call double @foo()
+ %ret = call double @foo() #0
%sub0 = call double @llvm.experimental.constrained.fsub.f64(
double %ret, double %val0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub1 = call double @llvm.experimental.constrained.fsub.f64(
double %sub0, double %val1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub2 = call double @llvm.experimental.constrained.fsub.f64(
double %sub1, double %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub3 = call double @llvm.experimental.constrained.fsub.f64(
double %sub2, double %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub4 = call double @llvm.experimental.constrained.fsub.f64(
double %sub3, double %val4,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub5 = call double @llvm.experimental.constrained.fsub.f64(
double %sub4, double %val5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub6 = call double @llvm.experimental.constrained.fsub.f64(
double %sub5, double %val6,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub7 = call double @llvm.experimental.constrained.fsub.f64(
double %sub6, double %val7,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub8 = call double @llvm.experimental.constrained.fsub.f64(
double %sub7, double %val8,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub9 = call double @llvm.experimental.constrained.fsub.f64(
double %sub8, double %val9,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%sub10 = call double @llvm.experimental.constrained.fsub.f64(
double %sub9, double %val10,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %sub10
}
+
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.fsub.f128(fp128, fp128, metadata, metadata)
; There is no memory form of 128-bit subtraction.
-define void @f1(fp128 *%ptr, float %f2) {
+define void @f1(fp128 *%ptr, float %f2) strictfp {
; CHECK-LABEL: f1:
; CHECK-DAG: lxebr %f0, %f0
; CHECK-DAG: ld %f1, 0(%r2)
%sum = call fp128 @llvm.experimental.constrained.fsub.f128(
fp128 %f1, fp128 %f2x,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %sum, fp128 *%ptr
ret void
}
declare fp128 @llvm.experimental.constrained.fsub.f128(fp128, fp128, metadata, metadata)
-define void @f1(fp128 *%ptr1, fp128 *%ptr2) {
+define void @f1(fp128 *%ptr1, fp128 *%ptr2) strictfp {
; CHECK-LABEL: f1:
; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
%sum = call fp128 @llvm.experimental.constrained.fsub.f128(
fp128 %f1, fp128 %f2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
store fp128 %sum, fp128 *%ptr1
ret void
}
; Test a v2f64 addition.
define <2 x double> @f5(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2) {
+ <2 x double> %val2) strictfp {
; CHECK-LABEL: f5:
; CHECK: vfadb %v24, %v26, %v28
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.fadd.v2f64(
<2 x double> %val1, <2 x double> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
ret <2 x double> %ret
}
; Test an f64 addition that uses vector registers.
-define double @f6(<2 x double> %val1, <2 x double> %val2) {
+define double @f6(<2 x double> %val1, <2 x double> %val2) strictfp {
; CHECK-LABEL: f6:
; CHECK: wfadb %f0, %v24, %v26
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.fadd.f64(
double %scalar1, double %scalar2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
ret double %ret
}
; Test a v4f32 addition.
define <4 x float> @f1(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2) {
+ <4 x float> %val2) strictfp {
; CHECK-LABEL: f1:
; CHECK: vfasb %v24, %v26, %v28
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.fadd.v4f32(
<4 x float> %val1, <4 x float> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
ret <4 x float> %ret
}
; Test an f32 addition that uses vector registers.
-define float @f2(<4 x float> %val1, <4 x float> %val2) {
+define float @f2(<4 x float> %val1, <4 x float> %val2) strictfp {
; CHECK-LABEL: f2:
; CHECK: wfasb %f0, %v24, %v26
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.fadd.f32(
float %scalar1, float %scalar2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") strictfp
ret float %ret
}
declare <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f32(<2 x float>, metadata)
; Test conversion of f64s to signed i64s.
-define <2 x i64> @f1(<2 x double> %doubles) {
+define <2 x i64> @f1(<2 x double> %doubles) #0 {
; CHECK-LABEL: f1:
; CHECK: vcgdb %v24, %v24, 0, 5
; CHECK: br %r14
%dwords = call <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f64(<2 x double> %doubles,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %dwords
}
; Test conversion of f64s to unsigned i64s.
-define <2 x i64> @f2(<2 x double> %doubles) {
+define <2 x i64> @f2(<2 x double> %doubles) #0 {
; CHECK-LABEL: f2:
; CHECK: vclgdb %v24, %v24, 0, 5
; CHECK: br %r14
%dwords = call <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f64(<2 x double> %doubles,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %dwords
}
; Test conversion of f64s to signed i32s, which must compile.
-define void @f5(<2 x double> %doubles, <2 x i32> *%ptr) {
+define void @f5(<2 x double> %doubles, <2 x i32> *%ptr) #0 {
%words = call <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f64(<2 x double> %doubles,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <2 x i32> %words, <2 x i32> *%ptr
ret void
}
; Test conversion of f64s to unsigned i32s, which must compile.
-define void @f6(<2 x double> %doubles, <2 x i32> *%ptr) {
+define void @f6(<2 x double> %doubles, <2 x i32> *%ptr) #0 {
%words = call <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f64(<2 x double> %doubles,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <2 x i32> %words, <2 x i32> *%ptr
ret void
}
; Test conversion of f32s to signed i64s, which must compile.
-define <2 x i64> @f9(<2 x float> *%ptr) {
+define <2 x i64> @f9(<2 x float> *%ptr) #0 {
%floats = load <2 x float>, <2 x float> *%ptr
%dwords = call <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f32(<2 x float> %floats,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %dwords
}
; Test conversion of f32s to unsigned i64s, which must compile.
-define <2 x i64> @f10(<2 x float> *%ptr) {
+define <2 x i64> @f10(<2 x float> *%ptr) #0 {
%floats = load <2 x float>, <2 x float> *%ptr
%dwords = call <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f32(<2 x float> %floats,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %dwords
}
+attributes #0 = { strictfp }
declare <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f32(<4 x float>, metadata)
; Test conversion of f32s to signed i32s.
-define <4 x i32> @f1(<4 x float> %floats) {
+define <4 x i32> @f1(<4 x float> %floats) #0 {
; CHECK-LABEL: f1:
; CHECK: vcfeb %v24, %v24, 0, 5
; CHECK: br %r14
%words = call <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f32(<4 x float> %floats,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %words
}
; Test conversion of f32s to unsigned i32s.
-define <4 x i32> @f2(<4 x float> %floats) {
+define <4 x i32> @f2(<4 x float> %floats) #0 {
; CHECK-LABEL: f2:
; CHECK: vclfeb %v24, %v24, 0, 5
; CHECK: br %r14
%words = call <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f32(<4 x float> %floats,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %words
}
+attributes #0 = { strictfp }
; Test a v2f64 division.
define <2 x double> @f5(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2) {
+ <2 x double> %val2) #0 {
; CHECK-LABEL: f5:
; CHECK: vfddb %v24, %v26, %v28
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.fdiv.v2f64(
<2 x double> %val1, <2 x double> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
; Test an f64 division that uses vector registers.
-define double @f6(<2 x double> %val1, <2 x double> %val2) {
+define double @f6(<2 x double> %val1, <2 x double> %val2) #0 {
; CHECK-LABEL: f6:
; CHECK: wfddb %f0, %v24, %v26
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.fdiv.f64(
double %scalar1, double %scalar2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %ret
}
+
+attributes #0 = { strictfp }
; Test a v4f32 division.
define <4 x float> @f1(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2) {
+ <4 x float> %val2) #0 {
; CHECK-LABEL: f1:
; CHECK: vfdsb %v24, %v26, %v28
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.fdiv.v4f32(
<4 x float> %val1, <4 x float> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
; Test an f32 division that uses vector registers.
-define float @f2(<4 x float> %val1, <4 x float> %val2) {
+define float @f2(<4 x float> %val1, <4 x float> %val2) #0 {
; CHECK-LABEL: f2:
; CHECK: wfdsb %f0, %v24, %v26
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.fdiv.f32(
float %scalar1, float %scalar2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %ret
}
+
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.maxnum.f128(fp128, fp128, metadata, metadata)
; Test the f64 maxnum intrinsic.
-define double @f1(double %dummy, double %val1, double %val2) {
+define double @f1(double %dummy, double %val1, double %val2) #0 {
; CHECK-LABEL: f1:
; CHECK: wfmaxdb %f0, %f2, %f4, 4
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.maxnum.f64(
double %val1, double %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %ret
}
; Test the v2f64 maxnum intrinsic.
define <2 x double> @f2(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2) {
+ <2 x double> %val2) #0 {
; CHECK-LABEL: f2:
; CHECK: vfmaxdb %v24, %v26, %v28, 4
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.maxnum.v2f64(
<2 x double> %val1, <2 x double> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
; Test the f32 maxnum intrinsic.
-define float @f3(float %dummy, float %val1, float %val2) {
+define float @f3(float %dummy, float %val1, float %val2) #0 {
; CHECK-LABEL: f3:
; CHECK: wfmaxsb %f0, %f2, %f4, 4
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.maxnum.f32(
float %val1, float %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %ret
}
; Test the v4f32 maxnum intrinsic.
define <4 x float> @f4(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2) {
+ <4 x float> %val2) #0 {
; CHECK-LABEL: f4:
; CHECK: vfmaxsb %v24, %v26, %v28, 4
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.maxnum.v4f32(
<4 x float> %val1, <4 x float> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
; Test the f128 maxnum intrinsic.
-define void @f5(fp128 *%ptr1, fp128 *%ptr2, fp128 *%dst) {
+define void @f5(fp128 *%ptr1, fp128 *%ptr2, fp128 *%dst) #0 {
; CHECK-LABEL: f5:
; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
%res = call fp128 @llvm.experimental.constrained.maxnum.f128(
fp128 %val1, fp128 %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128* %dst
ret void
}
+attributes #0 = { strictfp }
declare fp128 @llvm.experimental.constrained.minnum.f128(fp128, fp128, metadata, metadata)
; Test the f64 minnum intrinsic.
-define double @f1(double %dummy, double %val1, double %val2) {
+define double @f1(double %dummy, double %val1, double %val2) #0 {
; CHECK-LABEL: f1:
; CHECK: wfmindb %f0, %f2, %f4, 4
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.minnum.f64(
double %val1, double %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %ret
}
; Test the v2f64 minnum intrinsic.
define <2 x double> @f2(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2) {
+ <2 x double> %val2) #0 {
; CHECK-LABEL: f2:
; CHECK: vfmindb %v24, %v26, %v28, 4
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.minnum.v2f64(
<2 x double> %val1, <2 x double> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
; Test the f32 minnum intrinsic.
-define float @f3(float %dummy, float %val1, float %val2) {
+define float @f3(float %dummy, float %val1, float %val2) #0 {
; CHECK-LABEL: f3:
; CHECK: wfminsb %f0, %f2, %f4, 4
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.minnum.f32(
float %val1, float %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %ret
}
; Test the v4f32 minnum intrinsic.
define <4 x float> @f4(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2) {
+ <4 x float> %val2) #0 {
; CHECK-LABEL: f4:
; CHECK: vfminsb %v24, %v26, %v28, 4
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.minnum.v4f32(
<4 x float> %val1, <4 x float> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
; Test the f128 minnum intrinsic.
-define void @f5(fp128 *%ptr1, fp128 *%ptr2, fp128 *%dst) {
+define void @f5(fp128 *%ptr1, fp128 *%ptr2, fp128 *%dst) #0 {
; CHECK-LABEL: f5:
; CHECK-DAG: vl [[REG1:%v[0-9]+]], 0(%r2)
; CHECK-DAG: vl [[REG2:%v[0-9]+]], 0(%r3)
%res = call fp128 @llvm.experimental.constrained.minnum.f128(
fp128 %val1, fp128 %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store fp128 %res, fp128* %dst
ret void
}
+attributes #0 = { strictfp }
; Test a v2f64 multiplication.
define <2 x double> @f5(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2) {
+ <2 x double> %val2) #0 {
; CHECK-LABEL: f5:
; CHECK: vfmdb %v24, %v26, %v28
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.fmul.v2f64(
<2 x double> %val1, <2 x double> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
; Test an f64 multiplication that uses vector registers.
-define double @f6(<2 x double> %val1, <2 x double> %val2) {
+define double @f6(<2 x double> %val1, <2 x double> %val2) #0 {
; CHECK-LABEL: f6:
; CHECK: wfmdb %f0, %v24, %v26
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.fmul.f64(
double %scalar1, double %scalar2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %ret
}
+
+attributes #0 = { strictfp }
; Test a v2f64 multiply-and-add.
define <2 x double> @f4(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2, <2 x double> %val3) {
+ <2 x double> %val2, <2 x double> %val3) #0 {
; CHECK-LABEL: f4:
; CHECK: vfmadb %v24, %v26, %v28, %v30
; CHECK: br %r14
<2 x double> %val2,
<2 x double> %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
; Test a v2f64 multiply-and-subtract.
define <2 x double> @f5(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2, <2 x double> %val3) {
+ <2 x double> %val2, <2 x double> %val3) #0 {
; CHECK-LABEL: f5:
; CHECK: vfmsdb %v24, %v26, %v28, %v30
; CHECK: br %r14
<2 x double> %val2,
<2 x double> %negval3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
+
+attributes #0 = { strictfp }
; Test a v4f32 multiplication.
define <4 x float> @f1(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2) {
+ <4 x float> %val2) #0 {
; CHECK-LABEL: f1:
; CHECK: vfmsb %v24, %v26, %v28
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.fmul.v4f32(
<4 x float> %val1, <4 x float> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
; Test an f32 multiplication that uses vector registers.
-define float @f2(<4 x float> %val1, <4 x float> %val2) {
+define float @f2(<4 x float> %val1, <4 x float> %val2) #0 {
; CHECK-LABEL: f2:
; CHECK: wfmsb %f0, %v24, %v26
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.fmul.f32(
float %scalar1, float %scalar2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %ret
}
+
+attributes #0 = { strictfp }
; Test a v4f32 multiply-and-add.
define <4 x float> @f1(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2, <4 x float> %val3) {
+ <4 x float> %val2, <4 x float> %val3) #0 {
; CHECK-LABEL: f1:
; CHECK: vfmasb %v24, %v26, %v28, %v30
; CHECK: br %r14
<4 x float> %val2,
<4 x float> %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
; Test a v4f32 multiply-and-subtract.
define <4 x float> @f2(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2, <4 x float> %val3) {
+ <4 x float> %val2, <4 x float> %val3) #0 {
; CHECK-LABEL: f2:
; CHECK: vfmssb %v24, %v26, %v28, %v30
; CHECK: br %r14
<4 x float> %val2,
<4 x float> %negval3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
+
+attributes #0 = { strictfp }
; Test a v2f64 negative multiply-and-add.
define <2 x double> @f1(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2, <2 x double> %val3) {
+ <2 x double> %val2, <2 x double> %val3) #0 {
; CHECK-LABEL: f1:
; CHECK: vfnmadb %v24, %v26, %v28, %v30
; CHECK: br %r14
<2 x double> %val2,
<2 x double> %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%negret = fsub <2 x double> <double -0.0, double -0.0>, %ret
ret <2 x double> %negret
}
; Test a v2f64 negative multiply-and-subtract.
define <2 x double> @f2(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2, <2 x double> %val3) {
+ <2 x double> %val2, <2 x double> %val3) #0 {
; CHECK-LABEL: f2:
; CHECK: vfnmsdb %v24, %v26, %v28, %v30
; CHECK: br %r14
<2 x double> %val2,
<2 x double> %negval3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%negret = fsub <2 x double> <double -0.0, double -0.0>, %ret
ret <2 x double> %negret
}
; Test a v4f32 negative multiply-and-add.
define <4 x float> @f3(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2, <4 x float> %val3) {
+ <4 x float> %val2, <4 x float> %val3) #0 {
; CHECK-LABEL: f3:
; CHECK: vfnmasb %v24, %v26, %v28, %v30
; CHECK: br %r14
<4 x float> %val2,
<4 x float> %val3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%negret = fsub <4 x float> <float -0.0, float -0.0,
float -0.0, float -0.0>, %ret
ret <4 x float> %negret
; Test a v4f32 negative multiply-and-subtract.
define <4 x float> @f4(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2, <4 x float> %val3) {
+ <4 x float> %val2, <4 x float> %val3) #0 {
; CHECK-LABEL: f4:
; CHECK: vfnmssb %v24, %v26, %v28, %v30
; CHECK: br %r14
<4 x float> %val2,
<4 x float> %negval3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%negret = fsub <4 x float> <float -0.0, float -0.0,
float -0.0, float -0.0>, %ret
ret <4 x float> %negret
}
+
+attributes #0 = { strictfp }
declare <2 x double> @llvm.experimental.constrained.trunc.v2f64(<2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.round.v2f64(<2 x double>, metadata, metadata)
-define <2 x double> @f1(<2 x double> %val) {
+define <2 x double> @f1(<2 x double> %val) #0 {
; CHECK-LABEL: f1:
; CHECK: vfidb %v24, %v24, 0, 0
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.rint.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
-define <2 x double> @f2(<2 x double> %val) {
+define <2 x double> @f2(<2 x double> %val) #0 {
; CHECK-LABEL: f2:
; CHECK: vfidb %v24, %v24, 4, 0
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
-define <2 x double> @f3(<2 x double> %val) {
+define <2 x double> @f3(<2 x double> %val) #0 {
; CHECK-LABEL: f3:
; CHECK: vfidb %v24, %v24, 4, 7
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
-define <2 x double> @f4(<2 x double> %val) {
+define <2 x double> @f4(<2 x double> %val) #0 {
; CHECK-LABEL: f4:
; CHECK: vfidb %v24, %v24, 4, 6
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
-define <2 x double> @f5(<2 x double> %val) {
+define <2 x double> @f5(<2 x double> %val) #0 {
; CHECK-LABEL: f5:
; CHECK: vfidb %v24, %v24, 4, 5
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
-define <2 x double> @f6(<2 x double> %val) {
+define <2 x double> @f6(<2 x double> %val) #0 {
; CHECK-LABEL: f6:
; CHECK: vfidb %v24, %v24, 4, 1
; CHECK: br %r14
%res = call <2 x double> @llvm.experimental.constrained.round.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %res
}
-define double @f7(<2 x double> %val) {
+define double @f7(<2 x double> %val) #0 {
; CHECK-LABEL: f7:
; CHECK: wfidb %f0, %v24, 0, 0
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.rint.f64(
double %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f8(<2 x double> %val) {
+define double @f8(<2 x double> %val) #0 {
; CHECK-LABEL: f8:
; CHECK: wfidb %f0, %v24, 4, 0
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.nearbyint.f64(
double %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f9(<2 x double> %val) {
+define double @f9(<2 x double> %val) #0 {
; CHECK-LABEL: f9:
; CHECK: wfidb %f0, %v24, 4, 7
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.floor.f64(
double %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f10(<2 x double> %val) {
+define double @f10(<2 x double> %val) #0 {
; CHECK-LABEL: f10:
; CHECK: wfidb %f0, %v24, 4, 6
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.ceil.f64(
double %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f11(<2 x double> %val) {
+define double @f11(<2 x double> %val) #0 {
; CHECK-LABEL: f11:
; CHECK: wfidb %f0, %v24, 4, 5
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.trunc.f64(
double %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
-define double @f12(<2 x double> %val) {
+define double @f12(<2 x double> %val) #0 {
; CHECK-LABEL: f12:
; CHECK: wfidb %f0, %v24, 4, 1
; CHECK: br %r14
%res = call double @llvm.experimental.constrained.round.f64(
double %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %res
}
+
+attributes #0 = { strictfp }
declare <4 x float> @llvm.experimental.constrained.trunc.v4f32(<4 x float>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.round.v4f32(<4 x float>, metadata, metadata)
-define <4 x float> @f1(<4 x float> %val) {
+define <4 x float> @f1(<4 x float> %val) #0 {
; CHECK-LABEL: f1:
; CHECK: vfisb %v24, %v24, 0, 0
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.rint.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
-define <4 x float> @f2(<4 x float> %val) {
+define <4 x float> @f2(<4 x float> %val) #0 {
; CHECK-LABEL: f2:
; CHECK: vfisb %v24, %v24, 4, 0
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.nearbyint.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
-define <4 x float> @f3(<4 x float> %val) {
+define <4 x float> @f3(<4 x float> %val) #0 {
; CHECK-LABEL: f3:
; CHECK: vfisb %v24, %v24, 4, 7
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.floor.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
-define <4 x float> @f4(<4 x float> %val) {
+define <4 x float> @f4(<4 x float> %val) #0 {
; CHECK-LABEL: f4:
; CHECK: vfisb %v24, %v24, 4, 6
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.ceil.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
-define <4 x float> @f5(<4 x float> %val) {
+define <4 x float> @f5(<4 x float> %val) #0 {
; CHECK-LABEL: f5:
; CHECK: vfisb %v24, %v24, 4, 5
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.trunc.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
-define <4 x float> @f6(<4 x float> %val) {
+define <4 x float> @f6(<4 x float> %val) #0 {
; CHECK-LABEL: f6:
; CHECK: vfisb %v24, %v24, 4, 1
; CHECK: br %r14
%res = call <4 x float> @llvm.experimental.constrained.round.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %res
}
-define float @f7(<4 x float> %val) {
+define float @f7(<4 x float> %val) #0 {
; CHECK-LABEL: f7:
; CHECK: wfisb %f0, %v24, 0, 0
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.rint.f32(
float %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f8(<4 x float> %val) {
+define float @f8(<4 x float> %val) #0 {
; CHECK-LABEL: f8:
; CHECK: wfisb %f0, %v24, 4, 0
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.nearbyint.f32(
float %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f9(<4 x float> %val) {
+define float @f9(<4 x float> %val) #0 {
; CHECK-LABEL: f9:
; CHECK: wfisb %f0, %v24, 4, 7
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.floor.f32(
float %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f10(<4 x float> %val) {
+define float @f10(<4 x float> %val) #0 {
; CHECK-LABEL: f10:
; CHECK: wfisb %f0, %v24, 4, 6
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.ceil.f32(
float %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f11(<4 x float> %val) {
+define float @f11(<4 x float> %val) #0 {
; CHECK-LABEL: f11:
; CHECK: wfisb %f0, %v24, 4, 5
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.trunc.f32(
float %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
-define float @f12(<4 x float> %val) {
+define float @f12(<4 x float> %val) #0 {
; CHECK-LABEL: f12:
; CHECK: wfisb %f0, %v24, 4, 1
; CHECK: br %r14
%res = call float @llvm.experimental.constrained.round.f32(
float %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %res
}
+
+attributes #0 = { strictfp }
declare double @llvm.experimental.constrained.sqrt.f64(double, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.sqrt.v2f64(<2 x double>, metadata, metadata)
-define <2 x double> @f1(<2 x double> %val) {
+define <2 x double> @f1(<2 x double> %val) #0 {
; CHECK-LABEL: f1:
; CHECK: vfsqdb %v24, %v24
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.sqrt.v2f64(
<2 x double> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
-define double @f2(<2 x double> %val) {
+define double @f2(<2 x double> %val) #0 {
; CHECK-LABEL: f2:
; CHECK: wfsqdb %f0, %v24
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.sqrt.f64(
double %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %ret
}
+
+attributes #0 = { strictfp }
declare float @llvm.experimental.constrained.sqrt.f32(float, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.sqrt.v4f32(<4 x float>, metadata, metadata)
-define <4 x float> @f1(<4 x float> %val) {
+define <4 x float> @f1(<4 x float> %val) #0 {
; CHECK-LABEL: f1:
; CHECK: vfsqsb %v24, %v24
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.sqrt.v4f32(
<4 x float> %val,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
-define float @f2(<4 x float> %val) {
+define float @f2(<4 x float> %val) #0 {
; CHECK-LABEL: f2:
; CHECK: wfsqsb %f0, %v24
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.sqrt.f32(
float %scalar,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %ret
}
+
+attributes #0 = { strictfp }
; Test a v2f64 subtraction.
define <2 x double> @f6(<2 x double> %dummy, <2 x double> %val1,
- <2 x double> %val2) {
+ <2 x double> %val2) #0 {
; CHECK-LABEL: f6:
; CHECK: vfsdb %v24, %v26, %v28
; CHECK: br %r14
%ret = call <2 x double> @llvm.experimental.constrained.fsub.v2f64(
<2 x double> %val1, <2 x double> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ret
}
; Test an f64 subtraction that uses vector registers.
-define double @f7(<2 x double> %val1, <2 x double> %val2) {
+define double @f7(<2 x double> %val1, <2 x double> %val2) #0 {
; CHECK-LABEL: f7:
; CHECK: wfsdb %f0, %v24, %v26
; CHECK: br %r14
%ret = call double @llvm.experimental.constrained.fsub.f64(
double %scalar1, double %scalar2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %ret
}
+attributes #0 = { strictfp }
; Test a v4f32 subtraction.
define <4 x float> @f6(<4 x float> %dummy, <4 x float> %val1,
- <4 x float> %val2) {
+ <4 x float> %val2) #0 {
; CHECK-LABEL: f6:
; CHECK: vfssb %v24, %v26, %v28
; CHECK: br %r14
%ret = call <4 x float> @llvm.experimental.constrained.fsub.v4f32(
<4 x float> %val1, <4 x float> %val2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %ret
}
; Test an f32 subtraction that uses vector registers.
-define float @f7(<4 x float> %val1, <4 x float> %val2) {
+define float @f7(<4 x float> %val1, <4 x float> %val2) #0 {
; CHECK-LABEL: f7:
; CHECK: wfssb %f0, %v24, %v26
; CHECK: br %r14
%ret = call float @llvm.experimental.constrained.fsub.f32(
float %scalar1, float %scalar2,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %ret
}
+
+attributes #0 = { strictfp }
; RUN: llc -O3 -mtriple=s390x-linux-gnu < %s | FileCheck --check-prefix=S390X %s
; RUN: llc -O3 -mtriple=s390x-linux-gnu -mcpu=z13 < %s | FileCheck --check-prefix=SZ13 %s
-define <1 x float> @constrained_vector_fdiv_v1f32() {
+define <1 x float> @constrained_vector_fdiv_v1f32() #0 {
; S390X-LABEL: constrained_vector_fdiv_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI0_0
<1 x float> <float 1.000000e+00>,
<1 x float> <float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %div
}
-define <2 x double> @constrained_vector_fdiv_v2f64() {
+define <2 x double> @constrained_vector_fdiv_v2f64() #0 {
; S390X-LABEL: constrained_vector_fdiv_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI1_0
<2 x double> <double 1.000000e+00, double 2.000000e+00>,
<2 x double> <double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %div
}
-define <3 x float> @constrained_vector_fdiv_v3f32() {
+define <3 x float> @constrained_vector_fdiv_v3f32() #0 {
; S390X-LABEL: constrained_vector_fdiv_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI2_0
<3 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>,
<3 x float> <float 1.000000e+01, float 1.000000e+01, float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %div
}
-define void @constrained_vector_fdiv_v3f64(<3 x double>* %a) {
+define void @constrained_vector_fdiv_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_fdiv_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: ld %f0, 16(%r2)
<3 x double> <double 1.000000e+00, double 2.000000e+00, double 3.000000e+00>,
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %div, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_fdiv_v4f64() {
+define <4 x double> @constrained_vector_fdiv_v4f64() #0 {
; S390X-LABEL: constrained_vector_fdiv_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI4_0
<4 x double> <double 1.000000e+01, double 1.000000e+01,
double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %div
}
-define <1 x float> @constrained_vector_frem_v1f32() {
+define <1 x float> @constrained_vector_frem_v1f32() #0 {
; S390X-LABEL: constrained_vector_frem_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<1 x float> <float 1.000000e+00>,
<1 x float> <float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %rem
}
-define <2 x double> @constrained_vector_frem_v2f64() {
+define <2 x double> @constrained_vector_frem_v2f64() #0 {
; S390X-LABEL: constrained_vector_frem_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<2 x double> <double 1.000000e+00, double 2.000000e+00>,
<2 x double> <double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %rem
}
-define <3 x float> @constrained_vector_frem_v3f32() {
+define <3 x float> @constrained_vector_frem_v3f32() #0 {
; S390X-LABEL: constrained_vector_frem_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<3 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>,
<3 x float> <float 1.000000e+01, float 1.000000e+01, float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %rem
}
-define void @constrained_vector_frem_v3f64(<3 x double>* %a) {
+define void @constrained_vector_frem_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_frem_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
<3 x double> <double 1.000000e+00, double 2.000000e+00, double 3.000000e+00>,
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %rem, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_frem_v4f64() {
+define <4 x double> @constrained_vector_frem_v4f64() #0 {
; S390X-LABEL: constrained_vector_frem_v4f64:
; S390X: # %bb.0:
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 1.000000e+01, double 1.000000e+01,
double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %rem
}
-define <1 x float> @constrained_vector_fmul_v1f32() {
+define <1 x float> @constrained_vector_fmul_v1f32() #0 {
; S390X-LABEL: constrained_vector_fmul_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI10_0
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 2.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %mul
}
-define <2 x double> @constrained_vector_fmul_v2f64() {
+define <2 x double> @constrained_vector_fmul_v2f64() #0 {
; S390X-LABEL: constrained_vector_fmul_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI11_0
<2 x double> <double 0x7FEFFFFFFFFFFFFF, double 0x7FEFFFFFFFFFFFFF>,
<2 x double> <double 2.000000e+00, double 3.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %mul
}
-define <3 x float> @constrained_vector_fmul_v3f32() {
+define <3 x float> @constrained_vector_fmul_v3f32() #0 {
; S390X-LABEL: constrained_vector_fmul_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI12_0
float 0x7FF0000000000000>,
<3 x float> <float 1.000000e+00, float 1.000000e+01, float 1.000000e+02>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %mul
}
-define void @constrained_vector_fmul_v3f64(<3 x double>* %a) {
+define void @constrained_vector_fmul_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_fmul_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: ld %f0, 8(%r2)
double 0x7FEFFFFFFFFFFFFF>,
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %mul, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_fmul_v4f64() {
+define <4 x double> @constrained_vector_fmul_v4f64() #0 {
; S390X-LABEL: constrained_vector_fmul_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI14_0
<4 x double> <double 2.000000e+00, double 3.000000e+00,
double 4.000000e+00, double 5.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %mul
}
-define <1 x float> @constrained_vector_fadd_v1f32() {
+define <1 x float> @constrained_vector_fadd_v1f32() #0 {
; S390X-LABEL: constrained_vector_fadd_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI15_0
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 1.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %add
}
-define <2 x double> @constrained_vector_fadd_v2f64() {
+define <2 x double> @constrained_vector_fadd_v2f64() #0 {
; S390X-LABEL: constrained_vector_fadd_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI16_0
<2 x double> <double 0x7FEFFFFFFFFFFFFF, double 0x7FEFFFFFFFFFFFFF>,
<2 x double> <double 1.000000e+00, double 1.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %add
}
-define <3 x float> @constrained_vector_fadd_v3f32() {
+define <3 x float> @constrained_vector_fadd_v3f32() #0 {
; S390X-LABEL: constrained_vector_fadd_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI17_0
float 0xFFFFFFFFE0000000>,
<3 x float> <float 2.0, float 1.0, float 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %add
}
-define void @constrained_vector_fadd_v3f64(<3 x double>* %a) {
+define void @constrained_vector_fadd_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_fadd_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: ld %f0, 8(%r2)
double 0x7FEFFFFFFFFFFFFF>,
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %add, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_fadd_v4f64() {
+define <4 x double> @constrained_vector_fadd_v4f64() #0 {
; S390X-LABEL: constrained_vector_fadd_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI19_0
<4 x double> <double 1.000000e+00, double 1.000000e-01,
double 2.000000e+00, double 2.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %add
}
-define <1 x float> @constrained_vector_fsub_v1f32() {
+define <1 x float> @constrained_vector_fsub_v1f32() #0 {
; S390X-LABEL: constrained_vector_fsub_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI20_0
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 1.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %sub
}
-define <2 x double> @constrained_vector_fsub_v2f64() {
+define <2 x double> @constrained_vector_fsub_v2f64() #0 {
; S390X-LABEL: constrained_vector_fsub_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI21_0
<2 x double> <double 0xFFEFFFFFFFFFFFFF, double 0xFFEFFFFFFFFFFFFF>,
<2 x double> <double 1.000000e+00, double 1.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %sub
}
-define <3 x float> @constrained_vector_fsub_v3f32() {
+define <3 x float> @constrained_vector_fsub_v3f32() #0 {
; S390X-LABEL: constrained_vector_fsub_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI22_0
float 0xFFFFFFFFE0000000>,
<3 x float> <float 2.0, float 1.0, float 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %sub
}
-define void @constrained_vector_fsub_v3f64(<3 x double>* %a) {
+define void @constrained_vector_fsub_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_fsub_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI23_0
double 0xFFEFFFFFFFFFFFFF>,
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %sub, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_fsub_v4f64() {
+define <4 x double> @constrained_vector_fsub_v4f64() #0 {
; S390X-LABEL: constrained_vector_fsub_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI24_0
<4 x double> <double 1.000000e+00, double 1.000000e-01,
double 2.000000e+00, double 2.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %sub
}
-define <1 x float> @constrained_vector_sqrt_v1f32() {
+define <1 x float> @constrained_vector_sqrt_v1f32() #0 {
; S390X-LABEL: constrained_vector_sqrt_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI25_0
%sqrt = call <1 x float> @llvm.experimental.constrained.sqrt.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %sqrt
}
-define <2 x double> @constrained_vector_sqrt_v2f64() {
+define <2 x double> @constrained_vector_sqrt_v2f64() #0 {
; S390X-LABEL: constrained_vector_sqrt_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI26_0
%sqrt = call <2 x double> @llvm.experimental.constrained.sqrt.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %sqrt
}
-define <3 x float> @constrained_vector_sqrt_v3f32() {
+define <3 x float> @constrained_vector_sqrt_v3f32() #0 {
; S390X-LABEL: constrained_vector_sqrt_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI27_0
%sqrt = call <3 x float> @llvm.experimental.constrained.sqrt.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %sqrt
}
-define void @constrained_vector_sqrt_v3f64(<3 x double>* %a) {
+define void @constrained_vector_sqrt_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_sqrt_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: ld %f0, 8(%r2)
%sqrt = call <3 x double> @llvm.experimental.constrained.sqrt.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %sqrt, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_sqrt_v4f64() {
+define <4 x double> @constrained_vector_sqrt_v4f64() #0 {
; S390X-LABEL: constrained_vector_sqrt_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI29_0
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %sqrt
}
-define <1 x float> @constrained_vector_pow_v1f32() {
+define <1 x float> @constrained_vector_pow_v1f32() #0 {
; S390X-LABEL: constrained_vector_pow_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<1 x float> <float 42.0>,
<1 x float> <float 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %pow
}
-define <2 x double> @constrained_vector_pow_v2f64() {
+define <2 x double> @constrained_vector_pow_v2f64() #0 {
; S390X-LABEL: constrained_vector_pow_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<2 x double> <double 42.1, double 42.2>,
<2 x double> <double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %pow
}
-define <3 x float> @constrained_vector_pow_v3f32() {
+define <3 x float> @constrained_vector_pow_v3f32() #0 {
; S390X-LABEL: constrained_vector_pow_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<3 x float> <float 42.0, float 43.0, float 44.0>,
<3 x float> <float 3.0, float 3.0, float 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %pow
}
-define void @constrained_vector_pow_v3f64(<3 x double>* %a) {
+define void @constrained_vector_pow_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_pow_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
<3 x double> %b,
<3 x double> <double 3.0, double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %pow, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_pow_v4f64() {
+define <4 x double> @constrained_vector_pow_v4f64() #0 {
; S390X-LABEL: constrained_vector_pow_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 3.0, double 3.0,
double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %pow
}
-define <1 x float> @constrained_vector_powi_v1f32() {
+define <1 x float> @constrained_vector_powi_v1f32() #0 {
; S390X-LABEL: constrained_vector_powi_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<1 x float> <float 42.0>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %powi
}
-define <2 x double> @constrained_vector_powi_v2f64() {
+define <2 x double> @constrained_vector_powi_v2f64() #0 {
; S390X-LABEL: constrained_vector_powi_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<2 x double> <double 42.1, double 42.2>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %powi
}
-define <3 x float> @constrained_vector_powi_v3f32() {
+define <3 x float> @constrained_vector_powi_v3f32() #0 {
; S390X-LABEL: constrained_vector_powi_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<3 x float> <float 42.0, float 43.0, float 44.0>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %powi
}
-define void @constrained_vector_powi_v3f64(<3 x double>* %a) {
+define void @constrained_vector_powi_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_powi_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
<3 x double> <double 42.0, double 42.1, double 42.2>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %powi, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_powi_v4f64() {
+define <4 x double> @constrained_vector_powi_v4f64() #0 {
; S390X-LABEL: constrained_vector_powi_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
double 42.3, double 42.4>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %powi
}
-define <1 x float> @constrained_vector_sin_v1f32() {
+define <1 x float> @constrained_vector_sin_v1f32() #0 {
; S390X-LABEL: constrained_vector_sin_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%sin = call <1 x float> @llvm.experimental.constrained.sin.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %sin
}
-define <2 x double> @constrained_vector_sin_v2f64() {
+define <2 x double> @constrained_vector_sin_v2f64() #0 {
; S390X-LABEL: constrained_vector_sin_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%sin = call <2 x double> @llvm.experimental.constrained.sin.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %sin
}
-define <3 x float> @constrained_vector_sin_v3f32() {
+define <3 x float> @constrained_vector_sin_v3f32() #0 {
; S390X-LABEL: constrained_vector_sin_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%sin = call <3 x float> @llvm.experimental.constrained.sin.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %sin
}
-define void @constrained_vector_sin_v3f64(<3 x double>* %a) {
+define void @constrained_vector_sin_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_sin_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%sin = call <3 x double> @llvm.experimental.constrained.sin.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %sin, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_sin_v4f64() {
+define <4 x double> @constrained_vector_sin_v4f64() #0 {
; S390X-LABEL: constrained_vector_sin_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %sin
}
-define <1 x float> @constrained_vector_cos_v1f32() {
+define <1 x float> @constrained_vector_cos_v1f32() #0 {
; S390X-LABEL: constrained_vector_cos_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%cos = call <1 x float> @llvm.experimental.constrained.cos.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %cos
}
-define <2 x double> @constrained_vector_cos_v2f64() {
+define <2 x double> @constrained_vector_cos_v2f64() #0 {
; S390X-LABEL: constrained_vector_cos_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%cos = call <2 x double> @llvm.experimental.constrained.cos.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %cos
}
-define <3 x float> @constrained_vector_cos_v3f32() {
+define <3 x float> @constrained_vector_cos_v3f32() #0 {
; S390X-LABEL: constrained_vector_cos_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%cos = call <3 x float> @llvm.experimental.constrained.cos.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %cos
}
-define void @constrained_vector_cos_v3f64(<3 x double>* %a) {
+define void @constrained_vector_cos_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_cos_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%cos = call <3 x double> @llvm.experimental.constrained.cos.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %cos, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_cos_v4f64() {
+define <4 x double> @constrained_vector_cos_v4f64() #0 {
; S390X-LABEL: constrained_vector_cos_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %cos
}
-define <1 x float> @constrained_vector_exp_v1f32() {
+define <1 x float> @constrained_vector_exp_v1f32() #0 {
; S390X-LABEL: constrained_vector_exp_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%exp = call <1 x float> @llvm.experimental.constrained.exp.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %exp
}
-define <2 x double> @constrained_vector_exp_v2f64() {
+define <2 x double> @constrained_vector_exp_v2f64() #0 {
; S390X-LABEL: constrained_vector_exp_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%exp = call <2 x double> @llvm.experimental.constrained.exp.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %exp
}
-define <3 x float> @constrained_vector_exp_v3f32() {
+define <3 x float> @constrained_vector_exp_v3f32() #0 {
; S390X-LABEL: constrained_vector_exp_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%exp = call <3 x float> @llvm.experimental.constrained.exp.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %exp
}
-define void @constrained_vector_exp_v3f64(<3 x double>* %a) {
+define void @constrained_vector_exp_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_exp_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%exp = call <3 x double> @llvm.experimental.constrained.exp.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %exp, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_exp_v4f64() {
+define <4 x double> @constrained_vector_exp_v4f64() #0 {
; S390X-LABEL: constrained_vector_exp_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %exp
}
-define <1 x float> @constrained_vector_exp2_v1f32() {
+define <1 x float> @constrained_vector_exp2_v1f32() #0 {
; S390X-LABEL: constrained_vector_exp2_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%exp2 = call <1 x float> @llvm.experimental.constrained.exp2.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %exp2
}
-define <2 x double> @constrained_vector_exp2_v2f64() {
+define <2 x double> @constrained_vector_exp2_v2f64() #0 {
; S390X-LABEL: constrained_vector_exp2_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%exp2 = call <2 x double> @llvm.experimental.constrained.exp2.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %exp2
}
-define <3 x float> @constrained_vector_exp2_v3f32() {
+define <3 x float> @constrained_vector_exp2_v3f32() #0 {
; S390X-LABEL: constrained_vector_exp2_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%exp2 = call <3 x float> @llvm.experimental.constrained.exp2.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %exp2
}
-define void @constrained_vector_exp2_v3f64(<3 x double>* %a) {
+define void @constrained_vector_exp2_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_exp2_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%exp2 = call <3 x double> @llvm.experimental.constrained.exp2.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %exp2, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_exp2_v4f64() {
+define <4 x double> @constrained_vector_exp2_v4f64() #0 {
; S390X-LABEL: constrained_vector_exp2_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %exp2
}
-define <1 x float> @constrained_vector_log_v1f32() {
+define <1 x float> @constrained_vector_log_v1f32() #0 {
; S390X-LABEL: constrained_vector_log_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log = call <1 x float> @llvm.experimental.constrained.log.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %log
}
-define <2 x double> @constrained_vector_log_v2f64() {
+define <2 x double> @constrained_vector_log_v2f64() #0 {
; S390X-LABEL: constrained_vector_log_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log = call <2 x double> @llvm.experimental.constrained.log.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %log
}
-define <3 x float> @constrained_vector_log_v3f32() {
+define <3 x float> @constrained_vector_log_v3f32() #0 {
; S390X-LABEL: constrained_vector_log_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log = call <3 x float> @llvm.experimental.constrained.log.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %log
}
-define void @constrained_vector_log_v3f64(<3 x double>* %a) {
+define void @constrained_vector_log_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_log_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%log = call <3 x double> @llvm.experimental.constrained.log.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %log, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_log_v4f64() {
+define <4 x double> @constrained_vector_log_v4f64() #0 {
; S390X-LABEL: constrained_vector_log_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %log
}
-define <1 x float> @constrained_vector_log10_v1f32() {
+define <1 x float> @constrained_vector_log10_v1f32() #0 {
; S390X-LABEL: constrained_vector_log10_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log10 = call <1 x float> @llvm.experimental.constrained.log10.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %log10
}
-define <2 x double> @constrained_vector_log10_v2f64() {
+define <2 x double> @constrained_vector_log10_v2f64() #0 {
; S390X-LABEL: constrained_vector_log10_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log10 = call <2 x double> @llvm.experimental.constrained.log10.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %log10
}
-define <3 x float> @constrained_vector_log10_v3f32() {
+define <3 x float> @constrained_vector_log10_v3f32() #0 {
; S390X-LABEL: constrained_vector_log10_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log10 = call <3 x float> @llvm.experimental.constrained.log10.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %log10
}
-define void @constrained_vector_log10_v3f64(<3 x double>* %a) {
+define void @constrained_vector_log10_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_log10_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%log10 = call <3 x double> @llvm.experimental.constrained.log10.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %log10, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_log10_v4f64() {
+define <4 x double> @constrained_vector_log10_v4f64() #0 {
; S390X-LABEL: constrained_vector_log10_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %log10
}
-define <1 x float> @constrained_vector_log2_v1f32() {
+define <1 x float> @constrained_vector_log2_v1f32() #0 {
; S390X-LABEL: constrained_vector_log2_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log2 = call <1 x float> @llvm.experimental.constrained.log2.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %log2
}
-define <2 x double> @constrained_vector_log2_v2f64() {
+define <2 x double> @constrained_vector_log2_v2f64() #0 {
; S390X-LABEL: constrained_vector_log2_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log2 = call <2 x double> @llvm.experimental.constrained.log2.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %log2
}
-define <3 x float> @constrained_vector_log2_v3f32() {
+define <3 x float> @constrained_vector_log2_v3f32() #0 {
; S390X-LABEL: constrained_vector_log2_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%log2 = call <3 x float> @llvm.experimental.constrained.log2.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %log2
}
-define void @constrained_vector_log2_v3f64(<3 x double>* %a) {
+define void @constrained_vector_log2_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_log2_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%log2 = call <3 x double> @llvm.experimental.constrained.log2.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %log2, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_log2_v4f64() {
+define <4 x double> @constrained_vector_log2_v4f64() #0 {
; S390X-LABEL: constrained_vector_log2_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %log2
}
-define <1 x float> @constrained_vector_rint_v1f32() {
+define <1 x float> @constrained_vector_rint_v1f32() #0 {
; S390X-LABEL: constrained_vector_rint_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI75_0
%rint = call <1 x float> @llvm.experimental.constrained.rint.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %rint
}
-define <2 x double> @constrained_vector_rint_v2f64() {
+define <2 x double> @constrained_vector_rint_v2f64() #0 {
; S390X-LABEL: constrained_vector_rint_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI76_0
%rint = call <2 x double> @llvm.experimental.constrained.rint.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %rint
}
-define <3 x float> @constrained_vector_rint_v3f32() {
+define <3 x float> @constrained_vector_rint_v3f32() #0 {
; S390X-LABEL: constrained_vector_rint_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI77_0
%rint = call <3 x float> @llvm.experimental.constrained.rint.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %rint
}
-define void @constrained_vector_rint_v3f64(<3 x double>* %a) {
+define void @constrained_vector_rint_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_rint_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: ld %f0, 0(%r2)
%rint = call <3 x double> @llvm.experimental.constrained.rint.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %rint, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_rint_v4f64() {
+define <4 x double> @constrained_vector_rint_v4f64() #0 {
; S390X-LABEL: constrained_vector_rint_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI79_0
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %rint
}
-define <1 x float> @constrained_vector_nearbyint_v1f32() {
+define <1 x float> @constrained_vector_nearbyint_v1f32() #0 {
; S390X-LABEL: constrained_vector_nearbyint_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%nearby = call <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %nearby
}
-define <2 x double> @constrained_vector_nearbyint_v2f64() {
+define <2 x double> @constrained_vector_nearbyint_v2f64() #0 {
; S390X-LABEL: constrained_vector_nearbyint_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%nearby = call <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %nearby
}
-define <3 x float> @constrained_vector_nearbyint_v3f32() {
+define <3 x float> @constrained_vector_nearbyint_v3f32() #0 {
; S390X-LABEL: constrained_vector_nearbyint_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%nearby = call <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %nearby
}
-define void @constrained_vector_nearbyint_v3f64(<3 x double>* %a) {
+define void @constrained_vector_nearbyint_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_nearbyint_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%nearby = call <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %nearby, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_nearbyint_v4f64() {
+define <4 x double> @constrained_vector_nearbyint_v4f64() #0 {
; S390X-LABEL: constrained_vector_nearbyint_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %nearby
}
-define <1 x float> @constrained_vector_maxnum_v1f32() {
+define <1 x float> @constrained_vector_maxnum_v1f32() #0 {
; S390X-LABEL: constrained_vector_maxnum_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %max
}
-define <2 x double> @constrained_vector_maxnum_v2f64() {
+define <2 x double> @constrained_vector_maxnum_v2f64() #0 {
; S390X-LABEL: constrained_vector_maxnum_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %max
}
-define <3 x float> @constrained_vector_maxnum_v3f32() {
+define <3 x float> @constrained_vector_maxnum_v3f32() #0 {
; S390X-LABEL: constrained_vector_maxnum_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %max
}
-define void @constrained_vector_log10_maxnum_v3f64(<3 x double>* %a) {
+define void @constrained_vector_log10_maxnum_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_log10_maxnum_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
<3 x double> %b,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %max, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_maxnum_v4f64() {
+define <4 x double> @constrained_vector_maxnum_v4f64() #0 {
; S390X-LABEL: constrained_vector_maxnum_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %max
}
-define <1 x float> @constrained_vector_minnum_v1f32() {
+define <1 x float> @constrained_vector_minnum_v1f32() #0 {
; S390X-LABEL: constrained_vector_minnum_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %min
}
-define <2 x double> @constrained_vector_minnum_v2f64() {
+define <2 x double> @constrained_vector_minnum_v2f64() #0 {
; S390X-LABEL: constrained_vector_minnum_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %min
}
-define <3 x float> @constrained_vector_minnum_v3f32() {
+define <3 x float> @constrained_vector_minnum_v3f32() #0 {
; S390X-LABEL: constrained_vector_minnum_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %min
}
-define void @constrained_vector_minnum_v3f64(<3 x double>* %a) {
+define void @constrained_vector_minnum_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_minnum_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
<3 x double> %b,
<3 x double> <double 3.0, double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %min, <3 x double>* %a
ret void
}
-define <4 x double> @constrained_vector_minnum_v4f64() {
+define <4 x double> @constrained_vector_minnum_v4f64() #0 {
; S390X-LABEL: constrained_vector_minnum_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %min
}
-define <1 x float> @constrained_vector_fptrunc_v1f64() {
+define <1 x float> @constrained_vector_fptrunc_v1f64() #0 {
; S390X-LABEL: constrained_vector_fptrunc_v1f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI95_0
%result = call <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(
<1 x double><double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %result
}
-define <2 x float> @constrained_vector_fptrunc_v2f64() {
+define <2 x float> @constrained_vector_fptrunc_v2f64() #0 {
; S390X-LABEL: constrained_vector_fptrunc_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI96_0
%result = call <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(
<2 x double><double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x float> %result
}
-define void @constrained_vector_fptrunc_v3f64(<3 x double>* %src, <3 x float>* %dest) {
+define void @constrained_vector_fptrunc_v3f64(<3 x double>* %src, <3 x float>* %dest) #0 {
; S390X-LABEL: constrained_vector_fptrunc_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: ld %f0, 0(%r2)
%result = call <3 x float> @llvm.experimental.constrained.fptrunc.v3f32.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x float> %result, <3 x float>* %dest
ret void
}
-define <4 x float> @constrained_vector_fptrunc_v4f64() {
+define <4 x float> @constrained_vector_fptrunc_v4f64() #0 {
; S390X-LABEL: constrained_vector_fptrunc_v4f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI98_0
<4 x double><double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %result
}
-define <1 x double> @constrained_vector_fpext_v1f32() {
+define <1 x double> @constrained_vector_fpext_v1f32() #0 {
; S390X-LABEL: constrained_vector_fpext_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI99_0
entry:
%result = call <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(
<1 x float><float 42.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x double> %result
}
-define <2 x double> @constrained_vector_fpext_v2f32() {
+define <2 x double> @constrained_vector_fpext_v2f32() #0 {
; S390X-LABEL: constrained_vector_fpext_v2f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI100_0
entry:
%result = call <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(
<2 x float><float 42.0, float 43.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %result
}
-define void @constrained_vector_fpext_v3f64(<3 x float>* %src, <3 x double>* %dest) {
+define void @constrained_vector_fpext_v3f64(<3 x float>* %src, <3 x double>* %dest) #0 {
; S390X-LABEL: constrained_vector_fpext_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: lg %r0, 0(%r2)
%b = load <3 x float>, <3 x float>* %src
%result = call <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(
<3 x float> %b,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %result, <3 x double>* %dest
ret void
}
-define <4 x double> @constrained_vector_fpext_v4f32() {
+define <4 x double> @constrained_vector_fpext_v4f32() #0 {
; S390X-LABEL: constrained_vector_fpext_v4f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: larl %r1, .LCPI102_0
%result = call <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(
<4 x float><float 42.0, float 43.0,
float 44.0, float 45.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %result
}
-define <1 x float> @constrained_vector_ceil_v1f32() {
+define <1 x float> @constrained_vector_ceil_v1f32() #0 {
; S390X-LABEL: constrained_vector_ceil_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %ceil
}
-define <2 x double> @constrained_vector_ceil_v2f64() {
+define <2 x double> @constrained_vector_ceil_v2f64() #0 {
; S390X-LABEL: constrained_vector_ceil_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ceil
}
-define <3 x float> @constrained_vector_ceil_v3f32() {
+define <3 x float> @constrained_vector_ceil_v3f32() #0 {
; S390X-LABEL: constrained_vector_ceil_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %ceil
}
-define void @constrained_vector_ceil_v3f64(<3 x double>* %a) {
+define void @constrained_vector_ceil_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_ceil_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %ceil, <3 x double>* %a
ret void
}
-define <1 x float> @constrained_vector_floor_v1f32() {
+define <1 x float> @constrained_vector_floor_v1f32() #0 {
; S390X-LABEL: constrained_vector_floor_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %floor
}
-define <2 x double> @constrained_vector_floor_v2f64() {
+define <2 x double> @constrained_vector_floor_v2f64() #0 {
; S390X-LABEL: constrained_vector_floor_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %floor
}
-define <3 x float> @constrained_vector_floor_v3f32() {
+define <3 x float> @constrained_vector_floor_v3f32() #0 {
; S390X-LABEL: constrained_vector_floor_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %floor
}
-define void @constrained_vector_floor_v3f64(<3 x double>* %a) {
+define void @constrained_vector_floor_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_floor_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %floor, <3 x double>* %a
ret void
}
-define <1 x float> @constrained_vector_round_v1f32() {
+define <1 x float> @constrained_vector_round_v1f32() #0 {
; S390X-LABEL: constrained_vector_round_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %round
}
-define <2 x double> @constrained_vector_round_v2f64() {
+define <2 x double> @constrained_vector_round_v2f64() #0 {
; S390X-LABEL: constrained_vector_round_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %round
}
-define <3 x float> @constrained_vector_round_v3f32() {
+define <3 x float> @constrained_vector_round_v3f32() #0 {
; S390X-LABEL: constrained_vector_round_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %round
}
-define void @constrained_vector_round_v3f64(<3 x double>* %a) {
+define void @constrained_vector_round_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_round_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %round, <3 x double>* %a
ret void
}
-define <1 x float> @constrained_vector_trunc_v1f32() {
+define <1 x float> @constrained_vector_trunc_v1f32() #0 {
; S390X-LABEL: constrained_vector_trunc_v1f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %trunc
}
-define <2 x double> @constrained_vector_trunc_v2f64() {
+define <2 x double> @constrained_vector_trunc_v2f64() #0 {
; S390X-LABEL: constrained_vector_trunc_v2f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %trunc
}
-define <3 x float> @constrained_vector_trunc_v3f32() {
+define <3 x float> @constrained_vector_trunc_v3f32() #0 {
; S390X-LABEL: constrained_vector_trunc_v3f32:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r14, %r15, 112(%r15)
%trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %trunc
}
-define void @constrained_vector_trunc_v3f64(<3 x double>* %a) {
+define void @constrained_vector_trunc_v3f64(<3 x double>* %a) #0 {
; S390X-LABEL: constrained_vector_trunc_v3f64:
; S390X: # %bb.0: # %entry
; S390X-NEXT: stmg %r13, %r15, 104(%r15)
%trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
<3 x double> %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
store <3 x double> %trunc, <3 x double>* %a
ret void
}
+attributes #0 = { strictfp }
+
declare <2 x double> @llvm.experimental.constrained.fadd.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.fsub.v2f64(<2 x double>, <2 x double>, metadata, metadata)
declare <2 x double> @llvm.experimental.constrained.fmul.v2f64(<2 x double>, <2 x double>, metadata, metadata)
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -O3 -mtriple=x86_64-gnu-linux < %s | FileCheck %s
-define x86_fp80 @constrained_fpext_f32_as_fp80(float %mem) {
+define x86_fp80 @constrained_fpext_f32_as_fp80(float %mem) #0 {
; CHECK-LABEL: constrained_fpext_f32_as_fp80:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss %xmm0, -{{[0-9]+}}(%rsp)
entry:
%ext = call x86_fp80 @llvm.experimental.constrained.fpext.f80.f32(
float %mem,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret x86_fp80 %ext
}
-define float @constrained_fptrunc_f80_to_f32(x86_fp80 %reg) {
+define float @constrained_fptrunc_f80_to_f32(x86_fp80 %reg) #0 {
; CHECK-LABEL: constrained_fptrunc_f80_to_f32:
; CHECK: # %bb.0:
; CHECK-NEXT: fldt {{[0-9]+}}(%rsp)
%trunc = call float @llvm.experimental.constrained.fptrunc.f32.f80(
x86_fp80 %reg,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %trunc
}
-define x86_fp80 @constrained_fpext_f64_to_f80(double %mem) {
+define x86_fp80 @constrained_fpext_f64_to_f80(double %mem) #0 {
; CHECK-LABEL: constrained_fpext_f64_to_f80:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd %xmm0, -{{[0-9]+}}(%rsp)
entry:
%ext = call x86_fp80 @llvm.experimental.constrained.fpext.f80.f64(
double %mem,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret x86_fp80 %ext
}
-define double @constrained_fptrunc_f80_to_f64(x86_fp80 %reg) {
+define double @constrained_fptrunc_f80_to_f64(x86_fp80 %reg) #0 {
; CHECK-LABEL: constrained_fptrunc_f80_to_f64:
; CHECK: # %bb.0:
; CHECK-NEXT: fldt {{[0-9]+}}(%rsp)
%trunc = call double @llvm.experimental.constrained.fptrunc.f64.f80(
x86_fp80 %reg,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %trunc
}
+attributes #0 = { strictfp }
+
declare x86_fp80 @llvm.experimental.constrained.fpext.f80.f32(float, metadata)
declare x86_fp80 @llvm.experimental.constrained.fpext.f80.f64(double, metadata)
declare float @llvm.experimental.constrained.fptrunc.f32.f80(x86_fp80, metadata, metadata)
;
; CHECK-LABEL: f1
; COMMON: divsd
-define double @f1() {
+define double @f1() #0 {
entry:
%div = call double @llvm.experimental.constrained.fdiv.f64(
double 1.000000e+00,
double 1.000000e+01,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %div
}
;
; CHECK-LABEL: f2
; COMMON: subsd
-define double @f2(double %a) {
+define double @f2(double %a) #0 {
entry:
%sub = call double @llvm.experimental.constrained.fsub.f64(
double %a,
double 0.000000e+00,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %sub
}
; COMMON: subsd
; COMMON: mulsd
; COMMON: subsd
-define double @f3(double %a, double %b) {
+define double @f3(double %a, double %b) #0 {
entry:
%sub = call double @llvm.experimental.constrained.fsub.f64(
double -0.000000e+00, double %a,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul = call double @llvm.experimental.constrained.fmul.f64(
double %sub, double %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%ret = call double @llvm.experimental.constrained.fsub.f64(
double -0.000000e+00,
double %mul,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %ret
}
; COMMON: testl
; COMMON: jle
; COMMON: addsd
-define double @f4(i32 %n, double %a) {
+define double @f4(i32 %n, double %a) #0 {
entry:
%cmp = icmp sgt i32 %n, 0
br i1 %cmp, label %if.then, label %if.end
%add = call double @llvm.experimental.constrained.fadd.f64(
double 1.000000e+00, double %a,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
br label %if.end
if.end:
; Verify that sqrt(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f5
; COMMON: sqrtsd
-define double @f5() {
+define double @f5() #0 {
entry:
%result = call double @llvm.experimental.constrained.sqrt.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that pow(42.1, 3.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f6
; COMMON: pow
-define double @f6() {
+define double @f6() #0 {
entry:
%result = call double @llvm.experimental.constrained.pow.f64(double 42.1,
double 3.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that powi(42.1, 3) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f7
; COMMON: powi
-define double @f7() {
+define double @f7() #0 {
entry:
%result = call double @llvm.experimental.constrained.powi.f64(double 42.1,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that sin(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f8
; COMMON: sin
-define double @f8() {
+define double @f8() #0 {
entry:
%result = call double @llvm.experimental.constrained.sin.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that cos(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f9
; COMMON: cos
-define double @f9() {
+define double @f9() #0 {
entry:
%result = call double @llvm.experimental.constrained.cos.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that exp(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f10
; COMMON: exp
-define double @f10() {
+define double @f10() #0 {
entry:
%result = call double @llvm.experimental.constrained.exp.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that exp2(42.1) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f11
; COMMON: exp2
-define double @f11() {
+define double @f11() #0 {
entry:
%result = call double @llvm.experimental.constrained.exp2.f64(double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that log(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f12
; COMMON: log
-define double @f12() {
+define double @f12() #0 {
entry:
%result = call double @llvm.experimental.constrained.log.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that log10(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f13
; COMMON: log10
-define double @f13() {
+define double @f13() #0 {
entry:
%result = call double @llvm.experimental.constrained.log10.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that log2(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f14
; COMMON: log2
-define double @f14() {
+define double @f14() #0 {
entry:
%result = call double @llvm.experimental.constrained.log2.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; CHECK-LABEL: f15
; NO-FMA: rint
; HAS-FMA: vroundsd
-define double @f15() {
+define double @f15() #0 {
entry:
%result = call double @llvm.experimental.constrained.rint.f64(double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; CHECK-LABEL: f16
; NO-FMA: nearbyint
; HAS-FMA: vroundsd
-define double @f16() {
+define double @f16() #0 {
entry:
%result = call double @llvm.experimental.constrained.nearbyint.f64(
double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; CHECK-LABEL: f17
; FMACALL32: jmp fmaf # TAILCALL
; FMA32: vfmadd213ss
-define float @f17() {
+define float @f17() #0 {
entry:
%result = call float @llvm.experimental.constrained.fma.f32(
float 3.5,
float 3.5,
float 3.5,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %result
}
; CHECK-LABEL: f18
; FMACALL64: jmp fma # TAILCALL
; FMA64: vfmadd213sd
-define double @f18() {
+define double @f18() #0 {
entry:
%result = call double @llvm.experimental.constrained.fma.f64(
double 42.1,
double 42.1,
double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; CHECK-LABEL: f19
; COMMON: fmod
-define double @f19() {
+define double @f19() #0 {
entry:
%rem = call double @llvm.experimental.constrained.frem.f64(
double 1.000000e+00,
double 1.000000e+01,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %rem
}
; HAS-FMA: setae
; HAS-FMA: shll
; HAS-FMA: xorl
-define i32 @f20u(double %x) {
+define i32 @f20u(double %x) #0 {
entry:
%result = call i32 @llvm.experimental.constrained.fptoui.i32.f64(double %x,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %result
}
; Verify that no gross errors happen.
; CHECK-LABEL: @f21
; COMMON: cvtsd2ss
-define float @f21() {
+define float @f21() #0 {
entry:
%result = call float @llvm.experimental.constrained.fptrunc.f32.f64(
double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %result
}
; CHECK-LABEL: @f22
; COMMON: cvtss2sd
-define double @f22(float %x) {
+define double @f22(float %x) #0 {
entry:
%result = call double @llvm.experimental.constrained.fpext.f64.f32(float %x,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
+attributes #0 = { strictfp }
+
@llvm.fp.env = thread_local global i8 zeroinitializer, section "llvm.metadata"
declare double @llvm.experimental.constrained.fadd.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.fsub.f64(double, double, metadata, metadata)
; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
; RUN: llc -O3 -mtriple=x86_64-pc-linux -mattr=+fma < %s | FileCheck %s
-define <1 x float> @constrained_vector_fma_v1f32() {
+define <1 x float> @constrained_vector_fma_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fma_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: vmovss {{.*#+}} xmm1 = mem[0],zero,zero,zero
<1 x float> <float 2.5>,
<1 x float> <float 4.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %fma
}
-define <2 x double> @constrained_vector_fma_v2f64() {
+define <2 x double> @constrained_vector_fma_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fma_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: vmovapd {{.*#+}} xmm1 = [1.5E+0,5.0E-1]
<2 x double> <double 3.5, double 2.5>,
<2 x double> <double 5.5, double 4.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %fma
}
-define <3 x float> @constrained_vector_fma_v3f32() {
+define <3 x float> @constrained_vector_fma_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fma_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: vmovss {{.*#+}} xmm0 = mem[0],zero,zero,zero
<3 x float> <float 5.5, float 4.5, float 3.5>,
<3 x float> <float 8.5, float 7.5, float 6.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %fma
}
-define <3 x double> @constrained_vector_fma_v3f64() {
+define <3 x double> @constrained_vector_fma_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fma_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: vmovsd {{.*#+}} xmm0 = mem[0],zero
<3 x double> <double 5.5, double 4.5, double 3.5>,
<3 x double> <double 8.5, double 7.5, double 6.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %fma
}
-define <4 x double> @constrained_vector_fma_v4f64() {
+define <4 x double> @constrained_vector_fma_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fma_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: vmovapd {{.*#+}} ymm1 = [3.5E+0,2.5E+0,1.5E+0,5.0E-1]
<4 x double> <double 7.5, double 6.5, double 5.5, double 4.5>,
<4 x double> <double 11.5, double 10.5, double 9.5, double 8.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %fma
}
-define <4 x float> @constrained_vector_fma_v4f32() {
+define <4 x float> @constrained_vector_fma_v4f32() #0 {
; CHECK-LABEL: constrained_vector_fma_v4f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: vmovaps {{.*#+}} xmm1 = [3.5E+0,2.5E+0,1.5E+0,5.0E-1]
<4 x float> <float 7.5, float 6.5, float 5.5, float 4.5>,
<4 x float> <float 11.5, float 10.5, float 9.5, float 8.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %fma
}
-define <8 x float> @constrained_vector_fma_v8f32() {
+define <8 x float> @constrained_vector_fma_v8f32() #0 {
; CHECK-LABEL: constrained_vector_fma_v8f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: vmovaps {{.*#+}} ymm1 = [3.5E+0,2.5E+0,1.5E+0,5.0E-1,7.5E+0,6.5E+0,5.5E+0,4.5E+0]
<8 x float> <float 11.5, float 10.5, float 9.5, float 8.5,
float 15.5, float 14.5, float 13.5, float 12.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <8 x float> %fma
}
+attributes #0 = { strictfp }
+
; Single width declarations
declare <2 x double> @llvm.experimental.constrained.fma.v2f64(<2 x double>, <2 x double>, <2 x double>, metadata, metadata)
declare <4 x float> @llvm.experimental.constrained.fma.v4f32(<4 x float>, <4 x float>, <4 x float>, metadata, metadata)
; RUN: llc -O3 -mtriple=x86_64-pc-linux < %s | FileCheck %s
; RUN: llc -O3 -mtriple=x86_64-pc-linux -mattr=+avx < %s | FileCheck --check-prefix=AVX %s
-define <1 x float> @constrained_vector_fdiv_v1f32() {
+define <1 x float> @constrained_vector_fdiv_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fdiv_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
<1 x float> <float 1.000000e+00>,
<1 x float> <float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %div
}
-define <2 x double> @constrained_vector_fdiv_v2f64() {
+define <2 x double> @constrained_vector_fdiv_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fdiv_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movapd {{.*#+}} xmm0 = [1.0E+0,2.0E+0]
<2 x double> <double 1.000000e+00, double 2.000000e+00>,
<2 x double> <double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %div
}
-define <3 x float> @constrained_vector_fdiv_v3f32() {
+define <3 x float> @constrained_vector_fdiv_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fdiv_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm1 = mem[0],zero,zero,zero
<3 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>,
<3 x float> <float 1.000000e+01, float 1.000000e+01, float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %div
}
-define <3 x double> @constrained_vector_fdiv_v3f64() {
+define <3 x double> @constrained_vector_fdiv_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fdiv_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movapd {{.*#+}} xmm0 = [1.0E+0,2.0E+0]
<3 x double> <double 1.000000e+00, double 2.000000e+00, double 3.000000e+00>,
<3 x double> <double 1.000000e+01, double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %div
}
-define <4 x double> @constrained_vector_fdiv_v4f64() {
+define <4 x double> @constrained_vector_fdiv_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fdiv_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movapd {{.*#+}} xmm2 = [1.0E+1,1.0E+1]
<4 x double> <double 1.000000e+01, double 1.000000e+01,
double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %div
}
-define <1 x float> @constrained_vector_frem_v1f32() {
+define <1 x float> @constrained_vector_frem_v1f32() #0 {
; CHECK-LABEL: constrained_vector_frem_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
<1 x float> <float 1.000000e+00>,
<1 x float> <float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %rem
}
-define <2 x double> @constrained_vector_frem_v2f64() {
+define <2 x double> @constrained_vector_frem_v2f64() #0 {
; CHECK-LABEL: constrained_vector_frem_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<2 x double> <double 1.000000e+00, double 2.000000e+00>,
<2 x double> <double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %rem
}
-define <3 x float> @constrained_vector_frem_v3f32() {
+define <3 x float> @constrained_vector_frem_v3f32() #0 {
; CHECK-LABEL: constrained_vector_frem_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<3 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00>,
<3 x float> <float 1.000000e+01, float 1.000000e+01, float 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %rem
}
-define <3 x double> @constrained_vector_frem_v3f64() {
+define <3 x double> @constrained_vector_frem_v3f64() #0 {
; CHECK-LABEL: constrained_vector_frem_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<3 x double> <double 1.000000e+00, double 2.000000e+00, double 3.000000e+00>,
<3 x double> <double 1.000000e+01, double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %rem
}
-define <4 x double> @constrained_vector_frem_v4f64() {
+define <4 x double> @constrained_vector_frem_v4f64() #0 {
; CHECK-LABEL: constrained_vector_frem_v4f64:
; CHECK: # %bb.0:
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 1.000000e+01, double 1.000000e+01,
double 1.000000e+01, double 1.000000e+01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %rem
}
-define <1 x float> @constrained_vector_fmul_v1f32() {
+define <1 x float> @constrained_vector_fmul_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fmul_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 2.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %mul
}
-define <2 x double> @constrained_vector_fmul_v2f64() {
+define <2 x double> @constrained_vector_fmul_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fmul_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movapd {{.*#+}} xmm0 = [1.7976931348623157E+308,1.7976931348623157E+308]
<2 x double> <double 0x7FEFFFFFFFFFFFFF, double 0x7FEFFFFFFFFFFFFF>,
<2 x double> <double 2.000000e+00, double 3.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %mul
}
-define <3 x float> @constrained_vector_fmul_v3f32() {
+define <3 x float> @constrained_vector_fmul_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fmul_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm1 = mem[0],zero,zero,zero
float 0x7FF0000000000000>,
<3 x float> <float 1.000000e+00, float 1.000000e+01, float 1.000000e+02>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %mul
}
-define <3 x double> @constrained_vector_fmul_v3f64() {
+define <3 x double> @constrained_vector_fmul_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fmul_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movapd {{.*#+}} xmm0 = [1.7976931348623157E+308,1.7976931348623157E+308]
double 0x7FEFFFFFFFFFFFFF>,
<3 x double> <double 1.000000e+00, double 1.000000e+01, double 1.000000e+02>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %mul
}
-define <4 x double> @constrained_vector_fmul_v4f64() {
+define <4 x double> @constrained_vector_fmul_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fmul_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movapd {{.*#+}} xmm1 = [1.7976931348623157E+308,1.7976931348623157E+308]
<4 x double> <double 2.000000e+00, double 3.000000e+00,
double 4.000000e+00, double 5.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %mul
}
-define <1 x float> @constrained_vector_fadd_v1f32() {
+define <1 x float> @constrained_vector_fadd_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fadd_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 1.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %add
}
-define <2 x double> @constrained_vector_fadd_v2f64() {
+define <2 x double> @constrained_vector_fadd_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fadd_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
<2 x double> <double 0x7FEFFFFFFFFFFFFF, double 0x7FEFFFFFFFFFFFFF>,
<2 x double> <double 1.000000e+00, double 1.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %add
}
-define <3 x float> @constrained_vector_fadd_v3f32() {
+define <3 x float> @constrained_vector_fadd_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fadd_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: xorps %xmm1, %xmm1
float 0xFFFFFFFFE0000000>,
<3 x float> <float 2.0, float 1.0, float 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %add
}
-define <3 x double> @constrained_vector_fadd_v3f64() {
+define <3 x double> @constrained_vector_fadd_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fadd_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: xorpd %xmm2, %xmm2
double 0x7FEFFFFFFFFFFFFF>,
<3 x double> <double 2.0, double 1.0, double 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %add
}
-define <4 x double> @constrained_vector_fadd_v4f64() {
+define <4 x double> @constrained_vector_fadd_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fadd_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm1 = mem[0],zero
<4 x double> <double 1.000000e+00, double 1.000000e-01,
double 2.000000e+00, double 2.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %add
}
-define <1 x float> @constrained_vector_fsub_v1f32() {
+define <1 x float> @constrained_vector_fsub_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fsub_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
<1 x float> <float 0x7FF0000000000000>,
<1 x float> <float 1.000000e+00>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %sub
}
-define <2 x double> @constrained_vector_fsub_v2f64() {
+define <2 x double> @constrained_vector_fsub_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fsub_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
<2 x double> <double 0xFFEFFFFFFFFFFFFF, double 0xFFEFFFFFFFFFFFFF>,
<2 x double> <double 1.000000e+00, double 1.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %sub
}
-define <3 x float> @constrained_vector_fsub_v3f32() {
+define <3 x float> @constrained_vector_fsub_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fsub_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: xorps %xmm0, %xmm0
float 0xFFFFFFFFE0000000>,
<3 x float> <float 2.0, float 1.0, float 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %sub
}
-define <3 x double> @constrained_vector_fsub_v3f64() {
+define <3 x double> @constrained_vector_fsub_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fsub_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: xorpd %xmm0, %xmm0
double 0xFFEFFFFFFFFFFFFF>,
<3 x double> <double 2.0, double 1.0, double 0.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %sub
}
-define <4 x double> @constrained_vector_fsub_v4f64() {
+define <4 x double> @constrained_vector_fsub_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fsub_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm1 = mem[0],zero
<4 x double> <double 1.000000e+00, double 1.000000e-01,
double 2.000000e+00, double 2.000000e-01>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %sub
}
-define <1 x float> @constrained_vector_sqrt_v1f32() {
+define <1 x float> @constrained_vector_sqrt_v1f32() #0 {
; CHECK-LABEL: constrained_vector_sqrt_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
%sqrt = call <1 x float> @llvm.experimental.constrained.sqrt.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %sqrt
}
-define <2 x double> @constrained_vector_sqrt_v2f64() {
+define <2 x double> @constrained_vector_sqrt_v2f64() #0 {
; CHECK-LABEL: constrained_vector_sqrt_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: sqrtpd {{.*}}(%rip), %xmm0
%sqrt = call <2 x double> @llvm.experimental.constrained.sqrt.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %sqrt
}
-define <3 x float> @constrained_vector_sqrt_v3f32() {
+define <3 x float> @constrained_vector_sqrt_v3f32() #0 {
; CHECK-LABEL: constrained_vector_sqrt_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
%sqrt = call <3 x float> @llvm.experimental.constrained.sqrt.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %sqrt
}
-define <3 x double> @constrained_vector_sqrt_v3f64() {
+define <3 x double> @constrained_vector_sqrt_v3f64() #0 {
; CHECK-LABEL: constrained_vector_sqrt_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
%sqrt = call <3 x double> @llvm.experimental.constrained.sqrt.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %sqrt
}
-define <4 x double> @constrained_vector_sqrt_v4f64() {
+define <4 x double> @constrained_vector_sqrt_v4f64() #0 {
; CHECK-LABEL: constrained_vector_sqrt_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: sqrtpd {{.*}}(%rip), %xmm0
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %sqrt
}
-define <1 x float> @constrained_vector_pow_v1f32() {
+define <1 x float> @constrained_vector_pow_v1f32() #0 {
; CHECK-LABEL: constrained_vector_pow_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
<1 x float> <float 42.0>,
<1 x float> <float 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %pow
}
-define <2 x double> @constrained_vector_pow_v2f64() {
+define <2 x double> @constrained_vector_pow_v2f64() #0 {
; CHECK-LABEL: constrained_vector_pow_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<2 x double> <double 42.1, double 42.2>,
<2 x double> <double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %pow
}
-define <3 x float> @constrained_vector_pow_v3f32() {
+define <3 x float> @constrained_vector_pow_v3f32() #0 {
; CHECK-LABEL: constrained_vector_pow_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<3 x float> <float 42.0, float 43.0, float 44.0>,
<3 x float> <float 3.0, float 3.0, float 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %pow
}
-define <3 x double> @constrained_vector_pow_v3f64() {
+define <3 x double> @constrained_vector_pow_v3f64() #0 {
; CHECK-LABEL: constrained_vector_pow_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<3 x double> <double 42.0, double 42.1, double 42.2>,
<3 x double> <double 3.0, double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %pow
}
-define <4 x double> @constrained_vector_pow_v4f64() {
+define <4 x double> @constrained_vector_pow_v4f64() #0 {
; CHECK-LABEL: constrained_vector_pow_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 3.0, double 3.0,
double 3.0, double 3.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %pow
}
-define <1 x float> @constrained_vector_powi_v1f32() {
+define <1 x float> @constrained_vector_powi_v1f32() #0 {
; CHECK-LABEL: constrained_vector_powi_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
<1 x float> <float 42.0>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %powi
}
-define <2 x double> @constrained_vector_powi_v2f64() {
+define <2 x double> @constrained_vector_powi_v2f64() #0 {
; CHECK-LABEL: constrained_vector_powi_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<2 x double> <double 42.1, double 42.2>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %powi
}
-define <3 x float> @constrained_vector_powi_v3f32() {
+define <3 x float> @constrained_vector_powi_v3f32() #0 {
; CHECK-LABEL: constrained_vector_powi_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<3 x float> <float 42.0, float 43.0, float 44.0>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %powi
}
-define <3 x double> @constrained_vector_powi_v3f64() {
+define <3 x double> @constrained_vector_powi_v3f64() #0 {
; CHECK-LABEL: constrained_vector_powi_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<3 x double> <double 42.0, double 42.1, double 42.2>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %powi
}
-define <4 x double> @constrained_vector_powi_v4f64() {
+define <4 x double> @constrained_vector_powi_v4f64() #0 {
; CHECK-LABEL: constrained_vector_powi_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
double 42.3, double 42.4>,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %powi
}
-define <1 x float> @constrained_vector_sin_v1f32() {
+define <1 x float> @constrained_vector_sin_v1f32() #0 {
; CHECK-LABEL: constrained_vector_sin_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%sin = call <1 x float> @llvm.experimental.constrained.sin.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %sin
}
-define <2 x double> @constrained_vector_sin_v2f64() {
+define <2 x double> @constrained_vector_sin_v2f64() #0 {
; CHECK-LABEL: constrained_vector_sin_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%sin = call <2 x double> @llvm.experimental.constrained.sin.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %sin
}
-define <3 x float> @constrained_vector_sin_v3f32() {
+define <3 x float> @constrained_vector_sin_v3f32() #0 {
; CHECK-LABEL: constrained_vector_sin_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%sin = call <3 x float> @llvm.experimental.constrained.sin.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %sin
}
-define <3 x double> @constrained_vector_sin_v3f64() {
+define <3 x double> @constrained_vector_sin_v3f64() #0 {
; CHECK-LABEL: constrained_vector_sin_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%sin = call <3 x double> @llvm.experimental.constrained.sin.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %sin
}
-define <4 x double> @constrained_vector_sin_v4f64() {
+define <4 x double> @constrained_vector_sin_v4f64() #0 {
; CHECK-LABEL: constrained_vector_sin_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %sin
}
-define <1 x float> @constrained_vector_cos_v1f32() {
+define <1 x float> @constrained_vector_cos_v1f32() #0 {
; CHECK-LABEL: constrained_vector_cos_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%cos = call <1 x float> @llvm.experimental.constrained.cos.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %cos
}
-define <2 x double> @constrained_vector_cos_v2f64() {
+define <2 x double> @constrained_vector_cos_v2f64() #0 {
; CHECK-LABEL: constrained_vector_cos_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%cos = call <2 x double> @llvm.experimental.constrained.cos.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %cos
}
-define <3 x float> @constrained_vector_cos_v3f32() {
+define <3 x float> @constrained_vector_cos_v3f32() #0 {
; CHECK-LABEL: constrained_vector_cos_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%cos = call <3 x float> @llvm.experimental.constrained.cos.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %cos
}
-define <3 x double> @constrained_vector_cos_v3f64() {
+define <3 x double> @constrained_vector_cos_v3f64() #0 {
; CHECK-LABEL: constrained_vector_cos_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%cos = call <3 x double> @llvm.experimental.constrained.cos.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %cos
}
-define <4 x double> @constrained_vector_cos_v4f64() {
+define <4 x double> @constrained_vector_cos_v4f64() #0 {
; CHECK-LABEL: constrained_vector_cos_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %cos
}
-define <1 x float> @constrained_vector_exp_v1f32() {
+define <1 x float> @constrained_vector_exp_v1f32() #0 {
; CHECK-LABEL: constrained_vector_exp_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%exp = call <1 x float> @llvm.experimental.constrained.exp.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %exp
}
-define <2 x double> @constrained_vector_exp_v2f64() {
+define <2 x double> @constrained_vector_exp_v2f64() #0 {
; CHECK-LABEL: constrained_vector_exp_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%exp = call <2 x double> @llvm.experimental.constrained.exp.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %exp
}
-define <3 x float> @constrained_vector_exp_v3f32() {
+define <3 x float> @constrained_vector_exp_v3f32() #0 {
; CHECK-LABEL: constrained_vector_exp_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%exp = call <3 x float> @llvm.experimental.constrained.exp.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %exp
}
-define <3 x double> @constrained_vector_exp_v3f64() {
+define <3 x double> @constrained_vector_exp_v3f64() #0 {
; CHECK-LABEL: constrained_vector_exp_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%exp = call <3 x double> @llvm.experimental.constrained.exp.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %exp
}
-define <4 x double> @constrained_vector_exp_v4f64() {
+define <4 x double> @constrained_vector_exp_v4f64() #0 {
; CHECK-LABEL: constrained_vector_exp_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %exp
}
-define <1 x float> @constrained_vector_exp2_v1f32() {
+define <1 x float> @constrained_vector_exp2_v1f32() #0 {
; CHECK-LABEL: constrained_vector_exp2_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%exp2 = call <1 x float> @llvm.experimental.constrained.exp2.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %exp2
}
-define <2 x double> @constrained_vector_exp2_v2f64() {
+define <2 x double> @constrained_vector_exp2_v2f64() #0 {
; CHECK-LABEL: constrained_vector_exp2_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%exp2 = call <2 x double> @llvm.experimental.constrained.exp2.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %exp2
}
-define <3 x float> @constrained_vector_exp2_v3f32() {
+define <3 x float> @constrained_vector_exp2_v3f32() #0 {
; CHECK-LABEL: constrained_vector_exp2_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%exp2 = call <3 x float> @llvm.experimental.constrained.exp2.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %exp2
}
-define <3 x double> @constrained_vector_exp2_v3f64() {
+define <3 x double> @constrained_vector_exp2_v3f64() #0 {
; CHECK-LABEL: constrained_vector_exp2_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%exp2 = call <3 x double> @llvm.experimental.constrained.exp2.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %exp2
}
-define <4 x double> @constrained_vector_exp2_v4f64() {
+define <4 x double> @constrained_vector_exp2_v4f64() #0 {
; CHECK-LABEL: constrained_vector_exp2_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %exp2
}
-define <1 x float> @constrained_vector_log_v1f32() {
+define <1 x float> @constrained_vector_log_v1f32() #0 {
; CHECK-LABEL: constrained_vector_log_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%log = call <1 x float> @llvm.experimental.constrained.log.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %log
}
-define <2 x double> @constrained_vector_log_v2f64() {
+define <2 x double> @constrained_vector_log_v2f64() #0 {
; CHECK-LABEL: constrained_vector_log_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%log = call <2 x double> @llvm.experimental.constrained.log.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %log
}
-define <3 x float> @constrained_vector_log_v3f32() {
+define <3 x float> @constrained_vector_log_v3f32() #0 {
; CHECK-LABEL: constrained_vector_log_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%log = call <3 x float> @llvm.experimental.constrained.log.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %log
}
-define <3 x double> @constrained_vector_log_v3f64() {
+define <3 x double> @constrained_vector_log_v3f64() #0 {
; CHECK-LABEL: constrained_vector_log_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%log = call <3 x double> @llvm.experimental.constrained.log.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %log
}
-define <4 x double> @constrained_vector_log_v4f64() {
+define <4 x double> @constrained_vector_log_v4f64() #0 {
; CHECK-LABEL: constrained_vector_log_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %log
}
-define <1 x float> @constrained_vector_log10_v1f32() {
+define <1 x float> @constrained_vector_log10_v1f32() #0 {
; CHECK-LABEL: constrained_vector_log10_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%log10 = call <1 x float> @llvm.experimental.constrained.log10.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %log10
}
-define <2 x double> @constrained_vector_log10_v2f64() {
+define <2 x double> @constrained_vector_log10_v2f64() #0 {
; CHECK-LABEL: constrained_vector_log10_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%log10 = call <2 x double> @llvm.experimental.constrained.log10.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %log10
}
-define <3 x float> @constrained_vector_log10_v3f32() {
+define <3 x float> @constrained_vector_log10_v3f32() #0 {
; CHECK-LABEL: constrained_vector_log10_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%log10 = call <3 x float> @llvm.experimental.constrained.log10.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %log10
}
-define <3 x double> @constrained_vector_log10_v3f64() {
+define <3 x double> @constrained_vector_log10_v3f64() #0 {
; CHECK-LABEL: constrained_vector_log10_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%log10 = call <3 x double> @llvm.experimental.constrained.log10.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %log10
}
-define <4 x double> @constrained_vector_log10_v4f64() {
+define <4 x double> @constrained_vector_log10_v4f64() #0 {
; CHECK-LABEL: constrained_vector_log10_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %log10
}
-define <1 x float> @constrained_vector_log2_v1f32() {
+define <1 x float> @constrained_vector_log2_v1f32() #0 {
; CHECK-LABEL: constrained_vector_log2_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%log2 = call <1 x float> @llvm.experimental.constrained.log2.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %log2
}
-define <2 x double> @constrained_vector_log2_v2f64() {
+define <2 x double> @constrained_vector_log2_v2f64() #0 {
; CHECK-LABEL: constrained_vector_log2_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%log2 = call <2 x double> @llvm.experimental.constrained.log2.v2f64(
<2 x double> <double 42.0, double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %log2
}
-define <3 x float> @constrained_vector_log2_v3f32() {
+define <3 x float> @constrained_vector_log2_v3f32() #0 {
; CHECK-LABEL: constrained_vector_log2_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%log2 = call <3 x float> @llvm.experimental.constrained.log2.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %log2
}
-define <3 x double> @constrained_vector_log2_v3f64() {
+define <3 x double> @constrained_vector_log2_v3f64() #0 {
; CHECK-LABEL: constrained_vector_log2_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%log2 = call <3 x double> @llvm.experimental.constrained.log2.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %log2
}
-define <4 x double> @constrained_vector_log2_v4f64() {
+define <4 x double> @constrained_vector_log2_v4f64() #0 {
; CHECK-LABEL: constrained_vector_log2_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.0, double 42.1,
double 42.2, double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %log2
}
-define <1 x float> @constrained_vector_rint_v1f32() {
+define <1 x float> @constrained_vector_rint_v1f32() #0 {
; CHECK-LABEL: constrained_vector_rint_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%rint = call <1 x float> @llvm.experimental.constrained.rint.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %rint
}
-define <2 x double> @constrained_vector_rint_v2f64() {
+define <2 x double> @constrained_vector_rint_v2f64() #0 {
; CHECK-LABEL: constrained_vector_rint_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%rint = call <2 x double> @llvm.experimental.constrained.rint.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %rint
}
-define <3 x float> @constrained_vector_rint_v3f32() {
+define <3 x float> @constrained_vector_rint_v3f32() #0 {
; CHECK-LABEL: constrained_vector_rint_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%rint = call <3 x float> @llvm.experimental.constrained.rint.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %rint
}
-define <3 x double> @constrained_vector_rint_v3f64() {
+define <3 x double> @constrained_vector_rint_v3f64() #0 {
; CHECK-LABEL: constrained_vector_rint_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%rint = call <3 x double> @llvm.experimental.constrained.rint.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %rint
}
-define <4 x double> @constrained_vector_rint_v4f64() {
+define <4 x double> @constrained_vector_rint_v4f64() #0 {
; CHECK-LABEL: constrained_vector_rint_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %rint
}
-define <1 x float> @constrained_vector_nearbyint_v1f32() {
+define <1 x float> @constrained_vector_nearbyint_v1f32() #0 {
; CHECK-LABEL: constrained_vector_nearbyint_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%nearby = call <1 x float> @llvm.experimental.constrained.nearbyint.v1f32(
<1 x float> <float 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %nearby
}
-define <2 x double> @constrained_vector_nearbyint_v2f64() {
+define <2 x double> @constrained_vector_nearbyint_v2f64() #0 {
; CHECK-LABEL: constrained_vector_nearbyint_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%nearby = call <2 x double> @llvm.experimental.constrained.nearbyint.v2f64(
<2 x double> <double 42.1, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %nearby
}
-define <3 x float> @constrained_vector_nearbyint_v3f32() {
+define <3 x float> @constrained_vector_nearbyint_v3f32() #0 {
; CHECK-LABEL: constrained_vector_nearbyint_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%nearby = call <3 x float> @llvm.experimental.constrained.nearbyint.v3f32(
<3 x float> <float 42.0, float 43.0, float 44.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %nearby
}
-define <3 x double> @constrained_vector_nearby_v3f64() {
+define <3 x double> @constrained_vector_nearby_v3f64() #0 {
; CHECK-LABEL: constrained_vector_nearby_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%nearby = call <3 x double> @llvm.experimental.constrained.nearbyint.v3f64(
<3 x double> <double 42.0, double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %nearby
}
-define <4 x double> @constrained_vector_nearbyint_v4f64() {
+define <4 x double> @constrained_vector_nearbyint_v4f64() #0 {
; CHECK-LABEL: constrained_vector_nearbyint_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %nearby
}
-define <1 x float> @constrained_vector_maxnum_v1f32() {
+define <1 x float> @constrained_vector_maxnum_v1f32() #0 {
; CHECK-LABEL: constrained_vector_maxnum_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%max = call <1 x float> @llvm.experimental.constrained.maxnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %max
}
-define <2 x double> @constrained_vector_maxnum_v2f64() {
+define <2 x double> @constrained_vector_maxnum_v2f64() #0 {
; CHECK-LABEL: constrained_vector_maxnum_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %max
}
-define <3 x float> @constrained_vector_maxnum_v3f32() {
+define <3 x float> @constrained_vector_maxnum_v3f32() #0 {
; CHECK-LABEL: constrained_vector_maxnum_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %max
}
-define <3 x double> @constrained_vector_max_v3f64() {
+define <3 x double> @constrained_vector_max_v3f64() #0 {
; CHECK-LABEL: constrained_vector_max_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<3 x double> <double 43.0, double 44.0, double 45.0>,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %max
}
-define <4 x double> @constrained_vector_maxnum_v4f64() {
+define <4 x double> @constrained_vector_maxnum_v4f64() #0 {
; CHECK-LABEL: constrained_vector_maxnum_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %max
}
-define <1 x float> @constrained_vector_minnum_v1f32() {
+define <1 x float> @constrained_vector_minnum_v1f32() #0 {
; CHECK-LABEL: constrained_vector_minnum_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%min = call <1 x float> @llvm.experimental.constrained.minnum.v1f32(
<1 x float> <float 42.0>, <1 x float> <float 41.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %min
}
-define <2 x double> @constrained_vector_minnum_v2f64() {
+define <2 x double> @constrained_vector_minnum_v2f64() #0 {
; CHECK-LABEL: constrained_vector_minnum_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<2 x double> <double 43.0, double 42.0>,
<2 x double> <double 41.0, double 40.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %min
}
-define <3 x float> @constrained_vector_minnum_v3f32() {
+define <3 x float> @constrained_vector_minnum_v3f32() #0 {
; CHECK-LABEL: constrained_vector_minnum_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<3 x float> <float 43.0, float 44.0, float 45.0>,
<3 x float> <float 41.0, float 42.0, float 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %min
}
-define <3 x double> @constrained_vector_min_v3f64() {
+define <3 x double> @constrained_vector_min_v3f64() #0 {
; CHECK-LABEL: constrained_vector_min_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
<3 x double> <double 43.0, double 44.0, double 45.0>,
<3 x double> <double 40.0, double 41.0, double 42.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %min
}
-define <4 x double> @constrained_vector_minnum_v4f64() {
+define <4 x double> @constrained_vector_minnum_v4f64() #0 {
; CHECK-LABEL: constrained_vector_minnum_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
<4 x double> <double 40.0, double 41.0,
double 42.0, double 43.0>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %min
}
-define <1 x i32> @constrained_vector_fptosi_v1i32_v1f32() {
+define <1 x i32> @constrained_vector_fptosi_v1i32_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v1i32_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %eax
entry:
%result = call <1 x i32> @llvm.experimental.constrained.fptosi.v1i32.v1f32(
<1 x float><float 42.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x i32> %result
}
-define <2 x i32> @constrained_vector_fptosi_v2i32_v2f32() {
+define <2 x i32> @constrained_vector_fptosi_v2i32_v2f32() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v2i32_v2f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %eax
entry:
%result = call <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f32(
<2 x float><float 42.0, float 43.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i32> %result
}
-define <3 x i32> @constrained_vector_fptosi_v3i32_v3f32() {
+define <3 x i32> @constrained_vector_fptosi_v3i32_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v3i32_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %eax
%result = call <3 x i32> @llvm.experimental.constrained.fptosi.v3i32.v3f32(
<3 x float><float 42.0, float 43.0,
float 44.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x i32> %result
}
-define <4 x i32> @constrained_vector_fptosi_v4i32_v4f32() {
+define <4 x i32> @constrained_vector_fptosi_v4i32_v4f32() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v4i32_v4f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %eax
%result = call <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f32(
<4 x float><float 42.0, float 43.0,
float 44.0, float 45.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %result
}
-define <1 x i64> @constrained_vector_fptosi_v1i64_v1f32() {
+define <1 x i64> @constrained_vector_fptosi_v1i64_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v1i64_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %rax
entry:
%result = call <1 x i64> @llvm.experimental.constrained.fptosi.v1i64.v1f32(
<1 x float><float 42.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x i64> %result
}
-define <2 x i64> @constrained_vector_fptosi_v2i64_v2f32() {
+define <2 x i64> @constrained_vector_fptosi_v2i64_v2f32() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v2i64_v2f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %rax
entry:
%result = call <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f32(
<2 x float><float 42.0, float 43.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %result
}
-define <3 x i64> @constrained_vector_fptosi_v3i64_v3f32() {
+define <3 x i64> @constrained_vector_fptosi_v3i64_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v3i64_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %rax
%result = call <3 x i64> @llvm.experimental.constrained.fptosi.v3i64.v3f32(
<3 x float><float 42.0, float 43.0,
float 44.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x i64> %result
}
-define <4 x i64> @constrained_vector_fptosi_v4i64_v4f32() {
+define <4 x i64> @constrained_vector_fptosi_v4i64_v4f32() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v4i64_v4f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %rax
%result = call <4 x i64> @llvm.experimental.constrained.fptosi.v4i64.v4f32(
<4 x float><float 42.0, float 43.0,
float 44.0, float 45.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i64> %result
}
-define <1 x i32> @constrained_vector_fptosi_v1i32_v1f64() {
+define <1 x i32> @constrained_vector_fptosi_v1i32_v1f64() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v1i32_v1f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %eax
entry:
%result = call <1 x i32> @llvm.experimental.constrained.fptosi.v1i32.v1f64(
<1 x double><double 42.1>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x i32> %result
}
-define <2 x i32> @constrained_vector_fptosi_v2i32_v2f64() {
+define <2 x i32> @constrained_vector_fptosi_v2i32_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v2i32_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %eax
entry:
%result = call <2 x i32> @llvm.experimental.constrained.fptosi.v2i32.v2f64(
<2 x double><double 42.1, double 42.2>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i32> %result
}
-define <3 x i32> @constrained_vector_fptosi_v3i32_v3f64() {
+define <3 x i32> @constrained_vector_fptosi_v3i32_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v3i32_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %eax
%result = call <3 x i32> @llvm.experimental.constrained.fptosi.v3i32.v3f64(
<3 x double><double 42.1, double 42.2,
double 42.3>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x i32> %result
}
-define <4 x i32> @constrained_vector_fptosi_v4i32_v4f64() {
+define <4 x i32> @constrained_vector_fptosi_v4i32_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v4i32_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %eax
%result = call <4 x i32> @llvm.experimental.constrained.fptosi.v4i32.v4f64(
<4 x double><double 42.1, double 42.2,
double 42.3, double 42.4>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %result
}
-define <1 x i64> @constrained_vector_fptosi_v1i64_v1f64() {
+define <1 x i64> @constrained_vector_fptosi_v1i64_v1f64() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v1i64_v1f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %rax
entry:
%result = call <1 x i64> @llvm.experimental.constrained.fptosi.v1i64.v1f64(
<1 x double><double 42.1>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x i64> %result
}
-define <2 x i64> @constrained_vector_fptosi_v2i64_v2f64() {
+define <2 x i64> @constrained_vector_fptosi_v2i64_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v2i64_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %rax
entry:
%result = call <2 x i64> @llvm.experimental.constrained.fptosi.v2i64.v2f64(
<2 x double><double 42.1, double 42.2>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %result
}
-define <3 x i64> @constrained_vector_fptosi_v3i64_v3f64() {
+define <3 x i64> @constrained_vector_fptosi_v3i64_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v3i64_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %rax
%result = call <3 x i64> @llvm.experimental.constrained.fptosi.v3i64.v3f64(
<3 x double><double 42.1, double 42.2,
double 42.3>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x i64> %result
}
-define <4 x i64> @constrained_vector_fptosi_v4i64_v4f64() {
+define <4 x i64> @constrained_vector_fptosi_v4i64_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fptosi_v4i64_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %rax
%result = call <4 x i64> @llvm.experimental.constrained.fptosi.v4i64.v4f64(
<4 x double><double 42.1, double 42.2,
double 42.3, double 42.4>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i64> %result
}
-define <1 x i32> @constrained_vector_fptoui_v1i32_v1f32() {
+define <1 x i32> @constrained_vector_fptoui_v1i32_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v1i32_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %eax
entry:
%result = call <1 x i32> @llvm.experimental.constrained.fptoui.v1i32.v1f32(
<1 x float><float 42.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x i32> %result
}
-define <2 x i32> @constrained_vector_fptoui_v2i32_v2f32() {
+define <2 x i32> @constrained_vector_fptoui_v2i32_v2f32() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v2i32_v2f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %eax
entry:
%result = call <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f32(
<2 x float><float 42.0, float 43.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i32> %result
}
-define <3 x i32> @constrained_vector_fptoui_v3i32_v3f32() {
+define <3 x i32> @constrained_vector_fptoui_v3i32_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v3i32_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %eax
%result = call <3 x i32> @llvm.experimental.constrained.fptoui.v3i32.v3f32(
<3 x float><float 42.0, float 43.0,
float 44.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x i32> %result
}
-define <4 x i32> @constrained_vector_fptoui_v4i32_v4f32() {
+define <4 x i32> @constrained_vector_fptoui_v4i32_v4f32() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v4i32_v4f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %eax
%result = call <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f32(
<4 x float><float 42.0, float 43.0,
float 44.0, float 45.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %result
}
-define <1 x i64> @constrained_vector_fptoui_v1i64_v1f32() {
+define <1 x i64> @constrained_vector_fptoui_v1i64_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v1i64_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %rax
entry:
%result = call <1 x i64> @llvm.experimental.constrained.fptoui.v1i64.v1f32(
<1 x float><float 42.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x i64> %result
}
-define <2 x i64> @constrained_vector_fptoui_v2i64_v2f32() {
+define <2 x i64> @constrained_vector_fptoui_v2i64_v2f32() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v2i64_v2f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %rax
entry:
%result = call <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f32(
<2 x float><float 42.0, float 43.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %result
}
-define <3 x i64> @constrained_vector_fptoui_v3i64_v3f32() {
+define <3 x i64> @constrained_vector_fptoui_v3i64_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v3i64_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %rax
%result = call <3 x i64> @llvm.experimental.constrained.fptoui.v3i64.v3f32(
<3 x float><float 42.0, float 43.0,
float 44.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x i64> %result
}
-define <4 x i64> @constrained_vector_fptoui_v4i64_v4f32() {
+define <4 x i64> @constrained_vector_fptoui_v4i64_v4f32() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v4i64_v4f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttss2si {{.*}}(%rip), %rax
%result = call <4 x i64> @llvm.experimental.constrained.fptoui.v4i64.v4f32(
<4 x float><float 42.0, float 43.0,
float 44.0, float 45.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i64> %result
}
-define <1 x i32> @constrained_vector_fptoui_v1i32_v1f64() {
+define <1 x i32> @constrained_vector_fptoui_v1i32_v1f64() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v1i32_v1f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %eax
entry:
%result = call <1 x i32> @llvm.experimental.constrained.fptoui.v1i32.v1f64(
<1 x double><double 42.1>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x i32> %result
}
-define <2 x i32> @constrained_vector_fptoui_v2i32_v2f64() {
+define <2 x i32> @constrained_vector_fptoui_v2i32_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v2i32_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %eax
entry:
%result = call <2 x i32> @llvm.experimental.constrained.fptoui.v2i32.v2f64(
<2 x double><double 42.1, double 42.2>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i32> %result
}
-define <3 x i32> @constrained_vector_fptoui_v3i32_v3f64() {
+define <3 x i32> @constrained_vector_fptoui_v3i32_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v3i32_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %eax
%result = call <3 x i32> @llvm.experimental.constrained.fptoui.v3i32.v3f64(
<3 x double><double 42.1, double 42.2,
double 42.3>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x i32> %result
}
-define <4 x i32> @constrained_vector_fptoui_v4i32_v4f64() {
+define <4 x i32> @constrained_vector_fptoui_v4i32_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v4i32_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %eax
%result = call <4 x i32> @llvm.experimental.constrained.fptoui.v4i32.v4f64(
<4 x double><double 42.1, double 42.2,
double 42.3, double 42.4>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i32> %result
}
-define <1 x i64> @constrained_vector_fptoui_v1i64_v1f64() {
+define <1 x i64> @constrained_vector_fptoui_v1i64_v1f64() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v1i64_v1f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %rax
entry:
%result = call <1 x i64> @llvm.experimental.constrained.fptoui.v1i64.v1f64(
<1 x double><double 42.1>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x i64> %result
}
-define <2 x i64> @constrained_vector_fptoui_v2i64_v2f64() {
+define <2 x i64> @constrained_vector_fptoui_v2i64_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v2i64_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %rax
entry:
%result = call <2 x i64> @llvm.experimental.constrained.fptoui.v2i64.v2f64(
<2 x double><double 42.1, double 42.2>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x i64> %result
}
-define <3 x i64> @constrained_vector_fptoui_v3i64_v3f64() {
+define <3 x i64> @constrained_vector_fptoui_v3i64_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v3i64_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %rax
%result = call <3 x i64> @llvm.experimental.constrained.fptoui.v3i64.v3f64(
<3 x double><double 42.1, double 42.2,
double 42.3>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x i64> %result
}
-define <4 x i64> @constrained_vector_fptoui_v4i64_v4f64() {
+define <4 x i64> @constrained_vector_fptoui_v4i64_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fptoui_v4i64_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: cvttsd2si {{.*}}(%rip), %rax
%result = call <4 x i64> @llvm.experimental.constrained.fptoui.v4i64.v4f64(
<4 x double><double 42.1, double 42.2,
double 42.3, double 42.4>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x i64> %result
}
-define <1 x float> @constrained_vector_fptrunc_v1f64() {
+define <1 x float> @constrained_vector_fptrunc_v1f64() #0 {
; CHECK-LABEL: constrained_vector_fptrunc_v1f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
%result = call <1 x float> @llvm.experimental.constrained.fptrunc.v1f32.v1f64(
<1 x double><double 42.1>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %result
}
-define <2 x float> @constrained_vector_fptrunc_v2f64() {
+define <2 x float> @constrained_vector_fptrunc_v2f64() #0 {
; CHECK-LABEL: constrained_vector_fptrunc_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
%result = call <2 x float> @llvm.experimental.constrained.fptrunc.v2f32.v2f64(
<2 x double><double 42.1, double 42.2>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x float> %result
}
-define <3 x float> @constrained_vector_fptrunc_v3f64() {
+define <3 x float> @constrained_vector_fptrunc_v3f64() #0 {
; CHECK-LABEL: constrained_vector_fptrunc_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
<3 x double><double 42.1, double 42.2,
double 42.3>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %result
}
-define <4 x float> @constrained_vector_fptrunc_v4f64() {
+define <4 x float> @constrained_vector_fptrunc_v4f64() #0 {
; CHECK-LABEL: constrained_vector_fptrunc_v4f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movsd {{.*#+}} xmm0 = mem[0],zero
<4 x double><double 42.1, double 42.2,
double 42.3, double 42.4>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x float> %result
}
-define <1 x double> @constrained_vector_fpext_v1f32() {
+define <1 x double> @constrained_vector_fpext_v1f32() #0 {
; CHECK-LABEL: constrained_vector_fpext_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
entry:
%result = call <1 x double> @llvm.experimental.constrained.fpext.v1f64.v1f32(
<1 x float><float 42.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x double> %result
}
-define <2 x double> @constrained_vector_fpext_v2f32() {
+define <2 x double> @constrained_vector_fpext_v2f32() #0 {
; CHECK-LABEL: constrained_vector_fpext_v2f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
entry:
%result = call <2 x double> @llvm.experimental.constrained.fpext.v2f64.v2f32(
<2 x float><float 42.0, float 43.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %result
}
-define <3 x double> @constrained_vector_fpext_v3f32() {
+define <3 x double> @constrained_vector_fpext_v3f32() #0 {
; CHECK-LABEL: constrained_vector_fpext_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
%result = call <3 x double> @llvm.experimental.constrained.fpext.v3f64.v3f32(
<3 x float><float 42.0, float 43.0,
float 44.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %result
}
-define <4 x double> @constrained_vector_fpext_v4f32() {
+define <4 x double> @constrained_vector_fpext_v4f32() #0 {
; CHECK-LABEL: constrained_vector_fpext_v4f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: movss {{.*#+}} xmm0 = mem[0],zero,zero,zero
%result = call <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(
<4 x float><float 42.0, float 43.0,
float 44.0, float 45.0>,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <4 x double> %result
}
-define <1 x float> @constrained_vector_ceil_v1f32() {
+define <1 x float> @constrained_vector_ceil_v1f32() #0 {
; CHECK-LABEL: constrained_vector_ceil_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%ceil = call <1 x float> @llvm.experimental.constrained.ceil.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %ceil
}
-define <2 x double> @constrained_vector_ceil_v2f64() {
+define <2 x double> @constrained_vector_ceil_v2f64() #0 {
; CHECK-LABEL: constrained_vector_ceil_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%ceil = call <2 x double> @llvm.experimental.constrained.ceil.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %ceil
}
-define <3 x float> @constrained_vector_ceil_v3f32() {
+define <3 x float> @constrained_vector_ceil_v3f32() #0 {
; CHECK-LABEL: constrained_vector_ceil_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%ceil = call <3 x float> @llvm.experimental.constrained.ceil.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %ceil
}
-define <3 x double> @constrained_vector_ceil_v3f64() {
+define <3 x double> @constrained_vector_ceil_v3f64() #0 {
; CHECK-LABEL: constrained_vector_ceil_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%ceil = call <3 x double> @llvm.experimental.constrained.ceil.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %ceil
}
-define <1 x float> @constrained_vector_floor_v1f32() {
+define <1 x float> @constrained_vector_floor_v1f32() #0 {
; CHECK-LABEL: constrained_vector_floor_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%floor = call <1 x float> @llvm.experimental.constrained.floor.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %floor
}
-define <2 x double> @constrained_vector_floor_v2f64() {
+define <2 x double> @constrained_vector_floor_v2f64() #0 {
; CHECK-LABEL: constrained_vector_floor_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%floor = call <2 x double> @llvm.experimental.constrained.floor.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %floor
}
-define <3 x float> @constrained_vector_floor_v3f32() {
+define <3 x float> @constrained_vector_floor_v3f32() #0 {
; CHECK-LABEL: constrained_vector_floor_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%floor = call <3 x float> @llvm.experimental.constrained.floor.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %floor
}
-define <3 x double> @constrained_vector_floor_v3f64() {
+define <3 x double> @constrained_vector_floor_v3f64() #0 {
; CHECK-LABEL: constrained_vector_floor_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%floor = call <3 x double> @llvm.experimental.constrained.floor.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %floor
}
-define <1 x float> @constrained_vector_round_v1f32() {
+define <1 x float> @constrained_vector_round_v1f32() #0 {
; CHECK-LABEL: constrained_vector_round_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%round = call <1 x float> @llvm.experimental.constrained.round.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %round
}
-define <2 x double> @constrained_vector_round_v2f64() {
+define <2 x double> @constrained_vector_round_v2f64() #0 {
; CHECK-LABEL: constrained_vector_round_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%round = call <2 x double> @llvm.experimental.constrained.round.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %round
}
-define <3 x float> @constrained_vector_round_v3f32() {
+define <3 x float> @constrained_vector_round_v3f32() #0 {
; CHECK-LABEL: constrained_vector_round_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%round = call <3 x float> @llvm.experimental.constrained.round.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %round
}
-define <3 x double> @constrained_vector_round_v3f64() {
+define <3 x double> @constrained_vector_round_v3f64() #0 {
; CHECK-LABEL: constrained_vector_round_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%round = call <3 x double> @llvm.experimental.constrained.round.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %round
}
-define <1 x float> @constrained_vector_trunc_v1f32() {
+define <1 x float> @constrained_vector_trunc_v1f32() #0 {
; CHECK-LABEL: constrained_vector_trunc_v1f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: pushq %rax
%trunc = call <1 x float> @llvm.experimental.constrained.trunc.v1f32(
<1 x float> <float 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <1 x float> %trunc
}
-define <2 x double> @constrained_vector_trunc_v2f64() {
+define <2 x double> @constrained_vector_trunc_v2f64() #0 {
; CHECK-LABEL: constrained_vector_trunc_v2f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%trunc = call <2 x double> @llvm.experimental.constrained.trunc.v2f64(
<2 x double> <double 1.1, double 1.9>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <2 x double> %trunc
}
-define <3 x float> @constrained_vector_trunc_v3f32() {
+define <3 x float> @constrained_vector_trunc_v3f32() #0 {
; CHECK-LABEL: constrained_vector_trunc_v3f32:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $40, %rsp
%trunc = call <3 x float> @llvm.experimental.constrained.trunc.v3f32(
<3 x float> <float 1.5, float 2.5, float 3.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x float> %trunc
}
-define <3 x double> @constrained_vector_trunc_v3f64() {
+define <3 x double> @constrained_vector_trunc_v3f64() #0 {
; CHECK-LABEL: constrained_vector_trunc_v3f64:
; CHECK: # %bb.0: # %entry
; CHECK-NEXT: subq $24, %rsp
%trunc = call <3 x double> @llvm.experimental.constrained.trunc.v3f64(
<3 x double> <double 1.1, double 1.9, double 1.5>,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret <3 x double> %trunc
}
+attributes #0 = { strictfp }
; Single width declarations
declare <2 x double> @llvm.experimental.constrained.fadd.v2f64(<2 x double>, <2 x double>, metadata, metadata)
; Test to verify that constants aren't folded when the rounding mode is unknown.
; CHECK-LABEL: @f1
; CHECK: call double @llvm.experimental.constrained.fdiv.f64
-define double @f1() {
+define double @f1() #0 {
entry:
%div = call double @llvm.experimental.constrained.fdiv.f64(
double 1.000000e+00,
double 1.000000e+01,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %div
}
;
; CHECK-LABEL: @f2
; CHECK: call double @llvm.experimental.constrained.fsub.f64
-define double @f2(double %a) {
+define double @f2(double %a) #0 {
entry:
%div = call double @llvm.experimental.constrained.fsub.f64(
double %a, double 0.000000e+00,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %div
}
; CHECK: call double @llvm.experimental.constrained.fsub.f64
; CHECK: call double @llvm.experimental.constrained.fmul.f64
; CHECK: call double @llvm.experimental.constrained.fsub.f64
-define double @f3(double %a, double %b) {
+define double @f3(double %a, double %b) #0 {
entry:
%sub = call double @llvm.experimental.constrained.fsub.f64(
double -0.000000e+00, double %a,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%mul = call double @llvm.experimental.constrained.fmul.f64(
double %sub, double %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
%ret = call double @llvm.experimental.constrained.fsub.f64(
double -0.000000e+00,
double %mul,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %ret
}
; CHECK-LABEL: @f4
; CHECK-NOT: select
; CHECK: br i1 %cmp
-define double @f4(i32 %n, double %a) {
+define double @f4(i32 %n, double %a) #0 {
entry:
%cmp = icmp sgt i32 %n, 0
br i1 %cmp, label %if.then, label %if.end
%add = call double @llvm.experimental.constrained.fadd.f64(
double 1.000000e+00, double %a,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
br label %if.end
if.end:
; Verify that sqrt(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f5
; CHECK: call double @llvm.experimental.constrained.sqrt
-define double @f5() {
+define double @f5() #0 {
entry:
%result = call double @llvm.experimental.constrained.sqrt.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that pow(42.1, 3.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f6
; CHECK: call double @llvm.experimental.constrained.pow
-define double @f6() {
+define double @f6() #0 {
entry:
%result = call double @llvm.experimental.constrained.pow.f64(double 42.1,
double 3.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that powi(42.1, 3) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f7
; CHECK: call double @llvm.experimental.constrained.powi
-define double @f7() {
+define double @f7() #0 {
entry:
%result = call double @llvm.experimental.constrained.powi.f64(double 42.1,
i32 3,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that sin(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f8
; CHECK: call double @llvm.experimental.constrained.sin
-define double @f8() {
+define double @f8() #0 {
entry:
%result = call double @llvm.experimental.constrained.sin.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that cos(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f9
; CHECK: call double @llvm.experimental.constrained.cos
-define double @f9() {
+define double @f9() #0 {
entry:
%result = call double @llvm.experimental.constrained.cos.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that exp(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f10
; CHECK: call double @llvm.experimental.constrained.exp
-define double @f10() {
+define double @f10() #0 {
entry:
%result = call double @llvm.experimental.constrained.exp.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that exp2(42.1) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f11
; CHECK: call double @llvm.experimental.constrained.exp2
-define double @f11() {
+define double @f11() #0 {
entry:
%result = call double @llvm.experimental.constrained.exp2.f64(double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that log(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f12
; CHECK: call double @llvm.experimental.constrained.log
-define double @f12() {
+define double @f12() #0 {
entry:
%result = call double @llvm.experimental.constrained.log.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that log10(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f13
; CHECK: call double @llvm.experimental.constrained.log10
-define double @f13() {
+define double @f13() #0 {
entry:
%result = call double @llvm.experimental.constrained.log10.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that log2(42.0) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f14
; CHECK: call double @llvm.experimental.constrained.log2
-define double @f14() {
+define double @f14() #0 {
entry:
%result = call double @llvm.experimental.constrained.log2.f64(double 42.0,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; Verify that rint(42.1) isn't simplified when the rounding mode is unknown.
; CHECK-LABEL: f15
; CHECK: call double @llvm.experimental.constrained.rint
-define double @f15() {
+define double @f15() #0 {
entry:
%result = call double @llvm.experimental.constrained.rint.f64(double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; unknown.
; CHECK-LABEL: f16
; CHECK: call double @llvm.experimental.constrained.nearbyint
-define double @f16() {
+define double @f16() #0 {
entry:
%result = call double @llvm.experimental.constrained.nearbyint.f64(
double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; unknown.
; CHECK-LABEL: f17
; CHECK: call double @llvm.experimental.constrained.fma
-define double @f17() {
+define double @f17() #0 {
entry:
%result = call double @llvm.experimental.constrained.fma.f64(double 42.1, double 42.1, double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
; unknown.
; CHECK-LABEL: f18
; CHECK: call zeroext i32 @llvm.experimental.constrained.fptoui
-define zeroext i32 @f18() {
+define zeroext i32 @f18() #0 {
entry:
%result = call zeroext i32 @llvm.experimental.constrained.fptoui.i32.f64(
double 42.1,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %result
}
; unknown.
; CHECK-LABEL: f19
; CHECK: call i32 @llvm.experimental.constrained.fptosi
-define i32 @f19() {
+define i32 @f19() #0 {
entry:
%result = call i32 @llvm.experimental.constrained.fptosi.i32.f64(double 42.1,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret i32 %result
}
; unknown.
; CHECK-LABEL: f20
; CHECK: call float @llvm.experimental.constrained.fptrunc
-define float @f20() {
+define float @f20() #0 {
entry:
%result = call float @llvm.experimental.constrained.fptrunc.f32.f64(
double 42.1,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret float %result
}
; unknown.
; CHECK-LABEL: f21
; CHECK: call double @llvm.experimental.constrained.fpext
-define double @f21() {
+define double @f21() #0 {
entry:
%result = call double @llvm.experimental.constrained.fpext.f64.f32(float 42.0,
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %result
}
+attributes #0 = { strictfp }
+
@llvm.fp.env = thread_local global i8 zeroinitializer, section "llvm.metadata"
declare double @llvm.experimental.constrained.fdiv.f64(double, double, metadata, metadata)
declare double @llvm.experimental.constrained.fmul.f64(double, double, metadata, metadata)
; CHECK-NEXT: %cos3 = call double @cos(double 0.000000e+00)
%cos3 = call double @cos(double 0.000000e+00) nobuiltin
-; cos(1) strictfp sets FP status flags
-; CHECK-NEXT: %cos4 = call double @cos(double 1.000000e+00)
- %cos4 = call double @cos(double 1.000000e+00) strictfp
-
; pow(0, 1) is 0
%pow1 = call double @pow(double 0x7FF0000000000000, double 1.000000e+00)
; CHECK-NEXT: ret void
ret void
}
+
+define void @Tstrict() strictfp {
+entry:
+; CHECK-LABEL: @Tstrict(
+; CHECK-NEXT: entry:
+
+; cos(1) strictfp sets FP status flags
+; CHECK-NEXT: %cos4 = call double @cos(double 1.000000e+00)
+ %cos4 = call double @cos(double 1.000000e+00) strictfp
+
+; CHECK-NEXT: ret void
+ ret void
+}
; Check that we don't constant fold strictfp results that require rounding.
-define double @test_acos_strictfp() {
+define double @test_acos_strictfp() strictfp {
; CHECK-LABEL: @test_acos_strictfp
%pi = call double @acos(double -1.000000e+00) strictfp
; CHECK: call double @acos(double -1.000000e+00)
; Verify that the strictfp attr doesn't block this optimization.
-define i8* @test_simplify2(i8* %mem1, i8* %mem2, i32 %size) {
+define i8* @test_simplify2(i8* %mem1, i8* %mem2, i32 %size) strictfp {
; CHECK-LABEL: @test_simplify2(
; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i8* align 1 [[MEM1:%.*]], i8* align 1 [[MEM2:%.*]], i32 [[SIZE:%.*]], i1 false)
; CHECK-NEXT: ret i8* [[MEM1]]
; CHECK1: attributes #[[ATTR]] = { inaccessiblememonly nounwind willreturn }
; Note: FP exceptions aren't usually caught through normal unwind mechanisms,
; but we may want to revisit this for asynchronous exception handling.
-define double @f1(double %a, double %b) {
+define double @f1(double %a, double %b) #0 {
entry:
%fadd = call double @llvm.experimental.constrained.fadd.f64(
double %a, double %b,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %fadd
}
-define double @f1u(double %a) {
+define double @f1u(double %a) #0 {
entry:
%fsqrt = call double @llvm.experimental.constrained.sqrt.f64(
double %a,
metadata !"round.dynamic",
- metadata !"fpexcept.strict")
+ metadata !"fpexcept.strict") #0
ret double %fsqrt
}
; Test an illegal value for the rounding mode argument.
; CHECK2: invalid rounding mode argument
-;T2: define double @f2(double %a, double %b) {
+;T2: define double @f2(double %a, double %b) #0 {
;T2: entry:
;T2: %fadd = call double @llvm.experimental.constrained.fadd.f64(
;T2: double %a, double %b,
;T2: metadata !"round.dynomite",
-;T2: metadata !"fpexcept.strict")
+;T2: metadata !"fpexcept.strict") #0
;T2: ret double %fadd
;T2: }
; Test an illegal value for the exception behavior argument.
; CHECK3: invalid exception behavior argument
-;T3: define double @f3(double %a, double %b) {
+;T3: define double @f3(double %a, double %b) #0 {
;T3: entry:
;T3: %fadd = call double @llvm.experimental.constrained.fadd.f64(
;T3: double %a, double %b,
;T3: metadata !"round.dynamic",
-;T3: metadata !"fpexcept.restrict")
+;T3: metadata !"fpexcept.restrict") #0
;T3: ret double %fadd
;T3: }
; Test an illegal value for the rounding mode argument.
; CHECK4: invalid rounding mode argument
-;T4: define double @f4(double %a) {
+;T4: define double @f4(double %a) #0 {
;T4: entry:
;T4: %fadd = call double @llvm.experimental.constrained.sqrt.f64(
;T4: double %a,
;T4: metadata !"round.dynomite",
-;T4: metadata !"fpexcept.strict")
+;T4: metadata !"fpexcept.strict") #0
;T4: ret double %fadd
;T4: }
; Test an illegal value for the exception behavior argument.
; CHECK5: invalid exception behavior argument
-;T5: define double @f5(double %a) {
+;T5: define double @f5(double %a) #0 {
;T5: entry:
;T5: %fadd = call double @llvm.experimental.constrained.sqrt.f64(
;T5: double %a,
;T5: metadata !"round.dynamic",
-;T5: metadata !"fpexcept.restrict")
+;T5: metadata !"fpexcept.restrict") #0
;T5: ret double %fadd
;T5: }
+
+attributes #0 = { strictfp }
projects / llvm / commitdiff