Skip to content

Commit 1b235b0

Browse files
arsenmarsenm
committed
ValueTracking: Add baseline tests for fcmp with non-0/inf constants
Currently assumes only do anything for fcmps that perform an exact class test.
1 parent 1d82c76 commit 1b235b0

File tree

3 files changed

+3385
-0
lines changed

3 files changed

+3385
-0
lines changed

‎llvm/test/Transforms/Attributor/nofpclass-implied-by-fcmp.ll

Lines changed: 228 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1096,6 +1096,62 @@ define float @clamp_fabs_is_is_ole_smallest_normal_to_0(float %arg) {
10961096
ret float %select
10971097
}
10981098

1099+
define float @clamp_fabs_oeq_smallest_normal_to_zero(float %arg) {
1100+
; CHECK-LABEL: define float @clamp_fabs_oeq_smallest_normal_to_zero(
1101+
; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {
1102+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
1103+
; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[FABS_ARG]], 0x3810000000000000
1104+
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]
1105+
; CHECK-NEXT: ret float [[SELECT]]
1106+
;
1107+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
1108+
%is.oeq.smallest.normal = fcmp oeq float %fabs.arg, 0x3810000000000000
1109+
%select = select i1 %is.oeq.smallest.normal, float 0.0, float %arg
1110+
ret float %select
1111+
}
1112+
1113+
define float @clamp_fabs_one_smallest_normal_to_zero(float %arg) {
1114+
; CHECK-LABEL: define float @clamp_fabs_one_smallest_normal_to_zero(
1115+
; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {
1116+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
1117+
; CHECK-NEXT: [[IS_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[FABS_ARG]], 0x3810000000000000
1118+
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]
1119+
; CHECK-NEXT: ret float [[SELECT]]
1120+
;
1121+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
1122+
%is.one.smallest.normal = fcmp one float %fabs.arg, 0x3810000000000000
1123+
%select = select i1 %is.one.smallest.normal, float 0.0, float %arg
1124+
ret float %select
1125+
}
1126+
1127+
define float @clamp_fabs_ueq_smallest_normal_to_zero(float %arg) {
1128+
; CHECK-LABEL: define float @clamp_fabs_ueq_smallest_normal_to_zero(
1129+
; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {
1130+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
1131+
; CHECK-NEXT: [[IS_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[FABS_ARG]], 0x3810000000000000
1132+
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UEQ_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]
1133+
; CHECK-NEXT: ret float [[SELECT]]
1134+
;
1135+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
1136+
%is.ueq.smallest.normal = fcmp ueq float %fabs.arg, 0x3810000000000000
1137+
%select = select i1 %is.ueq.smallest.normal, float 0.0, float %arg
1138+
ret float %select
1139+
}
1140+
1141+
define float @clamp_fabs_une_smallest_normal_to_zero(float %arg) {
1142+
; CHECK-LABEL: define float @clamp_fabs_une_smallest_normal_to_zero(
1143+
; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {
1144+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
1145+
; CHECK-NEXT: [[IS_UNE_SMALLEST_NORMAL:%.*]] = fcmp une float [[FABS_ARG]], 0x3810000000000000
1146+
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UNE_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]
1147+
; CHECK-NEXT: ret float [[SELECT]]
1148+
;
1149+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
1150+
%is.une.smallest.normal = fcmp une float %fabs.arg, 0x3810000000000000
1151+
%select = select i1 %is.une.smallest.normal, float 0.0, float %arg
1152+
ret float %select
1153+
}
1154+
10991155
;---------------------------------------------------------------------
11001156
; compare fabs to negative normal
11011157
;---------------------------------------------------------------------
@@ -2167,5 +2223,177 @@ define float @ret_assumed_uge_known_negative(float %arg, float %unknown) {
21672223
ret float %arg
21682224
}
21692225

2226+
;---------------------------------------------------------------------
2227+
; assume compare to smallest normal
2228+
;---------------------------------------------------------------------
2229+
2230+
define float @assume_oeq_smallest_normal(float %arg) {
2231+
; CHECK-LABEL: define float @assume_oeq_smallest_normal(
2232+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2233+
; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[ARG]], 0x3810000000000000
2234+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]]
2235+
; CHECK-NEXT: ret float [[ARG]]
2236+
;
2237+
%is.oeq.smallest.normal = fcmp oeq float %arg, 0x3810000000000000
2238+
call void @llvm.assume(i1 %is.oeq.smallest.normal)
2239+
ret float %arg
2240+
}
2241+
2242+
define float @assume_one_smallest_normal(float %arg) {
2243+
; CHECK-LABEL: define float @assume_one_smallest_normal(
2244+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2245+
; CHECK-NEXT: [[IS_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[ARG]], 0x3810000000000000
2246+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ONE_SMALLEST_NORMAL]]) #[[ATTR5]]
2247+
; CHECK-NEXT: ret float [[ARG]]
2248+
;
2249+
%is.one.smallest.normal = fcmp one float %arg, 0x3810000000000000
2250+
call void @llvm.assume(i1 %is.one.smallest.normal)
2251+
ret float %arg
2252+
}
2253+
2254+
define float @assume_ueq_smallest_normal(float %arg) {
2255+
; CHECK-LABEL: define float @assume_ueq_smallest_normal(
2256+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2257+
; CHECK-NEXT: [[IS_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[ARG]], 0x3810000000000000
2258+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UEQ_SMALLEST_NORMAL]]) #[[ATTR5]]
2259+
; CHECK-NEXT: ret float [[ARG]]
2260+
;
2261+
%is.ueq.smallest.normal = fcmp ueq float %arg, 0x3810000000000000
2262+
call void @llvm.assume(i1 %is.ueq.smallest.normal)
2263+
ret float %arg
2264+
}
2265+
2266+
define float @assume_une_smallest_normal(float %arg) {
2267+
; CHECK-LABEL: define float @assume_une_smallest_normal(
2268+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2269+
; CHECK-NEXT: [[IS_UNE_SMALLEST_NORMAL:%.*]] = fcmp une float [[ARG]], 0x3810000000000000
2270+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UNE_SMALLEST_NORMAL]]) #[[ATTR5]]
2271+
; CHECK-NEXT: ret float [[ARG]]
2272+
;
2273+
%is.une.smallest.normal = fcmp une float %arg, 0x3810000000000000
2274+
call void @llvm.assume(i1 %is.une.smallest.normal)
2275+
ret float %arg
2276+
}
2277+
2278+
define float @assume_ord_smallest_normal(float %arg) {
2279+
; CHECK-LABEL: define nofpclass(nan) float @assume_ord_smallest_normal(
2280+
; CHECK-SAME: float returned nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] {
2281+
; CHECK-NEXT: [[IS_ORD_SMALLEST_NORMAL:%.*]] = fcmp ord float [[ARG]], 0x3810000000000000
2282+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ORD_SMALLEST_NORMAL]]) #[[ATTR5]]
2283+
; CHECK-NEXT: ret float [[ARG]]
2284+
;
2285+
%is.ord.smallest.normal = fcmp ord float %arg, 0x3810000000000000
2286+
call void @llvm.assume(i1 %is.ord.smallest.normal)
2287+
ret float %arg
2288+
}
2289+
2290+
define float @assume_uno_smallest_normal(float %arg) {
2291+
; CHECK-LABEL: define nofpclass(inf zero sub norm) float @assume_uno_smallest_normal(
2292+
; CHECK-SAME: float returned nofpclass(inf zero sub norm) [[ARG:%.*]]) #[[ATTR3]] {
2293+
; CHECK-NEXT: [[IS_UNO_SMALLEST_NORMAL:%.*]] = fcmp uno float [[ARG]], 0x3810000000000000
2294+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UNO_SMALLEST_NORMAL]]) #[[ATTR5]]
2295+
; CHECK-NEXT: ret float [[ARG]]
2296+
;
2297+
%is.uno.smallest.normal = fcmp uno float %arg, 0x3810000000000000
2298+
call void @llvm.assume(i1 %is.uno.smallest.normal)
2299+
ret float %arg
2300+
}
2301+
2302+
define float @assume_fabs_oeq_smallest_normal(float %arg) {
2303+
; CHECK-LABEL: define float @assume_fabs_oeq_smallest_normal(
2304+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2305+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
2306+
; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[FABS_ARG]], 0x3810000000000000
2307+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]]
2308+
; CHECK-NEXT: ret float [[ARG]]
2309+
;
2310+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
2311+
%is.oeq.smallest.normal = fcmp oeq float %fabs.arg, 0x3810000000000000
2312+
call void @llvm.assume(i1 %is.oeq.smallest.normal)
2313+
ret float %arg
2314+
}
2315+
2316+
define float @assume_fabs_one_smallest_normal(float %arg) {
2317+
; CHECK-LABEL: define float @assume_fabs_one_smallest_normal(
2318+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2319+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
2320+
; CHECK-NEXT: [[IS_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[FABS_ARG]], 0x3810000000000000
2321+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ONE_SMALLEST_NORMAL]]) #[[ATTR5]]
2322+
; CHECK-NEXT: ret float [[ARG]]
2323+
;
2324+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
2325+
%is.one.smallest.normal = fcmp one float %fabs.arg, 0x3810000000000000
2326+
call void @llvm.assume(i1 %is.one.smallest.normal)
2327+
ret float %arg
2328+
}
2329+
2330+
define float @assume_fabs_ueq_smallest_normal(float %arg) {
2331+
; CHECK-LABEL: define float @assume_fabs_ueq_smallest_normal(
2332+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2333+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
2334+
; CHECK-NEXT: [[IS_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[FABS_ARG]], 0x3810000000000000
2335+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UEQ_SMALLEST_NORMAL]]) #[[ATTR5]]
2336+
; CHECK-NEXT: ret float [[ARG]]
2337+
;
2338+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
2339+
%is.ueq.smallest.normal = fcmp ueq float %fabs.arg, 0x3810000000000000
2340+
call void @llvm.assume(i1 %is.ueq.smallest.normal)
2341+
ret float %arg
2342+
}
2343+
2344+
define float @assume_fabs_une_smallest_normal(float %arg) {
2345+
; CHECK-LABEL: define float @assume_fabs_une_smallest_normal(
2346+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2347+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
2348+
; CHECK-NEXT: [[IS_UNE_SMALLEST_NORMAL:%.*]] = fcmp une float [[FABS_ARG]], 0x3810000000000000
2349+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UNE_SMALLEST_NORMAL]]) #[[ATTR5]]
2350+
; CHECK-NEXT: ret float [[ARG]]
2351+
;
2352+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
2353+
%is.une.smallest.normal = fcmp une float %fabs.arg, 0x3810000000000000
2354+
call void @llvm.assume(i1 %is.une.smallest.normal)
2355+
ret float %arg
2356+
}
2357+
2358+
define float @assume_fabs_ord_smallest_normal(float %arg) {
2359+
; CHECK-LABEL: define float @assume_fabs_ord_smallest_normal(
2360+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2361+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
2362+
; CHECK-NEXT: [[IS_ORD_SMALLEST_NORMAL:%.*]] = fcmp ord float [[FABS_ARG]], 0x3810000000000000
2363+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ORD_SMALLEST_NORMAL]]) #[[ATTR5]]
2364+
; CHECK-NEXT: ret float [[ARG]]
2365+
;
2366+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
2367+
%is.ord.smallest.normal = fcmp ord float %fabs.arg, 0x3810000000000000
2368+
call void @llvm.assume(i1 %is.ord.smallest.normal)
2369+
ret float %arg
2370+
}
2371+
2372+
define float @assume_fabs_uno_smallest_normal(float %arg) {
2373+
; CHECK-LABEL: define float @assume_fabs_uno_smallest_normal(
2374+
; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {
2375+
; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]
2376+
; CHECK-NEXT: [[IS_UNO_SMALLEST_NORMAL:%.*]] = fcmp uno float [[FABS_ARG]], 0x3810000000000000
2377+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UNO_SMALLEST_NORMAL]]) #[[ATTR5]]
2378+
; CHECK-NEXT: ret float [[ARG]]
2379+
;
2380+
%fabs.arg = call float @llvm.fabs.f32(float %arg)
2381+
%is.uno.smallest.normal = fcmp uno float %fabs.arg, 0x3810000000000000
2382+
call void @llvm.assume(i1 %is.uno.smallest.normal)
2383+
ret float %arg
2384+
}
2385+
2386+
define float @assume_oeq_smallest_normal_known_pos(float nofpclass(ninf nsub nnorm nzero) %arg) {
2387+
; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @assume_oeq_smallest_normal_known_pos(
2388+
; CHECK-SAME: float returned nofpclass(ninf nzero nsub nnorm) [[ARG:%.*]]) #[[ATTR3]] {
2389+
; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[ARG]], 0x3810000000000000
2390+
; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]]
2391+
; CHECK-NEXT: ret float [[ARG]]
2392+
;
2393+
%is.oeq.smallest.normal = fcmp oeq float %arg, 0x3810000000000000
2394+
call void @llvm.assume(i1 %is.oeq.smallest.normal)
2395+
ret float %arg
2396+
}
2397+
21702398
;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
21712399
; TUNIT: {{.*}}

0 commit comments

Comments
 (0)