2818 lines · plain
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 32; RUN: opt -S -passes=attributor -attributor-manifest-internal < %s | FileCheck %s --check-prefixes=CHECK,TUNIT3 4declare float @llvm.fabs.f32(float)5declare float @llvm.copysign.f32(float, float)6declare void @llvm.assume(i1 noundef)7 8;---------------------------------------------------------------------9; compare > < to normal constant10;---------------------------------------------------------------------11 12; can't be +inf13define float @clamp_is_ogt_1_to_1(float %arg) {14; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_ogt_1_to_1(15; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2:[0-9]+]] {16; CHECK-NEXT: [[IS_OGT_1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+0017; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_1]], float 1.000000e+00, float [[ARG]]18; CHECK-NEXT: ret float [[SELECT]]19;20 %is.ogt.1 = fcmp ogt float %arg, 1.021 %select = select i1 %is.ogt.1, float 1.0, float %arg22 ret float %select23}24 25define float @clamp_is_ogt_1_to_1_commute(float %arg) {26; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_ogt_1_to_1_commute(27; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {28; CHECK-NEXT: [[IS_ULE_1:%.*]] = fcmp ule float [[ARG]], 1.000000e+0029; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_1]], float [[ARG]], float 1.000000e+0030; CHECK-NEXT: ret float [[SELECT]]31;32 %is.ule.1 = fcmp ule float %arg, 1.033 %select = select i1 %is.ule.1, float %arg, float 1.034 ret float %select35}36 37; can't be +inf or nan38define float @clamp_is_ugt_1_to_1(float %arg) {39; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_ugt_1_to_1(40; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {41; CHECK-NEXT: [[IS_UGT_1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+0042; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_1]], float 1.000000e+00, float [[ARG]]43; CHECK-NEXT: ret float [[SELECT]]44;45 %is.ugt.1 = fcmp ugt float %arg, 1.046 %select = select i1 %is.ugt.1, float 1.0, float %arg47 ret float %select48}49 50; can't be +inf or nan51define float @clamp_is_ugt_1_to_1_commute(float %arg) {52; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_ugt_1_to_1_commute(53; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {54; CHECK-NEXT: [[IS_OLE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+0055; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_1]], float [[ARG]], float 1.000000e+0056; CHECK-NEXT: ret float [[SELECT]]57;58 %is.ole.1 = fcmp ole float %arg, 1.059 %select = select i1 %is.ole.1, float %arg, float 1.060 ret float %select61}62 63; can't be +inf64define float @clamp_is_oge_1_to_1(float %arg) {65; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_oge_1_to_1(66; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {67; CHECK-NEXT: [[IS_OGE_1:%.*]] = fcmp oge float [[ARG]], 1.000000e+0068; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_1]], float 1.000000e+00, float [[ARG]]69; CHECK-NEXT: ret float [[SELECT]]70;71 %is.oge.1 = fcmp oge float %arg, 1.072 %select = select i1 %is.oge.1, float 1.0, float %arg73 ret float %select74}75 76define float @clamp_is_oge_1_to_1_commute(float %arg) {77; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_oge_1_to_1_commute(78; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {79; CHECK-NEXT: [[IS_ULT_1:%.*]] = fcmp ult float [[ARG]], 1.000000e+0080; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_1]], float [[ARG]], float 1.000000e+0081; CHECK-NEXT: ret float [[SELECT]]82;83 %is.ult.1 = fcmp ult float %arg, 1.084 %select = select i1 %is.ult.1, float %arg, float 1.085 ret float %select86}87 88; can't be +inf or nan89define float @clamp_is_uge_1_to_1(float %arg) {90; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_uge_1_to_1(91; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {92; CHECK-NEXT: [[IS_UGT_1:%.*]] = fcmp uge float [[ARG]], 1.000000e+0093; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_1]], float 1.000000e+00, float [[ARG]]94; CHECK-NEXT: ret float [[SELECT]]95;96 %is.ugt.1 = fcmp uge float %arg, 1.097 %select = select i1 %is.ugt.1, float 1.0, float %arg98 ret float %select99}100 101; can't be negative, zero, or denormal102define float @clamp_is_olt_1_to_1(float %arg) {103; CHECK-LABEL: define nofpclass(ninf zero sub nnorm) float @clamp_is_olt_1_to_1(104; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {105; CHECK-NEXT: [[IS_OLT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00106; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_1]], float 1.000000e+00, float [[ARG]]107; CHECK-NEXT: ret float [[SELECT]]108;109 %is.olt.1 = fcmp olt float %arg, 1.0110 %select = select i1 %is.olt.1, float 1.0, float %arg111 ret float %select112}113 114; can't be negative, zero, or denormal115define float @clamp_is_olt_1_to_1_commute(float %arg) {116; CHECK-LABEL: define nofpclass(ninf zero sub nnorm) float @clamp_is_olt_1_to_1_commute(117; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {118; CHECK-NEXT: [[IS_UGE_1:%.*]] = fcmp uge float [[ARG]], 1.000000e+00119; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_1]], float [[ARG]], float 1.000000e+00120; CHECK-NEXT: ret float [[SELECT]]121;122 %is.uge.1 = fcmp uge float %arg, 1.0123 %select = select i1 %is.uge.1, float %arg, float 1.0124 ret float %select125}126 127; can't be negative or zero, nan or denormal128define float @clamp_is_ult_1_to_1(float %arg) {129; CHECK-LABEL: define nofpclass(nan ninf zero sub nnorm) float @clamp_is_ult_1_to_1(130; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {131; CHECK-NEXT: [[IS_ULT_1:%.*]] = fcmp ult float [[ARG]], 1.000000e+00132; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_1]], float 1.000000e+00, float [[ARG]]133; CHECK-NEXT: ret float [[SELECT]]134;135 %is.ult.1 = fcmp ult float %arg, 1.0136 %select = select i1 %is.ult.1, float 1.0, float %arg137 ret float %select138}139 140; can't be negative or zero, nan or denormal141define float @clamp_is_ult_1_to_1_commute(float %arg) {142; CHECK-LABEL: define nofpclass(nan ninf zero sub nnorm) float @clamp_is_ult_1_to_1_commute(143; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {144; CHECK-NEXT: [[IS_OGE_1:%.*]] = fcmp oge float [[ARG]], 1.000000e+00145; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_1]], float [[ARG]], float 1.000000e+00146; CHECK-NEXT: ret float [[SELECT]]147;148 %is.oge.1 = fcmp oge float %arg, 1.0149 %select = select i1 %is.oge.1, float %arg, float 1.0150 ret float %select151}152 153; can't be negative, zero or denormal154define float @clamp_is_ole_1_to_1(float %arg) {155; CHECK-LABEL: define nofpclass(ninf zero sub nnorm) float @clamp_is_ole_1_to_1(156; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {157; CHECK-NEXT: [[IS_OLE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00158; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_1]], float 1.000000e+00, float [[ARG]]159; CHECK-NEXT: ret float [[SELECT]]160;161 %is.ole.1 = fcmp ole float %arg, 1.0162 %select = select i1 %is.ole.1, float 1.0, float %arg163 ret float %select164}165 166; can't be negative or zero, nan or denormal167define float @clamp_is_ule_1_to_1(float %arg) {168; CHECK-LABEL: define nofpclass(nan ninf zero sub nnorm) float @clamp_is_ule_1_to_1(169; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {170; CHECK-NEXT: [[IS_ULE_1:%.*]] = fcmp ule float [[ARG]], 1.000000e+00171; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_1]], float 1.000000e+00, float [[ARG]]172; CHECK-NEXT: ret float [[SELECT]]173;174 %is.ule.1 = fcmp ule float %arg, 1.0175 %select = select i1 %is.ule.1, float 1.0, float %arg176 ret float %select177}178 179; can't be negative or denormal180define float @clamp_is_olt_1_to_0(float %arg) {181; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_olt_1_to_0(182; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {183; CHECK-NEXT: [[IS_OLT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00184; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_1]], float 0.000000e+00, float [[ARG]]185; CHECK-NEXT: ret float [[SELECT]]186;187 %is.olt.1 = fcmp olt float %arg, 1.0188 %select = select i1 %is.olt.1, float 0.0, float %arg189 ret float %select190}191 192; can't be negative, nan or denormal193define float @clamp_is_ult_1_to_0(float %arg) {194; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_ult_1_to_0(195; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {196; CHECK-NEXT: [[IS_ULT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+00197; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_1]], float 0.000000e+00, float [[ARG]]198; CHECK-NEXT: ret float [[SELECT]]199;200 %is.ult.1 = fcmp olt float %arg, 1.0201 %select = select i1 %is.ult.1, float 0.0, float %arg202 ret float %select203}204 205; can't be negative or denormal206define float @clamp_is_ole_1_to_0(float %arg) {207; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_ole_1_to_0(208; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {209; CHECK-NEXT: [[IS_OLE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00210; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_1]], float 0.000000e+00, float [[ARG]]211; CHECK-NEXT: ret float [[SELECT]]212;213 %is.ole.1 = fcmp ole float %arg, 1.0214 %select = select i1 %is.ole.1, float 0.0, float %arg215 ret float %select216}217 218; can't be negative or denormal219define float @clamp_is_ole_1_to_0_commute(float %arg) {220; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_ole_1_to_0_commute(221; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {222; CHECK-NEXT: [[IS_UGT_1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+00223; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_1]], float [[ARG]], float 0.000000e+00224; CHECK-NEXT: ret float [[SELECT]]225;226 %is.ugt.1 = fcmp ugt float %arg, 1.0227 %select = select i1 %is.ugt.1, float %arg, float 0.0228 ret float %select229}230 231; can't be negative or denormal232define float @clamp_is_ule_1_to_0(float %arg) {233; CHECK-LABEL: define nofpclass(ninf nzero sub nnorm) float @clamp_is_ule_1_to_0(234; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {235; CHECK-NEXT: [[IS_ULE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+00236; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_1]], float 0.000000e+00, float [[ARG]]237; CHECK-NEXT: ret float [[SELECT]]238;239 %is.ule.1 = fcmp ole float %arg, 1.0240 %select = select i1 %is.ule.1, float 0.0, float %arg241 ret float %select242}243 244; can't be positive, zero or denormal245define float @clamp_is_ogt_neg1_to_neg1(float %arg) {246; CHECK-LABEL: define nofpclass(pinf zero sub pnorm) float @clamp_is_ogt_neg1_to_neg1(247; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {248; CHECK-NEXT: [[IS_OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00249; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_NEG1]], float -1.000000e+00, float [[ARG]]250; CHECK-NEXT: ret float [[SELECT]]251;252 %is.ogt.neg1 = fcmp ogt float %arg, -1.0253 %select = select i1 %is.ogt.neg1, float -1.0, float %arg254 ret float %select255}256 257; can't be positive, zero, nan or denormal258define float @clamp_is_ugt_neg1_to_neg1(float %arg) {259; CHECK-LABEL: define nofpclass(nan pinf zero sub pnorm) float @clamp_is_ugt_neg1_to_neg1(260; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {261; CHECK-NEXT: [[IS_UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00262; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_NEG1]], float -1.000000e+00, float [[ARG]]263; CHECK-NEXT: ret float [[SELECT]]264;265 %is.ugt.neg1 = fcmp ugt float %arg, -1.0266 %select = select i1 %is.ugt.neg1, float -1.0, float %arg267 ret float %select268}269 270; can't be positive or denormal271define float @clamp_is_ogt_neg1_to_0(float %arg) {272; CHECK-LABEL: define nofpclass(pinf nzero sub pnorm) float @clamp_is_ogt_neg1_to_0(273; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {274; CHECK-NEXT: [[IS_OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+00275; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_NEG1]], float 0.000000e+00, float [[ARG]]276; CHECK-NEXT: ret float [[SELECT]]277;278 %is.ogt.neg1 = fcmp ogt float %arg, -1.0279 %select = select i1 %is.ogt.neg1, float 0.0, float %arg280 ret float %select281}282 283; can't be positive, nan or denormal284define float @clamp_is_ugt_neg1_to_0(float %arg) {285; CHECK-LABEL: define nofpclass(nan pinf nzero sub pnorm) float @clamp_is_ugt_neg1_to_0(286; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {287; CHECK-NEXT: [[IS_UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+00288; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_NEG1]], float 0.000000e+00, float [[ARG]]289; CHECK-NEXT: ret float [[SELECT]]290;291 %is.ugt.neg1 = fcmp ugt float %arg, -1.0292 %select = select i1 %is.ugt.neg1, float 0.0, float %arg293 ret float %select294}295 296; can't be -inf297define float @clamp_is_olt_neg1_to_neg1_commute(float %arg) {298; CHECK-LABEL: define nofpclass(ninf) float @clamp_is_olt_neg1_to_neg1_commute(299; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {300; CHECK-NEXT: [[IS_UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+00301; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_NEG1]], float [[ARG]], float -1.000000e+00302; CHECK-NEXT: ret float [[SELECT]]303;304 %is.uge.neg1 = fcmp uge float %arg, -1.0305 %select = select i1 %is.uge.neg1, float %arg, float -1.0306 ret float %select307}308 309; can't be -inf310define float @clamp_is_olt_neg1_to_neg1(float %arg) {311; CHECK-LABEL: define nofpclass(ninf) float @clamp_is_olt_neg1_to_neg1(312; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {313; CHECK-NEXT: [[IS_OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+00314; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_NEG1]], float -1.000000e+00, float [[ARG]]315; CHECK-NEXT: ret float [[SELECT]]316;317 %is.olt.neg1 = fcmp olt float %arg, -1.0318 %select = select i1 %is.olt.neg1, float -1.0, float %arg319 ret float %select320}321 322; can't be -inf or nan323define float @clamp_is_ult_neg1_to_neg1(float %arg) {324; CHECK-LABEL: define nofpclass(nan ninf) float @clamp_is_ult_neg1_to_neg1(325; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {326; CHECK-NEXT: [[IS_ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+00327; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_NEG1]], float -1.000000e+00, float [[ARG]]328; CHECK-NEXT: ret float [[SELECT]]329;330 %is.ult.neg1 = fcmp ult float %arg, -1.0331 %select = select i1 %is.ult.neg1, float -1.0, float %arg332 ret float %select333}334 335; can't be -inf or nan336define float @clamp_is_ult_neg1_to_neg1_commute(float %arg) {337; CHECK-LABEL: define nofpclass(nan ninf) float @clamp_is_ult_neg1_to_neg1_commute(338; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {339; CHECK-NEXT: [[IS_OGE_NEG1:%.*]] = fcmp oge float [[ARG]], -1.000000e+00340; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_NEG1]], float [[ARG]], float -1.000000e+00341; CHECK-NEXT: ret float [[SELECT]]342;343 %is.oge.neg1 = fcmp oge float %arg, -1.0344 %select = select i1 %is.oge.neg1, float %arg, float -1.345 ret float %select346}347 348;---------------------------------------------------------------------349; compare ==, != to normal350;---------------------------------------------------------------------351 352; Must be 1, only posnormal353define float @fcmp_oeq_1_else_1(float %arg) {354; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @fcmp_oeq_1_else_1(355; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {356; CHECK-NEXT: [[IS_OEQ_1:%.*]] = fcmp oeq float [[ARG]], 1.000000e+00357; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_1]], float [[ARG]], float 1.000000e+00358; CHECK-NEXT: ret float [[SELECT]]359;360 %is.oeq.1 = fcmp oeq float %arg, 1.0361 %select = select i1 %is.oeq.1, float %arg, float 1.0362 ret float %select363}364 365; Don't know anything366define float @fcmp_one_1_else_1(float %arg) {367; CHECK-LABEL: define nofpclass(nan) float @fcmp_one_1_else_1(368; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {369; CHECK-NEXT: [[IS_ONE_1:%.*]] = fcmp one float [[ARG]], 1.000000e+00370; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_1]], float [[ARG]], float 1.000000e+00371; CHECK-NEXT: ret float [[SELECT]]372;373 %is.one.1 = fcmp one float %arg, 1.0374 %select = select i1 %is.one.1, float %arg, float 1.0375 ret float %select376}377 378; must be 1 or nan379define float @fcmp_one_1_1_else_arg(float %arg) {380; CHECK-LABEL: define nofpclass(inf zero sub nnorm) float @fcmp_one_1_1_else_arg(381; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {382; CHECK-NEXT: [[IS_ONE_1:%.*]] = fcmp one float [[ARG]], 1.000000e+00383; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_1]], float 1.000000e+00, float [[ARG]]384; CHECK-NEXT: ret float [[SELECT]]385;386 %is.one.1 = fcmp one float %arg, 1.0387 %select = select i1 %is.one.1, float 1.0, float %arg388 ret float %select389}390 391; must be 1392define float @fcmp_une_1_1_else_arg(float %arg) {393; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @fcmp_une_1_1_else_arg(394; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {395; CHECK-NEXT: [[IS_UNE_1:%.*]] = fcmp une float [[ARG]], 1.000000e+00396; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UNE_1]], float 1.000000e+00, float [[ARG]]397; CHECK-NEXT: ret float [[SELECT]]398;399 %is.une.1 = fcmp une float %arg, 1.0400 %select = select i1 %is.une.1, float 1.0, float %arg401 ret float %select402}403 404; Must be -1, only negnormal405define float @fcmp_oeq_neg1_else_neg1(float %arg) {406; CHECK-LABEL: define nofpclass(nan inf zero sub pnorm) float @fcmp_oeq_neg1_else_neg1(407; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {408; CHECK-NEXT: [[IS_OEQ_NEG1:%.*]] = fcmp oeq float [[ARG]], -1.000000e+00409; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_NEG1]], float [[ARG]], float -1.000000e+00410; CHECK-NEXT: ret float [[SELECT]]411;412 %is.oeq.neg1 = fcmp oeq float %arg, -1.0413 %select = select i1 %is.oeq.neg1, float %arg, float -1.0414 ret float %select415}416 417; Don't know anything418define float @fcmp_one_neg1_else_neg1(float %arg) {419; CHECK-LABEL: define nofpclass(nan) float @fcmp_one_neg1_else_neg1(420; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {421; CHECK-NEXT: [[IS_ONE_NEG1:%.*]] = fcmp one float [[ARG]], -1.000000e+00422; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_NEG1]], float [[ARG]], float -1.000000e+00423; CHECK-NEXT: ret float [[SELECT]]424;425 %is.one.neg1 = fcmp one float %arg, -1.0426 %select = select i1 %is.one.neg1, float %arg, float -1.0427 ret float %select428}429 430define float @fcmp_oeq_1_else_0(float %arg) {431; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub nnorm) float @fcmp_oeq_1_else_0(432; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {433; CHECK-NEXT: [[IS_OEQ_1:%.*]] = fcmp oeq float [[ARG]], 1.000000e+00434; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_1]], float 1.000000e+00, float 0.000000e+00435; CHECK-NEXT: ret float [[SELECT]]436;437 %is.oeq.1 = fcmp oeq float %arg, 1.0438 %select = select i1 %is.oeq.1, float 1.0, float 0.0439 ret float %select440}441 442define float @fcmp_ueq_1_else_0(float %arg) {443; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub nnorm) float @fcmp_ueq_1_else_0(444; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {445; CHECK-NEXT: [[IS_UEQ_1:%.*]] = fcmp ueq float [[ARG]], 1.000000e+00446; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UEQ_1]], float 1.000000e+00, float 0.000000e+00447; CHECK-NEXT: ret float [[SELECT]]448;449 %is.ueq.1 = fcmp ueq float %arg, 1.0450 %select = select i1 %is.ueq.1, float 1.0, float 0.0451 ret float %select452}453 454define float @if_fcmp_oeq_1_0_else_arg(float %arg) {455; CHECK-LABEL: define float @if_fcmp_oeq_1_0_else_arg(456; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {457; CHECK-NEXT: [[IS_OEQ_1:%.*]] = fcmp oeq float [[ARG]], 1.000000e+00458; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_1]], float 0.000000e+00, float [[ARG]]459; CHECK-NEXT: ret float [[SELECT]]460;461 %is.oeq.1 = fcmp oeq float %arg, 1.0462 %select = select i1 %is.oeq.1, float 0.0, float %arg463 ret float %select464}465 466define float @if_fcmp_oeq_0_1_else_arg(float %arg) {467; CHECK-LABEL: define nofpclass(zero) float @if_fcmp_oeq_0_1_else_arg(468; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {469; CHECK-NEXT: [[IS_OEQ_0:%.*]] = fcmp oeq float [[ARG]], 0.000000e+00470; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_0]], float 1.000000e+00, float [[ARG]]471; CHECK-NEXT: ret float [[SELECT]]472;473 %is.oeq.0 = fcmp oeq float %arg, 0.0474 %select = select i1 %is.oeq.0, float 1.0, float %arg475 ret float %select476}477 478define float @if_fcmp_one_0_arg_else_1(float %arg) {479; CHECK-LABEL: define nofpclass(nan zero) float @if_fcmp_one_0_arg_else_1(480; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {481; CHECK-NEXT: [[IS_ONE_0:%.*]] = fcmp one float [[ARG]], 0.000000e+00482; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_0]], float [[ARG]], float 1.000000e+00483; CHECK-NEXT: ret float [[SELECT]]484;485 %is.one.0 = fcmp one float %arg, 0.0486 %select = select i1 %is.one.0, float %arg, float 1.0487 ret float %select488}489 490define float @if_fcmp_une_0_arg_else_1(float %arg) {491; CHECK-LABEL: define nofpclass(zero) float @if_fcmp_une_0_arg_else_1(492; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {493; CHECK-NEXT: [[IS_UNE_0:%.*]] = fcmp une float [[ARG]], 0.000000e+00494; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UNE_0]], float [[ARG]], float 1.000000e+00495; CHECK-NEXT: ret float [[SELECT]]496;497 %is.une.0 = fcmp une float %arg, 0.0498 %select = select i1 %is.une.0, float %arg, float 1.0499 ret float %select500}501 502define float @if_fcmp_one_0_1_else_arg(float %arg) {503; CHECK-LABEL: define nofpclass(inf sub nnorm) float @if_fcmp_one_0_1_else_arg(504; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {505; CHECK-NEXT: [[IS_ONE_0:%.*]] = fcmp one float [[ARG]], 0.000000e+00506; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_0]], float 1.000000e+00, float [[ARG]]507; CHECK-NEXT: ret float [[SELECT]]508;509 %is.one.0 = fcmp one float %arg, 0.0510 %select = select i1 %is.one.0, float 1.0, float %arg511 ret float %select512}513 514define float @if_fcmp_one_1_arg_else_0(float %arg) {515; CHECK-LABEL: define nofpclass(nan) float @if_fcmp_one_1_arg_else_0(516; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {517; CHECK-NEXT: [[IS_ONE_1:%.*]] = fcmp one float [[ARG]], 1.000000e+00518; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_1]], float [[ARG]], float 0.000000e+00519; CHECK-NEXT: ret float [[SELECT]]520;521 %is.one.1 = fcmp one float %arg, 1.0522 %select = select i1 %is.one.1, float %arg, float 0.0523 ret float %select524}525 526define float @fcmp_fabs_oeq_1_else_1(float %arg) {527; CHECK-LABEL: define nofpclass(nan inf zero sub) float @fcmp_fabs_oeq_1_else_1(528; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {529; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4:[0-9]+]]530; CHECK-NEXT: [[FABS_IS_OEQ_1:%.*]] = fcmp oeq float [[FABS_ARG]], 1.000000e+00531; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_OEQ_1]], float [[ARG]], float 1.000000e+00532; CHECK-NEXT: ret float [[SELECT]]533;534 %fabs.arg = call float @llvm.fabs.f32(float %arg)535 %fabs.is.oeq.1 = fcmp oeq float %fabs.arg, 1.0536 %select = select i1 %fabs.is.oeq.1, float %arg, float 1.0537 ret float %select538}539 540define float @fcmp_fabs_oeq_1_0_else_arg(float %arg) {541; CHECK-LABEL: define float @fcmp_fabs_oeq_1_0_else_arg(542; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {543; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]544; CHECK-NEXT: [[FABS_IS_OEQ_1:%.*]] = fcmp oeq float [[FABS_ARG]], 1.000000e+00545; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_OEQ_1]], float 0.000000e+00, float [[ARG]]546; CHECK-NEXT: ret float [[SELECT]]547;548 %fabs.arg = call float @llvm.fabs.f32(float %arg)549 %fabs.is.oeq.1 = fcmp oeq float %fabs.arg, 1.0550 %select = select i1 %fabs.is.oeq.1, float 0.0, float %arg551 ret float %select552}553 554define float @fcmp_fabs_ueq_1_0_else_arg(float %arg) {555; CHECK-LABEL: define nofpclass(nan) float @fcmp_fabs_ueq_1_0_else_arg(556; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {557; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]558; CHECK-NEXT: [[FABS_IS_UEQ_1:%.*]] = fcmp ueq float [[FABS_ARG]], 1.000000e+00559; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_UEQ_1]], float 0.000000e+00, float [[ARG]]560; CHECK-NEXT: ret float [[SELECT]]561;562 %fabs.arg = call float @llvm.fabs.f32(float %arg)563 %fabs.is.ueq.1 = fcmp ueq float %fabs.arg, 1.0564 %select = select i1 %fabs.is.ueq.1, float 0.0, float %arg565 ret float %select566}567 568define float @fcmp_fabs_one_1_arg_else_0(float %arg) {569; CHECK-LABEL: define nofpclass(nan) float @fcmp_fabs_one_1_arg_else_0(570; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {571; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]572; CHECK-NEXT: [[FABS_IS_ONE_1:%.*]] = fcmp one float [[FABS_ARG]], 1.000000e+00573; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_ONE_1]], float [[ARG]], float 0.000000e+00574; CHECK-NEXT: ret float [[SELECT]]575;576 %fabs.arg = call float @llvm.fabs.f32(float %arg)577 %fabs.is.one.1 = fcmp one float %fabs.arg, 1.0578 %select = select i1 %fabs.is.one.1, float %arg, float 0.0579 ret float %select580}581 582define float @fcmp_fabs_une_1_arg_else_0(float %arg) {583; CHECK-LABEL: define float @fcmp_fabs_une_1_arg_else_0(584; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {585; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]586; CHECK-NEXT: [[FABS_IS_UNE_1:%.*]] = fcmp une float [[FABS_ARG]], 1.000000e+00587; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_UNE_1]], float [[ARG]], float 0.000000e+00588; CHECK-NEXT: ret float [[SELECT]]589;590 %fabs.arg = call float @llvm.fabs.f32(float %arg)591 %fabs.is.une.1 = fcmp une float %fabs.arg, 1.0592 %select = select i1 %fabs.is.une.1, float %arg, float 0.0593 ret float %select594}595 596define float @fcmp_fabs_one_1_0_else_arg(float %arg) {597; CHECK-LABEL: define nofpclass(inf nzero sub) float @fcmp_fabs_one_1_0_else_arg(598; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {599; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]600; CHECK-NEXT: [[FABS_IS_ONE_1:%.*]] = fcmp one float [[FABS_ARG]], 1.000000e+00601; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_ONE_1]], float 0.000000e+00, float [[ARG]]602; CHECK-NEXT: ret float [[SELECT]]603;604 %fabs.arg = call float @llvm.fabs.f32(float %arg)605 %fabs.is.one.1 = fcmp one float %fabs.arg, 1.0606 %select = select i1 %fabs.is.one.1, float 0.0, float %arg607 ret float %select608}609 610define float @fcmp_fabs_une_1_0_else_arg(float %arg) {611; CHECK-LABEL: define nofpclass(nan inf nzero sub) float @fcmp_fabs_une_1_0_else_arg(612; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {613; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]614; CHECK-NEXT: [[FABS_IS_UNE_1:%.*]] = fcmp une float [[FABS_ARG]], 1.000000e+00615; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_UNE_1]], float 0.000000e+00, float [[ARG]]616; CHECK-NEXT: ret float [[SELECT]]617;618 %fabs.arg = call float @llvm.fabs.f32(float %arg)619 %fabs.is.une.1 = fcmp une float %fabs.arg, 1.0620 %select = select i1 %fabs.is.une.1, float 0.0, float %arg621 ret float %select622}623 624define float @fcmp_fabs_one_1_neg2_else_arg(float %arg) {625; CHECK-LABEL: define nofpclass(inf zero sub) float @fcmp_fabs_one_1_neg2_else_arg(626; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {627; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]628; CHECK-NEXT: [[FABS_IS_ONE_1:%.*]] = fcmp one float [[FABS_ARG]], 1.000000e+00629; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_ONE_1]], float -2.000000e+00, float [[ARG]]630; CHECK-NEXT: ret float [[SELECT]]631;632 %fabs.arg = call float @llvm.fabs.f32(float %arg)633 %fabs.is.one.1 = fcmp one float %fabs.arg, 1.0634 %select = select i1 %fabs.is.one.1, float -2.0, float %arg635 ret float %select636}637 638;---------------------------------------------------------------------639; compare to denormal640;---------------------------------------------------------------------641 642define float @clamp_olt_largest_denormal_0.0(float %arg) {643; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @clamp_olt_largest_denormal_0.0(644; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {645; CHECK-NEXT: [[IS_OLT_LARGEST_DENORMAL:%.*]] = fcmp olt float [[ARG]], 0x380FFFFFC0000000646; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]]647; CHECK-NEXT: ret float [[SELECT]]648;649 %is.olt.largest.denormal = fcmp olt float %arg, 0x380FFFFFC0000000650 %select = select i1 %is.olt.largest.denormal, float 0.0, float %arg651 ret float %select652}653 654define float @clamp_ole_largest_denormal_0.0(float %arg) {655; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @clamp_ole_largest_denormal_0.0(656; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {657; CHECK-NEXT: [[IS_OLE_LARGEST_DENORMAL:%.*]] = fcmp ole float [[ARG]], 0x380FFFFFC0000000658; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]]659; CHECK-NEXT: ret float [[SELECT]]660;661 %is.ole.largest.denormal = fcmp ole float %arg, 0x380FFFFFC0000000662 %select = select i1 %is.ole.largest.denormal, float 0.0, float %arg663 ret float %select664}665 666define float @clamp_ult_largest_denormal_0.0(float %arg) {667; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @clamp_ult_largest_denormal_0.0(668; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {669; CHECK-NEXT: [[IS_ULT_LARGEST_DENORMAL:%.*]] = fcmp ult float [[ARG]], 0x380FFFFFC0000000670; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]]671; CHECK-NEXT: ret float [[SELECT]]672;673 %is.ult.largest.denormal = fcmp ult float %arg, 0x380FFFFFC0000000674 %select = select i1 %is.ult.largest.denormal, float 0.0, float %arg675 ret float %select676}677 678define float @clamp_ule_largest_denormal_0.0(float %arg) {679; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @clamp_ule_largest_denormal_0.0(680; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {681; CHECK-NEXT: [[IS_ULE_LARGEST_DENORMAL:%.*]] = fcmp ule float [[ARG]], 0x380FFFFFC0000000682; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]]683; CHECK-NEXT: ret float [[SELECT]]684;685 %is.ule.largest.denormal = fcmp ule float %arg, 0x380FFFFFC0000000686 %select = select i1 %is.ule.largest.denormal, float 0.0, float %arg687 ret float %select688}689 690define float @clamp_ogt_largest_denormal_0.0(float %arg) {691; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @clamp_ogt_largest_denormal_0.0(692; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {693; CHECK-NEXT: [[IS_OGT_LARGEST_DENORMAL:%.*]] = fcmp ogt float [[ARG]], 0x380FFFFFC0000000694; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00695; CHECK-NEXT: ret float [[SELECT]]696;697 %is.ogt.largest.denormal = fcmp ogt float %arg, 0x380FFFFFC0000000698 %select = select i1 %is.ogt.largest.denormal, float %arg, float 0.0699 ret float %select700}701 702define float @clamp_oge_largest_denormal_0.0(float %arg) {703; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @clamp_oge_largest_denormal_0.0(704; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {705; CHECK-NEXT: [[IS_OGE_LARGEST_DENORMAL:%.*]] = fcmp oge float [[ARG]], 0x380FFFFFC0000000706; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00707; CHECK-NEXT: ret float [[SELECT]]708;709 %is.oge.largest.denormal = fcmp oge float %arg, 0x380FFFFFC0000000710 %select = select i1 %is.oge.largest.denormal, float %arg, float 0.0711 ret float %select712}713 714define float @clamp_ugt_largest_denormal_0.0(float %arg) {715; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @clamp_ugt_largest_denormal_0.0(716; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {717; CHECK-NEXT: [[IS_UGT_LARGEST_DENORMAL:%.*]] = fcmp ugt float [[ARG]], 0x380FFFFFC0000000718; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00719; CHECK-NEXT: ret float [[SELECT]]720;721 %is.ugt.largest.denormal = fcmp ugt float %arg, 0x380FFFFFC0000000722 %select = select i1 %is.ugt.largest.denormal, float %arg, float 0.0723 ret float %select724}725 726define float @clamp_uge_largest_denormal_0.0(float %arg) {727; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @clamp_uge_largest_denormal_0.0(728; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {729; CHECK-NEXT: [[IS_UGE_LARGEST_DENORMAL:%.*]] = fcmp uge float [[ARG]], 0x380FFFFFC0000000730; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00731; CHECK-NEXT: ret float [[SELECT]]732;733 %is.uge.largest.denormal = fcmp uge float %arg, 0x380FFFFFC0000000734 %select = select i1 %is.uge.largest.denormal, float %arg, float 0.0735 ret float %select736}737 738define float @fcmp_oeq_largest_denormal_arg_else_0.0(float %arg) {739; CHECK-LABEL: define nofpclass(nan inf nzero nsub norm) float @fcmp_oeq_largest_denormal_arg_else_0.0(740; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {741; CHECK-NEXT: [[IS_OEQ_LARGEST_DENORMAL:%.*]] = fcmp oeq float [[ARG]], 0x380FFFFFC0000000742; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_LARGEST_DENORMAL]], float [[ARG]], float 0.000000e+00743; CHECK-NEXT: ret float [[SELECT]]744;745 %is.oeq.largest.denormal = fcmp oeq float %arg, 0x380FFFFFC0000000746 %select = select i1 %is.oeq.largest.denormal, float %arg, float 0.0747 ret float %select748}749 750define float @clamp_fabs_olt_largest_denormal_0.0(float %arg) {751; CHECK-LABEL: define nofpclass(nzero) float @clamp_fabs_olt_largest_denormal_0.0(752; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {753; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]754; CHECK-NEXT: [[IS_FABS_OLT_LARGEST_DENORMAL:%.*]] = fcmp olt float [[FABS_ARG]], 0x380FFFFFC0000000755; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_FABS_OLT_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]]756; CHECK-NEXT: ret float [[SELECT]]757;758 %fabs.arg = call float @llvm.fabs.f32(float %arg)759 %is.fabs.olt.largest.denormal = fcmp olt float %fabs.arg, 0x380FFFFFC0000000760 %select = select i1 %is.fabs.olt.largest.denormal, float 0.0, float %arg761 ret float %select762}763 764define float @clamp_fabs_ole_largest_denormal_0.0(float %arg) {765; CHECK-LABEL: define nofpclass(nzero) float @clamp_fabs_ole_largest_denormal_0.0(766; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {767; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]768; CHECK-NEXT: [[IS_FABS_OLE_LARGEST_DENORMAL:%.*]] = fcmp ole float [[FABS_ARG]], 0x380FFFFFC0000000769; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_FABS_OLE_LARGEST_DENORMAL]], float 0.000000e+00, float [[ARG]]770; CHECK-NEXT: ret float [[SELECT]]771;772 %fabs.arg = call float @llvm.fabs.f32(float %arg)773 %is.fabs.ole.largest.denormal = fcmp ole float %fabs.arg, 0x380FFFFFC0000000774 %select = select i1 %is.fabs.ole.largest.denormal, float 0.0, float %arg775 ret float %select776}777 778;---------------------------------------------------------------------779; clamp fabs to 1 copysign780;---------------------------------------------------------------------781 782; can't be inf783define float @clamp_fabs_value_ogt_1_to_1_copysign(float %arg) {784; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_value_ogt_1_to_1_copysign(785; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {786; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]787; CHECK-NEXT: [[FABS_IS_OGT_1:%.*]] = fcmp ogt float [[FABS_ARG]], 1.000000e+00788; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float noundef 1.000000e+00, float [[ARG]]) #[[ATTR4]]789; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_OGT_1]], float [[COPYSIGN]], float [[ARG]]790; CHECK-NEXT: ret float [[SELECT]]791;792 %fabs.arg = call float @llvm.fabs.f32(float %arg)793 %fabs.is.ogt.1 = fcmp ogt float %fabs.arg, 1.0794 %copysign = call float @llvm.copysign.f32(float 1.0, float %arg)795 %select = select i1 %fabs.is.ogt.1, float %copysign, float %arg796 ret float %select797}798 799; can't be inf800define float @clamp_fabs_value_oge_1_to_1_copysign(float %arg) {801; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_value_oge_1_to_1_copysign(802; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {803; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]804; CHECK-NEXT: [[FABS_IS_OGE_1:%.*]] = fcmp oge float [[FABS_ARG]], 1.000000e+00805; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float noundef 1.000000e+00, float [[ARG]]) #[[ATTR4]]806; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_OGE_1]], float [[COPYSIGN]], float [[ARG]]807; CHECK-NEXT: ret float [[SELECT]]808;809 %fabs.arg = call float @llvm.fabs.f32(float %arg)810 %fabs.is.oge.1 = fcmp oge float %fabs.arg, 1.0811 %copysign = call float @llvm.copysign.f32(float 1.0, float %arg)812 %select = select i1 %fabs.is.oge.1, float %copysign, float %arg813 ret float %select814}815 816; can't be inf or nan817define float @clamp_fabs_value_olt_1_to_1_copysign(float %arg) {818; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_value_olt_1_to_1_copysign(819; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {820; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]821; CHECK-NEXT: [[FABS_IS_OLT_1:%.*]] = fcmp olt float [[FABS_ARG]], 1.000000e+00822; CHECK-NEXT: [[COPYSIGN:%.*]] = call nofpclass(nan inf zero sub) float @llvm.copysign.f32(float noundef 1.000000e+00, float [[ARG]]) #[[ATTR4]]823; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_OLT_1]], float [[ARG]], float [[COPYSIGN]]824; CHECK-NEXT: ret float [[SELECT]]825;826 %fabs.arg = call float @llvm.fabs.f32(float %arg)827 %fabs.is.olt.1 = fcmp olt float %fabs.arg, 1.0828 %copysign = call float @llvm.copysign.f32(float 1.0, float %arg)829 %select = select i1 %fabs.is.olt.1, float %arg, float %copysign830 ret float %select831}832 833; can't be inf or nan834define float @clamp_fabs_value_ole_1_to_1_copysign(float %arg) {835; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_value_ole_1_to_1_copysign(836; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {837; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]838; CHECK-NEXT: [[FABS_IS_OLE_1:%.*]] = fcmp ole float [[FABS_ARG]], 1.000000e+00839; CHECK-NEXT: [[COPYSIGN:%.*]] = call nofpclass(nan inf zero sub) float @llvm.copysign.f32(float noundef 1.000000e+00, float [[ARG]]) #[[ATTR4]]840; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_OLE_1]], float [[ARG]], float [[COPYSIGN]]841; CHECK-NEXT: ret float [[SELECT]]842;843 %fabs.arg = call float @llvm.fabs.f32(float %arg)844 %fabs.is.ole.1 = fcmp ole float %fabs.arg, 1.0845 %copysign = call float @llvm.copysign.f32(float 1.0, float %arg)846 %select = select i1 %fabs.is.ole.1, float %arg, float %copysign847 ret float %select848}849 850; can't be inf or nan851define float @clamp_fabs_value_ugt_1_to_1_copysign(float %arg) {852; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_value_ugt_1_to_1_copysign(853; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {854; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]855; CHECK-NEXT: [[FABS_IS_UGT_1:%.*]] = fcmp ugt float [[FABS_ARG]], 1.000000e+00856; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float noundef 1.000000e+00, float [[ARG]]) #[[ATTR4]]857; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_UGT_1]], float [[COPYSIGN]], float [[ARG]]858; CHECK-NEXT: ret float [[SELECT]]859;860 %fabs.arg = call float @llvm.fabs.f32(float %arg)861 %fabs.is.ugt.1 = fcmp ugt float %fabs.arg, 1.0862 %copysign = call float @llvm.copysign.f32(float 1.0, float %arg)863 %select = select i1 %fabs.is.ugt.1, float %copysign, float %arg864 ret float %select865}866 867; can't be inf or nan868define float @clamp_fabs_value_uge_1_to_1_copysign(float %arg) {869; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_value_uge_1_to_1_copysign(870; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {871; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]872; CHECK-NEXT: [[FABS_IS_UGE_1:%.*]] = fcmp ugt float [[FABS_ARG]], 1.000000e+00873; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float noundef 1.000000e+00, float [[ARG]]) #[[ATTR4]]874; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_UGE_1]], float [[COPYSIGN]], float [[ARG]]875; CHECK-NEXT: ret float [[SELECT]]876;877 %fabs.arg = call float @llvm.fabs.f32(float %arg)878 %fabs.is.uge.1 = fcmp ugt float %fabs.arg, 1.0879 %copysign = call float @llvm.copysign.f32(float 1.0, float %arg)880 %select = select i1 %fabs.is.uge.1, float %copysign, float %arg881 ret float %select882}883 884; can't be inf885define float @clamp_fabs_value_ult_1_to_1_copysign(float %arg) {886; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_value_ult_1_to_1_copysign(887; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {888; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]889; CHECK-NEXT: [[FABS_IS_ULT_1:%.*]] = fcmp ult float [[FABS_ARG]], 1.000000e+00890; CHECK-NEXT: [[COPYSIGN:%.*]] = call nofpclass(nan inf zero sub) float @llvm.copysign.f32(float noundef 1.000000e+00, float [[ARG]]) #[[ATTR4]]891; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_ULT_1]], float [[ARG]], float [[COPYSIGN]]892; CHECK-NEXT: ret float [[SELECT]]893;894 %fabs.arg = call float @llvm.fabs.f32(float %arg)895 %fabs.is.ult.1 = fcmp ult float %fabs.arg, 1.0896 %copysign = call float @llvm.copysign.f32(float 1.0, float %arg)897 %select = select i1 %fabs.is.ult.1, float %arg, float %copysign898 ret float %select899}900 901; can't be inf902define float @clamp_fabs_value_ule_1_to_1_copysign(float %arg) {903; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_value_ule_1_to_1_copysign(904; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {905; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]906; CHECK-NEXT: [[FABS_IS_ULE_1:%.*]] = fcmp ule float [[FABS_ARG]], 1.000000e+00907; CHECK-NEXT: [[COPYSIGN:%.*]] = call nofpclass(nan inf zero sub) float @llvm.copysign.f32(float noundef 1.000000e+00, float [[ARG]]) #[[ATTR4]]908; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_ULE_1]], float [[ARG]], float [[COPYSIGN]]909; CHECK-NEXT: ret float [[SELECT]]910;911 %fabs.arg = call float @llvm.fabs.f32(float %arg)912 %fabs.is.ule.1 = fcmp ule float %fabs.arg, 1.0913 %copysign = call float @llvm.copysign.f32(float 1.0, float %arg)914 %select = select i1 %fabs.is.ule.1, float %arg, float %copysign915 ret float %select916}917 918;---------------------------------------------------------------------919; compare to largest normal920;---------------------------------------------------------------------921 922; Can't be +inf923define float @clamp_is_ogt_largest_normal_to_largest_normal(float %arg) {924; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_ogt_largest_normal_to_largest_normal(925; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {926; CHECK-NEXT: [[IS_OGT_LARGEST_NORMAL:%.*]] = fcmp ogt float [[ARG]], 0x47EFFFFFE0000000927; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]]928; CHECK-NEXT: ret float [[SELECT]]929;930 %is.ogt.largest.normal = fcmp ogt float %arg, 0x47EFFFFFE0000000931 %select = select i1 %is.ogt.largest.normal, float 0x47EFFFFFE0000000, float %arg932 ret float %select933}934 935; Can't be +inf936define float @clamp_is_oge_largest_normal_to_largest_normal(float %arg) {937; CHECK-LABEL: define nofpclass(pinf) float @clamp_is_oge_largest_normal_to_largest_normal(938; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {939; CHECK-NEXT: [[IS_OGE_LARGEST_NORMAL:%.*]] = fcmp oge float [[ARG]], 0x47EFFFFFE0000000940; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]]941; CHECK-NEXT: ret float [[SELECT]]942;943 %is.oge.largest.normal = fcmp oge float %arg, 0x47EFFFFFE0000000944 %select = select i1 %is.oge.largest.normal, float 0x47EFFFFFE0000000, float %arg945 ret float %select946}947 948; Can't be +inf or nan949define float @clamp_is_ugt_largest_normal_to_largest_normal(float %arg) {950; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_ugt_largest_normal_to_largest_normal(951; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {952; CHECK-NEXT: [[IS_UGT_LARGEST_NORMAL:%.*]] = fcmp ugt float [[ARG]], 0x47EFFFFFE0000000953; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]]954; CHECK-NEXT: ret float [[SELECT]]955;956 %is.ugt.largest.normal = fcmp ugt float %arg, 0x47EFFFFFE0000000957 %select = select i1 %is.ugt.largest.normal, float 0x47EFFFFFE0000000, float %arg958 ret float %select959}960 961; Can't be +inf or nan962define float @clamp_is_uge_largest_normal_to_largest_normal(float %arg) {963; CHECK-LABEL: define nofpclass(nan pinf) float @clamp_is_uge_largest_normal_to_largest_normal(964; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {965; CHECK-NEXT: [[IS_UGE_LARGEST_NORMAL:%.*]] = fcmp uge float [[ARG]], 0x47EFFFFFE0000000966; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]]967; CHECK-NEXT: ret float [[SELECT]]968;969 %is.uge.largest.normal = fcmp uge float %arg, 0x47EFFFFFE0000000970 %select = select i1 %is.uge.largest.normal, float 0x47EFFFFFE0000000, float %arg971 ret float %select972}973 974; Can't be +inf or -inf975define float @clamp_fabs_is_ogt_largest_normal_to_largest_normal(float %arg) {976; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_is_ogt_largest_normal_to_largest_normal(977; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {978; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]979; CHECK-NEXT: [[IS_OGT_LARGEST_NORMAL:%.*]] = fcmp ogt float [[FABS_ARG]], 0x47EFFFFFE0000000980; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]]981; CHECK-NEXT: ret float [[SELECT]]982;983 %fabs.arg = call float @llvm.fabs.f32(float %arg)984 %is.ogt.largest.normal = fcmp ogt float %fabs.arg, 0x47EFFFFFE0000000985 %select = select i1 %is.ogt.largest.normal, float 0x47EFFFFFE0000000, float %arg986 ret float %select987}988 989; Can't be +inf or -inf990define float @clamp_fabs_is_oge_largest_normal_to_largest_normal(float %arg) {991; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_is_oge_largest_normal_to_largest_normal(992; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {993; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]994; CHECK-NEXT: [[IS_OGE_LARGEST_NORMAL:%.*]] = fcmp oge float [[FABS_ARG]], 0x47EFFFFFE0000000995; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]]996; CHECK-NEXT: ret float [[SELECT]]997;998 %fabs.arg = call float @llvm.fabs.f32(float %arg)999 %is.oge.largest.normal = fcmp oge float %fabs.arg, 0x47EFFFFFE00000001000 %select = select i1 %is.oge.largest.normal, float 0x47EFFFFFE0000000, float %arg1001 ret float %select1002}1003 1004; Can't be +inf or -inf or nan1005define float @clamp_fabs_is_ugt_largest_normal_to_largest_normal(float %arg) {1006; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_is_ugt_largest_normal_to_largest_normal(1007; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1008; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1009; CHECK-NEXT: [[IS_UGT_LARGEST_NORMAL:%.*]] = fcmp ugt float [[FABS_ARG]], 0x47EFFFFFE00000001010; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]]1011; CHECK-NEXT: ret float [[SELECT]]1012;1013 %fabs.arg = call float @llvm.fabs.f32(float %arg)1014 %is.ugt.largest.normal = fcmp ugt float %fabs.arg, 0x47EFFFFFE00000001015 %select = select i1 %is.ugt.largest.normal, float 0x47EFFFFFE0000000, float %arg1016 ret float %select1017}1018 1019; Can't be +inf or -inf or nan1020define float @clamp_fabs_is_uge_largest_normal_to_largest_normal(float %arg) {1021; CHECK-LABEL: define nofpclass(nan inf) float @clamp_fabs_is_uge_largest_normal_to_largest_normal(1022; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1023; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1024; CHECK-NEXT: [[IS_UGT_LARGEST_NORMAL:%.*]] = fcmp uge float [[FABS_ARG]], 0x47EFFFFFE00000001025; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_LARGEST_NORMAL]], float 0x47EFFFFFE0000000, float [[ARG]]1026; CHECK-NEXT: ret float [[SELECT]]1027;1028 %fabs.arg = call float @llvm.fabs.f32(float %arg)1029 %is.ugt.largest.normal = fcmp uge float %fabs.arg, 0x47EFFFFFE00000001030 %select = select i1 %is.ugt.largest.normal, float 0x47EFFFFFE0000000, float %arg1031 ret float %select1032}1033 1034;---------------------------------------------------------------------1035; compare to smallest normal1036;---------------------------------------------------------------------1037 1038; can't be negative or positive subnormal1039define float @clamp_fabs_ogt_smallest_normal_to_zero(float %arg) {1040; CHECK-LABEL: define nofpclass(inf) float @clamp_fabs_ogt_smallest_normal_to_zero(1041; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1042; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1043; CHECK-NEXT: [[IS_OGT_SMALLEST_NORMAL:%.*]] = fcmp ogt float [[FABS_ARG]], 0x38100000000000001044; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]1045; CHECK-NEXT: ret float [[SELECT]]1046;1047 1048 %fabs.arg = call float @llvm.fabs.f32(float %arg)1049 %is.ogt.smallest.normal = fcmp ogt float %fabs.arg, 0x38100000000000001050 %select = select i1 %is.ogt.smallest.normal, float 0.0, float %arg1051 ret float %select1052}1053 1054; can't be negative or positive subnormal1055define float @clamp_fabs_oge_smallest_normal_to_zero(float %arg) {1056; CHECK-LABEL: define nofpclass(inf norm) float @clamp_fabs_oge_smallest_normal_to_zero(1057; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1058; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1059; CHECK-NEXT: [[IS_OGE_SMALLEST_NORMAL:%.*]] = fcmp oge float [[FABS_ARG]], 0x38100000000000001060; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]1061; CHECK-NEXT: ret float [[SELECT]]1062;1063 %fabs.arg = call float @llvm.fabs.f32(float %arg)1064 %is.oge.smallest.normal = fcmp oge float %fabs.arg, 0x38100000000000001065 %select = select i1 %is.oge.smallest.normal, float 0.0, float %arg1066 ret float %select1067}1068 1069; can't be negative or subnormal1070define float @clamp_fabs_olt_smallest_normal_to_zero(float %arg) {1071; CHECK-LABEL: define nofpclass(nzero sub) float @clamp_fabs_olt_smallest_normal_to_zero(1072; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1073; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1074; CHECK-NEXT: [[IS_OLT_SMALLEST_NORMAL:%.*]] = fcmp olt float [[FABS_ARG]], 0x38100000000000001075; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]1076; CHECK-NEXT: ret float [[SELECT]]1077;1078 %fabs.arg = call float @llvm.fabs.f32(float %arg)1079 %is.olt.smallest.normal = fcmp olt float %fabs.arg, 0x38100000000000001080 %select = select i1 %is.olt.smallest.normal, float 0.0, float %arg1081 ret float %select1082}1083 1084; can't be negative or subnormal1085define float @clamp_fabs_ole_smallest_normal_to_zero(float %arg) {1086; CHECK-LABEL: define nofpclass(nzero sub) float @clamp_fabs_ole_smallest_normal_to_zero(1087; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1088; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1089; CHECK-NEXT: [[IS_OLE_SMALLEST_NORMAL:%.*]] = fcmp ole float [[FABS_ARG]], 0x38100000000000001090; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]1091; CHECK-NEXT: ret float [[SELECT]]1092;1093 %fabs.arg = call float @llvm.fabs.f32(float %arg)1094 %is.ole.smallest.normal = fcmp ole float %fabs.arg, 0x38100000000000001095 %select = select i1 %is.ole.smallest.normal, float 0.0, float %arg1096 ret float %select1097}1098 1099define float @clamp_fabs_is_is_olt_smallest_normal_to_0(float %arg) {1100; CHECK-LABEL: define nofpclass(nzero sub) float @clamp_fabs_is_is_olt_smallest_normal_to_0(1101; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1102; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1103; CHECK-NEXT: [[IS_OLT_SMALLEST_NORMAL:%.*]] = fcmp olt float [[FABS_ARG]], 0x38100000000000001104; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_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.olt.smallest.normal = fcmp olt float %fabs.arg, 0x38100000000000001109 %select = select i1 %is.olt.smallest.normal, float 0.0, float %arg1110 ret float %select1111}1112 1113define float @clamp_fabs_is_is_ole_smallest_normal_to_0(float %arg) {1114; CHECK-LABEL: define nofpclass(nzero sub) float @clamp_fabs_is_is_ole_smallest_normal_to_0(1115; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1116; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1117; CHECK-NEXT: [[IS_OLE_SMALLEST_NORMAL:%.*]] = fcmp ole float [[FABS_ARG]], 0x38100000000000001118; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_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.ole.smallest.normal = fcmp ole float %fabs.arg, 0x38100000000000001123 %select = select i1 %is.ole.smallest.normal, float 0.0, float %arg1124 ret float %select1125}1126 1127define float @clamp_fabs_oeq_smallest_normal_to_zero(float %arg) {1128; CHECK-LABEL: define float @clamp_fabs_oeq_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_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[FABS_ARG]], 0x38100000000000001132; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OEQ_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.oeq.smallest.normal = fcmp oeq float %fabs.arg, 0x38100000000000001137 %select = select i1 %is.oeq.smallest.normal, float 0.0, float %arg1138 ret float %select1139}1140 1141define float @clamp_fabs_one_smallest_normal_to_zero(float %arg) {1142; CHECK-LABEL: define nofpclass(inf nzero sub) float @clamp_fabs_one_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_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[FABS_ARG]], 0x38100000000000001146; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ONE_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.one.smallest.normal = fcmp one float %fabs.arg, 0x38100000000000001151 %select = select i1 %is.one.smallest.normal, float 0.0, float %arg1152 ret float %select1153}1154 1155define float @clamp_fabs_ueq_smallest_normal_to_zero(float %arg) {1156; CHECK-LABEL: define nofpclass(nan) float @clamp_fabs_ueq_smallest_normal_to_zero(1157; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1158; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1159; CHECK-NEXT: [[IS_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[FABS_ARG]], 0x38100000000000001160; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UEQ_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]1161; CHECK-NEXT: ret float [[SELECT]]1162;1163 %fabs.arg = call float @llvm.fabs.f32(float %arg)1164 %is.ueq.smallest.normal = fcmp ueq float %fabs.arg, 0x38100000000000001165 %select = select i1 %is.ueq.smallest.normal, float 0.0, float %arg1166 ret float %select1167}1168 1169define float @clamp_fabs_une_smallest_normal_to_zero(float %arg) {1170; CHECK-LABEL: define nofpclass(nan inf nzero sub) float @clamp_fabs_une_smallest_normal_to_zero(1171; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1172; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1173; CHECK-NEXT: [[IS_UNE_SMALLEST_NORMAL:%.*]] = fcmp une float [[FABS_ARG]], 0x38100000000000001174; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UNE_SMALLEST_NORMAL]], float 0.000000e+00, float [[ARG]]1175; CHECK-NEXT: ret float [[SELECT]]1176;1177 %fabs.arg = call float @llvm.fabs.f32(float %arg)1178 %is.une.smallest.normal = fcmp une float %fabs.arg, 0x38100000000000001179 %select = select i1 %is.une.smallest.normal, float 0.0, float %arg1180 ret float %select1181}1182 1183;---------------------------------------------------------------------1184; compare fabs to negative normal1185;---------------------------------------------------------------------1186 1187define float @clamp_fabs_olt_neg1_to_neg1(float %arg) {1188; CHECK-LABEL: define float @clamp_fabs_olt_neg1_to_neg1(1189; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {1190; CHECK-NEXT: ret float [[ARG]]1191;1192 %fabs.arg = call float @llvm.fabs.f32(float %arg)1193 %fabs.is.olt.neg1 = fcmp olt float %fabs.arg, -1.01194 %select = select i1 %fabs.is.olt.neg1, float -1.0, float %arg1195 ret float %select1196}1197 1198define float @clamp_fabs_ole_neg1_to_neg1(float %arg) {1199; CHECK-LABEL: define float @clamp_fabs_ole_neg1_to_neg1(1200; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {1201; CHECK-NEXT: ret float [[ARG]]1202;1203 %fabs.arg = call float @llvm.fabs.f32(float %arg)1204 %fabs.is.ole.neg1 = fcmp ole float %fabs.arg, -1.01205 %select = select i1 %fabs.is.ole.neg1, float -1.0, float %arg1206 ret float %select1207}1208 1209define float @clamp_fabs_ult_neg1_to_neg1(float %arg) {1210; CHECK-LABEL: define nofpclass(nan) float @clamp_fabs_ult_neg1_to_neg1(1211; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1212; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1213; CHECK-NEXT: [[FABS_IS_ULT_NEG1:%.*]] = fcmp ult float [[FABS_ARG]], -1.000000e+001214; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_ULT_NEG1]], float -1.000000e+00, float [[ARG]]1215; CHECK-NEXT: ret float [[SELECT]]1216;1217 %fabs.arg = call float @llvm.fabs.f32(float %arg)1218 %fabs.is.ult.neg1 = fcmp ult float %fabs.arg, -1.01219 %select = select i1 %fabs.is.ult.neg1, float -1.0, float %arg1220 ret float %select1221}1222 1223define float @clamp_fabs_ule_neg1_to_neg1(float %arg) {1224; CHECK-LABEL: define nofpclass(nan) float @clamp_fabs_ule_neg1_to_neg1(1225; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1226; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1227; CHECK-NEXT: [[FABS_IS_ULE_NEG1:%.*]] = fcmp ule float [[FABS_ARG]], -1.000000e+001228; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_ULE_NEG1]], float -1.000000e+00, float [[ARG]]1229; CHECK-NEXT: ret float [[SELECT]]1230;1231 %fabs.arg = call float @llvm.fabs.f32(float %arg)1232 %fabs.is.ule.neg1 = fcmp ule float %fabs.arg, -1.01233 %select = select i1 %fabs.is.ule.neg1, float -1.0, float %arg1234 ret float %select1235}1236 1237define float @clamp_fabs_ogt_neg1_to_neg1(float %arg) {1238; CHECK-LABEL: define nofpclass(inf zero sub pnorm) float @clamp_fabs_ogt_neg1_to_neg1(1239; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1240; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1241; CHECK-NEXT: [[FABS_IS_OGT_NEG1:%.*]] = fcmp ogt float [[FABS_ARG]], -1.000000e+001242; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_OGT_NEG1]], float -1.000000e+00, float [[ARG]]1243; CHECK-NEXT: ret float [[SELECT]]1244;1245 %fabs.arg = call float @llvm.fabs.f32(float %arg)1246 %fabs.is.ogt.neg1 = fcmp ogt float %fabs.arg, -1.01247 %select = select i1 %fabs.is.ogt.neg1, float -1.0, float %arg1248 ret float %select1249}1250 1251define float @clamp_fabs_oge_neg1_to_neg1(float %arg) {1252; CHECK-LABEL: define nofpclass(inf zero sub pnorm) float @clamp_fabs_oge_neg1_to_neg1(1253; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1254; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1255; CHECK-NEXT: [[FABS_IS_OGE_NEG1:%.*]] = fcmp oge float [[FABS_ARG]], -1.000000e+001256; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_OGE_NEG1]], float -1.000000e+00, float [[ARG]]1257; CHECK-NEXT: ret float [[SELECT]]1258;1259 %fabs.arg = call float @llvm.fabs.f32(float %arg)1260 %fabs.is.oge.neg1 = fcmp oge float %fabs.arg, -1.01261 %select = select i1 %fabs.is.oge.neg1, float -1.0, float %arg1262 ret float %select1263}1264 1265define float @clamp_fabs_ugt_neg1_to_neg1(float %arg) {1266; CHECK-LABEL: define noundef nofpclass(nan inf zero sub pnorm) float @clamp_fabs_ugt_neg1_to_neg1(1267; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1268; CHECK-NEXT: ret float -1.000000e+001269;1270 %fabs.arg = call float @llvm.fabs.f32(float %arg)1271 %fabs.is.ugt.neg1 = fcmp ugt float %fabs.arg, -1.01272 %select = select i1 %fabs.is.ugt.neg1, float -1.0, float %arg1273 ret float %select1274}1275 1276define float @clamp_fabs_uge_neg1_to_neg1(float %arg) {1277; CHECK-LABEL: define noundef nofpclass(nan inf zero sub pnorm) float @clamp_fabs_uge_neg1_to_neg1(1278; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1279; CHECK-NEXT: ret float -1.000000e+001280;1281 %fabs.arg = call float @llvm.fabs.f32(float %arg)1282 %fabs.is.uge.neg1 = fcmp uge float %fabs.arg, -1.01283 %select = select i1 %fabs.is.uge.neg1, float -1.0, float %arg1284 ret float %select1285}1286 1287define float @clamp_fabs_oeq_neg1_to_neg1(float %arg) {1288; CHECK-LABEL: define float @clamp_fabs_oeq_neg1_to_neg1(1289; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {1290; CHECK-NEXT: ret float [[ARG]]1291;1292 %fabs.arg = call float @llvm.fabs.f32(float %arg)1293 %fabs.is.oeq.neg1 = fcmp oeq float %fabs.arg, -1.01294 %select = select i1 %fabs.is.oeq.neg1, float -1.0, float %arg1295 ret float %select1296}1297 1298define float @clamp_fabs_ueq_neg1_to_neg1(float %arg) {1299; CHECK-LABEL: define nofpclass(nan) float @clamp_fabs_ueq_neg1_to_neg1(1300; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1301; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1302; CHECK-NEXT: [[FABS_IS_UEQ_NEG1:%.*]] = fcmp ueq float [[FABS_ARG]], -1.000000e+001303; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_UEQ_NEG1]], float -1.000000e+00, float [[ARG]]1304; CHECK-NEXT: ret float [[SELECT]]1305;1306 %fabs.arg = call float @llvm.fabs.f32(float %arg)1307 %fabs.is.ueq.neg1 = fcmp ueq float %fabs.arg, -1.01308 %select = select i1 %fabs.is.ueq.neg1, float -1.0, float %arg1309 ret float %select1310}1311 1312define float @clamp_fabs_one_neg1_to_neg1(float %arg) {1313; CHECK-LABEL: define nofpclass(inf zero sub pnorm) float @clamp_fabs_one_neg1_to_neg1(1314; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1315; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1316; CHECK-NEXT: [[FABS_IS_ONE_NEG1:%.*]] = fcmp one float [[FABS_ARG]], -1.000000e+001317; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[FABS_IS_ONE_NEG1]], float -1.000000e+00, float [[ARG]]1318; CHECK-NEXT: ret float [[SELECT]]1319;1320 %fabs.arg = call float @llvm.fabs.f32(float %arg)1321 %fabs.is.one.neg1 = fcmp one float %fabs.arg, -1.01322 %select = select i1 %fabs.is.one.neg1, float -1.0, float %arg1323 ret float %select1324}1325 1326define float @clamp_fabs_une_neg1_to_neg1(float %arg) {1327; CHECK-LABEL: define noundef nofpclass(nan inf zero sub pnorm) float @clamp_fabs_une_neg1_to_neg1(1328; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {1329; CHECK-NEXT: ret float -1.000000e+001330;1331 %fabs.arg = call float @llvm.fabs.f32(float %arg)1332 %fabs.is.une.neg1 = fcmp une float %fabs.arg, -1.01333 %select = select i1 %fabs.is.une.neg1, float -1.0, float %arg1334 ret float %select1335}1336 1337;---------------------------------------------------------------------1338; assume > < to normal1339;---------------------------------------------------------------------1340 1341define float @ret_assumed_ogt_1(float %arg) {1342; CHECK-LABEL: define float @ret_assumed_ogt_1(1343; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3:[0-9]+]] {1344; CHECK-NEXT: [[OGT_1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+001345; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGT_1]]) #[[ATTR5:[0-9]+]]1346; CHECK-NEXT: ret float [[ARG]]1347;1348 %ogt.1 = fcmp ogt float %arg, 1.01349 call void @llvm.assume(i1 %ogt.1)1350 ret float %arg1351}1352 1353define float @ret_assumed_oge_1(float %arg) {1354; CHECK-LABEL: define float @ret_assumed_oge_1(1355; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1356; CHECK-NEXT: [[OGE_1:%.*]] = fcmp ogt float [[ARG]], 1.000000e+001357; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGE_1]]) #[[ATTR5]]1358; CHECK-NEXT: ret float [[ARG]]1359;1360 %oge.1 = fcmp ogt float %arg, 1.01361 call void @llvm.assume(i1 %oge.1)1362 ret float %arg1363}1364 1365define float @ret_assumed_olt_1(float %arg) {1366; CHECK-LABEL: define float @ret_assumed_olt_1(1367; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1368; CHECK-NEXT: [[OLT_1:%.*]] = fcmp olt float [[ARG]], 1.000000e+001369; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLT_1]]) #[[ATTR5]]1370; CHECK-NEXT: ret float [[ARG]]1371;1372 %olt.1 = fcmp olt float %arg, 1.01373 call void @llvm.assume(i1 %olt.1)1374 ret float %arg1375}1376 1377define float @ret_assumed_ole_1(float %arg) {1378; CHECK-LABEL: define float @ret_assumed_ole_1(1379; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1380; CHECK-NEXT: [[OLE_1:%.*]] = fcmp ole float [[ARG]], 1.000000e+001381; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLE_1]]) #[[ATTR5]]1382; CHECK-NEXT: ret float [[ARG]]1383;1384 %ole.1 = fcmp ole float %arg, 1.01385 call void @llvm.assume(i1 %ole.1)1386 ret float %arg1387}1388 1389define float @ret_assumed_ugt_1(float %arg) {1390; CHECK-LABEL: define float @ret_assumed_ugt_1(1391; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1392; CHECK-NEXT: [[UGT_1:%.*]] = fcmp ugt float [[ARG]], 1.000000e+001393; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGT_1]]) #[[ATTR5]]1394; CHECK-NEXT: ret float [[ARG]]1395;1396 %ugt.1 = fcmp ugt float %arg, 1.01397 call void @llvm.assume(i1 %ugt.1)1398 ret float %arg1399}1400 1401define float @ret_assumed_uge_1(float %arg) {1402; CHECK-LABEL: define float @ret_assumed_uge_1(1403; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1404; CHECK-NEXT: [[UGE_1:%.*]] = fcmp uge float [[ARG]], 1.000000e+001405; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGE_1]]) #[[ATTR5]]1406; CHECK-NEXT: ret float [[ARG]]1407;1408 %uge.1 = fcmp uge float %arg, 1.01409 call void @llvm.assume(i1 %uge.1)1410 ret float %arg1411}1412 1413define float @ret_assumed_ult_1(float %arg) {1414; CHECK-LABEL: define float @ret_assumed_ult_1(1415; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1416; CHECK-NEXT: [[ULT_1:%.*]] = fcmp ult float [[ARG]], 1.000000e+001417; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULT_1]]) #[[ATTR5]]1418; CHECK-NEXT: ret float [[ARG]]1419;1420 %ult.1 = fcmp ult float %arg, 1.01421 call void @llvm.assume(i1 %ult.1)1422 ret float %arg1423}1424 1425define float @ret_assumed_ule_1(float %arg) {1426; CHECK-LABEL: define float @ret_assumed_ule_1(1427; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1428; CHECK-NEXT: [[ULE_1:%.*]] = fcmp ule float [[ARG]], 1.000000e+001429; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULE_1]]) #[[ATTR5]]1430; CHECK-NEXT: ret float [[ARG]]1431;1432 %ule.1 = fcmp ule float %arg, 1.01433 call void @llvm.assume(i1 %ule.1)1434 ret float %arg1435}1436 1437define float @ret_assumed_fabs_ogt_1(float %arg) {1438; CHECK-LABEL: define float @ret_assumed_fabs_ogt_1(1439; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1440; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1441; CHECK-NEXT: [[OGT_1:%.*]] = fcmp ogt float [[ARG_FABS]], 1.000000e+001442; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGT_1]]) #[[ATTR5]]1443; CHECK-NEXT: ret float [[ARG]]1444;1445 %arg.fabs = call float @llvm.fabs.f32(float %arg)1446 %ogt.1 = fcmp ogt float %arg.fabs, 1.01447 call void @llvm.assume(i1 %ogt.1)1448 ret float %arg1449}1450 1451define float @ret_assumed_fabs_oge_1(float %arg) {1452; CHECK-LABEL: define float @ret_assumed_fabs_oge_1(1453; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1454; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1455; CHECK-NEXT: [[OGE_1:%.*]] = fcmp oge float [[ARG_FABS]], 1.000000e+001456; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGE_1]]) #[[ATTR5]]1457; CHECK-NEXT: ret float [[ARG]]1458;1459 %arg.fabs = call float @llvm.fabs.f32(float %arg)1460 %oge.1 = fcmp oge float %arg.fabs, 1.01461 call void @llvm.assume(i1 %oge.1)1462 ret float %arg1463}1464 1465define float @ret_assumed_fabs_olt_1(float %arg) {1466; CHECK-LABEL: define float @ret_assumed_fabs_olt_1(1467; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1468; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1469; CHECK-NEXT: [[OLT_1:%.*]] = fcmp olt float [[ARG_FABS]], 1.000000e+001470; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLT_1]]) #[[ATTR5]]1471; CHECK-NEXT: ret float [[ARG]]1472;1473 %arg.fabs = call float @llvm.fabs.f32(float %arg)1474 %olt.1 = fcmp olt float %arg.fabs, 1.01475 call void @llvm.assume(i1 %olt.1)1476 ret float %arg1477}1478 1479define float @ret_assumed_fabs_ole_1(float %arg) {1480; CHECK-LABEL: define float @ret_assumed_fabs_ole_1(1481; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1482; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1483; CHECK-NEXT: [[OLE_1:%.*]] = fcmp olt float [[ARG_FABS]], 1.000000e+001484; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLE_1]]) #[[ATTR5]]1485; CHECK-NEXT: ret float [[ARG]]1486;1487 %arg.fabs = call float @llvm.fabs.f32(float %arg)1488 %ole.1 = fcmp olt float %arg.fabs, 1.01489 call void @llvm.assume(i1 %ole.1)1490 ret float %arg1491}1492 1493define float @ret_assumed_fabs_ugt_1(float %arg) {1494; CHECK-LABEL: define float @ret_assumed_fabs_ugt_1(1495; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1496; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1497; CHECK-NEXT: [[UGT_1:%.*]] = fcmp ugt float [[ARG_FABS]], 1.000000e+001498; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGT_1]]) #[[ATTR5]]1499; CHECK-NEXT: ret float [[ARG]]1500;1501 %arg.fabs = call float @llvm.fabs.f32(float %arg)1502 %ugt.1 = fcmp ugt float %arg.fabs, 1.01503 call void @llvm.assume(i1 %ugt.1)1504 ret float %arg1505}1506 1507define float @ret_assumed_fabs_uge_1(float %arg) {1508; CHECK-LABEL: define float @ret_assumed_fabs_uge_1(1509; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1510; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1511; CHECK-NEXT: [[UGE_1:%.*]] = fcmp ugt float [[ARG_FABS]], 1.000000e+001512; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGE_1]]) #[[ATTR5]]1513; CHECK-NEXT: ret float [[ARG]]1514;1515 %arg.fabs = call float @llvm.fabs.f32(float %arg)1516 %uge.1 = fcmp ugt float %arg.fabs, 1.01517 call void @llvm.assume(i1 %uge.1)1518 ret float %arg1519}1520 1521define float @ret_assumed_fabs_ult_1(float %arg) {1522; CHECK-LABEL: define float @ret_assumed_fabs_ult_1(1523; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1524; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1525; CHECK-NEXT: [[ULT_1:%.*]] = fcmp ult float [[ARG_FABS]], 1.000000e+001526; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULT_1]]) #[[ATTR5]]1527; CHECK-NEXT: ret float [[ARG]]1528;1529 %arg.fabs = call float @llvm.fabs.f32(float %arg)1530 %ult.1 = fcmp ult float %arg.fabs, 1.01531 call void @llvm.assume(i1 %ult.1)1532 ret float %arg1533}1534 1535define float @ret_assumed_fabs_ule_1(float %arg) {1536; CHECK-LABEL: define float @ret_assumed_fabs_ule_1(1537; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1538; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1539; CHECK-NEXT: [[ULE_1:%.*]] = fcmp ule float [[ARG_FABS]], 1.000000e+001540; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULE_1]]) #[[ATTR5]]1541; CHECK-NEXT: ret float [[ARG]]1542;1543 %arg.fabs = call float @llvm.fabs.f32(float %arg)1544 %ule.1 = fcmp ule float %arg.fabs, 1.01545 call void @llvm.assume(i1 %ule.1)1546 ret float %arg1547}1548 1549define float @ret_assumed_ogt_neg1(float %arg) {1550; CHECK-LABEL: define float @ret_assumed_ogt_neg1(1551; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1552; CHECK-NEXT: [[OGT_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+001553; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGT_NEG1]]) #[[ATTR5]]1554; CHECK-NEXT: ret float [[ARG]]1555;1556 %ogt.neg1 = fcmp ogt float %arg, -1.01557 call void @llvm.assume(i1 %ogt.neg1)1558 ret float %arg1559}1560 1561define float @ret_assumed_oge_neg1(float %arg) {1562; CHECK-LABEL: define float @ret_assumed_oge_neg1(1563; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1564; CHECK-NEXT: [[OGE_NEG1:%.*]] = fcmp ogt float [[ARG]], -1.000000e+001565; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGE_NEG1]]) #[[ATTR5]]1566; CHECK-NEXT: ret float [[ARG]]1567;1568 %oge.neg1 = fcmp ogt float %arg, -1.01569 call void @llvm.assume(i1 %oge.neg1)1570 ret float %arg1571}1572 1573define float @ret_assumed_olt_neg1(float %arg) {1574; CHECK-LABEL: define float @ret_assumed_olt_neg1(1575; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1576; CHECK-NEXT: [[OLT_NEG1:%.*]] = fcmp olt float [[ARG]], -1.000000e+001577; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLT_NEG1]]) #[[ATTR5]]1578; CHECK-NEXT: ret float [[ARG]]1579;1580 %olt.neg1 = fcmp olt float %arg, -1.01581 call void @llvm.assume(i1 %olt.neg1)1582 ret float %arg1583}1584 1585define float @ret_assumed_ole_neg1(float %arg) {1586; CHECK-LABEL: define float @ret_assumed_ole_neg1(1587; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1588; CHECK-NEXT: [[OLE_NEG1:%.*]] = fcmp ole float [[ARG]], -1.000000e+001589; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLE_NEG1]]) #[[ATTR5]]1590; CHECK-NEXT: ret float [[ARG]]1591;1592 %ole.neg1 = fcmp ole float %arg, -1.01593 call void @llvm.assume(i1 %ole.neg1)1594 ret float %arg1595}1596 1597define float @ret_assumed_ugt_neg1(float %arg) {1598; CHECK-LABEL: define float @ret_assumed_ugt_neg1(1599; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1600; CHECK-NEXT: [[UGT_NEG1:%.*]] = fcmp ugt float [[ARG]], -1.000000e+001601; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGT_NEG1]]) #[[ATTR5]]1602; CHECK-NEXT: ret float [[ARG]]1603;1604 %ugt.neg1 = fcmp ugt float %arg, -1.01605 call void @llvm.assume(i1 %ugt.neg1)1606 ret float %arg1607}1608 1609define float @ret_assumed_uge_neg1(float %arg) {1610; CHECK-LABEL: define float @ret_assumed_uge_neg1(1611; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1612; CHECK-NEXT: [[UGE_NEG1:%.*]] = fcmp uge float [[ARG]], -1.000000e+001613; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGE_NEG1]]) #[[ATTR5]]1614; CHECK-NEXT: ret float [[ARG]]1615;1616 %uge.neg1 = fcmp uge float %arg, -1.01617 call void @llvm.assume(i1 %uge.neg1)1618 ret float %arg1619}1620 1621define float @ret_assumed_ult_neg1(float %arg) {1622; CHECK-LABEL: define float @ret_assumed_ult_neg1(1623; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1624; CHECK-NEXT: [[ULT_NEG1:%.*]] = fcmp ult float [[ARG]], -1.000000e+001625; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULT_NEG1]]) #[[ATTR5]]1626; CHECK-NEXT: ret float [[ARG]]1627;1628 %ult.neg1 = fcmp ult float %arg, -1.01629 call void @llvm.assume(i1 %ult.neg1)1630 ret float %arg1631}1632 1633define float @ret_assumed_ule_neg1(float %arg) {1634; CHECK-LABEL: define float @ret_assumed_ule_neg1(1635; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1636; CHECK-NEXT: [[ULE_NEG1:%.*]] = fcmp ule float [[ARG]], -1.000000e+001637; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULE_NEG1]]) #[[ATTR5]]1638; CHECK-NEXT: ret float [[ARG]]1639;1640 %ule.neg1 = fcmp ule float %arg, -1.01641 call void @llvm.assume(i1 %ule.neg1)1642 ret float %arg1643}1644 1645define float @ret_assumed_oeq_1(float %arg) {1646; CHECK-LABEL: define float @ret_assumed_oeq_1(1647; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1648; CHECK-NEXT: [[OEQ_1:%.*]] = fcmp oeq float [[ARG]], 1.000000e+001649; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OEQ_1]]) #[[ATTR5]]1650; CHECK-NEXT: ret float [[ARG]]1651;1652 %oeq.1 = fcmp oeq float %arg, 1.01653 call void @llvm.assume(i1 %oeq.1)1654 ret float %arg1655}1656 1657define float @ret_assumed_ueq_1(float %arg) {1658; CHECK-LABEL: define float @ret_assumed_ueq_1(1659; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1660; CHECK-NEXT: [[UEQ_1:%.*]] = fcmp ueq float [[ARG]], 1.000000e+001661; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UEQ_1]]) #[[ATTR5]]1662; CHECK-NEXT: ret float [[ARG]]1663;1664 %ueq.1 = fcmp ueq float %arg, 1.01665 call void @llvm.assume(i1 %ueq.1)1666 ret float %arg1667}1668 1669define float @ret_assumed_one_1(float %arg) {1670; CHECK-LABEL: define float @ret_assumed_one_1(1671; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1672; CHECK-NEXT: [[ONE_1:%.*]] = fcmp one float [[ARG]], 1.000000e+001673; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ONE_1]]) #[[ATTR5]]1674; CHECK-NEXT: ret float [[ARG]]1675;1676 %one.1 = fcmp one float %arg, 1.01677 call void @llvm.assume(i1 %one.1)1678 ret float %arg1679}1680 1681define float @ret_assumed_one_neg1(float %arg) {1682; CHECK-LABEL: define float @ret_assumed_one_neg1(1683; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1684; CHECK-NEXT: [[ONE_NEG1:%.*]] = fcmp one float [[ARG]], -1.000000e+001685; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ONE_NEG1]]) #[[ATTR5]]1686; CHECK-NEXT: ret float [[ARG]]1687;1688 %one.neg1 = fcmp one float %arg, -1.01689 call void @llvm.assume(i1 %one.neg1)1690 ret float %arg1691}1692 1693define float @ret_assumed_une_neg1(float %arg) {1694; CHECK-LABEL: define float @ret_assumed_une_neg1(1695; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1696; CHECK-NEXT: [[UNE_NEG1:%.*]] = fcmp une float [[ARG]], -1.000000e+001697; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UNE_NEG1]]) #[[ATTR5]]1698; CHECK-NEXT: ret float [[ARG]]1699;1700 %une.neg1 = fcmp une float %arg, -1.01701 call void @llvm.assume(i1 %une.neg1)1702 ret float %arg1703}1704 1705define float @ret_assumed_une_1(float %arg) {1706; CHECK-LABEL: define float @ret_assumed_une_1(1707; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1708; CHECK-NEXT: [[UNE_1:%.*]] = fcmp une float [[ARG]], 1.000000e+001709; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UNE_1]]) #[[ATTR5]]1710; CHECK-NEXT: ret float [[ARG]]1711;1712 %une.1 = fcmp une float %arg, 1.01713 call void @llvm.assume(i1 %une.1)1714 ret float %arg1715}1716 1717define float @ret_assumed_fabs_oeq_1(float %arg) {1718; CHECK-LABEL: define float @ret_assumed_fabs_oeq_1(1719; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1720; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1721; CHECK-NEXT: [[OEQ_1:%.*]] = fcmp oeq float [[ARG_FABS]], 1.000000e+001722; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OEQ_1]]) #[[ATTR5]]1723; CHECK-NEXT: ret float [[ARG]]1724;1725 %arg.fabs = call float @llvm.fabs.f32(float %arg)1726 %oeq.1 = fcmp oeq float %arg.fabs, 1.01727 call void @llvm.assume(i1 %oeq.1)1728 ret float %arg1729}1730 1731define float @ret_assumed_fabs_ueq_1(float %arg) {1732; CHECK-LABEL: define float @ret_assumed_fabs_ueq_1(1733; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1734; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1735; CHECK-NEXT: [[UEQ_1:%.*]] = fcmp ueq float [[ARG_FABS]], 1.000000e+001736; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UEQ_1]]) #[[ATTR5]]1737; CHECK-NEXT: ret float [[ARG]]1738;1739 %arg.fabs = call float @llvm.fabs.f32(float %arg)1740 %ueq.1 = fcmp ueq float %arg.fabs, 1.01741 call void @llvm.assume(i1 %ueq.1)1742 ret float %arg1743}1744 1745define float @ret_assumed_fabs_one_1(float %arg) {1746; CHECK-LABEL: define float @ret_assumed_fabs_one_1(1747; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1748; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1749; CHECK-NEXT: [[ONE_1:%.*]] = fcmp one float [[ARG_FABS]], 1.000000e+001750; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ONE_1]]) #[[ATTR5]]1751; CHECK-NEXT: ret float [[ARG]]1752;1753 %arg.fabs = call float @llvm.fabs.f32(float %arg)1754 %one.1 = fcmp one float %arg.fabs, 1.01755 call void @llvm.assume(i1 %one.1)1756 ret float %arg1757}1758 1759define float @ret_assumed_fabs_une_1(float %arg) {1760; CHECK-LABEL: define float @ret_assumed_fabs_une_1(1761; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1762; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1763; CHECK-NEXT: [[UNE_1:%.*]] = fcmp one float [[ARG_FABS]], 1.000000e+001764; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UNE_1]]) #[[ATTR5]]1765; CHECK-NEXT: ret float [[ARG]]1766;1767 %arg.fabs = call float @llvm.fabs.f32(float %arg)1768 %une.1 = fcmp one float %arg.fabs, 1.01769 call void @llvm.assume(i1 %une.1)1770 ret float %arg1771}1772 1773define float @ret_assumed_fabs_oeq_neg1(float %arg) {1774; CHECK-LABEL: define float @ret_assumed_fabs_oeq_neg1(1775; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1776; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]1777; CHECK-NEXT: ret float [[ARG]]1778;1779 %arg.fabs = call float @llvm.fabs.f32(float %arg)1780 %oeq.neg1 = fcmp oeq float %arg.fabs, -1.01781 call void @llvm.assume(i1 %oeq.neg1)1782 ret float %arg1783}1784 1785define float @ret_assumed_fabs_ueq_neg1(float %arg) {1786; CHECK-LABEL: define float @ret_assumed_fabs_ueq_neg1(1787; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1788; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1789; CHECK-NEXT: [[UEQ_NEG1:%.*]] = fcmp ueq float [[ARG_FABS]], -1.000000e+001790; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UEQ_NEG1]]) #[[ATTR5]]1791; CHECK-NEXT: ret float [[ARG]]1792;1793 %arg.fabs = call float @llvm.fabs.f32(float %arg)1794 %ueq.neg1 = fcmp ueq float %arg.fabs, -1.01795 call void @llvm.assume(i1 %ueq.neg1)1796 ret float %arg1797}1798 1799define float @ret_assumed_fabs_one_neg1(float %arg) {1800; CHECK-LABEL: define float @ret_assumed_fabs_one_neg1(1801; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1802; CHECK-NEXT: [[ARG_FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]1803; CHECK-NEXT: [[ONE_NEG1:%.*]] = fcmp one float [[ARG_FABS]], -1.000000e+001804; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ONE_NEG1]]) #[[ATTR5]]1805; CHECK-NEXT: ret float [[ARG]]1806;1807 %arg.fabs = call float @llvm.fabs.f32(float %arg)1808 %one.neg1 = fcmp one float %arg.fabs, -1.01809 call void @llvm.assume(i1 %one.neg1)1810 ret float %arg1811}1812 1813define float @ret_assumed_fabs_une_neg1(float %arg) {1814; CHECK-LABEL: define float @ret_assumed_fabs_une_neg1(1815; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {1816; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]1817; CHECK-NEXT: ret float [[ARG]]1818;1819 %arg.fabs = call float @llvm.fabs.f32(float %arg)1820 %une.neg1 = fcmp une float %arg.fabs, -1.01821 call void @llvm.assume(i1 %une.neg1)1822 ret float %arg1823}1824 1825;---------------------------------------------------------------------1826; compare > fabs(variable)1827;---------------------------------------------------------------------1828 1829; Can't be +inf1830define float @clamp_is_ogt_known_positive_to_1(float %arg, float %unknown) {1831; CHECK-LABEL: define float @clamp_is_ogt_known_positive_to_1(1832; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1833; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1834; CHECK-NEXT: [[IS_OGT_KNOWN_POSITIVE:%.*]] = fcmp ogt float [[ARG]], [[KNOWN_POSITIVE]]1835; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_KNOWN_POSITIVE]], float 1.000000e+00, float [[ARG]]1836; CHECK-NEXT: ret float [[SELECT]]1837;1838 %known.positive = call float @llvm.fabs.f32(float %unknown)1839 %is.ogt.known.positive = fcmp ogt float %arg, %known.positive1840 %select = select i1 %is.ogt.known.positive, float 1.0, float %arg1841 ret float %select1842}1843 1844define float @clamp_is_oge_known_positive_to_1(float %arg, float %unknown) {1845; CHECK-LABEL: define float @clamp_is_oge_known_positive_to_1(1846; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1847; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1848; CHECK-NEXT: [[IS_OGE_KNOWN_POSITIVE:%.*]] = fcmp oge float [[ARG]], [[KNOWN_POSITIVE]]1849; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_KNOWN_POSITIVE]], float 1.000000e+00, float [[ARG]]1850; CHECK-NEXT: ret float [[SELECT]]1851;1852 %known.positive = call float @llvm.fabs.f32(float %unknown)1853 %is.oge.known.positive = fcmp oge float %arg, %known.positive1854 %select = select i1 %is.oge.known.positive, float 1.0, float %arg1855 ret float %select1856}1857 1858define float @clamp_is_olt_known_positive_to_1(float %arg, float %unknown) {1859; CHECK-LABEL: define float @clamp_is_olt_known_positive_to_1(1860; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1861; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1862; CHECK-NEXT: [[IS_OLT_KNOWN_POSITIVE:%.*]] = fcmp olt float [[ARG]], [[KNOWN_POSITIVE]]1863; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_KNOWN_POSITIVE]], float 1.000000e+00, float [[ARG]]1864; CHECK-NEXT: ret float [[SELECT]]1865;1866 %known.positive = call float @llvm.fabs.f32(float %unknown)1867 %is.olt.known.positive = fcmp olt float %arg, %known.positive1868 %select = select i1 %is.olt.known.positive, float 1.0, float %arg1869 ret float %select1870}1871 1872define float @clamp_is_ole_known_positive_to_1(float %arg, float %unknown) {1873; CHECK-LABEL: define float @clamp_is_ole_known_positive_to_1(1874; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1875; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1876; CHECK-NEXT: [[IS_OLE_KNOWN_POSITIVE:%.*]] = fcmp olt float [[ARG]], [[KNOWN_POSITIVE]]1877; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_KNOWN_POSITIVE]], float 1.000000e+00, float [[ARG]]1878; CHECK-NEXT: ret float [[SELECT]]1879;1880 %known.positive = call float @llvm.fabs.f32(float %unknown)1881 %is.ole.known.positive = fcmp olt float %arg, %known.positive1882 %select = select i1 %is.ole.known.positive, float 1.0, float %arg1883 ret float %select1884}1885 1886define float @clamp_is_ugt_known_positive_to_1(float %arg, float %unknown) {1887; CHECK-LABEL: define float @clamp_is_ugt_known_positive_to_1(1888; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1889; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1890; CHECK-NEXT: [[IS_UGT_KNOWN_POSITIVE:%.*]] = fcmp ugt float [[ARG]], [[KNOWN_POSITIVE]]1891; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_KNOWN_POSITIVE]], float 1.000000e+00, float [[ARG]]1892; CHECK-NEXT: ret float [[SELECT]]1893;1894 %known.positive = call float @llvm.fabs.f32(float %unknown)1895 %is.ugt.known.positive = fcmp ugt float %arg, %known.positive1896 %select = select i1 %is.ugt.known.positive, float 1.0, float %arg1897 ret float %select1898}1899 1900define float @clamp_is_uge_known_positive_to_1(float %arg, float %unknown) {1901; CHECK-LABEL: define float @clamp_is_uge_known_positive_to_1(1902; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1903; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1904; CHECK-NEXT: [[IS_UGE_KNOWN_POSITIVE:%.*]] = fcmp uge float [[ARG]], [[KNOWN_POSITIVE]]1905; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_KNOWN_POSITIVE]], float 1.000000e+00, float [[ARG]]1906; CHECK-NEXT: ret float [[SELECT]]1907;1908 %known.positive = call float @llvm.fabs.f32(float %unknown)1909 %is.uge.known.positive = fcmp uge float %arg, %known.positive1910 %select = select i1 %is.uge.known.positive, float 1.0, float %arg1911 ret float %select1912}1913 1914define float @clamp_is_ult_known_positive_to_1(float %arg, float %unknown) {1915; CHECK-LABEL: define float @clamp_is_ult_known_positive_to_1(1916; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1917; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1918; CHECK-NEXT: [[IS_ULT_KNOWN_POSITIVE:%.*]] = fcmp ult float [[ARG]], [[KNOWN_POSITIVE]]1919; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_KNOWN_POSITIVE]], float 1.000000e+00, float [[ARG]]1920; CHECK-NEXT: ret float [[SELECT]]1921;1922 %known.positive = call float @llvm.fabs.f32(float %unknown)1923 %is.ult.known.positive = fcmp ult float %arg, %known.positive1924 %select = select i1 %is.ult.known.positive, float 1.0, float %arg1925 ret float %select1926}1927 1928define float @clamp_is_ule_known_positive_to_1(float %arg, float %unknown) {1929; CHECK-LABEL: define float @clamp_is_ule_known_positive_to_1(1930; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1931; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1932; CHECK-NEXT: [[IS_ULE_KNOWN_POSITIVE:%.*]] = fcmp ult float [[ARG]], [[KNOWN_POSITIVE]]1933; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_KNOWN_POSITIVE]], float 1.000000e+00, float [[ARG]]1934; CHECK-NEXT: ret float [[SELECT]]1935;1936 %known.positive = call float @llvm.fabs.f32(float %unknown)1937 %is.ule.known.positive = fcmp ult float %arg, %known.positive1938 %select = select i1 %is.ule.known.positive, float 1.0, float %arg1939 ret float %select1940}1941 1942define float @clamp_is_olt_known_negative_to_neg1(float %arg, float %unknown) {1943; CHECK-LABEL: define float @clamp_is_olt_known_negative_to_neg1(1944; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1945; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1946; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]1947; CHECK-NEXT: [[IS_OLT_NEGATIVE:%.*]] = fcmp olt float [[ARG]], [[KNOWN_NEGATIVE]]1948; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLT_NEGATIVE]], float -1.000000e+00, float [[ARG]]1949; CHECK-NEXT: ret float [[SELECT]]1950;1951 %known.positive = call float @llvm.fabs.f32(float %unknown)1952 %known.negative = fneg float %known.positive1953 %is.olt.negative = fcmp olt float %arg, %known.negative1954 %select = select i1 %is.olt.negative, float -1.0, float %arg1955 ret float %select1956}1957 1958define float @clamp_is_ole_known_negative_to_neg1(float %arg, float %unknown) {1959; CHECK-LABEL: define float @clamp_is_ole_known_negative_to_neg1(1960; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1961; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1962; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]1963; CHECK-NEXT: [[IS_OLE_NEGATIVE:%.*]] = fcmp ole float [[ARG]], [[KNOWN_NEGATIVE]]1964; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OLE_NEGATIVE]], float -1.000000e+00, float [[ARG]]1965; CHECK-NEXT: ret float [[SELECT]]1966;1967 %known.positive = call float @llvm.fabs.f32(float %unknown)1968 %known.negative = fneg float %known.positive1969 %is.ole.negative = fcmp ole float %arg, %known.negative1970 %select = select i1 %is.ole.negative, float -1.0, float %arg1971 ret float %select1972}1973 1974define float @clamp_is_ogt_known_negative_to_neg1(float %arg, float %unknown) {1975; CHECK-LABEL: define float @clamp_is_ogt_known_negative_to_neg1(1976; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1977; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1978; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]1979; CHECK-NEXT: [[IS_OGT_NEGATIVE:%.*]] = fcmp ogt float [[ARG]], [[KNOWN_NEGATIVE]]1980; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGT_NEGATIVE]], float -1.000000e+00, float [[ARG]]1981; CHECK-NEXT: ret float [[SELECT]]1982;1983 %known.positive = call float @llvm.fabs.f32(float %unknown)1984 %known.negative = fneg float %known.positive1985 %is.ogt.negative = fcmp ogt float %arg, %known.negative1986 %select = select i1 %is.ogt.negative, float -1.0, float %arg1987 ret float %select1988}1989 1990define float @clamp_is_oge_known_negative_to_neg1(float %arg, float %unknown) {1991; CHECK-LABEL: define float @clamp_is_oge_known_negative_to_neg1(1992; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {1993; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]1994; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]1995; CHECK-NEXT: [[IS_OGE_NEGATIVE:%.*]] = fcmp oge float [[ARG]], [[KNOWN_NEGATIVE]]1996; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_OGE_NEGATIVE]], float -1.000000e+00, float [[ARG]]1997; CHECK-NEXT: ret float [[SELECT]]1998;1999 %known.positive = call float @llvm.fabs.f32(float %unknown)2000 %known.negative = fneg float %known.positive2001 %is.oge.negative = fcmp oge float %arg, %known.negative2002 %select = select i1 %is.oge.negative, float -1.0, float %arg2003 ret float %select2004}2005 2006define float @clamp_is_ult_known_negative_to_neg1(float %arg, float %unknown) {2007; CHECK-LABEL: define float @clamp_is_ult_known_negative_to_neg1(2008; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {2009; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2010; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2011; CHECK-NEXT: [[IS_ULT_NEGATIVE:%.*]] = fcmp ult float [[ARG]], [[KNOWN_NEGATIVE]]2012; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULT_NEGATIVE]], float -1.000000e+00, float [[ARG]]2013; CHECK-NEXT: ret float [[SELECT]]2014;2015 %known.positive = call float @llvm.fabs.f32(float %unknown)2016 %known.negative = fneg float %known.positive2017 %is.ult.negative = fcmp ult float %arg, %known.negative2018 %select = select i1 %is.ult.negative, float -1.0, float %arg2019 ret float %select2020}2021 2022define float @clamp_is_ule_known_negative_to_neg1(float %arg, float %unknown) {2023; CHECK-LABEL: define float @clamp_is_ule_known_negative_to_neg1(2024; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {2025; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2026; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2027; CHECK-NEXT: [[IS_ULE_NEGATIVE:%.*]] = fcmp ule float [[ARG]], [[KNOWN_NEGATIVE]]2028; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_ULE_NEGATIVE]], float -1.000000e+00, float [[ARG]]2029; CHECK-NEXT: ret float [[SELECT]]2030;2031 %known.positive = call float @llvm.fabs.f32(float %unknown)2032 %known.negative = fneg float %known.positive2033 %is.ule.negative = fcmp ule float %arg, %known.negative2034 %select = select i1 %is.ule.negative, float -1.0, float %arg2035 ret float %select2036}2037 2038define float @clamp_is_ugt_known_negative_to_neg1(float %arg, float %unknown) {2039; CHECK-LABEL: define float @clamp_is_ugt_known_negative_to_neg1(2040; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {2041; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2042; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2043; CHECK-NEXT: [[IS_UGT_NEGATIVE:%.*]] = fcmp ugt float [[ARG]], [[KNOWN_NEGATIVE]]2044; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGT_NEGATIVE]], float -1.000000e+00, float [[ARG]]2045; CHECK-NEXT: ret float [[SELECT]]2046;2047 %known.positive = call float @llvm.fabs.f32(float %unknown)2048 %known.negative = fneg float %known.positive2049 %is.ugt.negative = fcmp ugt float %arg, %known.negative2050 %select = select i1 %is.ugt.negative, float -1.0, float %arg2051 ret float %select2052}2053 2054define float @clamp_is_uge_known_negative_to_neg1(float %arg, float %unknown) {2055; CHECK-LABEL: define float @clamp_is_uge_known_negative_to_neg1(2056; CHECK-SAME: float [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR2]] {2057; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2058; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2059; CHECK-NEXT: [[IS_UGE_NEGATIVE:%.*]] = fcmp uge float [[ARG]], [[KNOWN_NEGATIVE]]2060; CHECK-NEXT: [[SELECT:%.*]] = select i1 [[IS_UGE_NEGATIVE]], float -1.000000e+00, float [[ARG]]2061; CHECK-NEXT: ret float [[SELECT]]2062;2063 %known.positive = call float @llvm.fabs.f32(float %unknown)2064 %known.negative = fneg float %known.positive2065 %is.uge.negative = fcmp uge float %arg, %known.negative2066 %select = select i1 %is.uge.negative, float -1.0, float %arg2067 ret float %select2068}2069 2070define float @ret_assumed_ogt_known_positive(float %arg, float %unknown) {2071; CHECK-LABEL: define float @ret_assumed_ogt_known_positive(2072; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2073; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2074; CHECK-NEXT: [[OGT_KNOWN_POSITIVE:%.*]] = fcmp ogt float [[ARG]], [[KNOWN_POSITIVE]]2075; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGT_KNOWN_POSITIVE]]) #[[ATTR5]]2076; CHECK-NEXT: ret float [[ARG]]2077;2078 %known.positive = call float @llvm.fabs.f32(float %unknown)2079 %ogt.known.positive = fcmp ogt float %arg, %known.positive2080 call void @llvm.assume(i1 %ogt.known.positive)2081 ret float %arg2082}2083 2084define float @ret_assumed_oge_known_positive(float %arg, float %unknown) {2085; CHECK-LABEL: define float @ret_assumed_oge_known_positive(2086; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2087; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2088; CHECK-NEXT: [[OGE_KNOWN_POSITIVE:%.*]] = fcmp oge float [[ARG]], [[KNOWN_POSITIVE]]2089; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGE_KNOWN_POSITIVE]]) #[[ATTR5]]2090; CHECK-NEXT: ret float [[ARG]]2091;2092 %known.positive = call float @llvm.fabs.f32(float %unknown)2093 %oge.known.positive = fcmp oge float %arg, %known.positive2094 call void @llvm.assume(i1 %oge.known.positive)2095 ret float %arg2096}2097 2098define float @ret_assumed_ugt_known_positive(float %arg, float %unknown) {2099; CHECK-LABEL: define float @ret_assumed_ugt_known_positive(2100; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2101; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2102; CHECK-NEXT: [[UGT_KNOWN_POSITIVE:%.*]] = fcmp ugt float [[ARG]], [[KNOWN_POSITIVE]]2103; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGT_KNOWN_POSITIVE]]) #[[ATTR5]]2104; CHECK-NEXT: ret float [[ARG]]2105;2106 %known.positive = call float @llvm.fabs.f32(float %unknown)2107 %ugt.known.positive = fcmp ugt float %arg, %known.positive2108 call void @llvm.assume(i1 %ugt.known.positive)2109 ret float %arg2110}2111 2112define float @ret_assumed_uge_known_positive(float %arg, float %unknown) {2113; CHECK-LABEL: define float @ret_assumed_uge_known_positive(2114; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2115; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2116; CHECK-NEXT: [[UGE_KNOWN_POSITIVE:%.*]] = fcmp uge float [[ARG]], [[KNOWN_POSITIVE]]2117; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGE_KNOWN_POSITIVE]]) #[[ATTR5]]2118; CHECK-NEXT: ret float [[ARG]]2119;2120 %known.positive = call float @llvm.fabs.f32(float %unknown)2121 %uge.known.positive = fcmp uge float %arg, %known.positive2122 call void @llvm.assume(i1 %uge.known.positive)2123 ret float %arg2124}2125 2126define float @ret_assumed_olt_known_negative(float %arg, float %unknown) {2127; CHECK-LABEL: define float @ret_assumed_olt_known_negative(2128; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2129; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2130; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2131; CHECK-NEXT: [[OLT_KNOWN_NEGATIVE:%.*]] = fcmp olt float [[ARG]], [[KNOWN_NEGATIVE]]2132; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLT_KNOWN_NEGATIVE]]) #[[ATTR5]]2133; CHECK-NEXT: ret float [[ARG]]2134;2135 %known.positive = call float @llvm.fabs.f32(float %unknown)2136 %known.negative = fneg float %known.positive2137 %olt.known.negative = fcmp olt float %arg, %known.negative2138 call void @llvm.assume(i1 %olt.known.negative)2139 ret float %arg2140}2141 2142define float @ret_assumed_ole_known_negative(float %arg, float %unknown) {2143; CHECK-LABEL: define float @ret_assumed_ole_known_negative(2144; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2145; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2146; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2147; CHECK-NEXT: [[OLE_KNOWN_NEGATIVE:%.*]] = fcmp ole float [[ARG]], [[KNOWN_NEGATIVE]]2148; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OLE_KNOWN_NEGATIVE]]) #[[ATTR5]]2149; CHECK-NEXT: ret float [[ARG]]2150;2151 %known.positive = call float @llvm.fabs.f32(float %unknown)2152 %known.negative = fneg float %known.positive2153 %ole.known.negative = fcmp ole float %arg, %known.negative2154 call void @llvm.assume(i1 %ole.known.negative)2155 ret float %arg2156}2157 2158define float @ret_assumed_ult_known_negative(float %arg, float %unknown) {2159; CHECK-LABEL: define float @ret_assumed_ult_known_negative(2160; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2161; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2162; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2163; CHECK-NEXT: [[ULT_KNOWN_NEGATIVE:%.*]] = fcmp ult float [[ARG]], [[KNOWN_NEGATIVE]]2164; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULT_KNOWN_NEGATIVE]]) #[[ATTR5]]2165; CHECK-NEXT: ret float [[ARG]]2166;2167 %known.positive = call float @llvm.fabs.f32(float %unknown)2168 %known.negative = fneg float %known.positive2169 %ult.known.negative = fcmp ult float %arg, %known.negative2170 call void @llvm.assume(i1 %ult.known.negative)2171 ret float %arg2172}2173 2174define float @ret_assumed_ule_known_negative(float %arg, float %unknown) {2175; CHECK-LABEL: define float @ret_assumed_ule_known_negative(2176; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2177; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2178; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2179; CHECK-NEXT: [[ULE_KNOWN_NEGATIVE:%.*]] = fcmp ule float [[ARG]], [[KNOWN_NEGATIVE]]2180; CHECK-NEXT: call void @llvm.assume(i1 noundef [[ULE_KNOWN_NEGATIVE]]) #[[ATTR5]]2181; CHECK-NEXT: ret float [[ARG]]2182;2183 %known.positive = call float @llvm.fabs.f32(float %unknown)2184 %known.negative = fneg float %known.positive2185 %ule.known.negative = fcmp ule float %arg, %known.negative2186 call void @llvm.assume(i1 %ule.known.negative)2187 ret float %arg2188}2189 2190define float @ret_assumed_ogt_known_negative(float %arg, float %unknown) {2191; CHECK-LABEL: define float @ret_assumed_ogt_known_negative(2192; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2193; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2194; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2195; CHECK-NEXT: [[OGT_KNOWN_NEGATIVE:%.*]] = fcmp ogt float [[ARG]], [[KNOWN_NEGATIVE]]2196; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGT_KNOWN_NEGATIVE]]) #[[ATTR5]]2197; CHECK-NEXT: ret float [[ARG]]2198;2199 %known.positive = call float @llvm.fabs.f32(float %unknown)2200 %known.negative = fneg float %known.positive2201 %ogt.known.negative = fcmp ogt float %arg, %known.negative2202 call void @llvm.assume(i1 %ogt.known.negative)2203 ret float %arg2204}2205 2206define float @ret_assumed_oge_known_negative(float %arg, float %unknown) {2207; CHECK-LABEL: define float @ret_assumed_oge_known_negative(2208; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2209; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2210; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2211; CHECK-NEXT: [[OGE_KNOWN_NEGATIVE:%.*]] = fcmp oge float [[ARG]], [[KNOWN_NEGATIVE]]2212; CHECK-NEXT: call void @llvm.assume(i1 noundef [[OGE_KNOWN_NEGATIVE]]) #[[ATTR5]]2213; CHECK-NEXT: ret float [[ARG]]2214;2215 %known.positive = call float @llvm.fabs.f32(float %unknown)2216 %known.negative = fneg float %known.positive2217 %oge.known.negative = fcmp oge float %arg, %known.negative2218 call void @llvm.assume(i1 %oge.known.negative)2219 ret float %arg2220}2221 2222define float @ret_assumed_ugt_known_negative(float %arg, float %unknown) {2223; CHECK-LABEL: define float @ret_assumed_ugt_known_negative(2224; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2225; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2226; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2227; CHECK-NEXT: [[UGT_KNOWN_NEGATIVE:%.*]] = fcmp ugt float [[ARG]], [[KNOWN_NEGATIVE]]2228; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGT_KNOWN_NEGATIVE]]) #[[ATTR5]]2229; CHECK-NEXT: ret float [[ARG]]2230;2231 %known.positive = call float @llvm.fabs.f32(float %unknown)2232 %known.negative = fneg float %known.positive2233 %ugt.known.negative = fcmp ugt float %arg, %known.negative2234 call void @llvm.assume(i1 %ugt.known.negative)2235 ret float %arg2236}2237 2238define float @ret_assumed_uge_known_negative(float %arg, float %unknown) {2239; CHECK-LABEL: define float @ret_assumed_uge_known_negative(2240; CHECK-SAME: float returned [[ARG:%.*]], float [[UNKNOWN:%.*]]) #[[ATTR3]] {2241; CHECK-NEXT: [[KNOWN_POSITIVE:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) #[[ATTR4]]2242; CHECK-NEXT: [[KNOWN_NEGATIVE:%.*]] = fneg float [[KNOWN_POSITIVE]]2243; CHECK-NEXT: [[UGE_KNOWN_NEGATIVE:%.*]] = fcmp uge float [[ARG]], [[KNOWN_NEGATIVE]]2244; CHECK-NEXT: call void @llvm.assume(i1 noundef [[UGE_KNOWN_NEGATIVE]]) #[[ATTR5]]2245; CHECK-NEXT: ret float [[ARG]]2246;2247 %known.positive = call float @llvm.fabs.f32(float %unknown)2248 %known.negative = fneg float %known.positive2249 %uge.known.negative = fcmp uge float %arg, %known.negative2250 call void @llvm.assume(i1 %uge.known.negative)2251 ret float %arg2252}2253 2254;---------------------------------------------------------------------2255; assume compare to smallest normal2256;---------------------------------------------------------------------2257 2258define float @assume_oeq_smallest_normal(float %arg) {2259; CHECK-LABEL: define float @assume_oeq_smallest_normal(2260; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2261; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[ARG]], 0x38100000000000002262; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]]2263; CHECK-NEXT: ret float [[ARG]]2264;2265 %is.oeq.smallest.normal = fcmp oeq float %arg, 0x38100000000000002266 call void @llvm.assume(i1 %is.oeq.smallest.normal)2267 ret float %arg2268}2269 2270define float @assume_one_smallest_normal(float %arg) {2271; CHECK-LABEL: define float @assume_one_smallest_normal(2272; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2273; CHECK-NEXT: [[IS_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[ARG]], 0x38100000000000002274; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ONE_SMALLEST_NORMAL]]) #[[ATTR5]]2275; CHECK-NEXT: ret float [[ARG]]2276;2277 %is.one.smallest.normal = fcmp one float %arg, 0x38100000000000002278 call void @llvm.assume(i1 %is.one.smallest.normal)2279 ret float %arg2280}2281 2282define float @assume_ueq_smallest_normal(float %arg) {2283; CHECK-LABEL: define float @assume_ueq_smallest_normal(2284; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2285; CHECK-NEXT: [[IS_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[ARG]], 0x38100000000000002286; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UEQ_SMALLEST_NORMAL]]) #[[ATTR5]]2287; CHECK-NEXT: ret float [[ARG]]2288;2289 %is.ueq.smallest.normal = fcmp ueq float %arg, 0x38100000000000002290 call void @llvm.assume(i1 %is.ueq.smallest.normal)2291 ret float %arg2292}2293 2294define float @assume_une_smallest_normal(float %arg) {2295; CHECK-LABEL: define float @assume_une_smallest_normal(2296; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2297; CHECK-NEXT: [[IS_UNE_SMALLEST_NORMAL:%.*]] = fcmp une float [[ARG]], 0x38100000000000002298; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UNE_SMALLEST_NORMAL]]) #[[ATTR5]]2299; CHECK-NEXT: ret float [[ARG]]2300;2301 %is.une.smallest.normal = fcmp une float %arg, 0x38100000000000002302 call void @llvm.assume(i1 %is.une.smallest.normal)2303 ret float %arg2304}2305 2306define float @assume_ord_smallest_normal(float %arg) {2307; CHECK-LABEL: define float @assume_ord_smallest_normal(2308; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2309; CHECK-NEXT: [[IS_ORD_SMALLEST_NORMAL:%.*]] = fcmp ord float [[ARG]], 0x38100000000000002310; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ORD_SMALLEST_NORMAL]]) #[[ATTR5]]2311; CHECK-NEXT: ret float [[ARG]]2312;2313 %is.ord.smallest.normal = fcmp ord float %arg, 0x38100000000000002314 call void @llvm.assume(i1 %is.ord.smallest.normal)2315 ret float %arg2316}2317 2318define float @assume_uno_smallest_normal(float %arg) {2319; CHECK-LABEL: define float @assume_uno_smallest_normal(2320; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2321; CHECK-NEXT: [[IS_UNO_SMALLEST_NORMAL:%.*]] = fcmp uno float [[ARG]], 0x38100000000000002322; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UNO_SMALLEST_NORMAL]]) #[[ATTR5]]2323; CHECK-NEXT: ret float [[ARG]]2324;2325 %is.uno.smallest.normal = fcmp uno float %arg, 0x38100000000000002326 call void @llvm.assume(i1 %is.uno.smallest.normal)2327 ret float %arg2328}2329 2330define float @assume_fabs_oeq_smallest_normal(float %arg) {2331; CHECK-LABEL: define float @assume_fabs_oeq_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_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[FABS_ARG]], 0x38100000000000002335; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]]2336; CHECK-NEXT: ret float [[ARG]]2337;2338 %fabs.arg = call float @llvm.fabs.f32(float %arg)2339 %is.oeq.smallest.normal = fcmp oeq float %fabs.arg, 0x38100000000000002340 call void @llvm.assume(i1 %is.oeq.smallest.normal)2341 ret float %arg2342}2343 2344define float @assume_fabs_one_smallest_normal(float %arg) {2345; CHECK-LABEL: define float @assume_fabs_one_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_ONE_SMALLEST_NORMAL:%.*]] = fcmp one float [[FABS_ARG]], 0x38100000000000002349; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ONE_SMALLEST_NORMAL]]) #[[ATTR5]]2350; CHECK-NEXT: ret float [[ARG]]2351;2352 %fabs.arg = call float @llvm.fabs.f32(float %arg)2353 %is.one.smallest.normal = fcmp one float %fabs.arg, 0x38100000000000002354 call void @llvm.assume(i1 %is.one.smallest.normal)2355 ret float %arg2356}2357 2358define float @assume_fabs_ueq_smallest_normal(float %arg) {2359; CHECK-LABEL: define float @assume_fabs_ueq_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_UEQ_SMALLEST_NORMAL:%.*]] = fcmp ueq float [[FABS_ARG]], 0x38100000000000002363; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UEQ_SMALLEST_NORMAL]]) #[[ATTR5]]2364; CHECK-NEXT: ret float [[ARG]]2365;2366 %fabs.arg = call float @llvm.fabs.f32(float %arg)2367 %is.ueq.smallest.normal = fcmp ueq float %fabs.arg, 0x38100000000000002368 call void @llvm.assume(i1 %is.ueq.smallest.normal)2369 ret float %arg2370}2371 2372define float @assume_fabs_une_smallest_normal(float %arg) {2373; CHECK-LABEL: define float @assume_fabs_une_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_UNE_SMALLEST_NORMAL:%.*]] = fcmp une float [[FABS_ARG]], 0x38100000000000002377; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UNE_SMALLEST_NORMAL]]) #[[ATTR5]]2378; CHECK-NEXT: ret float [[ARG]]2379;2380 %fabs.arg = call float @llvm.fabs.f32(float %arg)2381 %is.une.smallest.normal = fcmp une float %fabs.arg, 0x38100000000000002382 call void @llvm.assume(i1 %is.une.smallest.normal)2383 ret float %arg2384}2385 2386define float @assume_fabs_ord_smallest_normal(float %arg) {2387; CHECK-LABEL: define float @assume_fabs_ord_smallest_normal(2388; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2389; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]2390; CHECK-NEXT: [[IS_ORD_SMALLEST_NORMAL:%.*]] = fcmp ord float [[FABS_ARG]], 0x38100000000000002391; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_ORD_SMALLEST_NORMAL]]) #[[ATTR5]]2392; CHECK-NEXT: ret float [[ARG]]2393;2394 %fabs.arg = call float @llvm.fabs.f32(float %arg)2395 %is.ord.smallest.normal = fcmp ord float %fabs.arg, 0x38100000000000002396 call void @llvm.assume(i1 %is.ord.smallest.normal)2397 ret float %arg2398}2399 2400define float @assume_fabs_uno_smallest_normal(float %arg) {2401; CHECK-LABEL: define float @assume_fabs_uno_smallest_normal(2402; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2403; CHECK-NEXT: [[FABS_ARG:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]2404; CHECK-NEXT: [[IS_UNO_SMALLEST_NORMAL:%.*]] = fcmp uno float [[FABS_ARG]], 0x38100000000000002405; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_UNO_SMALLEST_NORMAL]]) #[[ATTR5]]2406; CHECK-NEXT: ret float [[ARG]]2407;2408 %fabs.arg = call float @llvm.fabs.f32(float %arg)2409 %is.uno.smallest.normal = fcmp uno float %fabs.arg, 0x38100000000000002410 call void @llvm.assume(i1 %is.uno.smallest.normal)2411 ret float %arg2412}2413 2414define float @assume_oeq_smallest_normal_known_pos(float nofpclass(ninf nsub nnorm nzero) %arg) {2415; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @assume_oeq_smallest_normal_known_pos(2416; CHECK-SAME: float returned nofpclass(ninf nzero nsub nnorm) [[ARG:%.*]]) #[[ATTR3]] {2417; CHECK-NEXT: [[IS_OEQ_SMALLEST_NORMAL:%.*]] = fcmp oeq float [[ARG]], 0x38100000000000002418; CHECK-NEXT: call void @llvm.assume(i1 noundef [[IS_OEQ_SMALLEST_NORMAL]]) #[[ATTR5]]2419; CHECK-NEXT: ret float [[ARG]]2420;2421 %is.oeq.smallest.normal = fcmp oeq float %arg, 0x38100000000000002422 call void @llvm.assume(i1 %is.oeq.smallest.normal)2423 ret float %arg2424}2425 2426;---------------------------------------------------------------------2427; compare to inf2428;---------------------------------------------------------------------2429 2430define float @assume_ole_pinf(float %arg) {2431; CHECK-LABEL: define float @assume_ole_pinf(2432; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2433; CHECK-NEXT: [[FCMP:%.*]] = fcmp ole float [[ARG]], 0x7FF00000000000002434; CHECK-NEXT: call void @llvm.assume(i1 noundef [[FCMP]]) #[[ATTR5]]2435; CHECK-NEXT: ret float [[ARG]]2436;2437 %fcmp = fcmp ole float %arg, 0x7FF00000000000002438 call void @llvm.assume(i1 %fcmp)2439 ret float %arg2440}2441 2442define float @assume_ole_ninf(float %arg) {2443; CHECK-LABEL: define float @assume_ole_ninf(2444; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2445; CHECK-NEXT: [[FCMP:%.*]] = fcmp ole float [[ARG]], 0xFFF00000000000002446; CHECK-NEXT: call void @llvm.assume(i1 noundef [[FCMP]]) #[[ATTR5]]2447; CHECK-NEXT: ret float [[ARG]]2448;2449 %fcmp = fcmp ole float %arg, 0xFFF00000000000002450 call void @llvm.assume(i1 %fcmp)2451 ret float %arg2452}2453 2454define float @assume_ugt_pinf(float %arg) {2455; CHECK-LABEL: define float @assume_ugt_pinf(2456; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2457; CHECK-NEXT: [[FCMP:%.*]] = fcmp ugt float [[ARG]], 0x7FF00000000000002458; CHECK-NEXT: call void @llvm.assume(i1 noundef [[FCMP]]) #[[ATTR5]]2459; CHECK-NEXT: ret float [[ARG]]2460;2461 %fcmp = fcmp ugt float %arg, 0x7FF00000000000002462 call void @llvm.assume(i1 %fcmp)2463 ret float %arg2464}2465 2466define float @assume_ugt_ninf(float %arg) {2467; CHECK-LABEL: define float @assume_ugt_ninf(2468; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2469; CHECK-NEXT: [[FCMP:%.*]] = fcmp ugt float [[ARG]], 0xFFF00000000000002470; CHECK-NEXT: call void @llvm.assume(i1 noundef [[FCMP]]) #[[ATTR5]]2471; CHECK-NEXT: ret float [[ARG]]2472;2473 %fcmp = fcmp ugt float %arg, 0xFFF00000000000002474 call void @llvm.assume(i1 %fcmp)2475 ret float %arg2476}2477 2478define float @assume_fabs_ole_pinf(float %arg) {2479; CHECK-LABEL: define float @assume_fabs_ole_pinf(2480; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2481; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]2482; CHECK-NEXT: [[FCMP:%.*]] = fcmp ole float [[FABS]], 0x7FF00000000000002483; CHECK-NEXT: call void @llvm.assume(i1 noundef [[FCMP]]) #[[ATTR5]]2484; CHECK-NEXT: ret float [[ARG]]2485;2486 %fabs = call float @llvm.fabs.f32(float %arg)2487 %fcmp = fcmp ole float %fabs, 0x7FF00000000000002488 call void @llvm.assume(i1 %fcmp)2489 ret float %arg2490}2491 2492define float @assume_fabs_ole_ninf(float %arg) {2493; CHECK-LABEL: define float @assume_fabs_ole_ninf(2494; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2495; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]2496; CHECK-NEXT: ret float [[ARG]]2497;2498 %fabs = call float @llvm.fabs.f32(float %arg)2499 %fcmp = fcmp ole float %fabs, 0xFFF00000000000002500 call void @llvm.assume(i1 %fcmp)2501 ret float %arg2502}2503 2504define float @assume_fabs_ugt_pinf(float %arg) {2505; CHECK-LABEL: define float @assume_fabs_ugt_pinf(2506; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2507; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[ARG]]) #[[ATTR4]]2508; CHECK-NEXT: [[FCMP:%.*]] = fcmp ugt float [[FABS]], 0x7FF00000000000002509; CHECK-NEXT: call void @llvm.assume(i1 noundef [[FCMP]]) #[[ATTR5]]2510; CHECK-NEXT: ret float [[ARG]]2511;2512 %fabs = call float @llvm.fabs.f32(float %arg)2513 %fcmp = fcmp ugt float %fabs, 0x7FF00000000000002514 call void @llvm.assume(i1 %fcmp)2515 ret float %arg2516}2517 2518define float @assume_fabs_ugt_ninf(float %arg) {2519; CHECK-LABEL: define float @assume_fabs_ugt_ninf(2520; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2521; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]2522; CHECK-NEXT: ret float [[ARG]]2523;2524 %fabs = call float @llvm.fabs.f32(float %arg)2525 %fcmp = fcmp ugt float %fabs, 0xFFF00000000000002526 call void @llvm.assume(i1 %fcmp)2527 ret float %arg2528}2529 2530;---------------------------------------------------------------------2531; fcmp false2532;---------------------------------------------------------------------2533 2534define float @assume_fabs_false_pinf(float %arg) {2535; CHECK-LABEL: define float @assume_fabs_false_pinf(2536; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2537; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]2538; CHECK-NEXT: ret float [[ARG]]2539;2540 %fabs = call float @llvm.fabs.f32(float %arg)2541 %fcmp = fcmp false float %fabs, 0x7FF00000000000002542 call void @llvm.assume(i1 %fcmp)2543 ret float %arg2544}2545 2546define float @assume_fabs_false_ninf(float %arg) {2547; CHECK-LABEL: define float @assume_fabs_false_ninf(2548; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2549; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]2550; CHECK-NEXT: ret float [[ARG]]2551;2552 %fabs = call float @llvm.fabs.f32(float %arg)2553 %fcmp = fcmp false float %fabs, 0xFFF00000000000002554 call void @llvm.assume(i1 %fcmp)2555 ret float %arg2556}2557 2558define float @assume_false_pinf(float %arg) {2559; CHECK-LABEL: define float @assume_false_pinf(2560; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2561; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]2562; CHECK-NEXT: ret float [[ARG]]2563;2564 %fcmp = fcmp false float %arg, 0x7FF00000000000002565 call void @llvm.assume(i1 %fcmp)2566 ret float %arg2567}2568 2569define float @assume_false_ninf(float %arg) {2570; CHECK-LABEL: define float @assume_false_ninf(2571; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2572; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]2573; CHECK-NEXT: ret float [[ARG]]2574;2575 %fcmp = fcmp false float %arg, 0xFFF00000000000002576 call void @llvm.assume(i1 %fcmp)2577 ret float %arg2578}2579 2580define float @clamp_false_pinf_0.0(float %arg) {2581; CHECK-LABEL: define float @clamp_false_pinf_0.0(2582; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {2583; CHECK-NEXT: ret float [[ARG]]2584;2585 %fcmp = fcmp false float %arg, 0x7FF00000000000002586 %select = select i1 %fcmp, float 0.0, float %arg2587 ret float %select2588}2589 2590define float @clamp_false_ninf_0.0(float %arg) {2591; CHECK-LABEL: define float @clamp_false_ninf_0.0(2592; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {2593; CHECK-NEXT: ret float [[ARG]]2594;2595 %fcmp = fcmp false float %arg, 0xFFF00000000000002596 %select = select i1 %fcmp, float 0.0, float %arg2597 ret float %select2598}2599 2600define float @clamp_false_smallest_normal_0.0(float %arg) {2601; CHECK-LABEL: define float @clamp_false_smallest_normal_0.0(2602; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {2603; CHECK-NEXT: ret float [[ARG]]2604;2605 %fcmp = fcmp false float %arg, 0x38100000000000002606 %select = select i1 %fcmp, float 0.0, float %arg2607 ret float %select2608}2609 2610define float @assume_false_p0(float %arg) {2611; CHECK-LABEL: define float @assume_false_p0(2612; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2613; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]2614; CHECK-NEXT: ret float [[ARG]]2615;2616 %fcmp = fcmp false float %arg, 0.02617 call void @llvm.assume(i1 %fcmp)2618 ret float %arg2619}2620 2621define float @assume_false_n0(float %arg) {2622; CHECK-LABEL: define float @assume_false_n0(2623; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2624; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]2625; CHECK-NEXT: ret float [[ARG]]2626;2627 %fcmp = fcmp false float %arg, -0.02628 call void @llvm.assume(i1 %fcmp)2629 ret float %arg2630}2631 2632define float @assume_false_smallest_normal(float %arg) {2633; CHECK-LABEL: define float @assume_false_smallest_normal(2634; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2635; CHECK-NEXT: call void @llvm.assume(i1 noundef false) #[[ATTR5]]2636; CHECK-NEXT: ret float [[ARG]]2637;2638 %fcmp = fcmp false float %arg, 0x38100000000000002639 call void @llvm.assume(i1 %fcmp)2640 ret float %arg2641}2642 2643define float @clamp_false_nan(float %arg) {2644; CHECK-LABEL: define float @clamp_false_nan(2645; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {2646; CHECK-NEXT: ret float [[ARG]]2647;2648 %fcmp = fcmp false float %arg, 0x7FF80000000000002649 %select = select i1 %fcmp, float 0.0, float %arg2650 ret float %select2651}2652 2653define float @clamp_false_p0(float %arg) {2654; CHECK-LABEL: define float @clamp_false_p0(2655; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {2656; CHECK-NEXT: ret float [[ARG]]2657;2658 %fcmp = fcmp false float %arg, 0.02659 %select = select i1 %fcmp, float 0.0, float %arg2660 ret float %select2661}2662 2663define float @clamp_false_n0(float %arg) {2664; CHECK-LABEL: define float @clamp_false_n0(2665; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {2666; CHECK-NEXT: ret float [[ARG]]2667;2668 %fcmp = fcmp false float %arg, -0.02669 %select = select i1 %fcmp, float 0.0, float %arg2670 ret float %select2671}2672 2673;---------------------------------------------------------------------2674; fcmp true2675;---------------------------------------------------------------------2676 2677define float @assume_fabs_true_pinf(float %arg) {2678; CHECK-LABEL: define float @assume_fabs_true_pinf(2679; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2680; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]2681; CHECK-NEXT: ret float [[ARG]]2682;2683 %fabs = call float @llvm.fabs.f32(float %arg)2684 %fcmp = fcmp true float %fabs, 0x7FF00000000000002685 call void @llvm.assume(i1 %fcmp)2686 ret float %arg2687}2688 2689define float @assume_fabs_true_ninf(float %arg) {2690; CHECK-LABEL: define float @assume_fabs_true_ninf(2691; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2692; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]2693; CHECK-NEXT: ret float [[ARG]]2694;2695 %fabs = call float @llvm.fabs.f32(float %arg)2696 %fcmp = fcmp true float %fabs, 0xFFF00000000000002697 call void @llvm.assume(i1 %fcmp)2698 ret float %arg2699}2700 2701define float @assume_true_pinf(float %arg) {2702; CHECK-LABEL: define float @assume_true_pinf(2703; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2704; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]2705; CHECK-NEXT: ret float [[ARG]]2706;2707 %fcmp = fcmp true float %arg, 0x7FF00000000000002708 call void @llvm.assume(i1 %fcmp)2709 ret float %arg2710}2711 2712define float @assume_true_ninf(float %arg) {2713; CHECK-LABEL: define float @assume_true_ninf(2714; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2715; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]2716; CHECK-NEXT: ret float [[ARG]]2717;2718 %fcmp = fcmp true float %arg, 0xFFF00000000000002719 call void @llvm.assume(i1 %fcmp)2720 ret float %arg2721}2722 2723define float @assume_true_p0(float %arg) {2724; CHECK-LABEL: define float @assume_true_p0(2725; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2726; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]2727; CHECK-NEXT: ret float [[ARG]]2728;2729 %fcmp = fcmp true float %arg, 0.02730 call void @llvm.assume(i1 %fcmp)2731 ret float %arg2732}2733 2734define float @assume_true_n0(float %arg) {2735; CHECK-LABEL: define float @assume_true_n0(2736; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2737; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]2738; CHECK-NEXT: ret float [[ARG]]2739;2740 %fcmp = fcmp true float %arg, -0.02741 call void @llvm.assume(i1 %fcmp)2742 ret float %arg2743}2744 2745define float @assume_true_smallest_normal(float %arg) {2746; CHECK-LABEL: define float @assume_true_smallest_normal(2747; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR3]] {2748; CHECK-NEXT: call void @llvm.assume(i1 noundef true) #[[ATTR5]]2749; CHECK-NEXT: ret float [[ARG]]2750;2751 %fcmp = fcmp true float %arg, 0x38100000000000002752 call void @llvm.assume(i1 %fcmp)2753 ret float %arg2754}2755 2756define float @clamp_true_pinf_0.0(float %arg) {2757; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @clamp_true_pinf_0.0(2758; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {2759; CHECK-NEXT: ret float 0.000000e+002760;2761 %fcmp = fcmp true float %arg, 0x7FF00000000000002762 %select = select i1 %fcmp, float 0.0, float %arg2763 ret float %select2764}2765 2766define float @clamp_true_ninf_0.0(float %arg) {2767; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @clamp_true_ninf_0.0(2768; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {2769; CHECK-NEXT: ret float 0.000000e+002770;2771 %fcmp = fcmp true float %arg, 0xFFF00000000000002772 %select = select i1 %fcmp, float 0.0, float %arg2773 ret float %select2774}2775 2776define float @clamp_true_smallest_normal_0.0(float %arg) {2777; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @clamp_true_smallest_normal_0.0(2778; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {2779; CHECK-NEXT: ret float 0.000000e+002780;2781 %fcmp = fcmp true float %arg, 0x38100000000000002782 %select = select i1 %fcmp, float 0.0, float %arg2783 ret float %select2784}2785 2786define float @clamp_true_nan(float %arg) {2787; CHECK-LABEL: define float @clamp_true_nan(2788; CHECK-SAME: float returned [[ARG:%.*]]) #[[ATTR2]] {2789; CHECK-NEXT: ret float [[ARG]]2790;2791 %fcmp = fcmp true float %arg, 0x7FF80000000000002792 %select = select i1 %fcmp, float %arg, float 0.02793 ret float %select2794}2795 2796define float @clamp_true_p0(float %arg) {2797; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @clamp_true_p0(2798; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {2799; CHECK-NEXT: ret float 0.000000e+002800;2801 %fcmp = fcmp true float %arg, 0.02802 %select = select i1 %fcmp, float 0.0, float %arg2803 ret float %select2804}2805 2806define float @clamp_true_n0(float %arg) {2807; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @clamp_true_n0(2808; CHECK-SAME: float [[ARG:%.*]]) #[[ATTR2]] {2809; CHECK-NEXT: ret float 0.000000e+002810;2811 %fcmp = fcmp true float %arg, -0.02812 %select = select i1 %fcmp, float 0.0, float %arg2813 ret float %select2814}2815 2816;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:2817; TUNIT: {{.*}}2818