shylie/llvm-project
1
0
Fork 0
Code Issues Pull Requests Actions 6 Packages Projects Releases Wiki Activity
llvm-project/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass-phi.ll
Matt Arsenault 2f5d9b6d96
InstCombine: Support basic phis in SimplifyDemandedFPClass (#184124) 
Some complex function edge case epilogs are only handled under
some control flow paths (e.g. lgamma and erfcinv).
2026-03-11 16:03:28 +00:00

645 lines
22 KiB
LLVM
Raw Blame History

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 6
; RUN: opt -S -passes=instcombine < %s | FileCheck %s
declare nofpclass(inf norm sub zero) float @nan_only()
define nofpclass(nan) half @ret_phi_if_ret_0(i1 %cond1, i1 %cond2, half %unknown) {
; CHECK-LABEL: define nofpclass(nan) half @ret_phi_if_ret_0(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND1]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[UNKNOWN]], %[[IF]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
br i1 %cond1, label %if, label %ret
if:
%select = select i1 %cond2, half 0xH7E00, half %unknown
br label %ret
ret:
%phi = phi half [ %select, %if ], [ 0.0, %entry ]
ret half %phi
}
define nofpclass(nan inf norm sub nzero) half @ret_phi_only_pzero(i1 %cond1, i1 %cond2, half %unknown) {
; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) half @ret_phi_only_pzero(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: br i1 [[COND1]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half 0xH0000
;
entry:
br i1 %cond1, label %if, label %ret
if:
%select = select i1 %cond2, half 0xH7E00, half %unknown
br label %ret
ret:
%phi = phi half [ %select, %if ], [ 0.0, %entry ]
ret half %phi
}
define nofpclass(inf norm sub zero) half @ret_phi_only_nan(i1 %cond1, i1 %cond2, half %unknown) {
; CHECK-LABEL: define nofpclass(inf zero sub norm) half @ret_phi_only_nan(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND1]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[COND2]], half 0xH7E00, half [[UNKNOWN]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT]], %[[IF]] ], [ poison, %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
br i1 %cond1, label %if, label %ret
if:
%select = select i1 %cond2, half 0xH7E00, half %unknown
br label %ret
ret:
%phi = phi half [ %select, %if ], [ 0.0, %entry ]
ret half %phi
}
define nofpclass(nan) half @ret_phi_if_ret_1(i1 %cond1, i1 %cond2, half %unknown) {
; CHECK-LABEL: define nofpclass(nan) half @ret_phi_if_ret_1(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND1]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ 0xH0000, %[[ENTRY]] ], [ [[UNKNOWN]], %[[IF]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
br i1 %cond1, label %if, label %ret
if:
%select = select i1 %cond2, half 0xH7E00, half %unknown
br label %ret
ret:
%phi = phi half [ 0.0, %entry ], [ %select, %if ]
ret half %phi
}
; Make sure all block references use the same simplified value.
define nofpclass(nan) half @ret_repeated_switch_pred(i8 %switch.cond, i1 %cond2, half %unknown) {
; CHECK-LABEL: define nofpclass(nan) half @ret_repeated_switch_pred(
; CHECK-SAME: i8 [[SWITCH_COND:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: switch i8 [[SWITCH_COND]], label %[[DEFAULT:.*]] [
; CHECK-NEXT: i8 0, label %[[RET:.*]]
; CHECK-NEXT: i8 1, label %[[RET]]
; CHECK-NEXT: i8 2, label %[[IF:.*]]
; CHECK-NEXT: ]
; CHECK: [[IF]]:
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[DEFAULT]]:
; CHECK-NEXT: unreachable
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ 0xH0000, %[[IF]] ], [ [[UNKNOWN]], %[[ENTRY]] ], [ [[UNKNOWN]], %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
%select = select i1 %cond2, half 0xH7E00, half %unknown
switch i8 %switch.cond, label %default
[ i8 0, label %ret
i8 1, label %ret
i8 2, label %if
]
if:
br label %ret
default:
unreachable
ret:
%phi = phi half [ 0.0, %if ], [ %select, %entry ], [ %select, %entry ]
ret half %phi
}
define nofpclass(nan) half @ret_phi_chain(i1 %cond1, i1 %cond2, i1 %cond3, half %unknown) {
; CHECK-LABEL: define nofpclass(nan) half @ret_phi_chain(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], i1 [[COND3:%.*]], half [[UNKNOWN:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND1]], label %[[IF0:.*]], label %[[IF1:.*]]
; CHECK: [[IF0]]:
; CHECK-NEXT: br i1 [[COND2]], label %[[IF1]], label %[[RET:.*]]
; CHECK: [[IF1]]:
; CHECK-NEXT: [[PHI0:%.*]] = phi half [ [[UNKNOWN]], %[[IF0]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI1:%.*]] = phi half [ [[PHI0]], %[[IF1]] ], [ 0xH0000, %[[IF0]] ]
; CHECK-NEXT: ret half [[PHI1]]
;
entry:
br i1 %cond1, label %if0, label %if1
if0:
%select0 = select i1 %cond2, half 0xH7E00, half %unknown
br i1 %cond2, label %if1, label %ret
if1:
%phi0 = phi half [ %select0, %if0 ], [ 0.0, %entry ]
br label %ret
ret:
%phi1 = phi half [ %phi0, %if1 ], [ 0.0, %if0 ]
ret half %phi1
}
define nofpclass(nan) half @basic_loop_break_entry_block(i1 %cond1, i1 %cond2, half %unknown, ptr %p0, ptr %p1) {
; CHECK-LABEL: define nofpclass(nan) half @basic_loop_break_entry_block(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ [[UNKNOWN]], %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half [[PHI]]
;
entry:
%select = select i1 %cond2, half 0xH7E00, half %unknown
br label %loop
loop:
%phi = phi half [ %load, %loop ], [ %select, %entry ]
%load = load half, ptr %p1
%break.cond = load i1, ptr %p0
br i1 %break.cond, label %ret, label %loop
ret:
ret half %phi
}
define nofpclass(nan) half @basic_loop_break_mid_loop(i1 %cond1, i1 %cond2, half %unknown, ptr %p0, ptr %p1) {
; CHECK-LABEL: define nofpclass(nan) half @basic_loop_break_mid_loop(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], half [[UNKNOWN:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half [[PHI]]
;
entry:
br label %loop
loop:
%phi = phi half [ %select, %loop ], [ 0.0, %entry ]
%load = load half, ptr %p1
%select = select i1 %cond2, half 0xH7E00, half %load
%break.cond = load i1, ptr %p0
br i1 %break.cond, label %ret, label %loop
ret:
ret half %phi
}
define nofpclass(inf) half @recurrence(i1 %select.cond, half %unknown, ptr %p0, ptr %p1) {
; CHECK-LABEL: define nofpclass(inf) half @recurrence(
; CHECK-SAME: i1 [[SELECT_COND:%.*]], half [[UNKNOWN:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half [[PHI]]
;
entry:
br label %loop
loop:
%phi = phi half [ %select, %loop ], [ 0.0, %entry ]
%load = load half, ptr %p1
%select = select i1 %select.cond, half 0xH7C00, half %load
%break.cond = load i1, ptr %p0
br i1 %break.cond, label %ret, label %loop
ret:
ret half %phi
}
define nofpclass(nan) half @path_dependent(i1 %select.cond, half %unknown, half %x) {
; CHECK-LABEL: define nofpclass(nan) half @path_dependent(
; CHECK-SAME: i1 [[SELECT_COND:%.*]], half [[UNKNOWN:%.*]], half [[X:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[X]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[UNKNOWN]], %[[IF]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
%is.nan = fcmp uno half %x, 0.0
br i1 %is.nan, label %if, label %ret
if:
%select = select i1 %select.cond, half %x, half %unknown
br label %ret
ret:
%phi = phi half [ %select, %if ], [ 0.0, %entry ]
ret half %phi
}
define nofpclass(nan) half @path_dependent_wrong(i1 %select.cond, half %unknown, half %x) {
; CHECK-LABEL: define nofpclass(nan) half @path_dependent_wrong(
; CHECK-SAME: i1 [[SELECT_COND:%.*]], half [[UNKNOWN:%.*]], half [[X:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: [[IS_NOT_NAN:%.*]] = fcmp ord half [[X]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NOT_NAN]], label %[[IF:.*]], label %[[RET:.*]]
; CHECK: [[IF]]:
; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[SELECT_COND]], half [[X]], half [[UNKNOWN]]
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[SELECT]], %[[IF]] ], [ 0xH0000, %[[ENTRY]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
%is.not.nan = fcmp ord half %x, 0.0
br i1 %is.not.nan, label %if, label %ret
if:
%select = select i1 %select.cond, half %x, half %unknown
br label %ret
ret:
%phi = phi half [ %select, %if ], [ 0.0, %entry ]
ret half %phi
}
define nofpclass(nan) half @diamond_same_select(i1 %select.cond, half %unknown, half %x) {
; CHECK-LABEL: define nofpclass(nan) half @diamond_same_select(
; CHECK-SAME: i1 [[SELECT_COND:%.*]], half [[UNKNOWN:%.*]], half [[X:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[X]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IF:.*]], label %[[ELSE:.*]]
; CHECK: [[IF]]:
; CHECK-NEXT: br label %[[ENDIF:.*]]
; CHECK: [[ELSE]]:
; CHECK-NEXT: [[SELECT1:%.*]] = select i1 [[SELECT_COND]], half [[X]], half [[UNKNOWN]]
; CHECK-NEXT: br label %[[ENDIF]]
; CHECK: [[ENDIF]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[UNKNOWN]], %[[IF]] ], [ [[SELECT1]], %[[ELSE]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
%is.nan = fcmp uno half %x, 0.0
br i1 %is.nan, label %if, label %else
if:
%select0 = select i1 %select.cond, half %x, half %unknown
br label %endif
else:
%select1 = select i1 %select.cond, half %x, half %unknown
br label %endif
endif:
%phi = phi half [ %select0, %if ], [ %select1, %else ]
ret half %phi
}
define nofpclass(nan) half @remove_nan_start_value(ptr %p0, ptr %p1) {
; CHECK-LABEL: define nofpclass(nan) half @remove_nan_start_value(
; CHECK-SAME: ptr [[P0:%.*]], ptr [[P1:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ poison, %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half [[PHI]]
;
entry:
br label %loop
loop:
%phi = phi half [ %load, %loop ], [ 0xH7E00, %entry ]
%load = load half, ptr %p1
%break.cond = load i1, ptr %p0
br i1 %break.cond, label %ret, label %loop
ret:
ret half %phi
}
define nofpclass(nan) half @keep_nan_start_value_multi_use(i1 %cond1, i1 %cond2, ptr %p0, ptr %p1) {
; CHECK-LABEL: define nofpclass(nan) half @keep_nan_start_value_multi_use(
; CHECK-SAME: i1 [[COND1:%.*]], i1 [[COND2:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ 0xH7E00, %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P1]], align 2
; CHECK-NEXT: [[BREAK_COND:%.*]] = load i1, ptr [[P0]], align 1
; CHECK-NEXT: br i1 [[BREAK_COND]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: store half [[PHI]], ptr [[P0]], align 2
; CHECK-NEXT: ret half [[PHI]]
;
entry:
br label %loop
loop:
%phi = phi half [ %load, %loop ], [ 0xH7E00, %entry ]
%load = load half, ptr %p1
%break.cond = load i1, ptr %p0
br i1 %break.cond, label %ret, label %loop
ret:
store half %phi, ptr %p0
ret half %phi
}
; TODO: Why doesn't this fold to ret poison?
define nofpclass(nan) half @loop_break_if_nan(ptr %p0) {
; CHECK-LABEL: define nofpclass(nan) half @loop_break_if_nan(
; CHECK-SAME: ptr [[P0:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD:%.*]], %[[LOOP]] ], [ poison, %[[ENTRY]] ]
; CHECK-NEXT: [[LOAD]] = load half, ptr [[P0]], align 2
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[LOAD]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half [[PHI]]
;
entry:
br label %loop
loop:
%phi = phi half [ %load, %loop ], [ 0xH7E00, %entry ]
%load = load half, ptr %p0
%is.nan = fcmp uno half %load, 0.0
br i1 %is.nan, label %ret, label %loop
ret:
ret half %phi
}
define nofpclass(nan) half @loop_break_if_nan_abs(ptr %p0) {
; CHECK-LABEL: define nofpclass(nan) half @loop_break_if_nan_abs(
; CHECK-SAME: ptr [[P0:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: br label %[[LOOP:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[LOAD:%.*]] = load half, ptr [[P0]], align 2
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[LOAD]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[RET:.*]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half poison
;
entry:
br label %loop
loop:
%phi = phi half [ %load, %loop ], [ 0xH7E00, %entry ]
%load = load half, ptr %p0
%abs = call half @llvm.fabs.f16(half %load)
%is.nan = fcmp uno half %load, 0.0
br i1 %is.nan, label %ret, label %loop
ret:
ret half %abs
}
define nofpclass(nan) half @ret_loop_under_if_phi(half %unknown, i1 %cond, i1 %cond2, ptr %p0, ptr %p1) {
; CHECK-LABEL: define nofpclass(nan) half @ret_loop_under_if_phi(
; CHECK-SAME: half [[UNKNOWN:%.*]], i1 [[COND:%.*]], i1 [[COND2:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: br i1 [[COND]], label %[[LOOP:.*]], label %[[RET:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[LOOP_COND:%.*]] = load i1, ptr [[P1]], align 1
; CHECK-NEXT: br i1 [[LOOP_COND]], label %[[RET]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half [[UNKNOWN]]
;
entry:
%entry.select = select i1 %cond2, half 0xH7E00, half %unknown
br i1 %cond, label %loop, label %ret
loop:
%loop.phi = phi half [ %loop.select, %loop ], [ 0xH7E00, %entry ]
%loop.select = select i1 %cond2, half 0xH7E00, half %unknown
%loop.cond = load i1, ptr %p1
br i1 %loop.cond, label %ret, label %loop
ret:
%outer.phi = phi half [ 0xH7E00, %entry ], [ %loop.phi, %loop ]
ret half %outer.phi
}
define nofpclass(nan) half @assume_in_loop(half %assumed.nan.in.loop, half %unknown, i1 %cond, i1 %cond2, ptr %p0, ptr %p1) {
; CHECK-LABEL: define nofpclass(nan) half @assume_in_loop(
; CHECK-SAME: half [[ASSUMED_NAN_IN_LOOP:%.*]], half [[UNKNOWN:%.*]], i1 [[COND:%.*]], i1 [[COND2:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: br i1 [[COND]], label %[[LOOP:.*]], label %[[RET:.*]]
; CHECK: [[LOOP]]:
; CHECK-NEXT: [[LOOP_PHI:%.*]] = phi half [ [[UNKNOWN]], %[[LOOP]] ], [ [[ASSUMED_NAN_IN_LOOP]], %[[ENTRY]] ]
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[ASSUMED_NAN_IN_LOOP]], 0xH0000
; CHECK-NEXT: call void @llvm.assume(i1 [[IS_NAN]])
; CHECK-NEXT: [[LOOP_COND:%.*]] = load i1, ptr [[P1]], align 1
; CHECK-NEXT: br i1 [[LOOP_COND]], label %[[RET]], label %[[LOOP]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[OUTER_PHI:%.*]] = phi half [ [[ASSUMED_NAN_IN_LOOP]], %[[ENTRY]] ], [ [[LOOP_PHI]], %[[LOOP]] ]
; CHECK-NEXT: ret half [[OUTER_PHI]]
;
entry:
br i1 %cond, label %loop, label %ret
loop:
%loop.phi = phi half [ %loop.select, %loop ], [ %assumed.nan.in.loop, %entry ]
%is.nan = fcmp uno half %assumed.nan.in.loop, 0.0
call void @llvm.assume(i1 %is.nan)
%loop.select = select i1 %cond2, half %assumed.nan.in.loop, half %unknown
%loop.cond = load i1, ptr %p1
br i1 %loop.cond, label %ret, label %loop
ret:
%outer.phi = phi half [ %assumed.nan.in.loop, %entry ], [ %loop.phi, %loop ]
ret half %outer.phi
}
define nofpclass(nan) half @ret_phi_nan_check(half %checked.if.nan, half %unknown, i1 %cond) {
; CHECK-LABEL: define nofpclass(nan) half @ret_phi_nan_check(
; CHECK-SAME: half [[CHECKED_IF_NAN:%.*]], half [[UNKNOWN:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[CHECKED_IF_NAN]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IF_NAN:.*]], label %[[RET:.*]]
; CHECK: [[IF_NAN]]:
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[CHECKED_IF_NAN]], %[[ENTRY]] ], [ [[UNKNOWN]], %[[IF_NAN]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
%is.nan = fcmp uno half %checked.if.nan, 0.0
br i1 %is.nan, label %if_nan, label %ret
if_nan:
%select = select i1 %cond, half %checked.if.nan, half %unknown
br label %ret
ret:
%phi = phi half [ %checked.if.nan, %entry ], [ %select, %if_nan ]
ret half %phi
}
define nofpclass(nan inf) half @edge_case_if_chain(half %x, i1 %cond, ptr %p0, ptr %p1, ptr %p2) {
; CHECK-LABEL: define nofpclass(nan inf) half @edge_case_if_chain(
; CHECK-SAME: half [[X:%.*]], i1 [[COND:%.*]], ptr [[P0:%.*]], ptr [[P1:%.*]], ptr [[P2:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: [[IS_INF:%.*]] = fcmp oeq half [[X]], 0xH7C00
; CHECK-NEXT: br i1 [[IS_INF]], label %[[IS_INF:.*]], label %[[ELSE:.*]]
; CHECK: [[IS_INF]]:
; CHECK-NEXT: [[LOAD0:%.*]] = load half, ptr [[P0]], align 2
; CHECK-NEXT: br label %[[RET:.*]]
; CHECK: [[ELSE]]:
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[X]], 0xH0000
; CHECK-NEXT: [[LOAD1:%.*]] = load half, ptr [[P0]], align 2
; CHECK-NEXT: [[VAL1:%.*]] = select i1 [[COND]], half [[LOAD1]], half [[X]]
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IS_NAN:.*]], label %[[RET]]
; CHECK: [[IS_NAN]]:
; CHECK-NEXT: [[LOAD2:%.*]] = load half, ptr [[P2]], align 2
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[LOAD0]], %[[IS_INF]] ], [ [[VAL1]], %[[ELSE]] ], [ [[LOAD2]], %[[IS_NAN]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
%is.inf = fcmp oeq half %x, 0xH7C00
br i1 %is.inf, label %is_inf, label %else
is_inf:
%load0 = load half, ptr %p0
%val0 = select i1 %cond, half %x, half %load0
br label %ret
else:
%is.nan = fcmp uno half %x, 0.0
%load1 = load half, ptr %p0
%val1 = select i1 %cond, half %load1, half %x
br i1 %is.nan, label %is_nan, label %ret
is_nan:
%load2 = load half, ptr %p2
%val2 = select i1 %cond, half %x, half %load2
br label %ret
ret:
%phi = phi half [ %val0, %is_inf ], [ %val1, %else ], [ %val2, %is_nan ]
ret half %phi
}
; Fold the %is_nan input value to %unknown, though the select is
; defined in a different block.
define nofpclass(nan) half @evaluate_phi_input_at_incoming_edge(half %known.nan.in.branch, half %unknown, i1 %cond) {
; CHECK-LABEL: define nofpclass(nan) half @evaluate_phi_input_at_incoming_edge(
; CHECK-SAME: half [[KNOWN_NAN_IN_BRANCH:%.*]], half [[UNKNOWN:%.*]], i1 [[COND:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*]]:
; CHECK-NEXT: [[IS_NAN:%.*]] = fcmp uno half [[KNOWN_NAN_IN_BRANCH]], 0xH0000
; CHECK-NEXT: br i1 [[IS_NAN]], label %[[IS_NAN:.*]], label %[[RET:.*]]
; CHECK: [[IS_NAN]]:
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: [[PHI:%.*]] = phi half [ [[KNOWN_NAN_IN_BRANCH]], %[[ENTRY]] ], [ [[UNKNOWN]], %[[IS_NAN]] ]
; CHECK-NEXT: ret half [[PHI]]
;
entry:
%entry.select = select i1 %cond, half %known.nan.in.branch, half %unknown
%is.nan = fcmp uno half %known.nan.in.branch, 0.0
br i1 %is.nan, label %is_nan, label %ret
is_nan:
br label %ret
ret:
%phi = phi half [ %known.nan.in.branch, %entry ], [ %entry.select, %is_nan ]
ret half %phi
}
; This phi should fold out into a ret 0. This depends on trying to
; simplify both phi inputs at once, with the predecessor terminator as
; the context.
define nofpclass(nan) half @multi_simplify_lost_phi_context_(half %x, half %y, i1 %cond0, i1 %cond1, i1 %cond2) {
; CHECK-LABEL: define nofpclass(nan) half @multi_simplify_lost_phi_context_(
; CHECK-SAME: half [[X:%.*]], half [[Y:%.*]], i1 [[COND0:%.*]], i1 [[COND1:%.*]], i1 [[COND2:%.*]]) {
; CHECK-NEXT: [[ENTRY:.*:]]
; CHECK-NEXT: br i1 [[COND0]], label %[[ASSUME_A:.*]], label %[[ASSUME_B:.*]]
; CHECK: [[ASSUME_A]]:
; CHECK-NEXT: [[X_IS_NAN:%.*]] = fcmp uno half [[X]], 0xH0000
; CHECK-NEXT: call void @llvm.assume(i1 [[X_IS_NAN]])
; CHECK-NEXT: br label %[[A:.*]]
; CHECK: [[A]]:
; CHECK-NEXT: br label %[[RET:.*]]
; CHECK: [[ASSUME_B]]:
; CHECK-NEXT: [[Y_IS_NAN:%.*]] = fcmp uno half [[Y]], 0xH0000
; CHECK-NEXT: call void @llvm.assume(i1 [[Y_IS_NAN]])
; CHECK-NEXT: br label %[[B:.*]]
; CHECK: [[B]]:
; CHECK-NEXT: br label %[[RET]]
; CHECK: [[RET]]:
; CHECK-NEXT: ret half 0xH0000
;
entry:
br i1 %cond0, label %assume_a, label %assume_b
assume_a:
%x.is.nan = fcmp uno half %x, 0.0
call void @llvm.assume(i1 %x.is.nan)
br label %a
a:
%select_a = select i1 %cond2, half %x, half 0xH7E00
br label %ret
assume_b:
%y.is.nan = fcmp uno half %y, 0.0
call void @llvm.assume(i1 %y.is.nan)
br label %b
b:
%select_b = select i1 %cond2, half %y, half 0xH7E00
br label %ret
ret:
%phi.must.be.nan = phi half [ %select_a, %a ], [ %select_b, %b ]
%select = select i1 %cond2, half %phi.must.be.nan, half 0.0
ret half %select
}
Reference in New Issue View Git Blame Copy Permalink