llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-llvm-support @llvm/pr-subscribers-llvm-transforms Author: Matt Arsenault (arsenm) <details> <summary>Changes</summary> Prepare to support more folds and multiple uses. --- Patch is 46.39 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/176915.diff 1 Files Affected: - (modified) llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll (+651) ``````````diff diff --git a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll index eaed9019cacc3..91e55e2fb2645 100644 --- a/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll +++ b/llvm/test/Transforms/InstCombine/simplify-demanded-fpclass.ll @@ -1996,3 +1996,654 @@ define nofpclass(nan) float @ret_nonan_fmul_select_nan_other_use_commute(i1 %con %nan.user = fmul float %select, %y ret float %nan.user } + +define nofpclass(snan) float @copysign_src_known_positive__sign_known_negative_multiple_use(float nofpclass(nan ninf nnorm nsub nzero) %always.positive, float nofpclass(nan pinf pnorm psub pzero) %always.negative, ptr %ptr) { +; CHECK-LABEL: define nofpclass(snan) float @copysign_src_known_positive__sign_known_negative_multiple_use +; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = fneg float [[ALWAYS_POSITIVE]] +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive, float %always.negative) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(snan) float @copysign_src_known_negative__sign_known_negative_multiple_use(float nofpclass(nan pinf pnorm psub pzero) %always.negative0, float nofpclass(nan pinf pnorm psub pzero) %always.negative1, ptr %ptr) { +; CHECK-LABEL: define nofpclass(snan) float @copysign_src_known_negative__sign_known_negative_multiple_use +; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE0:%.*]], float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE1:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[ALWAYS_NEGATIVE0]]) +; CHECK-NEXT: [[COPYSIGN:%.*]] = fneg float [[TMP1]] +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[ALWAYS_NEGATIVE0]] +; + %copysign = call float @llvm.copysign.f32(float %always.negative0, float %always.negative1) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(snan) float @copysign_src_known_positive__sign_known_positive_multiple_use(float nofpclass(nan ninf nnorm nsub nzero) %always.positive0, float nofpclass(nan ninf nnorm nsub nzero) %always.positive1, ptr %ptr) { +; CHECK-LABEL: define nofpclass(snan) float @copysign_src_known_positive__sign_known_positive_multiple_use +; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE0:%.*]], float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE1:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: store float [[ALWAYS_POSITIVE0]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[ALWAYS_POSITIVE0]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive0, float %always.positive1) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(nan) float @ret_nonan__copysign_src_known_negative_or_nan__sign_known_negative_multiple_use(float nofpclass(pinf pnorm psub pzero) %always.negative0.or.nan, float nofpclass(nan pinf pnorm psub pzero) %always.negative1, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan) float @ret_nonan__copysign_src_known_negative_or_nan__sign_known_negative_multiple_use +; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[ALWAYS_NEGATIVE0_OR_NAN:%.*]], float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE1:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[ALWAYS_NEGATIVE0_OR_NAN]]) +; CHECK-NEXT: [[COPYSIGN:%.*]] = fneg float [[TMP1]] +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[ALWAYS_NEGATIVE0_OR_NAN]] +; + %copysign = call float @llvm.copysign.f32(float %always.negative0.or.nan, float %always.negative1) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(nan ninf nnorm nsub nzero) float @ret_only_positive__copysign__sign_known_negative_multiple_use(float %unknown, float nofpclass(nan pinf pnorm psub pzero) %always.negative, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_only_positive__copysign__sign_known_negative_multiple_use +; CHECK-SAME: (float [[UNKNOWN:%.*]], float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) +; CHECK-NEXT: [[COPYSIGN:%.*]] = fneg float [[TMP1]] +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float poison +; + %copysign = call float @llvm.copysign.f32(float %unknown, float %always.negative) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(nan ninf nnorm nsub nzero) float @ret_only_positive__copysign__sign_known_positive_multiple_use(float %unknown, float nofpclass(nan ninf nnorm nsub nzero) %always.positive, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_only_positive__copysign__sign_known_positive_multiple_use +; CHECK-SAME: (float [[UNKNOWN:%.*]], float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %unknown, float %always.positive) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(nan pinf pnorm psub pzero) float @ret_only_negative__copysign__sign_known_negative_multiple_use(float %unknown, float nofpclass(nan pinf pnorm psub pzero) %always.negative, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @ret_only_negative__copysign__sign_known_negative_multiple_use +; CHECK-SAME: (float [[UNKNOWN:%.*]], float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[TMP1:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) +; CHECK-NEXT: [[COPYSIGN:%.*]] = fneg float [[TMP1]] +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %unknown, float %always.negative) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(nan pinf pnorm psub pzero) float @ret_only_negative__copysign__sign_known_positive_multiple_use(float %unknown, float nofpclass(nan ninf nnorm nsub nzero) %always.positive, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @ret_only_negative__copysign__sign_known_positive_multiple_use +; CHECK-SAME: (float [[UNKNOWN:%.*]], float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.fabs.f32(float [[UNKNOWN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float poison +; + %copysign = call float @llvm.copysign.f32(float %unknown, float %always.positive) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(nan ninf nnorm nsub nzero) float @ret_only_positive__copysign_multiple_use(float %unknown.mag, float %unknown.sign, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_only_positive__copysign_multiple_use +; CHECK-SAME: (float [[UNKNOWN_MAG:%.*]], float [[UNKNOWN_SIGN:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[UNKNOWN_MAG]], float [[UNKNOWN_SIGN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %unknown.mag, float %unknown.sign) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(nan pinf pnorm psub pzero) float @ret_only_negative__copysign_multiple_use(float %unknown.mag, float %unknown.sign, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @ret_only_negative__copysign_multiple_use +; CHECK-SAME: (float [[UNKNOWN_MAG:%.*]], float [[UNKNOWN_SIGN:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[UNKNOWN_MAG]], float [[UNKNOWN_SIGN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %unknown.mag, float %unknown.sign) + store float %copysign, ptr %ptr + ret float %copysign +} + +; Fold to direct use of %always.positive +define nofpclass(nan ninf nnorm nsub nzero) float @ret_only_positive__copysign_src_known_positive__sign_unknown(float nofpclass(nan ninf nnorm nsub nzero) %always.positive, float %unknown) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_only_positive__copysign_src_known_positive__sign_unknown +; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: ret float [[ALWAYS_POSITIVE]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive, float %unknown) + ret float %copysign +} + +; Fold to direct use of %always.positive +define nofpclass(nan ninf nnorm nsub nzero) float @ret_only_positive__copysign_src_known_positive__sign_unknown_multiple_use(float nofpclass(nan ninf nnorm nsub nzero) %always.positive, float %unknown, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_only_positive__copysign_src_known_positive__sign_unknown_multiple_use +; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], float [[UNKNOWN:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[ALWAYS_POSITIVE]], float [[UNKNOWN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive, float %unknown) + store float %copysign, ptr %ptr + ret float %copysign +} + +; Fold to direct use of %always.negative +define nofpclass(nan pinf pnorm psub pzero) float @ret_only_negative__copysign_src_known_negative__sign_unknown(float nofpclass(nan pinf pnorm psub pzero) %always.negative, float %unknown) { +; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @ret_only_negative__copysign_src_known_negative__sign_unknown +; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: ret float [[ALWAYS_NEGATIVE]] +; + %copysign = call float @llvm.copysign.f32(float %always.negative, float %unknown) + ret float %copysign +} + +; Fold to direct use of %always.negative +define nofpclass(nan pinf pnorm psub pzero) float @ret_only_negative__copysign_src_known_negative__sign_unknown_multiple_use(float nofpclass(nan pinf pnorm psub pzero) %always.negative, float %unknown, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @ret_only_negative__copysign_src_known_negative__sign_unknown_multiple_use +; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE:%.*]], float [[UNKNOWN:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[ALWAYS_NEGATIVE]], float [[UNKNOWN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.negative, float %unknown) + store float %copysign, ptr %ptr + ret float %copysign +} + +; Negative test +define nofpclass(nan ninf nnorm nsub nzero) float @ret_only_positive__copysign_src_known_negative__sign_unknown(float nofpclass(nan pinf pnorm psub pzero) %always.negative, float %unknown) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_only_positive__copysign_src_known_negative__sign_unknown +; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.fabs.f32(float [[ALWAYS_NEGATIVE]]) +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.negative, float %unknown) + ret float %copysign +} + +; Negative test +define nofpclass(nan ninf nnorm nsub nzero) float @ret_only_positive__copysign_src_known_negative__sign_unknown_multiple_use(float nofpclass(nan pinf pnorm psub pzero) %always.negative, float %unknown, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @ret_only_positive__copysign_src_known_negative__sign_unknown_multiple_use +; CHECK-SAME: (float nofpclass(nan pinf pzero psub pnorm) [[ALWAYS_NEGATIVE:%.*]], float [[UNKNOWN:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[ALWAYS_NEGATIVE]], float [[UNKNOWN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.negative, float %unknown) + store float %copysign, ptr %ptr + ret float %copysign +} + +; Negative test +define nofpclass(nan pinf pnorm psub pzero) float @ret_only_negative__copysign_src_known_positive__sign_unknown(float nofpclass(nan ninf nnorm nsub nzero) %always.positive, float %unknown) { +; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @ret_only_negative__copysign_src_known_positive__sign_unknown +; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = fneg float [[ALWAYS_POSITIVE]] +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive, float %unknown) + ret float %copysign +} + +; Could still be positive for +inf input +define nofpclass(nan nnorm nsub nzero) float @ret_only_positive_or_ninf__copysign_src_known_positive__sign_unknown(float nofpclass(nan ninf nnorm nsub nzero) %always.positive, float %unknown) { +; CHECK-LABEL: define nofpclass(nan nzero nsub nnorm) float @ret_only_positive_or_ninf__copysign_src_known_positive__sign_unknown +; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[ALWAYS_POSITIVE]], float [[UNKNOWN]]) +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive, float %unknown) + ret float %copysign +} + +; The ninf flag gives the missing no-infs +define nofpclass(nan nnorm nsub nzero) float @ret_only_positive_or_ninf__copysign_ninf_src_known_positive__sign_unknown(float nofpclass(nan ninf nnorm nsub nzero) %always.positive, float %unknown) { +; CHECK-LABEL: define nofpclass(nan nzero nsub nnorm) float @ret_only_positive_or_ninf__copysign_ninf_src_known_positive__sign_unknown +; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: ret float [[ALWAYS_POSITIVE]] +; + %copysign = call ninf float @llvm.copysign.f32(float %always.positive, float %unknown) + ret float %copysign +} + +; The ninf flag gives the missing no-infs +define nofpclass(nan nnorm nsub nzero) float @ret_only_positive_or_ninf__copysign_ninf_src_known_positive__sign_unknown_multiple_use(float nofpclass(nan ninf nnorm nsub nzero) %always.positive, float %unknown, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan nzero nsub nnorm) float @ret_only_positive_or_ninf__copysign_ninf_src_known_positive__sign_unknown_multiple_use +; CHECK-SAME: (float nofpclass(nan ninf nzero nsub nnorm) [[ALWAYS_POSITIVE:%.*]], float [[UNKNOWN:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call ninf float @llvm.copysign.f32(float [[ALWAYS_POSITIVE]], float [[UNKNOWN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call ninf float @llvm.copysign.f32(float %always.positive, float %unknown) + store float %copysign, ptr %ptr + ret float %copysign +} + +; No pinf from argument +define nofpclass(nan nnorm nsub nzero) float @ret_only_positive_or_ninf__copysign_src_known_positive_no_inf__sign_unknown(float nofpclass(nan inf nnorm nsub nzero) %always.positive.no.inf, float %unknown) { +; CHECK-LABEL: define nofpclass(nan nzero nsub nnorm) float @ret_only_positive_or_ninf__copysign_src_known_positive_no_inf__sign_unknown +; CHECK-SAME: (float nofpclass(nan inf nzero nsub nnorm) [[ALWAYS_POSITIVE_NO_INF:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[ALWAYS_POSITIVE_NO_INF]], float [[UNKNOWN]]) +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive.no.inf, float %unknown) + ret float %copysign +} + +; No pinf from argument +define nofpclass(nan nnorm nsub nzero) float @ret_only_positive_or_ninf__copysign_src_known_positive_no_inf__sign_unknown_multiple_use(float nofpclass(nan inf nnorm nsub nzero) %always.positive.no.inf, float %unknown, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan nzero nsub nnorm) float @ret_only_positive_or_ninf__copysign_src_known_positive_no_inf__sign_unknown_multiple_use +; CHECK-SAME: (float nofpclass(nan inf nzero nsub nnorm) [[ALWAYS_POSITIVE_NO_INF:%.*]], float [[UNKNOWN:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[ALWAYS_POSITIVE_NO_INF]], float [[UNKNOWN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive.no.inf, float %unknown) + store float %copysign, ptr %ptr + ret float %copysign +} + +define nofpclass(nan ninf nnorm nsub) float @ret_only_positive_or_zero__copysign_src_known_positive__sign_unknown(float nofpclass(nan ninf nnorm nsub) %always.positive.or.zero, float %unknown) { +; CHECK-LABEL: define nofpclass(nan ninf nsub nnorm) float @ret_only_positive_or_zero__copysign_src_known_positive__sign_unknown +; CHECK-SAME: (float nofpclass(nan ninf nsub nnorm) [[ALWAYS_POSITIVE_OR_ZERO:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call float @llvm.copysign.f32(float [[ALWAYS_POSITIVE_OR_ZERO]], float [[UNKNOWN]]) +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call float @llvm.copysign.f32(float %always.positive.or.zero, float %unknown) + ret float %copysign +} + +; Ignore 0 mismatch with nsz +define nofpclass(nan ninf nnorm nsub) float @ret_only_positive_or_zero__copysign_nsz_src_known_positive__sign_unknown(float nofpclass(nan ninf nnorm nsub) %always.positive.or.zero, float %unknown) { +; CHECK-LABEL: define nofpclass(nan ninf nsub nnorm) float @ret_only_positive_or_zero__copysign_nsz_src_known_positive__sign_unknown +; CHECK-SAME: (float nofpclass(nan ninf nsub nnorm) [[ALWAYS_POSITIVE_OR_ZERO:%.*]], float [[UNKNOWN:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call nsz float @llvm.copysign.f32(float [[ALWAYS_POSITIVE_OR_ZERO]], float [[UNKNOWN]]) +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call nsz float @llvm.copysign.f32(float %always.positive.or.zero, float %unknown) + ret float %copysign +} + +; Do not use nsz with multiple uses +define nofpclass(nan ninf nnorm nsub) float @ret_only_positive_or_zero__copysign_nsz_src_known_positive__sign_unknown_multiple_use(float nofpclass(nan ninf nnorm nsub) %always.positive.or.zero, float %unknown, ptr %ptr) { +; CHECK-LABEL: define nofpclass(nan ninf nsub nnorm) float @ret_only_positive_or_zero__copysign_nsz_src_known_positive__sign_unknown_multiple_use +; CHECK-SAME: (float nofpclass(nan ninf nsub nnorm) [[ALWAYS_POSITIVE_OR_ZERO:%.*]], float [[UNKNOWN:%.*]], ptr [[PTR:%.*]]) { +; CHECK-NEXT: [[COPYSIGN:%.*]] = call nsz float @llvm.copysign.f32(float [[ALWAYS_POSITIVE_OR_ZERO]], float [[UNKNOWN]]) +; CHECK-NEXT: store float [[COPYSIGN]], ptr [[PTR]], align 4 +; CHECK-NEXT: ret float [[COPYSIGN]] +; + %copysign = call nsz float @llvm.copysign.f32(float %always.positive.or.zero, float %unknown) + store float %copysign, ptr %ptr + ret float %copysign +}... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/176915 _______________________________________________ llvm-branch-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
