| blob | 27cb70cd06fb9fa888d6b7e7651028248c068c4f |
1 ; Test strict 32-bit floating-point division.
2 ;
3 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z10 \
4 ; RUN: | FileCheck -check-prefix=CHECK -check-prefix=CHECK-SCALAR %s
5 ; RUN: llc < %s -mtriple=s390x-linux-gnu -mcpu=z14 | FileCheck %s
7 declare float @foo()
8 declare float @llvm.experimental.constrained.fdiv.f32(float, float, metadata, metadata)
10 ; Check register division.
11 define float @f1(float %f1, float %f2) #0 {
12 ; CHECK-LABEL: f1:
13 ; CHECK: debr %f0, %f2
14 ; CHECK: br %r14
15 %res = call float @llvm.experimental.constrained.fdiv.f32(
16 float %f1, float %f2,
17 metadata !"round.dynamic",
18 metadata !"fpexcept.strict") #0
19 ret float %res
20 }
22 ; Check the low end of the DEB range.
23 define float @f2(float %f1, float *%ptr) #0 {
24 ; CHECK-LABEL: f2:
25 ; CHECK: deb %f0, 0(%r2)
26 ; CHECK: br %r14
27 %f2 = load float, float *%ptr
28 %res = call float @llvm.experimental.constrained.fdiv.f32(
29 float %f1, float %f2,
30 metadata !"round.dynamic",
31 metadata !"fpexcept.strict") #0
32 ret float %res
33 }
35 ; Check the high end of the aligned DEB range.
36 define float @f3(float %f1, float *%base) #0 {
37 ; CHECK-LABEL: f3:
38 ; CHECK: deb %f0, 4092(%r2)
39 ; CHECK: br %r14
40 %ptr = getelementptr float, float *%base, i64 1023
41 %f2 = load float, float *%ptr
42 %res = call float @llvm.experimental.constrained.fdiv.f32(
43 float %f1, float %f2,
44 metadata !"round.dynamic",
45 metadata !"fpexcept.strict") #0
46 ret float %res
47 }
49 ; Check the next word up, which needs separate address logic.
50 ; Other sequences besides this one would be OK.
51 define float @f4(float %f1, float *%base) #0 {
52 ; CHECK-LABEL: f4:
53 ; CHECK: aghi %r2, 4096
54 ; CHECK: deb %f0, 0(%r2)
55 ; CHECK: br %r14
56 %ptr = getelementptr float, float *%base, i64 1024
57 %f2 = load float, float *%ptr
58 %res = call float @llvm.experimental.constrained.fdiv.f32(
59 float %f1, float %f2,
60 metadata !"round.dynamic",
61 metadata !"fpexcept.strict") #0
62 ret float %res
63 }
65 ; Check negative displacements, which also need separate address logic.
66 define float @f5(float %f1, float *%base) #0 {
67 ; CHECK-LABEL: f5:
68 ; CHECK: aghi %r2, -4
69 ; CHECK: deb %f0, 0(%r2)
70 ; CHECK: br %r14
71 %ptr = getelementptr float, float *%base, i64 -1
72 %f2 = load float, float *%ptr
73 %res = call float @llvm.experimental.constrained.fdiv.f32(
74 float %f1, float %f2,
75 metadata !"round.dynamic",
76 metadata !"fpexcept.strict") #0
77 ret float %res
78 }
80 ; Check that DEB allows indices.
81 define float @f6(float %f1, float *%base, i64 %index) #0 {
82 ; CHECK-LABEL: f6:
83 ; CHECK: sllg %r1, %r3, 2
84 ; CHECK: deb %f0, 400(%r1,%r2)
85 ; CHECK: br %r14
86 %ptr1 = getelementptr float, float *%base, i64 %index
87 %ptr2 = getelementptr float, float *%ptr1, i64 100
88 %f2 = load float, float *%ptr2
89 %res = call float @llvm.experimental.constrained.fdiv.f32(
90 float %f1, float %f2,
91 metadata !"round.dynamic",
92 metadata !"fpexcept.strict") #0
93 ret float %res
94 }
96 ; Check that divisions of spilled values can use DEB rather than DEBR.
97 define float @f7(float *%ptr0) #0 {
98 ; CHECK-LABEL: f7:
99 ; CHECK: brasl %r14, foo@PLT
100 ; CHECK-SCALAR: deb %f0, 16{{[04]}}(%r15)
101 ; CHECK: br %r14
102 %ptr1 = getelementptr float, float *%ptr0, i64 2
103 %ptr2 = getelementptr float, float *%ptr0, i64 4
104 %ptr3 = getelementptr float, float *%ptr0, i64 6
105 %ptr4 = getelementptr float, float *%ptr0, i64 8
106 %ptr5 = getelementptr float, float *%ptr0, i64 10
107 %ptr6 = getelementptr float, float *%ptr0, i64 12
108 %ptr7 = getelementptr float, float *%ptr0, i64 14
109 %ptr8 = getelementptr float, float *%ptr0, i64 16
110 %ptr9 = getelementptr float, float *%ptr0, i64 18
111 %ptr10 = getelementptr float, float *%ptr0, i64 20
113 %val0 = load float, float *%ptr0
114 %val1 = load float, float *%ptr1
115 %val2 = load float, float *%ptr2
116 %val3 = load float, float *%ptr3
117 %val4 = load float, float *%ptr4
118 %val5 = load float, float *%ptr5
119 %val6 = load float, float *%ptr6
120 %val7 = load float, float *%ptr7
121 %val8 = load float, float *%ptr8
122 %val9 = load float, float *%ptr9
123 %val10 = load float, float *%ptr10
125 %ret = call float @foo() #0
127 %div0 = call float @llvm.experimental.constrained.fdiv.f32(
128 float %ret, float %val0,
129 metadata !"round.dynamic",
130 metadata !"fpexcept.strict") #0
131 %div1 = call float @llvm.experimental.constrained.fdiv.f32(
132 float %div0, float %val1,
133 metadata !"round.dynamic",
134 metadata !"fpexcept.strict") #0
135 %div2 = call float @llvm.experimental.constrained.fdiv.f32(
136 float %div1, float %val2,
137 metadata !"round.dynamic",
138 metadata !"fpexcept.strict") #0
139 %div3 = call float @llvm.experimental.constrained.fdiv.f32(
140 float %div2, float %val3,
141 metadata !"round.dynamic",
142 metadata !"fpexcept.strict") #0
143 %div4 = call float @llvm.experimental.constrained.fdiv.f32(
144 float %div3, float %val4,
145 metadata !"round.dynamic",
146 metadata !"fpexcept.strict") #0
147 %div5 = call float @llvm.experimental.constrained.fdiv.f32(
148 float %div4, float %val5,
149 metadata !"round.dynamic",
150 metadata !"fpexcept.strict") #0
151 %div6 = call float @llvm.experimental.constrained.fdiv.f32(
152 float %div5, float %val6,
153 metadata !"round.dynamic",
154 metadata !"fpexcept.strict") #0
155 %div7 = call float @llvm.experimental.constrained.fdiv.f32(
156 float %div6, float %val7,
157 metadata !"round.dynamic",
158 metadata !"fpexcept.strict") #0
159 %div8 = call float @llvm.experimental.constrained.fdiv.f32(
160 float %div7, float %val8,
161 metadata !"round.dynamic",
162 metadata !"fpexcept.strict") #0
163 %div9 = call float @llvm.experimental.constrained.fdiv.f32(
164 float %div8, float %val9,
165 metadata !"round.dynamic",
166 metadata !"fpexcept.strict") #0
167 %div10 = call float @llvm.experimental.constrained.fdiv.f32(
168 float %div9, float %val10,
169 metadata !"round.dynamic",
170 metadata !"fpexcept.strict") #0
172 ret float %div10
173 }
175 attributes #0 = { strictfp }