1785 lines · plain
1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py2; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -passes=instcombine -S | FileCheck %s3 4; Make sure libcalls are replaced with intrinsic calls.5 6declare float @llvm.fabs.f32(float)7declare <2 x float> @llvm.fabs.v2f32(<2 x float>)8declare double @llvm.fabs.f64(double)9declare fp128 @llvm.fabs.f128(fp128)10 11declare float @fabsf(float)12declare double @fabs(double)13declare fp128 @fabsl(fp128)14declare float @llvm.fma.f32(float, float, float)15declare float @llvm.fmuladd.f32(float, float, float)16 17declare void @use(float)18declare void @usebool(i1)19 20define float @replace_fabs_call_f32(float %x) {21; CHECK-LABEL: @replace_fabs_call_f32(22; CHECK-NEXT: [[FABSF:%.*]] = tail call float @llvm.fabs.f32(float [[X:%.*]])23; CHECK-NEXT: ret float [[FABSF]]24;25 %fabsf = tail call float @fabsf(float %x)26 ret float %fabsf27}28 29define double @replace_fabs_call_f64(double %x) {30; CHECK-LABEL: @replace_fabs_call_f64(31; CHECK-NEXT: [[FABS:%.*]] = tail call double @llvm.fabs.f64(double [[X:%.*]])32; CHECK-NEXT: ret double [[FABS]]33;34 %fabs = tail call double @fabs(double %x)35 ret double %fabs36}37 38define fp128 @replace_fabs_call_f128(fp128 %x) {39; CHECK-LABEL: @replace_fabs_call_f128(40; CHECK-NEXT: [[FABSL:%.*]] = tail call fp128 @llvm.fabs.f128(fp128 [[X:%.*]])41; CHECK-NEXT: ret fp128 [[FABSL]]42;43 %fabsl = tail call fp128 @fabsl(fp128 %x)44 ret fp128 %fabsl45}46 47; Make sure fast math flags are preserved when replacing the libcall.48define float @fmf_replace_fabs_call_f32(float %x) {49; CHECK-LABEL: @fmf_replace_fabs_call_f32(50; CHECK-NEXT: [[FABSF:%.*]] = tail call nnan float @llvm.fabs.f32(float [[X:%.*]])51; CHECK-NEXT: ret float [[FABSF]]52;53 %fabsf = tail call nnan float @fabsf(float %x)54 ret float %fabsf55}56 57; Make sure all intrinsic calls are eliminated when the input is known58; positive.59 60; The fabs cannot be eliminated because %x may be a NaN61 62define float @square_fabs_intrinsic_f32(float %x) {63; CHECK-LABEL: @square_fabs_intrinsic_f32(64; CHECK-NEXT: [[MUL:%.*]] = fmul float [[X:%.*]], [[X]]65; CHECK-NEXT: [[FABSF:%.*]] = tail call float @llvm.fabs.f32(float [[MUL]])66; CHECK-NEXT: ret float [[FABSF]]67;68 %mul = fmul float %x, %x69 %fabsf = tail call float @llvm.fabs.f32(float %mul)70 ret float %fabsf71}72 73define double @square_fabs_intrinsic_f64(double %x) {74; CHECK-LABEL: @square_fabs_intrinsic_f64(75; CHECK-NEXT: [[MUL:%.*]] = fmul double [[X:%.*]], [[X]]76; CHECK-NEXT: [[FABS:%.*]] = tail call double @llvm.fabs.f64(double [[MUL]])77; CHECK-NEXT: ret double [[FABS]]78;79 %mul = fmul double %x, %x80 %fabs = tail call double @llvm.fabs.f64(double %mul)81 ret double %fabs82}83 84define fp128 @square_fabs_intrinsic_f128(fp128 %x) {85; CHECK-LABEL: @square_fabs_intrinsic_f128(86; CHECK-NEXT: [[MUL:%.*]] = fmul fp128 [[X:%.*]], [[X]]87; CHECK-NEXT: [[FABSL:%.*]] = tail call fp128 @llvm.fabs.f128(fp128 [[MUL]])88; CHECK-NEXT: ret fp128 [[FABSL]]89;90 %mul = fmul fp128 %x, %x91 %fabsl = tail call fp128 @llvm.fabs.f128(fp128 %mul)92 ret fp128 %fabsl93}94 95define float @square_nnan_fabs_intrinsic_f32(float %x) {96; CHECK-LABEL: @square_nnan_fabs_intrinsic_f32(97; CHECK-NEXT: [[MUL:%.*]] = fmul nnan float [[X:%.*]], [[X]]98; CHECK-NEXT: ret float [[MUL]]99;100 %mul = fmul nnan float %x, %x101 %fabsf = call float @llvm.fabs.f32(float %mul)102 ret float %fabsf103}104 105; Shrinking a library call to a smaller type should not be inhibited by nor inhibit the square optimization.106 107define float @square_fabs_shrink_call1(float %x) {108; CHECK-LABEL: @square_fabs_shrink_call1(109; CHECK-NEXT: [[TMP1:%.*]] = fmul float [[X:%.*]], [[X]]110; CHECK-NEXT: [[TRUNC:%.*]] = call float @llvm.fabs.f32(float [[TMP1]])111; CHECK-NEXT: ret float [[TRUNC]]112;113 %ext = fpext float %x to double114 %sq = fmul double %ext, %ext115 %fabs = call double @fabs(double %sq)116 %trunc = fptrunc double %fabs to float117 ret float %trunc118}119 120define float @square_fabs_shrink_call2(float %x) {121; CHECK-LABEL: @square_fabs_shrink_call2(122; CHECK-NEXT: [[SQ:%.*]] = fmul float [[X:%.*]], [[X]]123; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[SQ]])124; CHECK-NEXT: ret float [[TMP1]]125;126 %sq = fmul float %x, %x127 %ext = fpext float %sq to double128 %fabs = call double @fabs(double %ext)129 %trunc = fptrunc double %fabs to float130 ret float %trunc131}132 133define float @fabs_select_constant_negative_positive(i32 %c) {134; CHECK-LABEL: @fabs_select_constant_negative_positive(135; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C:%.*]], 0136; CHECK-NEXT: [[FABS:%.*]] = select i1 [[CMP]], float 1.000000e+00, float 2.000000e+00137; CHECK-NEXT: ret float [[FABS]]138;139 %cmp = icmp eq i32 %c, 0140 %select = select i1 %cmp, float -1.0, float 2.0141 %fabs = call float @llvm.fabs.f32(float %select)142 ret float %fabs143}144 145define float @fabs_select_constant_positive_negative(i32 %c) {146; CHECK-LABEL: @fabs_select_constant_positive_negative(147; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C:%.*]], 0148; CHECK-NEXT: [[FABS:%.*]] = select i1 [[CMP]], float 1.000000e+00, float 2.000000e+00149; CHECK-NEXT: ret float [[FABS]]150;151 %cmp = icmp eq i32 %c, 0152 %select = select i1 %cmp, float 1.0, float -2.0153 %fabs = call float @llvm.fabs.f32(float %select)154 ret float %fabs155}156 157define float @fabs_select_constant_negative_negative(i32 %c) {158; CHECK-LABEL: @fabs_select_constant_negative_negative(159; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C:%.*]], 0160; CHECK-NEXT: [[FABS:%.*]] = select i1 [[CMP]], float 1.000000e+00, float 2.000000e+00161; CHECK-NEXT: ret float [[FABS]]162;163 %cmp = icmp eq i32 %c, 0164 %select = select i1 %cmp, float -1.0, float -2.0165 %fabs = call float @llvm.fabs.f32(float %select)166 ret float %fabs167}168 169define float @fabs_select_constant_neg0(i32 %c) {170; CHECK-LABEL: @fabs_select_constant_neg0(171; CHECK-NEXT: ret float 0.000000e+00172;173 %cmp = icmp eq i32 %c, 0174 %select = select i1 %cmp, float -0.0, float 0.0175 %fabs = call float @llvm.fabs.f32(float %select)176 ret float %fabs177}178 179define float @fabs_select_var_constant_negative(i32 %c, float %x) {180; CHECK-LABEL: @fabs_select_var_constant_negative(181; CHECK-NEXT: [[CMP:%.*]] = icmp eq i32 [[C:%.*]], 0182; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[SELECT:%.*]])183; CHECK-NEXT: [[FABS1:%.*]] = select i1 [[CMP]], float [[FABS]], float 1.000000e+00184; CHECK-NEXT: ret float [[FABS1]]185;186 %cmp = icmp eq i32 %c, 0187 %select = select i1 %cmp, float %x, float -1.0188 %fabs = call float @llvm.fabs.f32(float %select)189 ret float %fabs190}191 192; The fabs cannot be eliminated because %x may be a NaN193 194define float @square_fma_fabs_intrinsic_f32(float %x) {195; CHECK-LABEL: @square_fma_fabs_intrinsic_f32(196; CHECK-NEXT: [[FMA:%.*]] = call float @llvm.fma.f32(float [[X:%.*]], float [[X]], float 1.000000e+00)197; CHECK-NEXT: [[FABSF:%.*]] = call float @llvm.fabs.f32(float [[FMA]])198; CHECK-NEXT: ret float [[FABSF]]199;200 %fma = call float @llvm.fma.f32(float %x, float %x, float 1.0)201 %fabsf = call float @llvm.fabs.f32(float %fma)202 ret float %fabsf203}204 205; The fabs cannot be eliminated because %x may be a NaN206 207define float @square_nnan_fma_fabs_intrinsic_f32(float %x) {208; CHECK-LABEL: @square_nnan_fma_fabs_intrinsic_f32(209; CHECK-NEXT: [[FMA:%.*]] = call nnan float @llvm.fma.f32(float [[X:%.*]], float [[X]], float 1.000000e+00)210; CHECK-NEXT: ret float [[FMA]]211;212 %fma = call nnan float @llvm.fma.f32(float %x, float %x, float 1.0)213 %fabsf = call float @llvm.fabs.f32(float %fma)214 ret float %fabsf215}216 217define float @square_fmuladd_fabs_intrinsic_f32(float %x) {218; CHECK-LABEL: @square_fmuladd_fabs_intrinsic_f32(219; CHECK-NEXT: [[FMULADD:%.*]] = call float @llvm.fmuladd.f32(float [[X:%.*]], float [[X]], float 1.000000e+00)220; CHECK-NEXT: [[FABSF:%.*]] = call float @llvm.fabs.f32(float [[FMULADD]])221; CHECK-NEXT: ret float [[FABSF]]222;223 %fmuladd = call float @llvm.fmuladd.f32(float %x, float %x, float 1.0)224 %fabsf = call float @llvm.fabs.f32(float %fmuladd)225 ret float %fabsf226}227 228define float @square_nnan_fmuladd_fabs_intrinsic_f32(float %x) {229; CHECK-LABEL: @square_nnan_fmuladd_fabs_intrinsic_f32(230; CHECK-NEXT: [[FMULADD:%.*]] = call nnan float @llvm.fmuladd.f32(float [[X:%.*]], float [[X]], float 1.000000e+00)231; CHECK-NEXT: ret float [[FMULADD]]232;233 %fmuladd = call nnan float @llvm.fmuladd.f32(float %x, float %x, float 1.0)234 %fabsf = call float @llvm.fabs.f32(float %fmuladd)235 ret float %fabsf236}237 238; Don't introduce a second fpext239 240define double @multi_use_fabs_fpext(float %x) {241; CHECK-LABEL: @multi_use_fabs_fpext(242; CHECK-NEXT: [[FPEXT:%.*]] = fpext float [[X:%.*]] to double243; CHECK-NEXT: [[FABS:%.*]] = call double @llvm.fabs.f64(double [[FPEXT]])244; CHECK-NEXT: store volatile double [[FPEXT]], ptr undef, align 8245; CHECK-NEXT: ret double [[FABS]]246;247 %fpext = fpext float %x to double248 %fabs = call double @llvm.fabs.f64(double %fpext)249 store volatile double %fpext, ptr undef250 ret double %fabs251}252 253; X <= 0.0 ? (0.0 - X) : X --> fabs(X)254 255define double @select_fcmp_ole_zero(double %x) {256; CHECK-LABEL: @select_fcmp_ole_zero(257; CHECK-NEXT: [[FABS:%.*]] = call double @llvm.fabs.f64(double [[X:%.*]])258; CHECK-NEXT: ret double [[FABS]]259;260 %lezero = fcmp nnan ole double %x, 0.0261 %negx = fsub double 0.0, %x262 %fabs = select i1 %lezero, double %negx, double %x263 ret double %fabs264}265 266define double @select_fcmp_ole_zero_no_nnan(double %x) {267; CHECK-LABEL: @select_fcmp_ole_zero_no_nnan(268; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ole double [[X:%.*]], 0.000000e+00269; CHECK-NEXT: [[NEGX:%.*]] = fsub double 0.000000e+00, [[X]]270; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], double [[NEGX]], double [[X]]271; CHECK-NEXT: ret double [[FABS]]272;273 %lezero = fcmp ole double %x, 0.0274 %negx = fsub double 0.0, %x275 %fabs = select i1 %lezero, double %negx, double %x276 ret double %fabs277}278 279define double @select_fcmp_ole_zero_no_nnan_input_nofpclass_nan(double nofpclass(nan) %x) {280; CHECK-LABEL: @select_fcmp_ole_zero_no_nnan_input_nofpclass_nan(281; CHECK-NEXT: [[FABS:%.*]] = call double @llvm.fabs.f64(double [[X:%.*]])282; CHECK-NEXT: ret double [[FABS]]283;284 %lezero = fcmp ole double %x, 0.0285 %negx = fsub double 0.0, %x286 %fabs = select i1 %lezero, double %negx, double %x287 ret double %fabs288}289 290define double @select_fcmp_ole_zero_select_nnan(double %x) {291; CHECK-LABEL: @select_fcmp_ole_zero_select_nnan(292; CHECK-NEXT: [[FABS:%.*]] = call nnan double @llvm.fabs.f64(double [[X:%.*]])293; CHECK-NEXT: ret double [[FABS]]294;295 %lezero = fcmp ole double %x, 0.0296 %negx = fsub double 0.0, %x297 %fabs = select nnan i1 %lezero, double %negx, double %x298 ret double %fabs299}300 301define double @select_fcmp_nnan_ole_zero(double %x) {302; CHECK-LABEL: @select_fcmp_nnan_ole_zero(303; CHECK-NEXT: [[FABS:%.*]] = call double @llvm.fabs.f64(double [[X:%.*]])304; CHECK-NEXT: ret double [[FABS]]305;306 %lezero = fcmp nnan ole double %x, 0.0307 %negx = fsub nnan double 0.0, %x308 %fabs = select i1 %lezero, double %negx, double %x309 ret double %fabs310}311 312define double @select_nnan_fcmp_nnan_ole_zero(double %x) {313; CHECK-LABEL: @select_nnan_fcmp_nnan_ole_zero(314; CHECK-NEXT: [[FABS:%.*]] = call nnan double @llvm.fabs.f64(double [[X:%.*]])315; CHECK-NEXT: ret double [[FABS]]316;317 %lezero = fcmp nnan ole double %x, 0.0318 %negx = fsub nnan double 0.0, %x319 %fabs = select nnan i1 %lezero, double %negx, double %x320 ret double %fabs321}322 323; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.324 325define double @select_fcmp_nnan_ule_zero(double %x) {326; CHECK-LABEL: @select_fcmp_nnan_ule_zero(327; CHECK-NEXT: [[FABS:%.*]] = call double @llvm.fabs.f64(double [[X:%.*]])328; CHECK-NEXT: ret double [[FABS]]329;330 %lezero = fcmp nnan ule double %x, 0.0331 %negx = fsub nnan double 0.0, %x332 %fabs = select i1 %lezero, double %negx, double %x333 ret double %fabs334}335 336; Negative test - wrong predicate.337 338define double @select_fcmp_nnan_olt_zero(double %x) {339; CHECK-LABEL: @select_fcmp_nnan_olt_zero(340; CHECK-NEXT: [[LEZERO:%.*]] = fcmp olt double [[X:%.*]], 0.000000e+00341; CHECK-NEXT: [[NEGX:%.*]] = fsub nnan double 0.000000e+00, [[X]]342; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], double [[NEGX]], double [[X]]343; CHECK-NEXT: ret double [[FABS]]344;345 %lezero = fcmp olt double %x, 0.0346 %negx = fsub nnan double 0.0, %x347 %fabs = select i1 %lezero, double %negx, double %x348 ret double %fabs349}350 351; X <= -0.0 ? (0.0 - X) : X --> fabs(X)352 353define <2 x float> @select_fcmp_nnan_ole_negzero(<2 x float> %x) {354; CHECK-LABEL: @select_fcmp_nnan_ole_negzero(355; CHECK-NEXT: [[FABS:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[X:%.*]])356; CHECK-NEXT: ret <2 x float> [[FABS]]357;358 %lezero = fcmp nnan ole <2 x float> %x, <float -0.0, float -0.0>359 %negx = fsub nnan <2 x float> <float 0.0, float poison>, %x360 %fabs = select <2 x i1> %lezero, <2 x float> %negx, <2 x float> %x361 ret <2 x float> %fabs362}363 364define <2 x float> @select_nnan_fcmp_nnan_ole_negzero(<2 x float> %x) {365; CHECK-LABEL: @select_nnan_fcmp_nnan_ole_negzero(366; CHECK-NEXT: [[FABS:%.*]] = call nnan <2 x float> @llvm.fabs.v2f32(<2 x float> [[X:%.*]])367; CHECK-NEXT: ret <2 x float> [[FABS]]368;369 %lezero = fcmp nnan ole <2 x float> %x, <float -0.0, float -0.0>370 %negx = fsub nnan <2 x float> <float 0.0, float poison>, %x371 %fabs = select nnan <2 x i1> %lezero, <2 x float> %negx, <2 x float> %x372 ret <2 x float> %fabs373}374 375; X > 0.0 ? X : (0.0 - X) --> fabs(X)376 377define fp128 @select_fcmp_ogt_zero(fp128 %x) {378; CHECK-LABEL: @select_fcmp_ogt_zero(379; CHECK-NEXT: [[FABS:%.*]] = call fp128 @llvm.fabs.f128(fp128 [[X:%.*]])380; CHECK-NEXT: ret fp128 [[FABS]]381;382 %gtzero = fcmp nnan ogt fp128 %x, zeroinitializer383 %negx = fsub fp128 zeroinitializer, %x384 %fabs = select i1 %gtzero, fp128 %x, fp128 %negx385 ret fp128 %fabs386}387 388; This is not fabs because that could produce a different signbit for a NAN input.389; PR59279390 391define float @select_nsz_fcmp_ogt_fneg(float %a) {392; CHECK-LABEL: @select_nsz_fcmp_ogt_fneg(393; CHECK-NEXT: [[FNEG:%.*]] = fneg float [[A:%.*]]394; CHECK-NEXT: [[CMP:%.*]] = fcmp ogt float [[A]], 0.000000e+00395; CHECK-NEXT: [[R:%.*]] = select nsz i1 [[CMP]], float [[A]], float [[FNEG]]396; CHECK-NEXT: ret float [[R]]397;398 %fneg = fneg float %a399 %cmp = fcmp ogt float %a, %fneg400 %r = select nsz i1 %cmp, float %a, float %fneg401 ret float %r402}403 404define float @select_nsz_nnan_fcmp_ogt_fneg(float %a) {405; CHECK-LABEL: @select_nsz_nnan_fcmp_ogt_fneg(406; CHECK-NEXT: [[R:%.*]] = call nnan nsz float @llvm.fabs.f32(float [[A:%.*]])407; CHECK-NEXT: ret float [[R]]408;409 %fneg = fneg float %a410 %cmp = fcmp ogt float %a, %fneg411 %r = select nsz nnan i1 %cmp, float %a, float %fneg412 ret float %r413}414 415define fp128 @select_fcmp_nnan_ogt_zero(fp128 %x) {416; CHECK-LABEL: @select_fcmp_nnan_ogt_zero(417; CHECK-NEXT: [[FABS:%.*]] = call fp128 @llvm.fabs.f128(fp128 [[X:%.*]])418; CHECK-NEXT: ret fp128 [[FABS]]419;420 %gtzero = fcmp nnan ogt fp128 %x, zeroinitializer421 %negx = fsub nnan fp128 zeroinitializer, %x422 %fabs = select i1 %gtzero, fp128 %x, fp128 %negx423 ret fp128 %fabs424}425 426define fp128 @select_nnan_fcmp_nnan_ogt_zero(fp128 %x) {427; CHECK-LABEL: @select_nnan_fcmp_nnan_ogt_zero(428; CHECK-NEXT: [[FABS:%.*]] = call nnan fp128 @llvm.fabs.f128(fp128 [[X:%.*]])429; CHECK-NEXT: ret fp128 [[FABS]]430;431 %gtzero = fcmp nnan ogt fp128 %x, zeroinitializer432 %negx = fsub nnan fp128 zeroinitializer, %x433 %fabs = select nnan i1 %gtzero, fp128 %x, fp128 %negx434 ret fp128 %fabs435}436 437; X > -0.0 ? X : (0.0 - X) --> fabs(X)438 439define half @select_fcmp_nnan_ogt_negzero(half %x) {440; CHECK-LABEL: @select_fcmp_nnan_ogt_negzero(441; CHECK-NEXT: [[FABS:%.*]] = call half @llvm.fabs.f16(half [[X:%.*]])442; CHECK-NEXT: ret half [[FABS]]443;444 %gtzero = fcmp nnan ogt half %x, -0.0445 %negx = fsub nnan half 0.0, %x446 %fabs = select i1 %gtzero, half %x, half %negx447 ret half %fabs448}449 450define half @select_nnan_fcmp_nnan_ogt_negzero(half %x) {451; CHECK-LABEL: @select_nnan_fcmp_nnan_ogt_negzero(452; CHECK-NEXT: [[FABS:%.*]] = call nnan half @llvm.fabs.f16(half [[X:%.*]])453; CHECK-NEXT: ret half [[FABS]]454;455 %gtzero = fcmp nnan ogt half %x, -0.0456 %negx = fsub nnan half 0.0, %x457 %fabs = select nnan i1 %gtzero, half %x, half %negx458 ret half %fabs459}460 461; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.462 463define half @select_fcmp_nnan_ugt_negzero(half %x) {464; CHECK-LABEL: @select_fcmp_nnan_ugt_negzero(465; CHECK-NEXT: [[FABS:%.*]] = call half @llvm.fabs.f16(half [[X:%.*]])466; CHECK-NEXT: ret half [[FABS]]467;468 %gtzero = fcmp nnan ugt half %x, -0.0469 %negx = fsub nnan half 0.0, %x470 %fabs = select i1 %gtzero, half %x, half %negx471 ret half %fabs472}473 474; Negative test - wrong predicate.475 476define half @select_fcmp_nnan_oge_negzero(half %x) {477; CHECK-LABEL: @select_fcmp_nnan_oge_negzero(478; CHECK-NEXT: [[GTZERO:%.*]] = fcmp oge half [[X:%.*]], 0xH0000479; CHECK-NEXT: [[NEGX:%.*]] = fsub nnan half 0xH0000, [[X]]480; CHECK-NEXT: [[FABS:%.*]] = select i1 [[GTZERO]], half [[X]], half [[NEGX]]481; CHECK-NEXT: ret half [[FABS]]482;483 %gtzero = fcmp oge half %x, -0.0484 %negx = fsub nnan half 0.0, %x485 %fabs = select i1 %gtzero, half %x, half %negx486 ret half %fabs487}488 489; This is not fabs because that could produce a different signbit for a NAN input.490; PR59279491 492define double @select_nsz_fcmp_olt_zero_unary_fneg(double %x) {493; CHECK-LABEL: @select_nsz_fcmp_olt_zero_unary_fneg(494; CHECK-NEXT: [[LTZERO:%.*]] = fcmp olt double [[X:%.*]], 0.000000e+00495; CHECK-NEXT: [[NEGX:%.*]] = fneg double [[X]]496; CHECK-NEXT: [[FABS:%.*]] = select nsz i1 [[LTZERO]], double [[NEGX]], double [[X]]497; CHECK-NEXT: ret double [[FABS]]498;499 %ltzero = fcmp olt double %x, 0.0500 %negx = fneg double %x501 %fabs = select nsz i1 %ltzero, double %negx, double %x502 ret double %fabs503}504 505; X < 0.0 ? -X : X --> fabs(X)506 507define double @select_nsz_nnan_fcmp_olt_zero_unary_fneg(double %x) {508; CHECK-LABEL: @select_nsz_nnan_fcmp_olt_zero_unary_fneg(509; CHECK-NEXT: [[FABS:%.*]] = call nnan nsz double @llvm.fabs.f64(double [[X:%.*]])510; CHECK-NEXT: ret double [[FABS]]511;512 %ltzero = fcmp olt double %x, 0.0513 %negx = fneg double %x514 %fabs = select nsz nnan i1 %ltzero, double %negx, double %x515 ret double %fabs516}517 518define double @select_fcmp_nnan_nsz_olt_zero(double %x) {519; CHECK-LABEL: @select_fcmp_nnan_nsz_olt_zero(520; CHECK-NEXT: [[LTZERO:%.*]] = fcmp olt double [[X:%.*]], 0.000000e+00521; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz double [[X]]522; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LTZERO]], double [[NEGX]], double [[X]]523; CHECK-NEXT: ret double [[FABS]]524;525 %ltzero = fcmp olt double %x, 0.0526 %negx = fsub nnan nsz double -0.0, %x527 %fabs = select i1 %ltzero, double %negx, double %x528 ret double %fabs529}530 531define double @select_nnan_nsz_fcmp_nnan_nsz_olt_zero(double %x) {532; CHECK-LABEL: @select_nnan_nsz_fcmp_nnan_nsz_olt_zero(533; CHECK-NEXT: [[FABS:%.*]] = call nnan nsz double @llvm.fabs.f64(double [[X:%.*]])534; CHECK-NEXT: ret double [[FABS]]535;536 %ltzero = fcmp olt double %x, 0.0537 %negx = fsub nnan nsz double -0.0, %x538 %fabs = select nnan nsz i1 %ltzero, double %negx, double %x539 ret double %fabs540}541 542; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.543 544define double @select_fcmp_nnan_nsz_ult_zero(double %x) {545; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_zero(546; CHECK-NEXT: [[LTZERO:%.*]] = fcmp ult double [[X:%.*]], 0.000000e+00547; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz double [[X]]548; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[LTZERO]], double [[NEGX]], double [[X]]549; CHECK-NEXT: ret double [[FABS]]550;551 %ltzero = fcmp ult double %x, 0.0552 %negx = fsub nnan nsz double -0.0, %x553 %fabs = select i1 %ltzero, double %negx, double %x554 ret double %fabs555}556 557define double @select_fcmp_nnan_nsz_olt_zero_unary_fneg(double %x) {558; CHECK-LABEL: @select_fcmp_nnan_nsz_olt_zero_unary_fneg(559; CHECK-NEXT: [[LTZERO:%.*]] = fcmp olt double [[X:%.*]], 0.000000e+00560; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz double [[X]]561; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LTZERO]], double [[NEGX]], double [[X]]562; CHECK-NEXT: ret double [[FABS]]563;564 %ltzero = fcmp olt double %x, 0.0565 %negx = fneg nnan nsz double %x566 %fabs = select i1 %ltzero, double %negx, double %x567 ret double %fabs568}569 570; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.571 572define double @select_fcmp_nnan_nsz_ult_zero_unary_fneg(double %x) {573; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_zero_unary_fneg(574; CHECK-NEXT: [[LTZERO:%.*]] = fcmp ult double [[X:%.*]], 0.000000e+00575; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz double [[X]]576; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[LTZERO]], double [[NEGX]], double [[X]]577; CHECK-NEXT: ret double [[FABS]]578;579 %ltzero = fcmp ult double %x, 0.0580 %negx = fneg nnan nsz double %x581 %fabs = select i1 %ltzero, double %negx, double %x582 ret double %fabs583}584 585; X < -0.0 ? -X : X --> fabs(X)586 587define float @select_fcmp_nnan_nsz_olt_negzero(float %x) {588; CHECK-LABEL: @select_fcmp_nnan_nsz_olt_negzero(589; CHECK-NEXT: [[LTZERO:%.*]] = fcmp olt float [[X:%.*]], 0.000000e+00590; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan ninf nsz float [[X]]591; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LTZERO]], float [[NEGX]], float [[X]]592; CHECK-NEXT: ret float [[FABS]]593;594 %ltzero = fcmp olt float %x, -0.0595 %negx = fsub nnan ninf nsz float -0.0, %x596 %fabs = select i1 %ltzero, float %negx, float %x597 ret float %fabs598}599 600define float @select_nnan_ninf_nsz_fcmp_nnan_nsz_olt_negzero(float %x) {601; CHECK-LABEL: @select_nnan_ninf_nsz_fcmp_nnan_nsz_olt_negzero(602; CHECK-NEXT: [[FABS:%.*]] = call nnan ninf nsz float @llvm.fabs.f32(float [[X:%.*]])603; CHECK-NEXT: ret float [[FABS]]604;605 %ltzero = fcmp olt float %x, -0.0606 %negx = fsub nnan nsz float -0.0, %x607 %fabs = select nnan ninf nsz i1 %ltzero, float %negx, float %x608 ret float %fabs609}610 611; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.612 613define float @select_fcmp_nnan_nsz_ult_negzero(float %x) {614; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_negzero(615; CHECK-NEXT: [[LTZERO:%.*]] = fcmp ult float [[X:%.*]], 0.000000e+00616; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan ninf nsz float [[X]]617; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[LTZERO]], float [[NEGX]], float [[X]]618; CHECK-NEXT: ret float [[FABS]]619;620 %ltzero = fcmp ult float %x, -0.0621 %negx = fsub nnan ninf nsz float -0.0, %x622 %fabs = select i1 %ltzero, float %negx, float %x623 ret float %fabs624}625 626define float @select_fcmp_nnan_nsz_olt_negzero_unary_fneg(float %x) {627; CHECK-LABEL: @select_fcmp_nnan_nsz_olt_negzero_unary_fneg(628; CHECK-NEXT: [[LTZERO:%.*]] = fcmp olt float [[X:%.*]], 0.000000e+00629; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan ninf nsz float [[X]]630; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LTZERO]], float [[NEGX]], float [[X]]631; CHECK-NEXT: ret float [[FABS]]632;633 %ltzero = fcmp olt float %x, -0.0634 %negx = fneg nnan ninf nsz float %x635 %fabs = select i1 %ltzero, float %negx, float %x636 ret float %fabs637}638 639; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.640 641define float @select_fcmp_nnan_nsz_ult_negzero_unary_fneg(float %x) {642; CHECK-LABEL: @select_fcmp_nnan_nsz_ult_negzero_unary_fneg(643; CHECK-NEXT: [[LTZERO:%.*]] = fcmp ult float [[X:%.*]], 0.000000e+00644; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan ninf nsz float [[X]]645; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[LTZERO]], float [[NEGX]], float [[X]]646; CHECK-NEXT: ret float [[FABS]]647;648 %ltzero = fcmp ult float %x, -0.0649 %negx = fneg nnan ninf nsz float %x650 %fabs = select i1 %ltzero, float %negx, float %x651 ret float %fabs652}653 654; X <= 0.0 ? -X : X --> fabs(X)655 656define double @select_fcmp_nnan_nsz_ole_zero(double %x) {657; CHECK-LABEL: @select_fcmp_nnan_nsz_ole_zero(658; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ole double [[X:%.*]], 0.000000e+00659; CHECK-NEXT: [[NEGX:%.*]] = fneg fast double [[X]]660; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], double [[NEGX]], double [[X]]661; CHECK-NEXT: ret double [[FABS]]662;663 %lezero = fcmp ole double %x, 0.0664 %negx = fsub fast double -0.0, %x665 %fabs = select i1 %lezero, double %negx, double %x666 ret double %fabs667}668 669define double @select_fast_fcmp_nnan_nsz_ole_zero(double %x) {670; CHECK-LABEL: @select_fast_fcmp_nnan_nsz_ole_zero(671; CHECK-NEXT: [[FABS:%.*]] = call fast double @llvm.fabs.f64(double [[X:%.*]])672; CHECK-NEXT: ret double [[FABS]]673;674 %lezero = fcmp ole double %x, 0.0675 %negx = fsub nnan nsz double -0.0, %x676 %fabs = select fast i1 %lezero, double %negx, double %x677 ret double %fabs678}679 680; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.681 682define double @select_fcmp_nnan_nsz_ule_zero(double %x) {683; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_zero(684; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ule double [[X:%.*]], 0.000000e+00685; CHECK-NEXT: [[NEGX:%.*]] = fneg fast double [[X]]686; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[LEZERO]], double [[NEGX]], double [[X]]687; CHECK-NEXT: ret double [[FABS]]688;689 %lezero = fcmp ule double %x, 0.0690 %negx = fsub fast double -0.0, %x691 %fabs = select i1 %lezero, double %negx, double %x692 ret double %fabs693}694 695define double @select_fcmp_nnan_nsz_ole_zero_unary_fneg(double %x) {696; CHECK-LABEL: @select_fcmp_nnan_nsz_ole_zero_unary_fneg(697; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ole double [[X:%.*]], 0.000000e+00698; CHECK-NEXT: [[NEGX:%.*]] = fneg fast double [[X]]699; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], double [[NEGX]], double [[X]]700; CHECK-NEXT: ret double [[FABS]]701;702 %lezero = fcmp ole double %x, 0.0703 %negx = fneg fast double %x704 %fabs = select i1 %lezero, double %negx, double %x705 ret double %fabs706}707 708; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.709 710define double @select_fcmp_nnan_nsz_ule_zero_unary_fneg(double %x) {711; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_zero_unary_fneg(712; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ule double [[X:%.*]], 0.000000e+00713; CHECK-NEXT: [[NEGX:%.*]] = fneg fast double [[X]]714; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[LEZERO]], double [[NEGX]], double [[X]]715; CHECK-NEXT: ret double [[FABS]]716;717 %lezero = fcmp ule double %x, 0.0718 %negx = fneg fast double %x719 %fabs = select i1 %lezero, double %negx, double %x720 ret double %fabs721}722 723; X <= -0.0 ? -X : X --> fabs(X)724 725define float @select_fcmp_nnan_nsz_ole_negzero(float %x) {726; CHECK-LABEL: @select_fcmp_nnan_nsz_ole_negzero(727; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ole float [[X:%.*]], 0.000000e+00728; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz float [[X]]729; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], float [[NEGX]], float [[X]]730; CHECK-NEXT: ret float [[FABS]]731;732 %lezero = fcmp ole float %x, -0.0733 %negx = fsub nnan nsz float -0.0, %x734 %fabs = select i1 %lezero, float %negx, float %x735 ret float %fabs736}737 738define float @select_nnan_nsz_fcmp_nnan_nsz_ole_negzero(float %x) {739; CHECK-LABEL: @select_nnan_nsz_fcmp_nnan_nsz_ole_negzero(740; CHECK-NEXT: [[FABS:%.*]] = call nnan nsz float @llvm.fabs.f32(float [[X:%.*]])741; CHECK-NEXT: ret float [[FABS]]742;743 %lezero = fcmp ole float %x, -0.0744 %negx = fsub nnan nsz float -0.0, %x745 %fabs = select nnan nsz i1 %lezero, float %negx, float %x746 ret float %fabs747}748 749; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.750 751define float @select_fcmp_nnan_nsz_ule_negzero(float %x) {752; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_negzero(753; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ule float [[X:%.*]], 0.000000e+00754; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz float [[X]]755; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[LEZERO]], float [[NEGX]], float [[X]]756; CHECK-NEXT: ret float [[FABS]]757;758 %lezero = fcmp ule float %x, -0.0759 %negx = fsub nnan nsz float -0.0, %x760 %fabs = select i1 %lezero, float %negx, float %x761 ret float %fabs762}763 764define float @select_fcmp_nnan_nsz_ole_negzero_unary_fneg(float %x) {765; CHECK-LABEL: @select_fcmp_nnan_nsz_ole_negzero_unary_fneg(766; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ole float [[X:%.*]], 0.000000e+00767; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz float [[X]]768; CHECK-NEXT: [[FABS:%.*]] = select i1 [[LEZERO]], float [[NEGX]], float [[X]]769; CHECK-NEXT: ret float [[FABS]]770;771 %lezero = fcmp ole float %x, -0.0772 %negx = fneg nnan nsz float %x773 %fabs = select i1 %lezero, float %negx, float %x774 ret float %fabs775}776 777; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.778 779define float @select_fcmp_nnan_nsz_ule_negzero_unary_fneg(float %x) {780; CHECK-LABEL: @select_fcmp_nnan_nsz_ule_negzero_unary_fneg(781; CHECK-NEXT: [[LEZERO:%.*]] = fcmp ule float [[X:%.*]], 0.000000e+00782; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz float [[X]]783; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[LEZERO]], float [[NEGX]], float [[X]]784; CHECK-NEXT: ret float [[FABS]]785;786 %lezero = fcmp ule float %x, -0.0787 %negx = fneg nnan nsz float %x788 %fabs = select i1 %lezero, float %negx, float %x789 ret float %fabs790}791 792; This is not fabs because that could produce a different signbit for a NAN input.793; PR59279794 795define <2 x float> @select_nsz_fcmp_ogt_zero_unary_fneg(<2 x float> %x) {796; CHECK-LABEL: @select_nsz_fcmp_ogt_zero_unary_fneg(797; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ogt <2 x float> [[X:%.*]], zeroinitializer798; CHECK-NEXT: [[NEGX:%.*]] = fneg <2 x float> [[X]]799; CHECK-NEXT: [[FABS:%.*]] = select nsz <2 x i1> [[GTZERO]], <2 x float> [[X]], <2 x float> [[NEGX]]800; CHECK-NEXT: ret <2 x float> [[FABS]]801;802 %gtzero = fcmp ogt <2 x float> %x, zeroinitializer803 %negx = fneg <2 x float> %x804 %fabs = select nsz <2 x i1> %gtzero, <2 x float> %x, <2 x float> %negx805 ret <2 x float> %fabs806}807 808; X > 0.0 ? X : (-X) --> fabs(X)809 810define <2 x float> @select_nsz_nnan_fcmp_ogt_zero_unary_fneg(<2 x float> %x) {811; CHECK-LABEL: @select_nsz_nnan_fcmp_ogt_zero_unary_fneg(812; CHECK-NEXT: [[FABS:%.*]] = call nnan nsz <2 x float> @llvm.fabs.v2f32(<2 x float> [[X:%.*]])813; CHECK-NEXT: ret <2 x float> [[FABS]]814;815 %gtzero = fcmp ogt <2 x float> %x, zeroinitializer816 %negx = fneg <2 x float> %x817 %fabs = select nsz nnan <2 x i1> %gtzero, <2 x float> %x, <2 x float> %negx818 ret <2 x float> %fabs819}820 821define <2 x float> @select_fcmp_nnan_nsz_ogt_zero(<2 x float> %x) {822; CHECK-LABEL: @select_fcmp_nnan_nsz_ogt_zero(823; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ogt <2 x float> [[X:%.*]], zeroinitializer824; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz arcp <2 x float> [[X]]825; CHECK-NEXT: [[FABS:%.*]] = select nnan <2 x i1> [[GTZERO]], <2 x float> [[X]], <2 x float> [[NEGX]]826; CHECK-NEXT: ret <2 x float> [[FABS]]827;828 %gtzero = fcmp ogt <2 x float> %x, zeroinitializer829 %negx = fsub nnan nsz arcp <2 x float> <float -0.0, float -0.0>, %x830 %fabs = select <2 x i1> %gtzero, <2 x float> %x, <2 x float> %negx831 ret <2 x float> %fabs832}833 834; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.835 836define <2 x float> @select_fcmp_nnan_nsz_ugt_zero(<2 x float> %x) {837; CHECK-LABEL: @select_fcmp_nnan_nsz_ugt_zero(838; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ugt <2 x float> [[X:%.*]], zeroinitializer839; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz arcp <2 x float> [[X]]840; CHECK-NEXT: [[FABS:%.*]] = select <2 x i1> [[GTZERO]], <2 x float> [[X]], <2 x float> [[NEGX]]841; CHECK-NEXT: ret <2 x float> [[FABS]]842;843 %gtzero = fcmp ugt <2 x float> %x, zeroinitializer844 %negx = fsub nnan nsz arcp <2 x float> <float -0.0, float -0.0>, %x845 %fabs = select <2 x i1> %gtzero, <2 x float> %x, <2 x float> %negx846 ret <2 x float> %fabs847}848 849define <2 x float> @select_fcmp_nnan_nsz_ogt_zero_unary_fneg(<2 x float> %x) {850; CHECK-LABEL: @select_fcmp_nnan_nsz_ogt_zero_unary_fneg(851; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ogt <2 x float> [[X:%.*]], zeroinitializer852; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz arcp <2 x float> [[X]]853; CHECK-NEXT: [[FABS:%.*]] = select nnan <2 x i1> [[GTZERO]], <2 x float> [[X]], <2 x float> [[NEGX]]854; CHECK-NEXT: ret <2 x float> [[FABS]]855;856 %gtzero = fcmp ogt <2 x float> %x, zeroinitializer857 %negx = fneg nnan nsz arcp <2 x float> %x858 %fabs = select <2 x i1> %gtzero, <2 x float> %x, <2 x float> %negx859 ret <2 x float> %fabs860}861 862; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.863 864define <2 x float> @select_fcmp_nnan_nsz_ugt_zero_unary_fneg(<2 x float> %x) {865; CHECK-LABEL: @select_fcmp_nnan_nsz_ugt_zero_unary_fneg(866; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ugt <2 x float> [[X:%.*]], zeroinitializer867; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz arcp <2 x float> [[X]]868; CHECK-NEXT: [[FABS:%.*]] = select <2 x i1> [[GTZERO]], <2 x float> [[X]], <2 x float> [[NEGX]]869; CHECK-NEXT: ret <2 x float> [[FABS]]870;871 %gtzero = fcmp ugt <2 x float> %x, zeroinitializer872 %negx = fneg nnan nsz arcp <2 x float> %x873 %fabs = select <2 x i1> %gtzero, <2 x float> %x, <2 x float> %negx874 ret <2 x float> %fabs875}876 877; X > -0.0 ? X : (0.0 - X) --> fabs(X)878 879define half @select_fcmp_nnan_nsz_ogt_negzero(half %x) {880; CHECK-LABEL: @select_fcmp_nnan_nsz_ogt_negzero(881; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ogt half [[X:%.*]], 0xH0000882; CHECK-NEXT: [[NEGX:%.*]] = fneg fast half [[X]]883; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[GTZERO]], half [[X]], half [[NEGX]]884; CHECK-NEXT: ret half [[FABS]]885;886 %gtzero = fcmp ogt half %x, -0.0887 %negx = fsub fast half 0.0, %x888 %fabs = select i1 %gtzero, half %x, half %negx889 ret half %fabs890}891 892; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.893 894define half @select_fcmp_nnan_nsz_ugt_negzero(half %x) {895; CHECK-LABEL: @select_fcmp_nnan_nsz_ugt_negzero(896; CHECK-NEXT: [[GTZERO:%.*]] = fcmp ugt half [[X:%.*]], 0xH0000897; CHECK-NEXT: [[NEGX:%.*]] = fneg fast half [[X]]898; CHECK-NEXT: [[FABS:%.*]] = select i1 [[GTZERO]], half [[X]], half [[NEGX]]899; CHECK-NEXT: ret half [[FABS]]900;901 %gtzero = fcmp ugt half %x, -0.0902 %negx = fsub fast half 0.0, %x903 %fabs = select i1 %gtzero, half %x, half %negx904 ret half %fabs905}906 907; X > 0.0 ? X : (0.0 - X) --> fabs(X)908 909define <2 x double> @select_fcmp_nnan_nsz_oge_zero(<2 x double> %x) {910; CHECK-LABEL: @select_fcmp_nnan_nsz_oge_zero(911; CHECK-NEXT: [[GEZERO:%.*]] = fcmp oge <2 x double> [[X:%.*]], zeroinitializer912; CHECK-NEXT: [[NEGX:%.*]] = fneg reassoc nnan nsz <2 x double> [[X]]913; CHECK-NEXT: [[FABS:%.*]] = select nnan <2 x i1> [[GEZERO]], <2 x double> [[X]], <2 x double> [[NEGX]]914; CHECK-NEXT: ret <2 x double> [[FABS]]915;916 %gezero = fcmp oge <2 x double> %x, zeroinitializer917 %negx = fsub nnan nsz reassoc <2 x double> <double -0.0, double -0.0>, %x918 %fabs = select <2 x i1> %gezero, <2 x double> %x, <2 x double> %negx919 ret <2 x double> %fabs920}921 922; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.923 924define <2 x double> @select_fcmp_nnan_nsz_uge_zero(<2 x double> %x) {925; CHECK-LABEL: @select_fcmp_nnan_nsz_uge_zero(926; CHECK-NEXT: [[GEZERO:%.*]] = fcmp uge <2 x double> [[X:%.*]], zeroinitializer927; CHECK-NEXT: [[NEGX:%.*]] = fneg reassoc nnan nsz <2 x double> [[X]]928; CHECK-NEXT: [[FABS:%.*]] = select <2 x i1> [[GEZERO]], <2 x double> [[X]], <2 x double> [[NEGX]]929; CHECK-NEXT: ret <2 x double> [[FABS]]930;931 %gezero = fcmp uge <2 x double> %x, zeroinitializer932 %negx = fsub nnan nsz reassoc <2 x double> <double -0.0, double -0.0>, %x933 %fabs = select <2 x i1> %gezero, <2 x double> %x, <2 x double> %negx934 ret <2 x double> %fabs935}936 937define <2 x double> @select_fcmp_nnan_nsz_oge_zero_unary_fneg(<2 x double> %x) {938; CHECK-LABEL: @select_fcmp_nnan_nsz_oge_zero_unary_fneg(939; CHECK-NEXT: [[GEZERO:%.*]] = fcmp oge <2 x double> [[X:%.*]], zeroinitializer940; CHECK-NEXT: [[NEGX:%.*]] = fneg reassoc nnan nsz <2 x double> [[X]]941; CHECK-NEXT: [[FABS:%.*]] = select nnan <2 x i1> [[GEZERO]], <2 x double> [[X]], <2 x double> [[NEGX]]942; CHECK-NEXT: ret <2 x double> [[FABS]]943;944 %gezero = fcmp oge <2 x double> %x, zeroinitializer945 %negx = fneg nnan nsz reassoc <2 x double> %x946 %fabs = select <2 x i1> %gezero, <2 x double> %x, <2 x double> %negx947 ret <2 x double> %fabs948}949 950; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.951 952define <2 x double> @select_fcmp_nnan_nsz_uge_zero_unary_fneg(<2 x double> %x) {953; CHECK-LABEL: @select_fcmp_nnan_nsz_uge_zero_unary_fneg(954; CHECK-NEXT: [[GEZERO:%.*]] = fcmp uge <2 x double> [[X:%.*]], zeroinitializer955; CHECK-NEXT: [[NEGX:%.*]] = fneg reassoc nnan nsz <2 x double> [[X]]956; CHECK-NEXT: [[FABS:%.*]] = select <2 x i1> [[GEZERO]], <2 x double> [[X]], <2 x double> [[NEGX]]957; CHECK-NEXT: ret <2 x double> [[FABS]]958;959 %gezero = fcmp uge <2 x double> %x, zeroinitializer960 %negx = fneg nnan nsz reassoc <2 x double> %x961 %fabs = select <2 x i1> %gezero, <2 x double> %x, <2 x double> %negx962 ret <2 x double> %fabs963}964 965; X > -0.0 ? X : (0.0 - X) --> fabs(X)966 967define half @select_fcmp_nnan_nsz_oge_negzero(half %x) {968; CHECK-LABEL: @select_fcmp_nnan_nsz_oge_negzero(969; CHECK-NEXT: [[GEZERO:%.*]] = fcmp oge half [[X:%.*]], 0xH0000970; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz half [[X]]971; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[GEZERO]], half [[X]], half [[NEGX]]972; CHECK-NEXT: ret half [[FABS]]973;974 %gezero = fcmp oge half %x, -0.0975 %negx = fsub nnan nsz half -0.0, %x976 %fabs = select i1 %gezero, half %x, half %negx977 ret half %fabs978}979 980; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.981 982define half @select_fcmp_nnan_nsz_uge_negzero(half %x) {983; CHECK-LABEL: @select_fcmp_nnan_nsz_uge_negzero(984; CHECK-NEXT: [[GEZERO:%.*]] = fcmp uge half [[X:%.*]], 0xH0000985; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz half [[X]]986; CHECK-NEXT: [[FABS:%.*]] = select i1 [[GEZERO]], half [[X]], half [[NEGX]]987; CHECK-NEXT: ret half [[FABS]]988;989 %gezero = fcmp uge half %x, -0.0990 %negx = fsub nnan nsz half -0.0, %x991 %fabs = select i1 %gezero, half %x, half %negx992 ret half %fabs993}994 995define half @select_fcmp_nnan_nsz_oge_negzero_unary_fneg(half %x) {996; CHECK-LABEL: @select_fcmp_nnan_nsz_oge_negzero_unary_fneg(997; CHECK-NEXT: [[GEZERO:%.*]] = fcmp oge half [[X:%.*]], 0xH0000998; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz half [[X]]999; CHECK-NEXT: [[FABS:%.*]] = select nnan i1 [[GEZERO]], half [[X]], half [[NEGX]]1000; CHECK-NEXT: ret half [[FABS]]1001;1002 %gezero = fcmp oge half %x, -0.01003 %negx = fneg nnan nsz half %x1004 %fabs = select i1 %gezero, half %x, half %negx1005 ret half %fabs1006}1007 1008; Repeat with unordered predicate - nnan allows us to treat ordered/unordered identically.1009 1010define half @select_fcmp_nnan_nsz_uge_negzero_unary_fneg(half %x) {1011; CHECK-LABEL: @select_fcmp_nnan_nsz_uge_negzero_unary_fneg(1012; CHECK-NEXT: [[GEZERO:%.*]] = fcmp uge half [[X:%.*]], 0xH00001013; CHECK-NEXT: [[NEGX:%.*]] = fneg nnan nsz half [[X]]1014; CHECK-NEXT: [[FABS:%.*]] = select i1 [[GEZERO]], half [[X]], half [[NEGX]]1015; CHECK-NEXT: ret half [[FABS]]1016;1017 %gezero = fcmp uge half %x, -0.01018 %negx = fneg nnan nsz half %x1019 %fabs = select i1 %gezero, half %x, half %negx1020 ret half %fabs1021}1022 1023define float @select_fneg(i1 %c, float %x) {1024; CHECK-LABEL: @select_fneg(1025; CHECK-NEXT: [[FABS:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])1026; CHECK-NEXT: ret float [[FABS]]1027;1028 %n = fneg float %x1029 %s = select i1 %c, float %n, float %x1030 %fabs = call float @llvm.fabs.f32(float %s)1031 ret float %fabs1032}1033 1034define float @select_fneg_use1(i1 %c, float %x) {1035; CHECK-LABEL: @select_fneg_use1(1036; CHECK-NEXT: [[N:%.*]] = fneg float [[X:%.*]]1037; CHECK-NEXT: call void @use(float [[N]])1038; CHECK-NEXT: [[FABS:%.*]] = call fast float @llvm.fabs.f32(float [[X]])1039; CHECK-NEXT: ret float [[FABS]]1040;1041 %n = fneg float %x1042 call void @use(float %n)1043 %s = select i1 %c, float %x, float %n1044 %fabs = call fast float @llvm.fabs.f32(float %s)1045 ret float %fabs1046}1047 1048define float @select_fneg_use2(i1 %c, float %x) {1049; CHECK-LABEL: @select_fneg_use2(1050; CHECK-NEXT: [[N:%.*]] = fneg arcp float [[X:%.*]]1051; CHECK-NEXT: [[S:%.*]] = select i1 [[C:%.*]], float [[N]], float [[X]]1052; CHECK-NEXT: call void @use(float [[S]])1053; CHECK-NEXT: [[FABS:%.*]] = call nnan nsz float @llvm.fabs.f32(float [[X]])1054; CHECK-NEXT: ret float [[FABS]]1055;1056 %n = fneg arcp float %x1057 %s = select i1 %c, float %n, float %x1058 call void @use(float %s)1059 %fabs = call nnan nsz float @llvm.fabs.f32(float %s)1060 ret float %fabs1061}1062 1063define <2 x float> @select_fneg_vec(<2 x i1> %c, <2 x float> %x) {1064; CHECK-LABEL: @select_fneg_vec(1065; CHECK-NEXT: [[FABS:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[X:%.*]])1066; CHECK-NEXT: ret <2 x float> [[FABS]]1067;1068 %n = fneg <2 x float> %x1069 %s = select fast <2 x i1> %c, <2 x float> %x, <2 x float> %n1070 %fabs = call <2 x float> @llvm.fabs.v2f32(<2 x float> %s)1071 ret <2 x float> %fabs1072}1073 1074define float @test_select_neg_negx_x(float %value) {1075; CHECK-LABEL: @test_select_neg_negx_x(1076; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = call float @llvm.fabs.f32(float [[VALUE:%.*]])1077; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1078;1079 %a0 = bitcast float %value to i321080 %a1 = icmp slt i32 %a0, 01081 %fneg.i = fneg float %value1082 %value.addr.0.i = select i1 %a1, float %fneg.i, float %value1083 ret float %value.addr.0.i1084}1085 1086define float @test_select_nneg_negx_x(float %value) {1087; CHECK-LABEL: @test_select_nneg_negx_x(1088; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[VALUE:%.*]])1089; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = fneg float [[TMP1]]1090; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1091;1092 %a0 = bitcast float %value to i321093 %a1 = icmp sgt i32 %a0, -11094 %fneg.i = fneg float %value1095 %value.addr.0.i = select i1 %a1, float %fneg.i, float %value1096 ret float %value.addr.0.i1097}1098 1099define float @test_select_neg_x_negx(float %value) {1100; CHECK-LABEL: @test_select_neg_x_negx(1101; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[VALUE:%.*]])1102; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = fneg float [[TMP1]]1103; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1104;1105 %a0 = bitcast float %value to i321106 %a1 = icmp slt i32 %a0, 01107 %fneg.i = fneg float %value1108 %value.addr.0.i = select i1 %a1, float %value, float %fneg.i1109 ret float %value.addr.0.i1110}1111 1112define float @test_select_nneg_x_negx(float %value) {1113; CHECK-LABEL: @test_select_nneg_x_negx(1114; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = call float @llvm.fabs.f32(float [[VALUE:%.*]])1115; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1116;1117 %a0 = bitcast float %value to i321118 %a1 = icmp sgt i32 %a0, -11119 %fneg.i = fneg float %value1120 %value.addr.0.i = select i1 %a1, float %value, float %fneg.i1121 ret float %value.addr.0.i1122}1123 1124define float @test_select_neg_negx_x_multiuse1(float %value) {1125; CHECK-LABEL: @test_select_neg_negx_x_multiuse1(1126; CHECK-NEXT: [[A0:%.*]] = bitcast float [[VALUE:%.*]] to i321127; CHECK-NEXT: [[A1:%.*]] = icmp slt i32 [[A0]], 01128; CHECK-NEXT: call void @usebool(i1 [[A1]])1129; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = call float @llvm.fabs.f32(float [[VALUE]])1130; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1131;1132 %a0 = bitcast float %value to i321133 %a1 = icmp slt i32 %a0, 01134 call void @usebool(i1 %a1)1135 %fneg.i = fneg float %value1136 %value.addr.0.i = select i1 %a1, float %fneg.i, float %value1137 ret float %value.addr.0.i1138}1139 1140define float @test_select_neg_negx_x_multiuse2(float %value) {1141; CHECK-LABEL: @test_select_neg_negx_x_multiuse2(1142; CHECK-NEXT: [[FNEG_I:%.*]] = fneg float [[VALUE:%.*]]1143; CHECK-NEXT: call void @use(float [[FNEG_I]])1144; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = call float @llvm.fabs.f32(float [[VALUE]])1145; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1146;1147 %a0 = bitcast float %value to i321148 %a1 = icmp slt i32 %a0, 01149 %fneg.i = fneg float %value1150 call void @use(float %fneg.i)1151 %value.addr.0.i = select i1 %a1, float %fneg.i, float %value1152 ret float %value.addr.0.i1153}1154 1155define float @test_select_neg_negx_x_multiuse3(float %value) {1156; CHECK-LABEL: @test_select_neg_negx_x_multiuse3(1157; CHECK-NEXT: [[A0:%.*]] = bitcast float [[VALUE:%.*]] to i321158; CHECK-NEXT: [[A1:%.*]] = icmp slt i32 [[A0]], 01159; CHECK-NEXT: call void @usebool(i1 [[A1]])1160; CHECK-NEXT: [[FNEG_I:%.*]] = fneg float [[VALUE]]1161; CHECK-NEXT: call void @use(float [[FNEG_I]])1162; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = call float @llvm.fabs.f32(float [[VALUE]])1163; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1164;1165 %a0 = bitcast float %value to i321166 %a1 = icmp slt i32 %a0, 01167 call void @usebool(i1 %a1)1168 %fneg.i = fneg float %value1169 call void @use(float %fneg.i)1170 %value.addr.0.i = select i1 %a1, float %fneg.i, float %value1171 ret float %value.addr.0.i1172}1173 1174define float @test_select_neg_negx_x_fmf(float %value) {1175; CHECK-LABEL: @test_select_neg_negx_x_fmf(1176; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = call nnan ninf nsz float @llvm.fabs.f32(float [[VALUE:%.*]])1177; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1178;1179 %a0 = bitcast float %value to i321180 %a1 = icmp slt i32 %a0, 01181 %fneg.i = fneg float %value1182 %value.addr.0.i = select nsz nnan ninf i1 %a1, float %fneg.i, float %value1183 ret float %value.addr.0.i1184}1185 1186define float @test_select_nneg_negx_x_fmf(float %value) {1187; CHECK-LABEL: @test_select_nneg_negx_x_fmf(1188; CHECK-NEXT: [[TMP1:%.*]] = call nnan ninf nsz float @llvm.fabs.f32(float [[VALUE:%.*]])1189; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = fneg nnan ninf nsz float [[TMP1]]1190; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1191;1192 %a0 = bitcast float %value to i321193 %a1 = icmp sgt i32 %a0, -11194 %fneg.i = fneg float %value1195 %value.addr.0.i = select nsz nnan ninf i1 %a1, float %fneg.i, float %value1196 ret float %value.addr.0.i1197}1198 1199; Negative tests1200 1201define float @test_select_nneg_negx_x_multiuse4(float %value) {1202; CHECK-LABEL: @test_select_nneg_negx_x_multiuse4(1203; CHECK-NEXT: [[A0:%.*]] = bitcast float [[VALUE:%.*]] to i321204; CHECK-NEXT: [[A1:%.*]] = icmp sgt i32 [[A0]], -11205; CHECK-NEXT: call void @usebool(i1 [[A1]])1206; CHECK-NEXT: [[FNEG_I:%.*]] = fneg float [[VALUE]]1207; CHECK-NEXT: call void @use(float [[FNEG_I]])1208; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = select i1 [[A1]], float [[FNEG_I]], float [[VALUE]]1209; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1210;1211 %a0 = bitcast float %value to i321212 %a1 = icmp sgt i32 %a0, -11213 call void @usebool(i1 %a1)1214 %fneg.i = fneg float %value1215 call void @use(float %fneg.i)1216 %value.addr.0.i = select i1 %a1, float %fneg.i, float %value1217 ret float %value.addr.0.i1218}1219 1220define float @test_select_neg_negx_x_mismatched1(float %value, float %y) {1221; CHECK-LABEL: @test_select_neg_negx_x_mismatched1(1222; CHECK-NEXT: [[A0:%.*]] = bitcast float [[Y:%.*]] to i321223; CHECK-NEXT: [[A1:%.*]] = icmp slt i32 [[A0]], 01224; CHECK-NEXT: [[FNEG_I:%.*]] = fneg float [[VALUE:%.*]]1225; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = select i1 [[A1]], float [[FNEG_I]], float [[VALUE]]1226; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1227;1228 %a0 = bitcast float %y to i321229 %a1 = icmp slt i32 %a0, 01230 %fneg.i = fneg float %value1231 %value.addr.0.i = select i1 %a1, float %fneg.i, float %value1232 ret float %value.addr.0.i1233}1234 1235define float @test_select_neg_negx_x_mismatched2(float %value, float %y) {1236; CHECK-LABEL: @test_select_neg_negx_x_mismatched2(1237; CHECK-NEXT: [[A0:%.*]] = bitcast float [[VALUE:%.*]] to i321238; CHECK-NEXT: [[A1:%.*]] = icmp slt i32 [[A0]], 01239; CHECK-NEXT: [[FNEG_I:%.*]] = fneg float [[Y:%.*]]1240; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = select i1 [[A1]], float [[FNEG_I]], float [[VALUE]]1241; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1242;1243 %a0 = bitcast float %value to i321244 %a1 = icmp slt i32 %a0, 01245 %fneg.i = fneg float %y1246 %value.addr.0.i = select i1 %a1, float %fneg.i, float %value1247 ret float %value.addr.0.i1248}1249 1250define float @test_select_neg_negx_x_mismatched3(float %value, float %y) {1251; CHECK-LABEL: @test_select_neg_negx_x_mismatched3(1252; CHECK-NEXT: [[A0:%.*]] = bitcast float [[VALUE:%.*]] to i321253; CHECK-NEXT: [[A1:%.*]] = icmp slt i32 [[A0]], 01254; CHECK-NEXT: [[FNEG_I:%.*]] = fneg float [[VALUE]]1255; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = select i1 [[A1]], float [[FNEG_I]], float [[Y:%.*]]1256; CHECK-NEXT: ret float [[VALUE_ADDR_0_I]]1257;1258 %a0 = bitcast float %value to i321259 %a1 = icmp slt i32 %a0, 01260 %fneg.i = fneg float %value1261 %value.addr.0.i = select i1 %a1, float %fneg.i, float %y1262 ret float %value.addr.0.i1263}1264 1265define <2 x float> @test_select_neg_negx_x_wrong_type(<2 x float> %value) {1266; CHECK-LABEL: @test_select_neg_negx_x_wrong_type(1267; CHECK-NEXT: [[A0:%.*]] = bitcast <2 x float> [[VALUE:%.*]] to i641268; CHECK-NEXT: [[A1:%.*]] = icmp slt i64 [[A0]], 01269; CHECK-NEXT: [[FNEG_I:%.*]] = fneg <2 x float> [[VALUE]]1270; CHECK-NEXT: [[VALUE_ADDR_0_I:%.*]] = select i1 [[A1]], <2 x float> [[FNEG_I]], <2 x float> [[VALUE]]1271; CHECK-NEXT: ret <2 x float> [[VALUE_ADDR_0_I]]1272;1273 %a0 = bitcast <2 x float> %value to i641274 %a1 = icmp slt i64 %a0, 01275 %fneg.i = fneg <2 x float> %value1276 %value.addr.0.i = select i1 %a1, <2 x float> %fneg.i, <2 x float> %value1277 ret <2 x float> %value.addr.0.i1278}1279 1280define i1 @test_fabs_used_by_fcmp(float %x, float %y) {1281; CHECK-LABEL: @test_fabs_used_by_fcmp(1282; CHECK-NEXT: [[SEL:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])1283; CHECK-NEXT: [[CMP2:%.*]] = fcmp olt float [[SEL]], [[Y:%.*]]1284; CHECK-NEXT: ret i1 [[CMP2]]1285;1286 %cmp = fcmp oge float %x, 0.000000e+001287 %neg = fneg float %x1288 %sel = select i1 %cmp, float %x, float %neg1289 %cmp2 = fcmp olt float %sel, %y1290 ret i1 %cmp21291}1292 1293define float @test_fabs_used_by_fpop_nnan_nsz(float %x, float %y) {1294; CHECK-LABEL: @test_fabs_used_by_fpop_nnan_nsz(1295; CHECK-NEXT: [[SEL:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])1296; CHECK-NEXT: [[ADD:%.*]] = fadd nnan nsz float [[SEL]], [[Y:%.*]]1297; CHECK-NEXT: ret float [[ADD]]1298;1299 %cmp = fcmp oge float %x, 0.000000e+001300 %neg = fneg float %x1301 %sel = select i1 %cmp, float %x, float %neg1302 %add = fadd nnan nsz float %sel, %y1303 ret float %add1304}1305 1306define i1 @test_fabs_fsub_used_by_fcmp(float %x, float %y) {1307; CHECK-LABEL: @test_fabs_fsub_used_by_fcmp(1308; CHECK-NEXT: [[SEL:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])1309; CHECK-NEXT: [[CMP2:%.*]] = fcmp olt float [[SEL]], [[Y:%.*]]1310; CHECK-NEXT: ret i1 [[CMP2]]1311;1312 %cmp = fcmp ogt float %x, 0.000000e+001313 %neg = fsub float 0.000000e+00, %x1314 %sel = select i1 %cmp, float %x, float %neg1315 %cmp2 = fcmp olt float %sel, %y1316 ret i1 %cmp21317}1318 1319define float @test_fabs_fsub_used_by_fpop_nnan(float %x, float %y) {1320; CHECK-LABEL: @test_fabs_fsub_used_by_fpop_nnan(1321; CHECK-NEXT: [[SEL:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])1322; CHECK-NEXT: [[ADD:%.*]] = fadd nnan float [[SEL]], [[Y:%.*]]1323; CHECK-NEXT: ret float [[ADD]]1324;1325 %cmp = fcmp ogt float %x, 0.000000e+001326 %neg = fsub float 0.000000e+00, %x1327 %sel = select i1 %cmp, float %x, float %neg1328 %add = fadd nnan float %sel, %y1329 ret float %add1330}1331 1332define float @test_fabs_used_by_fpop_nsz(float %x, float %y) {1333; CHECK-LABEL: @test_fabs_used_by_fpop_nsz(1334; CHECK-NEXT: [[SEL:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])1335; CHECK-NEXT: [[ADD:%.*]] = fadd nsz float [[SEL]], [[Y:%.*]]1336; CHECK-NEXT: ret float [[ADD]]1337;1338 %cmp = fcmp oge float %x, 0.000000e+001339 %neg = fneg float %x1340 %sel = select i1 %cmp, float %x, float %neg1341 %add = fadd nsz float %sel, %y1342 ret float %add1343}1344 1345define float @test_fabs_used_by_fcopysign_mag(float %x, float %y) {1346; CHECK-LABEL: @test_fabs_used_by_fcopysign_mag(1347; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[X:%.*]], float [[Y:%.*]])1348; CHECK-NEXT: ret float [[COPYSIGN]]1349;1350 %cmp = fcmp oge float %x, 0.000000e+001351 %neg = fneg float %x1352 %sel = select i1 %cmp, float %x, float %neg1353 %copysign = call float @llvm.copysign.f32(float %sel, float %y)1354 ret float %copysign1355}1356 1357define float @test_fabs_nsz_used_by_canonicalize(float %x) {1358; CHECK-LABEL: @test_fabs_nsz_used_by_canonicalize(1359; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1360; CHECK-NEXT: [[CANON:%.*]] = call float @llvm.canonicalize.f32(float [[SEL]])1361; CHECK-NEXT: ret float [[CANON]]1362;1363 %cmp = fcmp oge float %x, 0.000000e+001364 %neg = fneg float %x1365 %sel = select nsz i1 %cmp, float %x, float %neg1366 %canon = call float @llvm.canonicalize.f32(float %sel)1367 ret float %canon1368}1369 1370define void @test_fabs_used_by_nofpclass_nan(float %x) {1371; CHECK-LABEL: @test_fabs_used_by_nofpclass_nan(1372; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1373; CHECK-NEXT: call void @use(float nofpclass(nan) [[SEL]])1374; CHECK-NEXT: ret void1375;1376 %cmp = fcmp oge float %x, 0.000000e+001377 %neg = fneg float %x1378 %sel = select nsz i1 %cmp, float %x, float %neg1379 call void @use(float nofpclass(nan) %sel)1380 ret void1381}1382 1383define nofpclass(nan) float @test_fabs_used_by_ret_nofpclass_nan(float %x) {1384; CHECK-LABEL: @test_fabs_used_by_ret_nofpclass_nan(1385; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1386; CHECK-NEXT: ret float [[SEL]]1387;1388 %cmp = fcmp oge float %x, 0.000000e+001389 %neg = fneg float %x1390 %sel = select nsz i1 %cmp, float %x, float %neg1391 ret float %sel1392}1393 1394define i32 @test_fabs_used_fptosi(float %x) {1395; CHECK-LABEL: @test_fabs_used_fptosi(1396; CHECK-NEXT: [[SEL:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])1397; CHECK-NEXT: [[FPTOSI:%.*]] = fptosi float [[SEL]] to i321398; CHECK-NEXT: ret i32 [[FPTOSI]]1399;1400 %cmp = fcmp oge float %x, 0.000000e+001401 %neg = fneg float %x1402 %sel = select i1 %cmp, float %x, float %neg1403 %fptosi = fptosi float %sel to i321404 ret i32 %fptosi1405}1406 1407define i32 @test_fabs_used_fptoui(float %x) {1408; CHECK-LABEL: @test_fabs_used_fptoui(1409; CHECK-NEXT: [[SEL:%.*]] = call float @llvm.fabs.f32(float [[X:%.*]])1410; CHECK-NEXT: [[FPTOSI:%.*]] = fptoui float [[SEL]] to i321411; CHECK-NEXT: ret i32 [[FPTOSI]]1412;1413 %cmp = fcmp oge float %x, 0.000000e+001414 %neg = fneg float %x1415 %sel = select i1 %cmp, float %x, float %neg1416 %fptosi = fptoui float %sel to i321417 ret i32 %fptosi1418}1419 1420define float @test_fabs_nsz_used_by_maxnum(float %x, float %y) {1421; CHECK-LABEL: @test_fabs_nsz_used_by_maxnum(1422; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1423; CHECK-NEXT: [[MAX:%.*]] = call float @llvm.maxnum.f32(float [[Y:%.*]], float [[SEL]])1424; CHECK-NEXT: ret float [[MAX]]1425;1426 %cmp = fcmp oge float %x, 0.000000e+001427 %neg = fneg float %x1428 %sel = select nsz i1 %cmp, float %x, float %neg1429 %max = call float @llvm.maxnum.f32(float %y, float %sel)1430 ret float %max1431}1432 1433define i1 @test_fabs_used_is_fpclass_pnorm_or_nan(float %x) {1434; CHECK-LABEL: @test_fabs_used_is_fpclass_pnorm_or_nan(1435; CHECK-NEXT: [[IS_FPCLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[X:%.*]], i32 267)1436; CHECK-NEXT: ret i1 [[IS_FPCLASS]]1437;1438 %cmp = fcmp oge float %x, 0.000000e+001439 %neg = fneg float %x1440 %sel = select i1 %cmp, float %x, float %neg1441 %is_fpclass = call i1 @llvm.is.fpclass.f32(float %sel, i32 259)1442 ret i1 %is_fpclass1443}1444 1445define i1 @test_fabs_used_is_fpclass_zero_or_pinf(float %x) {1446; CHECK-LABEL: @test_fabs_used_is_fpclass_zero_or_pinf(1447; CHECK-NEXT: [[IS_FPCLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[X:%.*]], i32 612)1448; CHECK-NEXT: ret i1 [[IS_FPCLASS]]1449;1450 %cmp = fcmp oge float %x, 0.000000e+001451 %neg = fneg float %x1452 %sel = select i1 %cmp, float %x, float %neg1453 %is_fpclass = call i1 @llvm.is.fpclass.f32(float %sel, i32 608)1454 ret i1 %is_fpclass1455}1456 1457define float @test_fabs_nsz_used_by_fadd(float %x) {1458; CHECK-LABEL: @test_fabs_nsz_used_by_fadd(1459; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1460; CHECK-NEXT: [[OP:%.*]] = fadd float [[SEL]], 1.000000e+001461; CHECK-NEXT: ret float [[OP]]1462;1463 %cmp = fcmp oge float %x, 0.000000e+001464 %neg = fneg float %x1465 %sel = select nsz i1 %cmp, float %x, float %neg1466 %op = fadd float %sel, 1.000000e+001467 ret float %op1468}1469 1470define float @test_fabs_nsz_used_by_fsub(float %x) {1471; CHECK-LABEL: @test_fabs_nsz_used_by_fsub(1472; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1473; CHECK-NEXT: [[OP:%.*]] = fsub float 1.000000e+00, [[SEL]]1474; CHECK-NEXT: ret float [[OP]]1475;1476 %cmp = fcmp oge float %x, 0.000000e+001477 %neg = fneg float %x1478 %sel = select nsz i1 %cmp, float %x, float %neg1479 %op = fsub float 1.000000e+00, %sel1480 ret float %op1481}1482 1483define float @test_fabs_nsz_used_by_fmul(float %x) {1484; CHECK-LABEL: @test_fabs_nsz_used_by_fmul(1485; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1486; CHECK-NEXT: [[OP:%.*]] = fmul float [[SEL]], 3.000000e+001487; CHECK-NEXT: ret float [[OP]]1488;1489 %cmp = fcmp oge float %x, 0.000000e+001490 %neg = fneg float %x1491 %sel = select nsz i1 %cmp, float %x, float %neg1492 %op = fmul float %sel, 3.000000e+001493 ret float %op1494}1495 1496define float @test_fabs_nsz_used_by_fdiv(float %x) {1497; CHECK-LABEL: @test_fabs_nsz_used_by_fdiv(1498; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1499; CHECK-NEXT: [[OP:%.*]] = fdiv float [[SEL]], 3.000000e+001500; CHECK-NEXT: ret float [[OP]]1501;1502 %cmp = fcmp oge float %x, 0.000000e+001503 %neg = fneg float %x1504 %sel = select nsz i1 %cmp, float %x, float %neg1505 %op = fdiv float %sel, 3.000000e+001506 ret float %op1507}1508 1509define float @test_fabs_nsz_used_by_frem(float %x) {1510; CHECK-LABEL: @test_fabs_nsz_used_by_frem(1511; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1512; CHECK-NEXT: [[OP:%.*]] = fdiv float [[SEL]], 3.000000e+001513; CHECK-NEXT: ret float [[OP]]1514;1515 %cmp = fcmp oge float %x, 0.000000e+001516 %neg = fneg float %x1517 %sel = select nsz i1 %cmp, float %x, float %neg1518 %op = fdiv float %sel, 3.000000e+001519 ret float %op1520}1521 1522define half @test_fabs_nsz_used_by_fptrunc(float %x) {1523; CHECK-LABEL: @test_fabs_nsz_used_by_fptrunc(1524; CHECK-NEXT: [[TMP1:%.*]] = fptrunc float [[X:%.*]] to half1525; CHECK-NEXT: [[OP:%.*]] = call half @llvm.fabs.f16(half [[TMP1]])1526; CHECK-NEXT: ret half [[OP]]1527;1528 %cmp = fcmp oge float %x, 0.000000e+001529 %neg = fneg float %x1530 %sel = select nsz i1 %cmp, float %x, float %neg1531 %op = fptrunc float %sel to half1532 ret half %op1533}1534 1535define float @test_fabs_nsz_used_by_fpext(half %x) {1536; CHECK-LABEL: @test_fabs_nsz_used_by_fpext(1537; CHECK-NEXT: [[SEL:%.*]] = call nsz half @llvm.fabs.f16(half [[X:%.*]])1538; CHECK-NEXT: [[OP:%.*]] = fpext half [[SEL]] to float1539; CHECK-NEXT: ret float [[OP]]1540;1541 %cmp = fcmp oge half %x, 0.000000e+001542 %neg = fneg half %x1543 %sel = select nsz i1 %cmp, half %x, half %neg1544 %op = fpext half %sel to float1545 ret float %op1546}1547 1548define float @test_fabs_nsz_used_by_maximum(float %x, float %y) {1549; CHECK-LABEL: @test_fabs_nsz_used_by_maximum(1550; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1551; CHECK-NEXT: [[MAX:%.*]] = call float @llvm.maximum.f32(float [[Y:%.*]], float [[SEL]])1552; CHECK-NEXT: ret float [[MAX]]1553;1554 %cmp = fcmp oge float %x, 0.000000e+001555 %neg = fneg float %x1556 %sel = select nsz i1 %cmp, float %x, float %neg1557 %max = call float @llvm.maximum.f32(float %y, float %sel)1558 ret float %max1559}1560 1561define float @test_fabs_nsz_used_by_maximumnum(float %x, float %y) {1562; CHECK-LABEL: @test_fabs_nsz_used_by_maximumnum(1563; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1564; CHECK-NEXT: [[MAX:%.*]] = call float @llvm.maximumnum.f32(float [[Y:%.*]], float [[SEL]])1565; CHECK-NEXT: ret float [[MAX]]1566;1567 %cmp = fcmp oge float %x, 0.000000e+001568 %neg = fneg float %x1569 %sel = select nsz i1 %cmp, float %x, float %neg1570 %max = call float @llvm.maximumnum.f32(float %y, float %sel)1571 ret float %max1572}1573 1574define float @test_fabs_nsz_used_by_fma(float %x, float %y, float %z) {1575; CHECK-LABEL: @test_fabs_nsz_used_by_fma(1576; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1577; CHECK-NEXT: [[MAX:%.*]] = call float @llvm.fma.f32(float [[SEL]], float [[Z:%.*]], float [[Z]])1578; CHECK-NEXT: ret float [[MAX]]1579;1580 %cmp = fcmp oge float %x, 0.000000e+001581 %neg = fneg float %x1582 %sel = select nsz i1 %cmp, float %x, float %neg1583 %max = call float @llvm.fma.f32(float %sel, float %z, float %z)1584 ret float %max1585}1586 1587define float @test_fabs_nsz_used_by_sqrt(float %x) {1588; CHECK-LABEL: @test_fabs_nsz_used_by_sqrt(1589; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1590; CHECK-NEXT: [[OP:%.*]] = call float @llvm.sqrt.f32(float [[SEL]])1591; CHECK-NEXT: ret float [[OP]]1592;1593 %cmp = fcmp oge float %x, 0.000000e+001594 %neg = fneg float %x1595 %sel = select nsz i1 %cmp, float %x, float %neg1596 %op = call float @llvm.sqrt.f32(float %sel)1597 ret float %op1598}1599 1600define float @test_fabs_nsz_used_by_pow(float %x, float %y) {1601; CHECK-LABEL: @test_fabs_nsz_used_by_pow(1602; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1603; CHECK-NEXT: [[OP:%.*]] = call float @llvm.pow.f32(float [[SEL]], float [[Y:%.*]])1604; CHECK-NEXT: ret float [[OP]]1605;1606 %cmp = fcmp oge float %x, 0.000000e+001607 %neg = fneg float %x1608 %sel = select nsz i1 %cmp, float %x, float %neg1609 %op = call float @llvm.pow.f32(float %sel, float %y)1610 ret float %op1611}1612 1613define float @test_fabs_nsz_used_by_powi(float %x, i32 %y) {1614; CHECK-LABEL: @test_fabs_nsz_used_by_powi(1615; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1616; CHECK-NEXT: [[OP:%.*]] = call float @llvm.powi.f32.i32(float [[SEL]], i32 [[Y:%.*]])1617; CHECK-NEXT: ret float [[OP]]1618;1619 %cmp = fcmp oge float %x, 0.000000e+001620 %neg = fneg float %x1621 %sel = select nsz i1 %cmp, float %x, float %neg1622 %op = call float @llvm.powi.f32(float %sel, i32 %y)1623 ret float %op1624}1625 1626define i32 @test_fabs_nsz_used_by_fptoui_sat(float %x) {1627; CHECK-LABEL: @test_fabs_nsz_used_by_fptoui_sat(1628; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1629; CHECK-NEXT: [[OP:%.*]] = call i32 @llvm.fptoui.sat.i32.f32(float [[SEL]])1630; CHECK-NEXT: ret i32 [[OP]]1631;1632 %cmp = fcmp oge float %x, 0.000000e+001633 %neg = fneg float %x1634 %sel = select nsz i1 %cmp, float %x, float %neg1635 %op = call i32 @llvm.fptoui.sat.i32.f32(float %sel)1636 ret i32 %op1637}1638 1639define <2 x i1> @test_fabs_used_vp_is_fpclass_zero_or_pinf(<2 x float> %x, <2 x i1> %mask, i32 %evl) {1640; CHECK-LABEL: @test_fabs_used_vp_is_fpclass_zero_or_pinf(1641; CHECK-NEXT: [[SEL:%.*]] = call <2 x float> @llvm.fabs.v2f32(<2 x float> [[X:%.*]])1642; CHECK-NEXT: [[IS_FPCLASS:%.*]] = call <2 x i1> @llvm.vp.is.fpclass.v2f32(<2 x float> [[SEL]], i32 608, <2 x i1> [[MASK:%.*]], i32 [[EVL:%.*]])1643; CHECK-NEXT: ret <2 x i1> [[IS_FPCLASS]]1644;1645 %cmp = fcmp oge <2 x float> %x, zeroinitializer1646 %neg = fneg <2 x float> %x1647 %sel = select <2 x i1> %cmp, <2 x float> %x, <2 x float> %neg1648 %is_fpclass = call <2 x i1> @llvm.vp.is.fpclass.v2f32(<2 x float> %sel, i32 608, <2 x i1> %mask, i32 %evl)1649 ret <2 x i1> %is_fpclass1650}1651 1652define void @test_fabs_nsz_used_by_invoke(float %x) personality ptr null {1653; CHECK-LABEL: @test_fabs_nsz_used_by_invoke(1654; CHECK-NEXT: [[SEL:%.*]] = call nsz float @llvm.fabs.f32(float [[X:%.*]])1655; CHECK-NEXT: invoke void @use(float nofpclass(nan) [[SEL]])1656; CHECK-NEXT: to label [[NORMAL:%.*]] unwind label [[UNWIND:%.*]]1657; CHECK: normal:1658; CHECK-NEXT: ret void1659; CHECK: unwind:1660; CHECK-NEXT: [[TMP1:%.*]] = landingpad ptr1661; CHECK-NEXT: cleanup1662; CHECK-NEXT: resume ptr null1663;1664 %cmp = fcmp oge float %x, 0.000000e+001665 %neg = fneg float %x1666 %sel = select nsz i1 %cmp, float %x, float %neg1667 invoke void @use(float nofpclass(nan) %sel) to label %normal unwind label %unwind1668 1669normal:1670 ret void1671 1672unwind:1673 landingpad ptr cleanup1674 resume ptr null1675}1676 1677; Negative tests1678 1679define float @test_fabs_used_by_fpop_nnan(float %x, float %y) {1680; CHECK-LABEL: @test_fabs_used_by_fpop_nnan(1681; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[X:%.*]], 0.000000e+001682; CHECK-NEXT: [[NEG:%.*]] = fneg float [[X]]1683; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], float [[X]], float [[NEG]]1684; CHECK-NEXT: [[ADD:%.*]] = fadd nnan float [[SEL]], [[Y:%.*]]1685; CHECK-NEXT: ret float [[ADD]]1686;1687 %cmp = fcmp oge float %x, 0.000000e+001688 %neg = fneg float %x1689 %sel = select i1 %cmp, float %x, float %neg1690 %add = fadd nnan float %sel, %y1691 ret float %add1692}1693 1694define i1 @test_fabs_used_by_fcmp_multiuse(float %x, float %y) {1695; CHECK-LABEL: @test_fabs_used_by_fcmp_multiuse(1696; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[X:%.*]], 0.000000e+001697; CHECK-NEXT: [[NEG:%.*]] = fneg float [[X]]1698; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], float [[X]], float [[NEG]]1699; CHECK-NEXT: [[CMP2:%.*]] = fcmp olt float [[SEL]], [[Y:%.*]]1700; CHECK-NEXT: call void @use(float [[SEL]])1701; CHECK-NEXT: ret i1 [[CMP2]]1702;1703 %cmp = fcmp oge float %x, 0.000000e+001704 %neg = fneg float %x1705 %sel = select i1 %cmp, float %x, float %neg1706 %cmp2 = fcmp olt float %sel, %y1707 call void @use(float %sel)1708 ret i1 %cmp21709}1710 1711define float @test_fabs_used_by_fcopysign_sign(float %x, float %y) {1712; CHECK-LABEL: @test_fabs_used_by_fcopysign_sign(1713; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[X:%.*]], 0.000000e+001714; CHECK-NEXT: [[NEG:%.*]] = fneg float [[X]]1715; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], float [[X]], float [[NEG]]1716; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[Y:%.*]], float [[SEL]])1717; CHECK-NEXT: ret float [[COPYSIGN]]1718;1719 %cmp = fcmp oge float %x, 0.000000e+001720 %neg = fneg float %x1721 %sel = select i1 %cmp, float %x, float %neg1722 %copysign = call float @llvm.copysign.f32(float %y, float %sel)1723 ret float %copysign1724}1725 1726define float @test_fabs_used_by_maxnum(float %x, float %y) {1727; CHECK-LABEL: @test_fabs_used_by_maxnum(1728; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[X:%.*]], 0.000000e+001729; CHECK-NEXT: [[NEG:%.*]] = fneg float [[X]]1730; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], float [[X]], float [[NEG]]1731; CHECK-NEXT: [[MAX:%.*]] = call float @llvm.maxnum.f32(float [[Y:%.*]], float [[SEL]])1732; CHECK-NEXT: ret float [[MAX]]1733;1734 %cmp = fcmp oge float %x, 0.000000e+001735 %neg = fneg float %x1736 %sel = select i1 %cmp, float %x, float %neg1737 %max = call float @llvm.maxnum.f32(float %y, float %sel)1738 ret float %max1739}1740 1741define float @test_fabs_used_by_canonicalize(float %x) {1742; CHECK-LABEL: @test_fabs_used_by_canonicalize(1743; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[X:%.*]], 0.000000e+001744; CHECK-NEXT: [[NEG:%.*]] = fneg float [[X]]1745; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], float [[X]], float [[NEG]]1746; CHECK-NEXT: [[CANON:%.*]] = call float @llvm.canonicalize.f32(float [[SEL]])1747; CHECK-NEXT: ret float [[CANON]]1748;1749 %cmp = fcmp oge float %x, 0.000000e+001750 %neg = fneg float %x1751 %sel = select i1 %cmp, float %x, float %neg1752 %canon = call float @llvm.canonicalize.f32(float %sel)1753 ret float %canon1754}1755 1756define float @test_fabs_used_by_select(float %x, i1 %cond) {1757; CHECK-LABEL: @test_fabs_used_by_select(1758; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[X:%.*]], 0.000000e+001759; CHECK-NEXT: [[NEG:%.*]] = fneg float [[X]]1760; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], float [[X]], float [[NEG]]1761; CHECK-NEXT: [[SEL2:%.*]] = select i1 [[COND:%.*]], float [[SEL]], float 0.000000e+001762; CHECK-NEXT: ret float [[SEL2]]1763;1764 %cmp = fcmp oge float %x, 0.000000e+001765 %neg = fneg float %x1766 %sel = select i1 %cmp, float %x, float %neg1767 %sel2 = select i1 %cond, float %sel, float 0.000000e+001768 ret float %sel21769}1770 1771define i1 @test_fabs_used_is_fpclass_pzero(float %x) {1772; CHECK-LABEL: @test_fabs_used_is_fpclass_pzero(1773; CHECK-NEXT: [[CMP:%.*]] = fcmp oge float [[X:%.*]], 0.000000e+001774; CHECK-NEXT: [[NEG:%.*]] = fneg float [[X]]1775; CHECK-NEXT: [[SEL:%.*]] = select i1 [[CMP]], float [[X]], float [[NEG]]1776; CHECK-NEXT: [[IS_FPCLASS:%.*]] = call i1 @llvm.is.fpclass.f32(float [[SEL]], i32 64)1777; CHECK-NEXT: ret i1 [[IS_FPCLASS]]1778;1779 %cmp = fcmp oge float %x, 0.000000e+001780 %neg = fneg float %x1781 %sel = select i1 %cmp, float %x, float %neg1782 %is_fpclass = call i1 @llvm.is.fpclass.f32(float %sel, i32 64)1783 ret i1 %is_fpclass1784}1785