brintos / llvm-project-archived public Read only

1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --check-attributes --version 22; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-annotate-decl-cs -use-constant-fp-for-scalable-splat=false -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK-CV,TUNIT,TUNIT-CV3; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -use-constant-fp-for-scalable-splat=false -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK-CV,CGSCC,CGSCC-CV4 5; RUN: opt -aa-pipeline=basic-aa -passes=attributor -attributor-manifest-internal -attributor-annotate-decl-cs -use-constant-fp-for-scalable-splat -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK-CI,TUNIT,TUNIT-CI6; RUN: opt -aa-pipeline=basic-aa -passes=attributor-cgscc -attributor-manifest-internal -attributor-annotate-decl-cs -use-constant-fp-for-scalable-splat -S < %s | FileCheck %s --check-prefixes=CHECK,CHECK-CI,CGSCC,CGSCC-CI7 8declare nofpclass(nan) float @ret_nofpclass_nan()9declare [2 x [3 x float]] @ret_array()10declare float @extern()11declare float @extern.f32(float)12declare void @extern.use(float)13declare void @extern.use.array([2 x [3 x float]])14declare void @llvm.assume(i1 noundef)15declare void @unknown()16declare half @llvm.fabs.f16(half)17declare float @llvm.fabs.f32(float)18declare void @extern.use.f16(half)19declare i1 @llvm.is.fpclass.f32(float, i32 immarg)20declare float @llvm.experimental.constrained.sitofp.f32.i32(i32, metadata, metadata)21declare float @llvm.experimental.constrained.uitofp.f32.i32(i32, metadata, metadata)22declare float @llvm.arithmetic.fence.f32(float)23 24define float @returned_0() {25; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) float @returned_0() {26; CHECK-NEXT:    call void @unknown()27; CHECK-NEXT:    ret float 0.000000e+0028;29  call void @unknown()30  ret float 0.031}32 33define float @returned_neg0() {34; CHECK-LABEL: define noundef nofpclass(nan inf pzero sub norm) float @returned_neg0() {35; CHECK-NEXT:    call void @unknown()36; CHECK-NEXT:    ret float -0.000000e+0037;38  call void @unknown()39  ret float -0.040}41 42define float @returned_undef() {43; CHECK-LABEL: define nofpclass(all) float @returned_undef() {44; CHECK-NEXT:    call void @unknown()45; CHECK-NEXT:    ret float undef46;47  call void @unknown()48  ret float undef49}50 51define float @returned_poison() {52; CHECK-LABEL: define nofpclass(all) float @returned_poison() {53; CHECK-NEXT:    call void @unknown()54; CHECK-NEXT:    ret float poison55;56  call void @unknown()57  ret float poison58}59 60; Know nothing61define float @returned_freeze_poison() {62; CHECK-LABEL: define noundef float @returned_freeze_poison() {63; CHECK-NEXT:    call void @unknown()64; CHECK-NEXT:    [[FREEZE_POISON:%.*]] = freeze float poison65; CHECK-NEXT:    ret float [[FREEZE_POISON]]66;67  call void @unknown()68  %freeze.poison = freeze float poison69  ret float %freeze.poison70}71 72define double @returned_snan() {73; CHECK-LABEL: define noundef nofpclass(qnan inf zero sub norm) double @returned_snan() {74; CHECK-NEXT:    call void @unknown()75; CHECK-NEXT:    ret double 0x7FF000000000000176;77  call void @unknown()78  ret double 0x7FF000000000000179}80 81define double @returned_qnan() {82; CHECK-LABEL: define noundef nofpclass(snan inf zero sub norm) double @returned_qnan() {83; CHECK-NEXT:    call void @unknown()84; CHECK-NEXT:    ret double 0x7FF800000000000085;86  call void @unknown()87  ret double 0x7FF800000000000088}89 90define <2 x double> @returned_zero_vector() {91; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) <2 x double> @returned_zero_vector() {92; CHECK-NEXT:    call void @unknown()93; CHECK-NEXT:    ret <2 x double> zeroinitializer94;95  call void @unknown()96  ret <2 x double> zeroinitializer97}98 99define <2 x double> @returned_negzero_vector() {100; CHECK-LABEL: define noundef nofpclass(nan inf pzero sub norm) <2 x double> @returned_negzero_vector() {101; CHECK-NEXT:    call void @unknown()102; CHECK-NEXT:    ret <2 x double> splat (double -0.000000e+00)103;104  call void @unknown()105  ret <2 x double> <double -0.0, double -0.0>106}107 108; Test a vector element that's a constant but not ConstantFP.109define <2 x double> @returned_strange_constant_vector_elt() {110; CHECK-LABEL: define <2 x double> @returned_strange_constant_vector_elt() {111; CHECK-NEXT:    call void @unknown()112; CHECK-NEXT:    ret <2 x double> <double -0.000000e+00, double bitcast (i64 ptrtoint (ptr @unknown to i64) to double)>113;114  call void @unknown()115  ret <2 x double> <double -0.0, double bitcast (i64 ptrtoint (ptr @unknown to i64) to double)>116}117 118; Test a vector element that's undef119define <3 x double> @returned_undef_constant_vector_elt() {120; CHECK-LABEL: define <3 x double> @returned_undef_constant_vector_elt() {121; CHECK-NEXT:    call void @unknown()122; CHECK-NEXT:    ret <3 x double> <double -0.000000e+00, double 0.000000e+00, double undef>123;124  call void @unknown()125  ret <3 x double> <double -0.0, double 0.0, double undef>126}127 128; Test a vector element that's poison129define <3 x double> @returned_poison_constant_vector_elt() {130; CHECK-LABEL: define nofpclass(nan inf sub norm) <3 x double> @returned_poison_constant_vector_elt() {131; CHECK-NEXT:    call void @unknown()132; CHECK-NEXT:    ret <3 x double> <double -0.000000e+00, double 0.000000e+00, double poison>133;134  call void @unknown()135  ret <3 x double> <double -0.0, double 0.0, double poison>136}137 138define <2 x double> @returned_qnan_zero_vector() {139; CHECK-LABEL: define noundef nofpclass(snan inf nzero sub norm) <2 x double> @returned_qnan_zero_vector() {140; CHECK-NEXT:    call void @unknown()141; CHECK-NEXT:    ret <2 x double> <double 0x7FF8000000000000, double 0.000000e+00>142;143  call void @unknown()144  ret <2 x double> <double 0x7FF8000000000000, double 0.0>145}146 147; Return a float trivially nofpclass(nan) (call return attribute)148define float @return_nofpclass_nan_decl_return() {149; CHECK-LABEL: define nofpclass(nan) float @return_nofpclass_nan_decl_return() {150; CHECK-NEXT:    [[RET:%.*]] = call nofpclass(nan) float @ret_nofpclass_nan()151; CHECK-NEXT:    ret float [[RET]]152;153  %ret = call float @ret_nofpclass_nan()154  ret float %ret155}156 157; Return a float trivially nofpclass(nan) (argument attribute)158define float @return_nofpclass_nan_arg(float returned nofpclass(nan) %p) {159; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)160; CHECK-LABEL: define nofpclass(nan) float @return_nofpclass_nan_arg161; CHECK-SAME: (float returned nofpclass(nan) [[P:%.*]]) #[[ATTR3:[0-9]+]] {162; CHECK-NEXT:    ret float [[P]]163;164  ret float %p165}166 167define [2 x [3 x float]] @return_nofpclass_inf_ret_array() {168; CHECK-LABEL: define nofpclass(inf) [2 x [3 x float]] @return_nofpclass_inf_ret_array() {169; CHECK-NEXT:    [[RET:%.*]] = call nofpclass(inf) [2 x [3 x float]] @ret_array()170; CHECK-NEXT:    ret [2 x [3 x float]] [[RET]]171;172  %ret = call nofpclass(inf) [2 x [3 x float]]  @ret_array()173  ret [2 x [3 x float]] %ret174}175 176define float @returned_nnan_fadd(float %arg0, float %arg1) {177; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)178; CHECK-LABEL: define nofpclass(nan) float @returned_nnan_fadd179; CHECK-SAME: (float [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR3]] {180; CHECK-NEXT:    [[FADD:%.*]] = fadd nnan float [[ARG0]], [[ARG1]]181; CHECK-NEXT:    ret float [[FADD]]182;183  %fadd = fadd nnan float %arg0, %arg1184  ret float %fadd185}186 187define float @return_nofpclass_nan_callsite() {188; CHECK-LABEL: define nofpclass(nan) float @return_nofpclass_nan_callsite() {189; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan) float @extern()190; CHECK-NEXT:    ret float [[CALL]]191;192  %call = call nofpclass(nan) float @extern()193  ret float %call194}195 196; Can union the return classes197define nofpclass(inf) float @return_ninf_nofpclass_nan_callsite() {198; CHECK-LABEL: define nofpclass(nan inf) float @return_ninf_nofpclass_nan_callsite() {199; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan) float @extern()200; CHECK-NEXT:    ret float [[CALL]]201;202  %call = call nofpclass(nan) float @extern()203  ret float %call204}205 206define void @arg_used_by_nofpclass_nan_callsite(float %arg) {207; CHECK-LABEL: define void @arg_used_by_nofpclass_nan_callsite208; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) {209; CHECK-NEXT:    call void @extern.use(float nofpclass(nan) [[ARG]])210; CHECK-NEXT:    ret void211;212  call void @extern.use(float nofpclass(nan) %arg)213  ret void214}215 216; Callsite can union the incoming and outgoing217define void @ninf_arg_used_by_nofpclass_nan_callsite(float nofpclass(inf) %arg) {218; CHECK-LABEL: define void @ninf_arg_used_by_nofpclass_nan_callsite219; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) {220; CHECK-NEXT:    call void @extern.use(float nofpclass(nan inf) [[ARG]])221; CHECK-NEXT:    ret void222;223  call void @extern.use(float nofpclass(nan) %arg)224  ret void225}226 227define void @ninf_arg_used_by_callsite_array([2 x [3 x float]] nofpclass(inf) %arg) {228; CHECK-LABEL: define void @ninf_arg_used_by_callsite_array229; CHECK-SAME: ([2 x [3 x float]] nofpclass(inf) [[ARG:%.*]]) {230; CHECK-NEXT:    call void @extern.use.array([2 x [3 x float]] nofpclass(inf) [[ARG]])231; CHECK-NEXT:    ret void232;233  call void @extern.use.array([2 x [3 x float]]  %arg)234  ret void235}236 237define void @nofpclass_call_use_after_unannotated_use(float %arg) {238; CHECK-LABEL: define void @nofpclass_call_use_after_unannotated_use239; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) {240; CHECK-NEXT:    call void @extern(float nofpclass(nan inf) [[ARG]]) #[[ATTR17:[0-9]+]]241; CHECK-NEXT:    call void @extern(float nofpclass(nan inf) [[ARG]])242; CHECK-NEXT:    ret void243;244  call void @extern(float %arg) willreturn nounwind ; < annotate this use245  call void @extern(float nofpclass(nan inf) %arg)246  ret void247}248 249define float @mutually_recursive0(float %arg) {250; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)251; TUNIT-LABEL: define nofpclass(all) float @mutually_recursive0252; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR4:[0-9]+]] {253; TUNIT-NEXT:    ret float undef254;255; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)256; CGSCC-LABEL: define nofpclass(all) float @mutually_recursive0257; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {258; CGSCC-NEXT:    ret float undef259;260  %call = call float @mutually_recursive1(float %arg)261  ret float %call262}263 264define float @mutually_recursive1(float %arg) {265; TUNIT: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)266; TUNIT-LABEL: define nofpclass(all) float @mutually_recursive1267; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR4]] {268; TUNIT-NEXT:    ret float undef269;270; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)271; CGSCC-LABEL: define nofpclass(all) float @mutually_recursive1272; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {273; CGSCC-NEXT:    ret float undef274;275  %call = call float @mutually_recursive0(float %arg)276  ret float %call277}278 279define float @recursive_phi(ptr %ptr) {280; CHECK-LABEL: define nofpclass(nan) float @recursive_phi281; CHECK-SAME: (ptr nofree [[PTR:%.*]]) {282; CHECK-NEXT:  entry:283; CHECK-NEXT:    [[RET:%.*]] = call nofpclass(nan) float @ret_nofpclass_nan()284; CHECK-NEXT:    br label [[LOOP:%.*]]285; CHECK:       loop:286; CHECK-NEXT:    [[PHI:%.*]] = phi float [ [[RET]], [[ENTRY:%.*]] ], [ [[RET]], [[LOOP]] ]287; CHECK-NEXT:    [[COND:%.*]] = load volatile i1, ptr [[PTR]], align 1288; CHECK-NEXT:    br i1 [[COND]], label [[LOOP]], label [[EXIT:%.*]]289; CHECK:       exit:290; CHECK-NEXT:    ret float [[RET]]291;292entry:293  %ret = call float @ret_nofpclass_nan()294  br label %loop295 296loop:297  %phi = phi float [%ret, %entry], [%phi, %loop]298  %cond = load volatile i1, ptr %ptr299  br i1 %cond, label %loop, label %exit300 301exit:302  ret float %phi303}304 305; Should be able to infer nofpclass(nan) return306define float @fcmp_uno_check(float %arg) local_unnamed_addr {307; CHECK-LABEL: define float @fcmp_uno_check308; CHECK-SAME: (float [[ARG:%.*]]) local_unnamed_addr {309; CHECK-NEXT:  entry:310; CHECK-NEXT:    [[ISNAN:%.*]] = fcmp uno float [[ARG]], 0.000000e+00311; CHECK-NEXT:    br i1 [[ISNAN]], label [[BB0:%.*]], label [[BB1:%.*]]312; CHECK:       bb0:313; CHECK-NEXT:    [[CALL:%.*]] = call nofpclass(nan) float @ret_nofpclass_nan()314; CHECK-NEXT:    br label [[BB1]]315; CHECK:       bb1:316; CHECK-NEXT:    [[PHI:%.*]] = phi float [ [[CALL]], [[BB0]] ], [ [[ARG]], [[ENTRY:%.*]] ]317; CHECK-NEXT:    ret float [[PHI]]318;319entry:320  %isnan = fcmp uno float %arg, 0.0321  br i1 %isnan, label %bb0, label %bb1322 323bb0:324  %call = call float @ret_nofpclass_nan()325  br label %bb1326 327bb1:328  %phi = phi float [ %call, %bb0 ], [ %arg, %entry ]329  ret float %phi330}331 332; Should be able to infer nofpclass(nan) on %arg use333define void @fcmp_ord_guard_callsite_arg(float %arg) {334; CHECK-LABEL: define void @fcmp_ord_guard_callsite_arg335; CHECK-SAME: (float [[ARG:%.*]]) {336; CHECK-NEXT:  entry:337; CHECK-NEXT:    [[IS_NOT_NAN:%.*]] = fcmp ord float [[ARG]], 0.000000e+00338; CHECK-NEXT:    br i1 [[IS_NOT_NAN]], label [[BB0:%.*]], label [[BB1:%.*]]339; CHECK:       bb0:340; CHECK-NEXT:    call void @extern.use(float [[ARG]])341; CHECK-NEXT:    br label [[BB1]]342; CHECK:       bb1:343; CHECK-NEXT:    ret void344;345entry:346  %is.not.nan = fcmp ord float %arg, 0.0347  br i1 %is.not.nan, label %bb0, label %bb1348 349bb0:350  call void @extern.use(float %arg)351  br label %bb1352 353bb1:354  ret void355}356 357; Should be able to infer nofpclass on both %arg uses358define float @fcmp_ord_assume_callsite_arg_return(float %arg) {359; CHECK-LABEL: define float @fcmp_ord_assume_callsite_arg_return360; CHECK-SAME: (float returned [[ARG:%.*]]) {361; CHECK-NEXT:  entry:362; CHECK-NEXT:    [[IS_NOT_NAN:%.*]] = fcmp ord float [[ARG]], 0.000000e+00363; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[IS_NOT_NAN]]) #[[ATTR18:[0-9]+]]364; CHECK-NEXT:    call void @extern.use(float [[ARG]])365; CHECK-NEXT:    ret float [[ARG]]366;367entry:368  %is.not.nan = fcmp ord float %arg, 0.0369  call void @llvm.assume(i1 %is.not.nan)370  call void @extern.use(float %arg)371  ret float %arg372}373 374define internal float @returned_dead() {375; CHECK-LABEL: define internal nofpclass(nan inf nzero sub norm) float @returned_dead() {376; CHECK-NEXT:    call void @unknown()377; CHECK-NEXT:    ret float undef378;379  call void @unknown()380  ret float 0.0381}382 383define void @returned_dead_caller() {384; CHECK-LABEL: define void @returned_dead_caller() {385; CHECK-NEXT:    [[TMP1:%.*]] = call float @returned_dead()386; CHECK-NEXT:    ret void387;388  call float @returned_dead()389  ret void390}391 392define internal float @only_nofpclass_inf_callers(float %arg) {393; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)394; CHECK-LABEL: define internal float @only_nofpclass_inf_callers395; CHECK-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] {396; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG]], [[ARG]]397; CHECK-NEXT:    ret float [[ADD]]398;399  %add = fadd float %arg, %arg400  ret float %add401}402 403define float @call_noinf_0(float nofpclass(inf) %arg) {404; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)405; TUNIT-LABEL: define float @call_noinf_0406; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] {407; TUNIT-NEXT:    [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR19:[0-9]+]]408; TUNIT-NEXT:    ret float [[RESULT]]409;410; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)411; CGSCC-LABEL: define float @call_noinf_0412; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR4:[0-9]+]] {413; CGSCC-NEXT:    [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR19:[0-9]+]]414; CGSCC-NEXT:    ret float [[RESULT]]415;416  %result = call float @only_nofpclass_inf_callers(float %arg)417  ret float %result418}419 420define float @call_noinf_1(float %arg) {421; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)422; TUNIT-LABEL: define float @call_noinf_1423; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] {424; TUNIT-NEXT:    [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR19]]425; TUNIT-NEXT:    ret float [[RESULT]]426;427; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)428; CGSCC-LABEL: define float @call_noinf_1429; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR4]] {430; CGSCC-NEXT:    [[RESULT:%.*]] = call float @only_nofpclass_inf_callers(float nofpclass(inf) [[ARG]]) #[[ATTR19]]431; CGSCC-NEXT:    ret float [[RESULT]]432;433  %result = call float @only_nofpclass_inf_callers(float nofpclass(inf) %arg)434  ret float %result435}436 437; TODO: Should be able to infer nofpclass(inf) on return438define internal float @only_nofpclass_inf_return_users(float %arg) {439; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)440; CHECK-LABEL: define internal float @only_nofpclass_inf_return_users441; CHECK-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {442; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG]], [[ARG]]443; CHECK-NEXT:    ret float [[ADD]]444;445  %add = fadd float %arg, %arg446  ret float %add447}448 449define float @call_noinf_return_0(float %arg) {450; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)451; TUNIT-LABEL: define nofpclass(inf) float @call_noinf_return_0452; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {453; TUNIT-NEXT:    [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR19]]454; TUNIT-NEXT:    ret float [[RESULT]]455;456; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)457; CGSCC-LABEL: define nofpclass(inf) float @call_noinf_return_0458; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR4]] {459; CGSCC-NEXT:    [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR19]]460; CGSCC-NEXT:    ret float [[RESULT]]461;462  %result = call nofpclass(inf) float @only_nofpclass_inf_return_users(float %arg)463  ret float %result464}465 466define float @call_noinf_return_1(float %arg) {467; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)468; TUNIT-LABEL: define nofpclass(inf) float @call_noinf_return_1469; TUNIT-SAME: (float [[ARG:%.*]]) #[[ATTR3]] {470; TUNIT-NEXT:    [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR19]]471; TUNIT-NEXT:    ret float [[RESULT]]472;473; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)474; CGSCC-LABEL: define nofpclass(inf) float @call_noinf_return_1475; CGSCC-SAME: (float [[ARG:%.*]]) #[[ATTR4]] {476; CGSCC-NEXT:    [[RESULT:%.*]] = call nofpclass(inf) float @only_nofpclass_inf_return_users(float [[ARG]]) #[[ATTR19]]477; CGSCC-NEXT:    ret float [[RESULT]]478;479  %result = call nofpclass(inf) float @only_nofpclass_inf_return_users(float %arg)480  ret float %result481}482 483define float @fcmp_olt_assume_one_0_callsite_arg_return(float %arg) {484; CHECK-LABEL: define float @fcmp_olt_assume_one_0_callsite_arg_return485; CHECK-SAME: (float returned [[ARG:%.*]]) {486; CHECK-NEXT:  entry:487; CHECK-NEXT:    [[IS_NOT_ZERO_OR_NAN:%.*]] = fcmp one float [[ARG]], 0.000000e+00488; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[IS_NOT_ZERO_OR_NAN]]) #[[ATTR18]]489; CHECK-NEXT:    call void @extern.use(float [[ARG]])490; CHECK-NEXT:    ret float [[ARG]]491;492entry:493  %is.not.zero.or.nan = fcmp one float %arg, 0.0494  call void @llvm.assume(i1 %is.not.zero.or.nan)495  call void @extern.use(float %arg)496  ret float %arg497}498 499define float @fcmp_olt_assume_une_0_callsite_arg_return(float %arg) {500; CHECK-LABEL: define float @fcmp_olt_assume_une_0_callsite_arg_return501; CHECK-SAME: (float returned [[ARG:%.*]]) {502; CHECK-NEXT:  entry:503; CHECK-NEXT:    [[IS_NOT_ZERO_OR_NAN:%.*]] = fcmp une float [[ARG]], 0.000000e+00504; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[IS_NOT_ZERO_OR_NAN]]) #[[ATTR18]]505; CHECK-NEXT:    call void @extern.use(float [[ARG]])506; CHECK-NEXT:    ret float [[ARG]]507;508entry:509  %is.not.zero.or.nan = fcmp une float %arg, 0.0510  call void @llvm.assume(i1 %is.not.zero.or.nan)511  call void @extern.use(float %arg)512  ret float %arg513}514 515define half @fcmp_assume_issubnormal_callsite_arg_return(half %arg) {516; CHECK-LABEL: define half @fcmp_assume_issubnormal_callsite_arg_return517; CHECK-SAME: (half returned [[ARG:%.*]]) {518; CHECK-NEXT:  entry:519; CHECK-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) half @llvm.fabs.f16(half [[ARG]]) #[[ATTR20:[0-9]+]]520; CHECK-NEXT:    [[IS_SUBNORMAL:%.*]] = fcmp olt half [[FABS]], 0xH0400521; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[IS_SUBNORMAL]]) #[[ATTR18]]522; CHECK-NEXT:    call void @extern.use.f16(half [[ARG]])523; CHECK-NEXT:    ret half [[ARG]]524;525entry:526  %fabs = call half @llvm.fabs.f16(half %arg)527  %is.subnormal = fcmp olt half %fabs, 0xH0400528  call void @llvm.assume(i1 %is.subnormal)529  call void @extern.use.f16(half %arg)530  ret half %arg531}532 533; Assume is after the call, shouldn't mark callsite.534define half @fcmp_assume_not_inf_after_call(half %arg) {535; CHECK-LABEL: define half @fcmp_assume_not_inf_after_call536; CHECK-SAME: (half returned [[ARG:%.*]]) {537; CHECK-NEXT:  entry:538; CHECK-NEXT:    call void @extern.use.f16(half [[ARG]])539; CHECK-NEXT:    [[NOT_INF:%.*]] = fcmp oeq half [[ARG]], 0xH7C00540; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[NOT_INF]])541; CHECK-NEXT:    ret half [[ARG]]542;543entry:544  call void @extern.use.f16(half %arg)545  %not.inf = fcmp oeq half %arg, 0xH7C00546  call void @llvm.assume(i1 %not.inf)547  ret half %arg548}549 550; Assume not subnormal or zero, and not infinity551define half @fcmp_assume2_callsite_arg_return(half %arg) {552; CHECK-LABEL: define half @fcmp_assume2_callsite_arg_return553; CHECK-SAME: (half returned [[ARG:%.*]]) {554; CHECK-NEXT:  entry:555; CHECK-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) half @llvm.fabs.f16(half [[ARG]]) #[[ATTR20]]556; CHECK-NEXT:    [[NOT_SUBNORMAL_OR_ZERO:%.*]] = fcmp oge half [[FABS]], 0xH0400557; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[NOT_SUBNORMAL_OR_ZERO]]) #[[ATTR18]]558; CHECK-NEXT:    [[NOT_INF:%.*]] = fcmp one half [[ARG]], 0xH7C00559; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[NOT_INF]]) #[[ATTR18]]560; CHECK-NEXT:    call void @extern.use.f16(half [[ARG]])561; CHECK-NEXT:    ret half [[ARG]]562;563entry:564  %fabs = call half @llvm.fabs.f16(half %arg)565  %not.subnormal.or.zero = fcmp oge half %fabs, 0xH0400566  call void @llvm.assume(i1 %not.subnormal.or.zero)567 568  %not.inf = fcmp one half %arg, 0xH7C00569  call void @llvm.assume(i1 %not.inf)570 571  call void @extern.use.f16(half %arg)572  ret half %arg573}574 575define float @is_fpclass_assume_arg_return(float %arg) {576; CHECK-LABEL: define float @is_fpclass_assume_arg_return577; CHECK-SAME: (float returned [[ARG:%.*]]) {578; CHECK-NEXT:  entry:579; CHECK-NEXT:    [[CLASS_TEST:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG]], i32 noundef 292) #[[ATTR20]]580; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[CLASS_TEST]]) #[[ATTR18]]581; CHECK-NEXT:    call void @extern.use(float [[ARG]])582; CHECK-NEXT:    ret float [[ARG]]583;584entry:585  %class.test = call i1 @llvm.is.fpclass.f32(float %arg, i32 292)586  call void @llvm.assume(i1 %class.test)587  call void @extern.use(float %arg)588  ret float %arg589}590 591; Make sure we don't get confused by looking at an unrelated assume592; based on the fabs of the value.593define half @assume_fcmp_fabs_with_other_fabs_assume(half %arg) {594; CHECK-LABEL: define half @assume_fcmp_fabs_with_other_fabs_assume595; CHECK-SAME: (half returned [[ARG:%.*]]) {596; CHECK-NEXT:  entry:597; CHECK-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) half @llvm.fabs.f16(half [[ARG]]) #[[ATTR20]]598; CHECK-NEXT:    [[UNRELATED_FABS:%.*]] = fcmp one half [[FABS]], 0xH0000599; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[UNRELATED_FABS]]) #[[ATTR18]]600; CHECK-NEXT:    [[IS_SUBNORMAL:%.*]] = fcmp olt half [[FABS]], 0xH0400601; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[IS_SUBNORMAL]]) #[[ATTR18]]602; CHECK-NEXT:    call void @extern.use.f16(half [[ARG]])603; CHECK-NEXT:    call void @extern.use.f16(half nofpclass(ninf nzero nsub nnorm) [[FABS]])604; CHECK-NEXT:    ret half [[ARG]]605;606entry:607 608  %fabs = call half @llvm.fabs.f16(half %arg)609  %unrelated.fabs = fcmp one half %fabs, 0.0610  call void @llvm.assume(i1 %unrelated.fabs)611  %is.subnormal = fcmp olt half %fabs, 0xH0400612  call void @llvm.assume(i1 %is.subnormal)613  call void @extern.use.f16(half %arg)614  call void @extern.use.f16(half %fabs)615  ret half %arg616}617 618; Make sure if looking through the fabs finds a different source619; value, we still identify a test mask by ignoring the fabs620define half @assume_fcmp_fabs_with_other_fabs_assume_fallback(half %arg) {621; CHECK-LABEL: define half @assume_fcmp_fabs_with_other_fabs_assume_fallback622; CHECK-SAME: (half returned [[ARG:%.*]]) {623; CHECK-NEXT:  entry:624; CHECK-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) half @llvm.fabs.f16(half [[ARG]]) #[[ATTR20]]625; CHECK-NEXT:    call void @llvm.assume(i1 noundef true) #[[ATTR18]]626; CHECK-NEXT:    [[UNRELATED_FABS:%.*]] = fcmp oeq half [[FABS]], 0xH0000627; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[UNRELATED_FABS]]) #[[ATTR18]]628; CHECK-NEXT:    call void @llvm.assume(i1 noundef true) #[[ATTR18]]629; CHECK-NEXT:    call void @extern.use.f16(half [[ARG]])630; CHECK-NEXT:    call void @extern.use.f16(half nofpclass(ninf nzero nsub nnorm) [[FABS]])631; CHECK-NEXT:    ret half [[ARG]]632;633entry:634 635  %fabs = call half @llvm.fabs.f16(half %arg)636 637  %one.inf = fcmp one half %arg, 0xH7C00638  call void @llvm.assume(i1 %one.inf)639 640  %unrelated.fabs = fcmp oeq half %fabs, 0.0641  call void @llvm.assume(i1 %unrelated.fabs)642 643  %is.subnormal = fcmp olt half %fabs, 0xH0400644  call void @llvm.assume(i1 %is.subnormal)645  call void @extern.use.f16(half %arg)646  call void @extern.use.f16(half %fabs)647  ret half %arg648}649 650define float @assume_bundles(i1 %c, float %ret) {651; CHECK-LABEL: define float @assume_bundles652; CHECK-SAME: (i1 noundef [[C:%.*]], float returned [[RET:%.*]]) {653; CHECK-NEXT:  entry:654; CHECK-NEXT:    br i1 [[C]], label [[A:%.*]], label [[B:%.*]]655; CHECK:       A:656; CHECK-NEXT:    call void @llvm.assume(i1 noundef true) #[[ATTR18]] [ "nofpclass"(float [[RET]], i32 3) ]657; CHECK-NEXT:    call void @extern.use(float nofpclass(nan) [[RET]])658; CHECK-NEXT:    ret float [[RET]]659; CHECK:       B:660; CHECK-NEXT:    call void @llvm.assume(i1 noundef true) [ "nofpclass"(float [[RET]], i32 12) ]661; CHECK-NEXT:    call void @extern.use(float nofpclass(ninf nnorm) [[RET]])662; CHECK-NEXT:    ret float [[RET]]663;664entry:665  br i1 %c, label %A, label %B666 667A:668  call void @llvm.assume(i1 true) [ "nofpclass"(float %ret, i32 3) ]669  call void @extern.use(float %ret)670  ret float %ret671 672B:673  call void @llvm.assume(i1 true) [ "nofpclass"(float %ret, i32 12) ]674  call void @extern.use(float %ret)675  ret float %ret676}677 678define float @returned_load(ptr %ptr) {679; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: read)680; CHECK-LABEL: define float @returned_load681; CHECK-SAME: (ptr nofree noundef nonnull readonly align 4 captures(none) dereferenceable(4) [[PTR:%.*]]) #[[ATTR5:[0-9]+]] {682; CHECK-NEXT:    [[LOAD:%.*]] = load float, ptr [[PTR]], align 4683; CHECK-NEXT:    ret float [[LOAD]]684;685  %load = load float, ptr %ptr686  ret float %load687}688 689define float @pass_nofpclass_inf_through_memory(float nofpclass(inf) %arg) {690; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)691; TUNIT-LABEL: define float @pass_nofpclass_inf_through_memory692; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] {693; TUNIT-NEXT:    [[ALLOCA:%.*]] = alloca float, align 4694; TUNIT-NEXT:    store float [[ARG]], ptr [[ALLOCA]], align 4695; TUNIT-NEXT:    [[RET:%.*]] = call float @returned_load(ptr noalias nofree noundef nonnull readonly align 4 captures(none) dereferenceable(4) [[ALLOCA]]) #[[ATTR21:[0-9]+]]696; TUNIT-NEXT:    ret float [[RET]]697;698; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)699; CGSCC-LABEL: define float @pass_nofpclass_inf_through_memory700; CGSCC-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR4]] {701; CGSCC-NEXT:    [[ALLOCA:%.*]] = alloca float, align 4702; CGSCC-NEXT:    store float [[ARG]], ptr [[ALLOCA]], align 4703; CGSCC-NEXT:    [[RET:%.*]] = call float @returned_load(ptr noalias nofree noundef nonnull readonly align 4 captures(none) dereferenceable(4) [[ALLOCA]]) #[[ATTR21:[0-9]+]]704; CGSCC-NEXT:    ret float [[RET]]705;706  %alloca = alloca float707  store float %arg, ptr %alloca708  %ret = call float @returned_load(ptr %alloca)709  ret float %ret710}711 712define float @returned_fabs(float %x) {713; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)714; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs715; TUNIT-SAME: (float [[X:%.*]]) #[[ATTR3]] {716; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR22:[0-9]+]]717; TUNIT-NEXT:    ret float [[FABS]]718;719; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)720; CGSCC-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs721; CGSCC-SAME: (float [[X:%.*]]) #[[ATTR3]] {722; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR19]]723; CGSCC-NEXT:    ret float [[FABS]]724;725  %fabs = call float @llvm.fabs.f32(float %x)726  ret float %fabs727}728 729define float @returned_fabs_nosnan(float nofpclass(snan) %x) {730; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)731; TUNIT-LABEL: define nofpclass(snan ninf nzero nsub nnorm) float @returned_fabs_nosnan732; TUNIT-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR3]] {733; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR22]]734; TUNIT-NEXT:    ret float [[FABS]]735;736; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)737; CGSCC-LABEL: define nofpclass(snan ninf nzero nsub nnorm) float @returned_fabs_nosnan738; CGSCC-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR3]] {739; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR19]]740; CGSCC-NEXT:    ret float [[FABS]]741;742  %fabs = call float @llvm.fabs.f32(float %x)743  ret float %fabs744}745 746define float @returned_fabs_noqnan(float nofpclass(qnan) %x) {747; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)748; TUNIT-LABEL: define nofpclass(qnan ninf nzero nsub nnorm) float @returned_fabs_noqnan749; TUNIT-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR3]] {750; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR22]]751; TUNIT-NEXT:    ret float [[FABS]]752;753; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)754; CGSCC-LABEL: define nofpclass(qnan ninf nzero nsub nnorm) float @returned_fabs_noqnan755; CGSCC-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR3]] {756; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR19]]757; CGSCC-NEXT:    ret float [[FABS]]758;759  %fabs = call float @llvm.fabs.f32(float %x)760  ret float %fabs761}762 763define float @returned_fabs_nonan(float nofpclass(nan) %x) {764; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)765; TUNIT-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nonan766; TUNIT-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR3]] {767; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR22]]768; TUNIT-NEXT:    ret float [[FABS]]769;770; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)771; CGSCC-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nonan772; CGSCC-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR3]] {773; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR19]]774; CGSCC-NEXT:    ret float [[FABS]]775;776  %fabs = call float @llvm.fabs.f32(float %x)777  ret float %fabs778}779 780define float @returned_fabs_noinf(float nofpclass(inf) %x) {781; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)782; TUNIT-LABEL: define nofpclass(inf nzero nsub nnorm) float @returned_fabs_noinf783; TUNIT-SAME: (float nofpclass(inf) [[X:%.*]]) #[[ATTR3]] {784; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(inf) [[X]]) #[[ATTR22]]785; TUNIT-NEXT:    ret float [[FABS]]786;787; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)788; CGSCC-LABEL: define nofpclass(inf nzero nsub nnorm) float @returned_fabs_noinf789; CGSCC-SAME: (float nofpclass(inf) [[X:%.*]]) #[[ATTR3]] {790; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(inf) [[X]]) #[[ATTR19]]791; CGSCC-NEXT:    ret float [[FABS]]792;793  %fabs = call float @llvm.fabs.f32(float %x)794  ret float %fabs795}796 797define float @returned_fabs_nopos(float nofpclass(psub pnorm pinf) %x) {798; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)799; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos800; TUNIT-SAME: (float nofpclass(pinf psub pnorm) [[X:%.*]]) #[[ATTR3]] {801; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf psub pnorm) [[X]]) #[[ATTR22]]802; TUNIT-NEXT:    ret float [[FABS]]803;804; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)805; CGSCC-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos806; CGSCC-SAME: (float nofpclass(pinf psub pnorm) [[X:%.*]]) #[[ATTR3]] {807; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf psub pnorm) [[X]]) #[[ATTR19]]808; CGSCC-NEXT:    ret float [[FABS]]809;810  %fabs = call float @llvm.fabs.f32(float %x)811  ret float %fabs812}813 814define float @returned_fabs_nopos_nopzero(float nofpclass(psub pnorm pinf pzero) %x) {815; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)816; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos_nopzero817; TUNIT-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR3]] {818; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR22]]819; TUNIT-NEXT:    ret float [[FABS]]820;821; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)822; CGSCC-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopos_nopzero823; CGSCC-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR3]] {824; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR19]]825; CGSCC-NEXT:    ret float [[FABS]]826;827  %fabs = call float @llvm.fabs.f32(float %x)828  ret float %fabs829}830 831define float @returned_fabs_nopos_nozero(float nofpclass(psub pnorm pinf zero) %x) {832; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)833; TUNIT-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_nopos_nozero834; TUNIT-SAME: (float nofpclass(pinf zero psub pnorm) [[X:%.*]]) #[[ATTR3]] {835; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf zero psub pnorm) [[X]]) #[[ATTR22]]836; TUNIT-NEXT:    ret float [[FABS]]837;838; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)839; CGSCC-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_nopos_nozero840; CGSCC-SAME: (float nofpclass(pinf zero psub pnorm) [[X:%.*]]) #[[ATTR3]] {841; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf zero psub pnorm) [[X]]) #[[ATTR19]]842; CGSCC-NEXT:    ret float [[FABS]]843;844  %fabs = call float @llvm.fabs.f32(float %x)845  ret float %fabs846}847 848define float @returned_fabs_nopos_nonan(float nofpclass(psub pnorm pinf nan) %x) {849; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)850; TUNIT-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nopos_nonan851; TUNIT-SAME: (float nofpclass(nan pinf psub pnorm) [[X:%.*]]) #[[ATTR3]] {852; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan pinf psub pnorm) [[X]]) #[[ATTR22]]853; TUNIT-NEXT:    ret float [[FABS]]854;855; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)856; CGSCC-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_nopos_nonan857; CGSCC-SAME: (float nofpclass(nan pinf psub pnorm) [[X:%.*]]) #[[ATTR3]] {858; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan pinf psub pnorm) [[X]]) #[[ATTR19]]859; CGSCC-NEXT:    ret float [[FABS]]860;861  %fabs = call float @llvm.fabs.f32(float %x)862  ret float %fabs863}864 865define float @returned_fabs_noneg(float nofpclass(nsub nnorm ninf) %x) {866; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)867; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg868; TUNIT-SAME: (float nofpclass(ninf nsub nnorm) [[X:%.*]]) #[[ATTR3]] {869; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nsub nnorm) [[X]]) #[[ATTR22]]870; TUNIT-NEXT:    ret float [[FABS]]871;872; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)873; CGSCC-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg874; CGSCC-SAME: (float nofpclass(ninf nsub nnorm) [[X:%.*]]) #[[ATTR3]] {875; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nsub nnorm) [[X]]) #[[ATTR19]]876; CGSCC-NEXT:    ret float [[FABS]]877;878  %fabs = call float @llvm.fabs.f32(float %x)879  ret float %fabs880}881 882define float @returned_fabs_noneg_nonzero(float nofpclass(nsub nnorm ninf nzero) %x) {883; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)884; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg_nonzero885; TUNIT-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR3]] {886; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR22]]887; TUNIT-NEXT:    ret float [[FABS]]888;889; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)890; CGSCC-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_noneg_nonzero891; CGSCC-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR3]] {892; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR19]]893; CGSCC-NEXT:    ret float [[FABS]]894;895  %fabs = call float @llvm.fabs.f32(float %x)896  ret float %fabs897}898 899define float @returned_fabs_noneg_nozero(float nofpclass(nsub nnorm ninf zero) %x) {900; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)901; TUNIT-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_noneg_nozero902; TUNIT-SAME: (float nofpclass(ninf zero nsub nnorm) [[X:%.*]]) #[[ATTR3]] {903; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf zero nsub nnorm) [[X]]) #[[ATTR22]]904; TUNIT-NEXT:    ret float [[FABS]]905;906; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)907; CGSCC-LABEL: define nofpclass(ninf zero nsub nnorm) float @returned_fabs_noneg_nozero908; CGSCC-SAME: (float nofpclass(ninf zero nsub nnorm) [[X:%.*]]) #[[ATTR3]] {909; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf zero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf zero nsub nnorm) [[X]]) #[[ATTR19]]910; CGSCC-NEXT:    ret float [[FABS]]911;912  %fabs = call float @llvm.fabs.f32(float %x)913  ret float %fabs914}915 916define float @returned_fabs_noneg_nonan(float nofpclass(nsub nnorm ninf nan) %x) {917; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)918; TUNIT-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_noneg_nonan919; TUNIT-SAME: (float nofpclass(nan ninf nsub nnorm) [[X:%.*]]) #[[ATTR3]] {920; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan ninf nsub nnorm) [[X]]) #[[ATTR22]]921; TUNIT-NEXT:    ret float [[FABS]]922;923; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)924; CGSCC-LABEL: define nofpclass(nan ninf nzero nsub nnorm) float @returned_fabs_noneg_nonan925; CGSCC-SAME: (float nofpclass(nan ninf nsub nnorm) [[X:%.*]]) #[[ATTR3]] {926; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan ninf nsub nnorm) [[X]]) #[[ATTR19]]927; CGSCC-NEXT:    ret float [[FABS]]928;929  %fabs = call float @llvm.fabs.f32(float %x)930  ret float %fabs931}932 933define float @returned_fabs_nonsub_nopnorm_nonzero(float nofpclass(nsub pnorm nzero) %x) {934; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)935; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonsub_nopnorm_nonzero936; TUNIT-SAME: (float nofpclass(nzero nsub pnorm) [[X:%.*]]) #[[ATTR3]] {937; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nsub pnorm) [[X]]) #[[ATTR22]]938; TUNIT-NEXT:    ret float [[FABS]]939;940; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)941; CGSCC-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonsub_nopnorm_nonzero942; CGSCC-SAME: (float nofpclass(nzero nsub pnorm) [[X:%.*]]) #[[ATTR3]] {943; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nsub pnorm) [[X]]) #[[ATTR19]]944; CGSCC-NEXT:    ret float [[FABS]]945;946  %fabs = call float @llvm.fabs.f32(float %x)947  ret float %fabs948}949 950define float @returned_fabs_nopsub_nonnorm_nopzero(float nofpclass(psub nnorm pzero) %x) {951; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)952; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopsub_nonnorm_nopzero953; TUNIT-SAME: (float nofpclass(pzero psub nnorm) [[X:%.*]]) #[[ATTR3]] {954; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pzero psub nnorm) [[X]]) #[[ATTR22]]955; TUNIT-NEXT:    ret float [[FABS]]956;957; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)958; CGSCC-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nopsub_nonnorm_nopzero959; CGSCC-SAME: (float nofpclass(pzero psub nnorm) [[X:%.*]]) #[[ATTR3]] {960; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pzero psub nnorm) [[X]]) #[[ATTR19]]961; CGSCC-NEXT:    ret float [[FABS]]962;963  %fabs = call float @llvm.fabs.f32(float %x)964  ret float %fabs965}966 967define float @returned_fabs_nonnorm_nozero(float nofpclass(nnorm nzero) %x) {968; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)969; TUNIT-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonnorm_nozero970; TUNIT-SAME: (float nofpclass(nzero nnorm) [[X:%.*]]) #[[ATTR3]] {971; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nnorm) [[X]]) #[[ATTR22]]972; TUNIT-NEXT:    ret float [[FABS]]973;974; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)975; CGSCC-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fabs_nonnorm_nozero976; CGSCC-SAME: (float nofpclass(nzero nnorm) [[X:%.*]]) #[[ATTR3]] {977; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nzero nnorm) [[X]]) #[[ATTR19]]978; CGSCC-NEXT:    ret float [[FABS]]979;980  %fabs = call float @llvm.fabs.f32(float %x)981  ret float %fabs982}983 984define float @returned_fneg(float %x) {985; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)986; CHECK-LABEL: define float @returned_fneg987; CHECK-SAME: (float [[X:%.*]]) #[[ATTR3]] {988; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]989; CHECK-NEXT:    ret float [[FNEG]]990;991  %fneg = fneg float %x992  ret float %fneg993}994 995define float @returned_fneg_nosnan(float nofpclass(snan) %x) {996; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)997; CHECK-LABEL: define nofpclass(snan) float @returned_fneg_nosnan998; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR3]] {999; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1000; CHECK-NEXT:    ret float [[FNEG]]1001;1002  %fneg = fneg float %x1003  ret float %fneg1004}1005 1006define float @returned_fneg_noqnan(float nofpclass(qnan) %x) {1007; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1008; CHECK-LABEL: define nofpclass(qnan) float @returned_fneg_noqnan1009; CHECK-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR3]] {1010; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1011; CHECK-NEXT:    ret float [[FNEG]]1012;1013  %fneg = fneg float %x1014  ret float %fneg1015}1016 1017define float @returned_fneg_nosnan_ninf_flag(float nofpclass(snan) %x) {1018; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1019; CHECK-LABEL: define nofpclass(snan inf) float @returned_fneg_nosnan_ninf_flag1020; CHECK-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR3]] {1021; CHECK-NEXT:    [[FNEG:%.*]] = fneg ninf float [[X]]1022; CHECK-NEXT:    ret float [[FNEG]]1023;1024  %fneg = fneg ninf float %x1025  ret float %fneg1026}1027 1028define float @returned_fneg_nonan(float nofpclass(nan) %x) {1029; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1030; CHECK-LABEL: define nofpclass(nan) float @returned_fneg_nonan1031; CHECK-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR3]] {1032; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1033; CHECK-NEXT:    ret float [[FNEG]]1034;1035  %fneg = fneg float %x1036  ret float %fneg1037}1038 1039define float @returned_fneg_noinf(float nofpclass(inf) %x) {1040; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1041; CHECK-LABEL: define nofpclass(inf) float @returned_fneg_noinf1042; CHECK-SAME: (float nofpclass(inf) [[X:%.*]]) #[[ATTR3]] {1043; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1044; CHECK-NEXT:    ret float [[FNEG]]1045;1046  %fneg = fneg float %x1047  ret float %fneg1048}1049 1050define float @returned_fneg_noneg(float nofpclass(ninf nsub nnorm nzero) %x) {1051; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1052; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_noneg1053; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR3]] {1054; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1055; CHECK-NEXT:    ret float [[FNEG]]1056;1057  %fneg = fneg float %x1058  ret float %fneg1059}1060 1061define float @returned_fneg_noneg_nnan_flag(float nofpclass(ninf nsub nnorm nzero) %x) {1062; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1063; CHECK-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @returned_fneg_noneg_nnan_flag1064; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR3]] {1065; CHECK-NEXT:    [[FNEG:%.*]] = fneg nnan float [[X]]1066; CHECK-NEXT:    ret float [[FNEG]]1067;1068  %fneg = fneg nnan float %x1069  ret float %fneg1070}1071 1072define float @returned_fneg_nonsubnnorm(float nofpclass(nsub nnorm) %x) {1073; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1074; CHECK-LABEL: define nofpclass(psub pnorm) float @returned_fneg_nonsubnnorm1075; CHECK-SAME: (float nofpclass(nsub nnorm) [[X:%.*]]) #[[ATTR3]] {1076; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1077; CHECK-NEXT:    ret float [[FNEG]]1078;1079  %fneg = fneg float %x1080  ret float %fneg1081}1082 1083define float @returned_fneg_nopos(float nofpclass(pinf psub pnorm pzero) %x) {1084; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1085; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @returned_fneg_nopos1086; CHECK-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR3]] {1087; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1088; CHECK-NEXT:    ret float [[FNEG]]1089;1090  %fneg = fneg float %x1091  ret float %fneg1092}1093 1094define float @returned_fneg_nopnormpsub(float nofpclass(psub pnorm) %x) {1095; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1096; CHECK-LABEL: define nofpclass(nsub nnorm) float @returned_fneg_nopnormpsub1097; CHECK-SAME: (float nofpclass(psub pnorm) [[X:%.*]]) #[[ATTR3]] {1098; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1099; CHECK-NEXT:    ret float [[FNEG]]1100;1101  %fneg = fneg float %x1102  ret float %fneg1103}1104 1105define float @returned_fneg_mixed(float nofpclass(psub nnorm nzero qnan ninf) %x) {1106; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1107; CHECK-LABEL: define nofpclass(qnan pinf pzero nsub pnorm) float @returned_fneg_mixed1108; CHECK-SAME: (float nofpclass(qnan ninf nzero psub nnorm) [[X:%.*]]) #[[ATTR3]] {1109; CHECK-NEXT:    [[FNEG:%.*]] = fneg float [[X]]1110; CHECK-NEXT:    ret float [[FNEG]]1111;1112  %fneg = fneg float %x1113  ret float %fneg1114}1115 1116define float @returned_fneg_fabs(float %x) {1117; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1118; TUNIT-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs1119; TUNIT-SAME: (float [[X:%.*]]) #[[ATTR3]] {1120; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR22]]1121; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1122; TUNIT-NEXT:    ret float [[FNEG_FABS]]1123;1124; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1125; CGSCC-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs1126; CGSCC-SAME: (float [[X:%.*]]) #[[ATTR3]] {1127; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR19]]1128; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1129; CGSCC-NEXT:    ret float [[FNEG_FABS]]1130;1131  %fabs = call float @llvm.fabs.f32(float %x)1132  %fneg.fabs = fneg float %fabs1133  ret float %fneg.fabs1134}1135 1136define float @returned_fneg_fabs_nosnan(float nofpclass(snan) %x) {1137; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1138; TUNIT-LABEL: define nofpclass(snan pinf pzero psub pnorm) float @returned_fneg_fabs_nosnan1139; TUNIT-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR3]] {1140; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR22]]1141; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1142; TUNIT-NEXT:    ret float [[FNEG_FABS]]1143;1144; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1145; CGSCC-LABEL: define nofpclass(snan pinf pzero psub pnorm) float @returned_fneg_fabs_nosnan1146; CGSCC-SAME: (float nofpclass(snan) [[X:%.*]]) #[[ATTR3]] {1147; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(snan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(snan) [[X]]) #[[ATTR19]]1148; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1149; CGSCC-NEXT:    ret float [[FNEG_FABS]]1150;1151  %fabs = call float @llvm.fabs.f32(float %x)1152  %fneg.fabs = fneg float %fabs1153  ret float %fneg.fabs1154}1155 1156define float @returned_fneg_fabs_noqnan(float nofpclass(qnan) %x) {1157; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1158; TUNIT-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_noqnan1159; TUNIT-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR3]] {1160; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR22]]1161; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1162; TUNIT-NEXT:    ret float [[FNEG_FABS]]1163;1164; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1165; CGSCC-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_noqnan1166; CGSCC-SAME: (float nofpclass(qnan) [[X:%.*]]) #[[ATTR3]] {1167; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan) [[X]]) #[[ATTR19]]1168; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1169; CGSCC-NEXT:    ret float [[FNEG_FABS]]1170;1171  %fabs = call float @llvm.fabs.f32(float %x)1172  %fneg.fabs = fneg float %fabs1173  ret float %fneg.fabs1174}1175 1176define float @returned_fneg_fabs_nonan(float nofpclass(nan) %x) {1177; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1178; TUNIT-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @returned_fneg_fabs_nonan1179; TUNIT-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR3]] {1180; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR22]]1181; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1182; TUNIT-NEXT:    ret float [[FNEG_FABS]]1183;1184; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1185; CGSCC-LABEL: define nofpclass(nan pinf pzero psub pnorm) float @returned_fneg_fabs_nonan1186; CGSCC-SAME: (float nofpclass(nan) [[X:%.*]]) #[[ATTR3]] {1187; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(nan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(nan) [[X]]) #[[ATTR19]]1188; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1189; CGSCC-NEXT:    ret float [[FNEG_FABS]]1190;1191  %fabs = call float @llvm.fabs.f32(float %x)1192  %fneg.fabs = fneg float %fabs1193  ret float %fneg.fabs1194}1195 1196define float @returned_fneg_fabs_noneg(float nofpclass(ninf nsub nnorm nzero) %x) {1197; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1198; TUNIT-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_noneg1199; TUNIT-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR3]] {1200; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR22]]1201; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1202; TUNIT-NEXT:    ret float [[FNEG_FABS]]1203;1204; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1205; CGSCC-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_noneg1206; CGSCC-SAME: (float nofpclass(ninf nzero nsub nnorm) [[X:%.*]]) #[[ATTR3]] {1207; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(ninf nzero nsub nnorm) [[X]]) #[[ATTR19]]1208; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1209; CGSCC-NEXT:    ret float [[FNEG_FABS]]1210;1211  %fabs = call float @llvm.fabs.f32(float %x)1212  %fneg.fabs = fneg float %fabs1213  ret float %fneg.fabs1214}1215 1216define float @returned_fneg_fabs_nopos(float nofpclass(pinf psub pnorm pzero) %x) {1217; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1218; TUNIT-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_nopos1219; TUNIT-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR3]] {1220; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR22]]1221; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1222; TUNIT-NEXT:    ret float [[FNEG_FABS]]1223;1224; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1225; CGSCC-LABEL: define nofpclass(pinf pzero psub pnorm) float @returned_fneg_fabs_nopos1226; CGSCC-SAME: (float nofpclass(pinf pzero psub pnorm) [[X:%.*]]) #[[ATTR3]] {1227; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(pinf pzero psub pnorm) [[X]]) #[[ATTR19]]1228; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1229; CGSCC-NEXT:    ret float [[FNEG_FABS]]1230;1231  %fabs = call float @llvm.fabs.f32(float %x)1232  %fneg.fabs = fneg float %fabs1233  ret float %fneg.fabs1234}1235 1236define float @returned_fneg_fabs_mixed(float nofpclass(psub nnorm nzero qnan ninf) %x) {1237; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1238; TUNIT-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_mixed1239; TUNIT-SAME: (float nofpclass(qnan ninf nzero psub nnorm) [[X:%.*]]) #[[ATTR3]] {1240; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan ninf nzero psub nnorm) [[X]]) #[[ATTR22]]1241; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1242; TUNIT-NEXT:    ret float [[FNEG_FABS]]1243;1244; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1245; CGSCC-LABEL: define nofpclass(qnan pinf pzero psub pnorm) float @returned_fneg_fabs_mixed1246; CGSCC-SAME: (float nofpclass(qnan ninf nzero psub nnorm) [[X:%.*]]) #[[ATTR3]] {1247; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(qnan ninf nzero nsub nnorm) float @llvm.fabs.f32(float nofpclass(qnan ninf nzero psub nnorm) [[X]]) #[[ATTR19]]1248; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1249; CGSCC-NEXT:    ret float [[FNEG_FABS]]1250;1251  %fabs = call float @llvm.fabs.f32(float %x)1252  %fneg.fabs = fneg float %fabs1253  ret float %fneg.fabs1254}1255 1256define float @returned_fneg_fabs_ninf_flag_fabs(float %x) {1257; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1258; TUNIT-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fabs1259; TUNIT-SAME: (float [[X:%.*]]) #[[ATTR3]] {1260; TUNIT-NEXT:    [[FABS:%.*]] = call ninf nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR22]]1261; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1262; TUNIT-NEXT:    ret float [[FNEG_FABS]]1263;1264; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1265; CGSCC-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fabs1266; CGSCC-SAME: (float [[X:%.*]]) #[[ATTR3]] {1267; CGSCC-NEXT:    [[FABS:%.*]] = call ninf nofpclass(inf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR19]]1268; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg float [[FABS]]1269; CGSCC-NEXT:    ret float [[FNEG_FABS]]1270;1271  %fabs = call ninf float @llvm.fabs.f32(float %x)1272  %fneg.fabs = fneg float %fabs1273  ret float %fneg.fabs1274}1275 1276define float @returned_fneg_fabs_ninf_flag_fneg(float %x) {1277; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1278; TUNIT-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fneg1279; TUNIT-SAME: (float [[X:%.*]]) #[[ATTR3]] {1280; TUNIT-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR22]]1281; TUNIT-NEXT:    [[FNEG_FABS:%.*]] = fneg ninf float [[FABS]]1282; TUNIT-NEXT:    ret float [[FNEG_FABS]]1283;1284; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1285; CGSCC-LABEL: define nofpclass(inf pzero psub pnorm) float @returned_fneg_fabs_ninf_flag_fneg1286; CGSCC-SAME: (float [[X:%.*]]) #[[ATTR3]] {1287; CGSCC-NEXT:    [[FABS:%.*]] = call nofpclass(ninf nzero nsub nnorm) float @llvm.fabs.f32(float [[X]]) #[[ATTR19]]1288; CGSCC-NEXT:    [[FNEG_FABS:%.*]] = fneg ninf float [[FABS]]1289; CGSCC-NEXT:    ret float [[FNEG_FABS]]1290;1291  %fabs = call float @llvm.fabs.f32(float %x)1292  %fneg.fabs = fneg ninf float %fabs1293  ret float %fneg.fabs1294}1295 1296define float @uitofp_i32_to_f32(i32 %arg) {1297; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1298; CHECK-LABEL: define nofpclass(nan inf nzero sub nnorm) float @uitofp_i32_to_f321299; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {1300; CHECK-NEXT:    [[CVT:%.*]] = uitofp i32 [[ARG]] to float1301; CHECK-NEXT:    ret float [[CVT]]1302;1303  %cvt = uitofp i32 %arg to float1304  ret float %cvt1305}1306 1307define float @sitofp_i32_to_f32(i32 %arg) {1308; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1309; CHECK-LABEL: define nofpclass(nan inf nzero sub) float @sitofp_i32_to_f321310; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {1311; CHECK-NEXT:    [[CVT:%.*]] = sitofp i32 [[ARG]] to float1312; CHECK-NEXT:    ret float [[CVT]]1313;1314  %cvt = sitofp i32 %arg to float1315  ret float %cvt1316}1317 1318define <2 x float> @uitofp_v2i32_to_v2f32(<2 x i32> %arg) {1319; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1320; CHECK-LABEL: define nofpclass(nan inf nzero sub nnorm) <2 x float> @uitofp_v2i32_to_v2f321321; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR3]] {1322; CHECK-NEXT:    [[CVT:%.*]] = uitofp <2 x i32> [[ARG]] to <2 x float>1323; CHECK-NEXT:    ret <2 x float> [[CVT]]1324;1325  %cvt = uitofp <2 x i32> %arg to <2 x float>1326  ret <2 x float> %cvt1327}1328 1329define <2 x float> @sitofp_v2i32_to_v2i32(<2 x i32> %arg) {1330; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1331; CHECK-LABEL: define nofpclass(nan inf nzero sub) <2 x float> @sitofp_v2i32_to_v2i321332; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR3]] {1333; CHECK-NEXT:    [[CVT:%.*]] = sitofp <2 x i32> [[ARG]] to <2 x float>1334; CHECK-NEXT:    ret <2 x float> [[CVT]]1335;1336  %cvt = sitofp <2 x i32> %arg to <2 x float>1337  ret <2 x float> %cvt1338}1339 1340define half @uitofp_i17_to_f16(i17 %arg) {1341; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1342; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) half @uitofp_i17_to_f161343; CHECK-SAME: (i17 [[ARG:%.*]]) #[[ATTR3]] {1344; CHECK-NEXT:    [[CVT:%.*]] = uitofp i17 [[ARG]] to half1345; CHECK-NEXT:    ret half [[CVT]]1346;1347  %cvt = uitofp i17 %arg to half1348  ret half %cvt1349}1350 1351define half @sitofp_i17_to_f16(i17 %arg) {1352; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1353; CHECK-LABEL: define nofpclass(nan nzero sub) half @sitofp_i17_to_f161354; CHECK-SAME: (i17 [[ARG:%.*]]) #[[ATTR3]] {1355; CHECK-NEXT:    [[CVT:%.*]] = sitofp i17 [[ARG]] to half1356; CHECK-NEXT:    ret half [[CVT]]1357;1358  %cvt = sitofp i17 %arg to half1359  ret half %cvt1360}1361 1362define <2 x half> @uitofp_v2i17_to_v2f16(<2 x i17> %arg) {1363; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1364; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) <2 x half> @uitofp_v2i17_to_v2f161365; CHECK-SAME: (<2 x i17> [[ARG:%.*]]) #[[ATTR3]] {1366; CHECK-NEXT:    [[CVT:%.*]] = uitofp <2 x i17> [[ARG]] to <2 x half>1367; CHECK-NEXT:    ret <2 x half> [[CVT]]1368;1369  %cvt = uitofp <2 x i17> %arg to <2 x half>1370  ret <2 x half> %cvt1371}1372 1373define <2 x half> @sitofp_v2i17_to_v2i17(<2 x i17> %arg) {1374; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1375; CHECK-LABEL: define nofpclass(nan nzero sub) <2 x half> @sitofp_v2i17_to_v2i171376; CHECK-SAME: (<2 x i17> [[ARG:%.*]]) #[[ATTR3]] {1377; CHECK-NEXT:    [[CVT:%.*]] = sitofp <2 x i17> [[ARG]] to <2 x half>1378; CHECK-NEXT:    ret <2 x half> [[CVT]]1379;1380  %cvt = sitofp <2 x i17> %arg to <2 x half>1381  ret <2 x half> %cvt1382}1383 1384define float @assume_intersection_not_zero_and_not_nan(float %arg) {1385; CHECK-LABEL: define float @assume_intersection_not_zero_and_not_nan1386; CHECK-SAME: (float returned [[ARG:%.*]]) {1387; CHECK-NEXT:  entry:1388; CHECK-NEXT:    [[IS_NOT_ZERO_OR_NAN:%.*]] = fcmp une float [[ARG]], 0.000000e+001389; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[IS_NOT_ZERO_OR_NAN]]) #[[ATTR18]]1390; CHECK-NEXT:    [[IS_ORD:%.*]] = fcmp ord float [[ARG]], 0.000000e+001391; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[IS_ORD]]) #[[ATTR18]]1392; CHECK-NEXT:    call void @extern.use(float [[ARG]])1393; CHECK-NEXT:    ret float [[ARG]]1394;1395entry:1396  %is.not.zero.or.nan = fcmp une float %arg, 0.01397  call void @llvm.assume(i1 %is.not.zero.or.nan)1398  %is.ord = fcmp ord float %arg, 0.01399  call void @llvm.assume(i1 %is.ord)1400  call void @extern.use(float %arg)1401  ret float %arg1402}1403 1404define float @assume_intersection_class(float %arg) {1405; CHECK-LABEL: define float @assume_intersection_class1406; CHECK-SAME: (float returned [[ARG:%.*]]) {1407; CHECK-NEXT:  entry:1408; CHECK-NEXT:    [[POS_NORMAL_OR_POS_SUBNORMAL:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG]], i32 noundef 384) #[[ATTR20]]1409; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[POS_NORMAL_OR_POS_SUBNORMAL]]) #[[ATTR18]]1410; CHECK-NEXT:    [[IS_NORMAL:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG]], i32 noundef 264) #[[ATTR20]]1411; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[IS_NORMAL]]) #[[ATTR18]]1412; CHECK-NEXT:    call void @extern.use(float [[ARG]])1413; CHECK-NEXT:    ret float [[ARG]]1414;1415entry:1416  %pos.normal.or.pos.subnormal = call i1 @llvm.is.fpclass.f32(float %arg, i32 384)1417  call void @llvm.assume(i1 %pos.normal.or.pos.subnormal)1418  %is.normal = call i1 @llvm.is.fpclass.f32(float %arg, i32 264)1419  call void @llvm.assume(i1 %is.normal)1420 1421  call void @extern.use(float %arg)1422  ret float %arg1423}1424 1425define float @assume_intersection_none(float %arg) {1426; CHECK-LABEL: define float @assume_intersection_none1427; CHECK-SAME: (float returned [[ARG:%.*]]) {1428; CHECK-NEXT:  entry:1429; CHECK-NEXT:    [[CLASS1:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG]], i32 noundef 682) #[[ATTR20]]1430; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[CLASS1]]) #[[ATTR18]]1431; CHECK-NEXT:    [[CLASS2:%.*]] = call i1 @llvm.is.fpclass.f32(float [[ARG]], i32 noundef 341) #[[ATTR20]]1432; CHECK-NEXT:    call void @llvm.assume(i1 noundef [[CLASS2]]) #[[ATTR18]]1433; CHECK-NEXT:    call void @extern.use(float [[ARG]])1434; CHECK-NEXT:    ret float [[ARG]]1435;1436entry:1437  %class1 = call i1 @llvm.is.fpclass.f32(float %arg, i32 682)1438  call void @llvm.assume(i1 %class1)1439  %class2 = call i1 @llvm.is.fpclass.f32(float %arg, i32 341)1440  call void @llvm.assume(i1 %class2)1441  call void @extern.use(float %arg)1442  ret float %arg1443}1444 1445define float @returned_extractelement_dynamic_index(<4 x float> nofpclass(nan) %vec, i32 %idx) {1446; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1447; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_dynamic_index1448; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]], i32 [[IDX:%.*]]) #[[ATTR3]] {1449; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 [[IDX]]1450; CHECK-NEXT:    ret float [[EXTRACT]]1451;1452  %extract = extractelement <4 x float> %vec, i32 %idx1453  ret float %extract1454}1455 1456define float @returned_extractelement_index0(<4 x float> nofpclass(nan) %vec) {1457; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1458; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_index01459; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR3]] {1460; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 01461; CHECK-NEXT:    ret float [[EXTRACT]]1462;1463  %extract = extractelement <4 x float> %vec, i32 01464  ret float %extract1465}1466 1467define float @returned_extractelement_index_oob(<4 x float> nofpclass(nan) %vec) {1468; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1469; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_index_oob1470; CHECK-SAME: (<4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR3]] {1471; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[VEC]], i32 51472; CHECK-NEXT:    ret float [[EXTRACT]]1473;1474  %extract = extractelement <4 x float> %vec, i32 51475  ret float %extract1476}1477 1478define float @returned_extractelement_scalable(<vscale x 4 x float> nofpclass(nan) %vec) {1479; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1480; CHECK-LABEL: define nofpclass(nan) float @returned_extractelement_scalable1481; CHECK-SAME: (<vscale x 4 x float> nofpclass(nan) [[VEC:%.*]]) #[[ATTR3]] {1482; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <vscale x 4 x float> [[VEC]], i32 01483; CHECK-NEXT:    ret float [[EXTRACT]]1484;1485  %extract = extractelement <vscale x 4 x float> %vec, i32 01486  ret float %extract1487}1488 1489define float @returned_extractvalue([4 x float] nofpclass(nan) %array) {1490; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1491; CHECK-LABEL: define nofpclass(nan) float @returned_extractvalue1492; CHECK-SAME: ([4 x float] nofpclass(nan) [[ARRAY:%.*]]) #[[ATTR3]] {1493; CHECK-NEXT:    [[EXTRACT:%.*]] = extractvalue [4 x float] [[ARRAY]], 01494; CHECK-NEXT:    ret float [[EXTRACT]]1495;1496  %extract = extractvalue [4 x float] %array, 01497  ret float %extract1498}1499 1500define float @return_nofpclass_freeze_nan_arg(float nofpclass(nan) %arg) {1501; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1502; CHECK-LABEL: define noundef float @return_nofpclass_freeze_nan_arg1503; CHECK-SAME: (float nofpclass(nan) [[ARG:%.*]]) #[[ATTR3]] {1504; CHECK-NEXT:    [[FREEZE:%.*]] = freeze float [[ARG]]1505; CHECK-NEXT:    ret float [[FREEZE]]1506;1507  %freeze = freeze float %arg1508  ret float %freeze1509}1510 1511define float @return_nofpclass_extractelement_freeze_pinf_arg(<2 x float> nofpclass(pinf) %arg) {1512; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1513; CHECK-LABEL: define noundef float @return_nofpclass_extractelement_freeze_pinf_arg1514; CHECK-SAME: (<2 x float> nofpclass(pinf) [[ARG:%.*]]) #[[ATTR3]] {1515; CHECK-NEXT:    [[FREEZE:%.*]] = freeze <2 x float> [[ARG]]1516; CHECK-NEXT:    [[ELT:%.*]] = extractelement <2 x float> [[FREEZE]], i32 01517; CHECK-NEXT:    ret float [[ELT]]1518;1519  %freeze = freeze <2 x float> %arg1520  %elt = extractelement <2 x float> %freeze, i32 01521  ret float %elt1522}1523 1524define <4 x float> @insertelement_constant_chain() {1525; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1526; CHECK-LABEL: define nofpclass(nan ninf nzero sub) <4 x float> @insertelement_constant_chain1527; CHECK-SAME: () #[[ATTR3]] {1528; CHECK-NEXT:    [[INS_0:%.*]] = insertelement <4 x float> poison, float 1.000000e+00, i32 01529; CHECK-NEXT:    [[INS_1:%.*]] = insertelement <4 x float> [[INS_0]], float 0.000000e+00, i32 11530; CHECK-NEXT:    [[INS_2:%.*]] = insertelement <4 x float> [[INS_1]], float -9.000000e+00, i32 21531; CHECK-NEXT:    [[INS_3:%.*]] = insertelement <4 x float> [[INS_2]], float 0x7FF0000000000000, i32 31532; CHECK-NEXT:    ret <4 x float> [[INS_3]]1533;1534  %ins.0 = insertelement <4 x float> poison, float 1.0, i32 01535  %ins.1 = insertelement <4 x float> %ins.0, float 0.0, i32 11536  %ins.2 = insertelement <4 x float> %ins.1, float -9.0, i32 21537  %ins.3 = insertelement <4 x float> %ins.2, float 0x7FF0000000000000, i32 31538  ret <4 x float> %ins.31539}1540 1541define <4 x float> @insertelement_non_constant_chain(i32 %idx) {1542; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1543; CHECK-LABEL: define nofpclass(nan inf nzero sub) <4 x float> @insertelement_non_constant_chain1544; CHECK-SAME: (i32 [[IDX:%.*]]) #[[ATTR3]] {1545; CHECK-NEXT:    [[INS_0:%.*]] = insertelement <4 x float> poison, float 1.000000e+00, i32 01546; CHECK-NEXT:    [[INS_1:%.*]] = insertelement <4 x float> [[INS_0]], float 0.000000e+00, i32 11547; CHECK-NEXT:    [[INS_2:%.*]] = insertelement <4 x float> [[INS_1]], float -9.000000e+00, i32 21548; CHECK-NEXT:    [[INS_3:%.*]] = insertelement <4 x float> [[INS_2]], float 3.000000e+00, i32 31549; CHECK-NEXT:    [[INS_4:%.*]] = insertelement <4 x float> [[INS_2]], float 4.000000e+00, i32 [[IDX]]1550; CHECK-NEXT:    ret <4 x float> [[INS_4]]1551;1552  %ins.0 = insertelement <4 x float> poison, float 1.0, i32 01553  %ins.1 = insertelement <4 x float> %ins.0, float 0.0, i32 11554  %ins.2 = insertelement <4 x float> %ins.1, float -9.0, i32 21555  %ins.3 = insertelement <4 x float> %ins.2, float 3.0, i32 31556  %ins.4 = insertelement <4 x float> %ins.2, float 4.0, i32 %idx1557  ret <4 x float> %ins.41558}1559 1560define <vscale x 4 x float> @insertelement_scalable_constant_chain() {1561; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1562; CHECK-LABEL: define <vscale x 4 x float> @insertelement_scalable_constant_chain1563; CHECK-SAME: () #[[ATTR3]] {1564; CHECK-NEXT:    [[INS_0:%.*]] = insertelement <vscale x 4 x float> poison, float 1.000000e+00, i32 01565; CHECK-NEXT:    [[INS_1:%.*]] = insertelement <vscale x 4 x float> [[INS_0]], float 0.000000e+00, i32 11566; CHECK-NEXT:    [[INS_2:%.*]] = insertelement <vscale x 4 x float> [[INS_1]], float -9.000000e+00, i32 21567; CHECK-NEXT:    [[INS_3:%.*]] = insertelement <vscale x 4 x float> [[INS_2]], float 0x7FF0000000000000, i32 31568; CHECK-NEXT:    ret <vscale x 4 x float> [[INS_3]]1569;1570  %ins.0 = insertelement <vscale x 4 x float> poison, float 1.0, i32 01571  %ins.1 = insertelement <vscale x 4 x float> %ins.0, float 0.0, i32 11572  %ins.2 = insertelement <vscale x 4 x float> %ins.1, float -9.0, i32 21573  %ins.3 = insertelement <vscale x 4 x float> %ins.2, float 0x7FF0000000000000, i32 31574  ret <vscale x 4 x float> %ins.31575}1576 1577define <4 x float> @insertelement_unknown_base(<4 x float> %arg0) {1578; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1579; CHECK-LABEL: define <4 x float> @insertelement_unknown_base1580; CHECK-SAME: (<4 x float> [[ARG0:%.*]]) #[[ATTR3]] {1581; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 11582; CHECK-NEXT:    ret <4 x float> [[INSERT]]1583;1584  %insert = insertelement <4 x float> %arg0, float 0.0, i32 11585  ret <4 x float> %insert1586}1587 1588define float @insertelement_extractelement_same(<4 x float> %arg0) {1589; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1590; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) float @insertelement_extractelement_same1591; CHECK-SAME: (<4 x float> [[ARG0:%.*]]) #[[ATTR3]] {1592; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 11593; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 11594; CHECK-NEXT:    ret float [[EXTRACT]]1595;1596  %insert = insertelement <4 x float> %arg0, float 0.0, i32 11597  %extract = extractelement <4 x float> %insert, i32 11598  ret float %extract1599}1600 1601define float @insertelement_extractelement_different(<4 x float> nofpclass(zero) %arg0) {1602; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1603; CHECK-LABEL: define nofpclass(zero) float @insertelement_extractelement_different1604; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]]) #[[ATTR3]] {1605; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 11606; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 21607; CHECK-NEXT:    ret float [[EXTRACT]]1608;1609  %insert = insertelement <4 x float> %arg0, float 0.0, i32 11610  %extract = extractelement <4 x float> %insert, i32 21611  ret float %extract1612}1613 1614define float @insertelement_extractelement_unknown(<4 x float> nofpclass(zero) %arg0, i32 %idx) {1615; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1616; CHECK-LABEL: define nofpclass(nzero) float @insertelement_extractelement_unknown1617; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]], i32 [[IDX:%.*]]) #[[ATTR3]] {1618; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 11619; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[INSERT]], i32 [[IDX]]1620; CHECK-NEXT:    ret float [[EXTRACT]]1621;1622  %insert = insertelement <4 x float> %arg0, float 0.0, i32 11623  %extract = extractelement <4 x float> %insert, i32 %idx1624  ret float %extract1625}1626 1627define <4 x float> @insertelement_index_oob_chain() {1628; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1629; CHECK-LABEL: define nofpclass(nan ninf nzero sub norm) <4 x float> @insertelement_index_oob_chain1630; CHECK-SAME: () #[[ATTR3]] {1631; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> zeroinitializer, float 0x7FF0000000000000, i32 41632; CHECK-NEXT:    ret <4 x float> [[INSERT]]1633;1634  %insert = insertelement <4 x float> zeroinitializer, float 0x7FF0000000000000, i32 41635  ret <4 x float> %insert1636}1637 1638define <2 x float> @multiple_extractelement(<4 x float> nofpclass(zero) %arg0) {1639; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1640; CHECK-LABEL: define nofpclass(zero) <2 x float> @multiple_extractelement1641; CHECK-SAME: (<4 x float> nofpclass(zero) [[ARG0:%.*]]) #[[ATTR3]] {1642; CHECK-NEXT:    [[INSERT:%.*]] = insertelement <4 x float> [[ARG0]], float 0.000000e+00, i32 11643; CHECK-NEXT:    [[EXTRACT2:%.*]] = extractelement <4 x float> [[INSERT]], i32 21644; CHECK-NEXT:    [[EXTRACT3:%.*]] = extractelement <4 x float> [[INSERT]], i32 31645; CHECK-NEXT:    [[INS_0:%.*]] = insertelement <2 x float> poison, float [[EXTRACT3]], i32 01646; CHECK-NEXT:    [[INS_1:%.*]] = insertelement <2 x float> [[INS_0]], float [[EXTRACT2]], i32 11647; CHECK-NEXT:    ret <2 x float> [[INS_1]]1648;1649  %insert = insertelement <4 x float> %arg0, float 0.0, i32 11650  %extract2 = extractelement <4 x float> %insert, i32 21651  %extract3 = extractelement <4 x float> %insert, i32 31652  %ins.0 = insertelement <2 x float> poison, float %extract3, i32 01653  %ins.1 = insertelement <2 x float> %ins.0, float %extract2, i32 11654  ret <2 x float> %ins.11655}1656 1657; FIXME: Doesn't actually reach computeKnownFPClass1658define <4 x float> @shufflevector_constexpr() {1659; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1660; CHECK-LABEL: define <4 x float> @shufflevector_constexpr1661; CHECK-SAME: () #[[ATTR3]] {1662; CHECK-NEXT:    ret <4 x float> <float 1.000000e+00, float bitcast (i32 ptrtoint (ptr @shufflevector_constexpr to i32) to float), float 4.000000e+00, float 0.000000e+00>1663;1664  ret <4 x float> shufflevector (<2 x float> <float 1.0, float bitcast (i32 ptrtoint (ptr @shufflevector_constexpr to i32) to float)>, <2 x float> <float 4.0, float 0.0>, <4 x i32> <i32 0, i32 1, i32 2, i32 3>)1665}1666 1667define <4 x float> @shufflevector_concat_disjoint(<2 x float> nofpclass(nan) %arg0, <2 x float> nofpclass(inf) %arg1) {1668; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1669; CHECK-LABEL: define <4 x float> @shufflevector_concat_disjoint1670; CHECK-SAME: (<2 x float> nofpclass(nan) [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1671; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>1672; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1673;1674  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 2, i32 3>1675  ret <4 x float> %shuffle1676}1677 1678define <4 x float> @shufflevector_concat_overlap(<2 x float> nofpclass(nan norm psub) %arg0, <2 x float> nofpclass(inf nan sub) %arg1) {1679; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1680; CHECK-LABEL: define nofpclass(nan psub) <4 x float> @shufflevector_concat_overlap1681; CHECK-SAME: (<2 x float> nofpclass(nan psub norm) [[ARG0:%.*]], <2 x float> nofpclass(nan inf sub) [[ARG1:%.*]]) #[[ATTR3]] {1682; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>1683; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1684;1685  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 2, i32 3>1686  ret <4 x float> %shuffle1687}1688 1689define <4 x float> @shufflevector_unknown_lhs(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {1690; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1691; CHECK-LABEL: define <4 x float> @shufflevector_unknown_lhs1692; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1693; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0>1694; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1695;1696  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0>1697  ret <4 x float> %shuffle1698}1699 1700define <4 x float> @shufflevector_unknown_rhs(<2 x float> nofpclass(inf) %arg0, <2 x float> %arg1) {1701; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1702; CHECK-LABEL: define <4 x float> @shufflevector_unknown_rhs1703; CHECK-SAME: (<2 x float> nofpclass(inf) [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR3]] {1704; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0>1705; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1706;1707  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0>1708  ret <4 x float> %shuffle1709}1710 1711define <4 x float> @shufflevector_unknown_all(<2 x float> %arg0, <2 x float> %arg1) {1712; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1713; CHECK-LABEL: define <4 x float> @shufflevector_unknown_all1714; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR3]] {1715; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 3, i32 2, i32 1, i32 0>1716; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1717;1718  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 3, i32 2, i32 1, i32 0>1719  ret <4 x float> %shuffle1720}1721 1722define <4 x float> @shufflevector_only_demand_lhs(<2 x float> nofpclass(inf) %arg0, <2 x float> %arg1) {1723; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1724; CHECK-LABEL: define nofpclass(inf) <4 x float> @shufflevector_only_demand_lhs1725; CHECK-SAME: (<2 x float> nofpclass(inf) [[ARG0:%.*]], <2 x float> [[ARG1:%.*]]) #[[ATTR3]] {1726; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 1, i32 0>1727; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1728;1729  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 1, i32 0>1730  ret <4 x float> %shuffle1731}1732 1733define <4 x float> @shufflevector_only_demand_rhs(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {1734; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1735; CHECK-LABEL: define nofpclass(inf) <4 x float> @shufflevector_only_demand_rhs1736; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1737; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 2, i32 3, i32 3, i32 2>1738; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1739;1740  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 2, i32 3, i32 3, i32 2>1741  ret <4 x float> %shuffle1742}1743 1744define <4 x float> @shufflevector_undef_demanded(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {1745; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1746; CHECK-LABEL: define <4 x float> @shufflevector_undef_demanded1747; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1748; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> poison1749; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1750;1751  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> undef1752  ret <4 x float> %shuffle1753}1754 1755define <4 x float> @shufflevector_zeroinit_demanded(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {1756; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1757; CHECK-LABEL: define <4 x float> @shufflevector_zeroinit_demanded1758; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1759; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> zeroinitializer1760; CHECK-NEXT:    ret <4 x float> [[SHUFFLE]]1761;1762  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> zeroinitializer1763  ret <4 x float> %shuffle1764}1765 1766define float @shufflevector_extractelt0(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {1767; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1768; CHECK-LABEL: define float @shufflevector_extractelt01769; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1770; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1>1771; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 01772; CHECK-NEXT:    ret float [[EXTRACT]]1773;1774  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1>1775  %extract = extractelement <4 x float> %shuffle, i32 01776  ret float %extract1777}1778 1779define float @shufflevector_extractelt1(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {1780; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1781; CHECK-LABEL: define nofpclass(inf) float @shufflevector_extractelt11782; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1783; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1>1784; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 11785; CHECK-NEXT:    ret float [[EXTRACT]]1786;1787  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1>1788  %extract = extractelement <4 x float> %shuffle, i32 11789  ret float %extract1790}1791 1792define float @shufflevector_extractelt2(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {1793; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1794; CHECK-LABEL: define float @shufflevector_extractelt21795; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1796; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1>1797; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 21798; CHECK-NEXT:    ret float [[EXTRACT]]1799;1800  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1>1801  %extract = extractelement <4 x float> %shuffle, i32 21802  ret float %extract1803}1804 1805define float @shufflevector_extractelt3(<2 x float> %arg0, <2 x float> nofpclass(inf) %arg1) {1806; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1807; CHECK-LABEL: define float @shufflevector_extractelt31808; CHECK-SAME: (<2 x float> [[ARG0:%.*]], <2 x float> nofpclass(inf) [[ARG1:%.*]]) #[[ATTR3]] {1809; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <2 x float> [[ARG0]], <2 x float> [[ARG1]], <4 x i32> <i32 1, i32 3, i32 0, i32 1>1810; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <4 x float> [[SHUFFLE]], i32 31811; CHECK-NEXT:    ret float [[EXTRACT]]1812;1813  %shuffle = shufflevector <2 x float> %arg0, <2 x float> %arg1, <4 x i32> <i32 1, i32 3, i32 0, i32 1>1814  %extract = extractelement <4 x float> %shuffle, i32 31815  ret float %extract1816}1817 1818define float @shufflevector_constantdatavector_demanded0() {1819; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1820; CHECK-LABEL: define nofpclass(nan inf zero sub nnorm) float @shufflevector_constantdatavector_demanded01821; CHECK-SAME: () #[[ATTR3]] {1822; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <3 x float> <float 1.000000e+00, float 0x7FF8000000000000, float 0.000000e+00>, <3 x float> poison, <2 x i32> <i32 0, i32 2>1823; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <2 x float> [[SHUFFLE]], i32 01824; CHECK-NEXT:    ret float [[EXTRACT]]1825;1826  %shuffle = shufflevector <3 x float> <float 1.0, float 0x7FF8000000000000, float 0.0>, <3 x float> poison, <2 x i32> <i32 0, i32 2>1827  %extract = extractelement <2 x float> %shuffle, i32 01828  ret float %extract1829}1830 1831define float @shufflevector_constantdatavector_demanded1() {1832; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1833; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) float @shufflevector_constantdatavector_demanded11834; CHECK-SAME: () #[[ATTR3]] {1835; CHECK-NEXT:    [[SHUFFLE:%.*]] = shufflevector <3 x float> <float 1.000000e+00, float 0x7FF8000000000000, float 0.000000e+00>, <3 x float> poison, <2 x i32> <i32 0, i32 2>1836; CHECK-NEXT:    [[EXTRACT:%.*]] = extractelement <2 x float> [[SHUFFLE]], i32 11837; CHECK-NEXT:    ret float [[EXTRACT]]1838;1839  %shuffle = shufflevector <3 x float> <float 1.0, float 0x7FF8000000000000, float 0.0>, <3 x float> poison, <2 x i32> <i32 0, i32 2>1840  %extract = extractelement <2 x float> %shuffle, i32 11841  ret float %extract1842}1843 1844define i32 @fptosi(float nofpclass(inf nan) %arg) {1845; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1846; CHECK-LABEL: define i32 @fptosi1847; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR3]] {1848; CHECK-NEXT:    [[FPTOSI:%.*]] = fptosi float [[ARG]] to i321849; CHECK-NEXT:    [[ADD:%.*]] = add i32 [[FPTOSI]], 11850; CHECK-NEXT:    ret i32 [[ADD]]1851;1852  %fptosi = fptosi float %arg to i321853  %add = add i32 %fptosi, 11854  ret i32 %add1855}1856 1857define float @fptrunc(double nofpclass(inf nan) %arg) {1858; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1859; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @fptrunc1860; CHECK-SAME: (double nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR3]] {1861; CHECK-NEXT:    [[CAST:%.*]] = fptrunc double [[ARG]] to float1862; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[CAST]], [[CAST]]1863; CHECK-NEXT:    ret float [[MUL]]1864;1865  %cast = fptrunc double %arg to float1866  %mul = fmul float %cast, %cast1867  ret float %mul1868}1869 1870define double @fpext(float nofpclass(inf nan) %arg) {1871; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1872; CHECK-LABEL: define nofpclass(nan ninf nzero nsub nnorm) double @fpext1873; CHECK-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR3]] {1874; CHECK-NEXT:    [[CAST:%.*]] = fpext float [[ARG]] to double1875; CHECK-NEXT:    [[MUL:%.*]] = fmul double [[CAST]], [[CAST]]1876; CHECK-NEXT:    ret double [[MUL]]1877;1878  %cast = fpext float %arg to double1879  %mul = fmul double %cast, %cast1880  ret double %mul1881}1882 1883define float @atomicrmw_fadd(ptr %ptr, float nofpclass(inf nan) %val) {1884; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)1885; CHECK-LABEL: define float @atomicrmw_fadd1886; CHECK-SAME: (ptr nofree noundef nonnull align 4 captures(none) dereferenceable(4) [[PTR:%.*]], float nofpclass(nan inf) [[VAL:%.*]]) #[[ATTR6:[0-9]+]] {1887; CHECK-NEXT:    [[RESULT:%.*]] = atomicrmw fadd ptr [[PTR]], float [[VAL]] seq_cst, align 41888; CHECK-NEXT:    ret float [[RESULT]]1889;1890  %result = atomicrmw fadd ptr %ptr, float %val seq_cst1891  ret float %result1892}1893 1894define float @load(ptr %ptr, float nofpclass(nan inf) %val) {1895; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(argmem: readwrite)1896; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @load1897; CHECK-SAME: (ptr nofree noundef nonnull align 4 captures(none) dereferenceable(4) [[PTR:%.*]], float nofpclass(nan inf) [[VAL:%.*]]) #[[ATTR7:[0-9]+]] {1898; CHECK-NEXT:    store float [[VAL]], ptr [[PTR]], align 41899; CHECK-NEXT:    [[LOAD:%.*]] = load float, ptr [[PTR]], align 41900; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[LOAD]], [[LOAD]]1901; CHECK-NEXT:    ret float [[MUL]]1902;1903  store float %val, ptr %ptr1904  %load = load float, ptr %ptr1905  %mul = fmul float %load, %load1906  ret float %mul1907}1908 1909define float @load_atomic(ptr %ptr, float nofpclass(nan inf) %val) {1910; CHECK: Function Attrs: mustprogress nofree norecurse nounwind willreturn memory(argmem: readwrite)1911; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @load_atomic1912; CHECK-SAME: (ptr nofree noundef nonnull align 4 captures(none) dereferenceable(4) [[PTR:%.*]], float nofpclass(nan inf) [[VAL:%.*]]) #[[ATTR6]] {1913; CHECK-NEXT:    store atomic float [[VAL]], ptr [[PTR]] seq_cst, align 41914; CHECK-NEXT:    [[LOAD:%.*]] = load atomic float, ptr [[PTR]] seq_cst, align 41915; CHECK-NEXT:    [[MUL:%.*]] = fmul float [[LOAD]], [[LOAD]]1916; CHECK-NEXT:    ret float [[MUL]]1917;1918  store atomic float %val, ptr %ptr seq_cst, align 41919  %load = load atomic float, ptr %ptr seq_cst, align 41920  %mul = fmul float %load, %load1921  ret float %mul1922}1923 1924define <8 x float> @shufflevector_shufflevector(<4 x float> nofpclass(inf nan) %arg0, <4 x float> nofpclass(inf nan zero) %arg1) {1925; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1926; CHECK-LABEL: define nofpclass(nan inf) <8 x float> @shufflevector_shufflevector1927; CHECK-SAME: (<4 x float> nofpclass(nan inf) [[ARG0:%.*]], <4 x float> nofpclass(nan inf zero) [[ARG1:%.*]]) #[[ATTR3]] {1928; CHECK-NEXT:    [[SHUFFLE0:%.*]] = shufflevector <4 x float> [[ARG0]], <4 x float> [[ARG0]], <4 x i32> <i32 3, i32 2, i32 1, i32 0>1929; CHECK-NEXT:    [[SHUFFLE1:%.*]] = shufflevector <4 x float> [[ARG1]], <4 x float> [[ARG1]], <4 x i32> <i32 0, i32 1, i32 2, i32 3>1930; CHECK-NEXT:    [[SHUFFLE2:%.*]] = shufflevector <4 x float> [[SHUFFLE0]], <4 x float> [[SHUFFLE1]], <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>1931; CHECK-NEXT:    ret <8 x float> [[SHUFFLE2]]1932;1933  %shuffle0 = shufflevector <4 x float> %arg0, <4 x float> %arg0, <4 x i32> <i32 3, i32 2, i32 1, i32 0>1934  %shuffle1 = shufflevector <4 x float> %arg1, <4 x float> %arg1, <4 x i32> <i32 0, i32 1, i32 2, i32 3>1935  %shuffle2 = shufflevector <4 x float> %shuffle0, <4 x float> %shuffle1, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7>1936  ret <8 x float> %shuffle21937}1938 1939define float @constrained_sitofp(i32 %arg) strictfp {1940; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite)1941; CHECK-LABEL: define nofpclass(nan nzero sub) float @constrained_sitofp1942; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR8:[0-9]+]] {1943; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(nan nzero sub) float @llvm.experimental.constrained.sitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR20]]1944; CHECK-NEXT:    ret float [[VAL]]1945;1946  %val = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")1947  ret float %val1948}1949 1950define float @constrained_uitofp(i32 %arg) strictfp {1951; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind strictfp willreturn memory(inaccessiblemem: readwrite)1952; CHECK-LABEL: define nofpclass(nan ninf nzero sub nnorm) float @constrained_uitofp1953; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR8]] {1954; CHECK-NEXT:    [[VAL:%.*]] = call nofpclass(nan ninf nzero sub nnorm) float @llvm.experimental.constrained.uitofp.f32.i32(i32 [[ARG]], metadata !"round.dynamic", metadata !"fpexcept.strict") #[[ATTR20]]1955; CHECK-NEXT:    ret float [[VAL]]1956;1957  %val = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %arg, metadata !"round.dynamic", metadata !"fpexcept.strict")1958  ret float %val1959}1960 1961define float @fadd_p0(float %arg0) {1962; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1963; CHECK-LABEL: define nofpclass(nzero) float @fadd_p01964; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR3]] {1965; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+001966; CHECK-NEXT:    ret float [[ADD]]1967;1968  %add = fadd float %arg0, 0.01969  ret float %add1970}1971 1972define float @fadd_n0(float %arg0) {1973; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1974; CHECK-LABEL: define float @fadd_n01975; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR3]] {1976; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+001977; CHECK-NEXT:    ret float [[ADD]]1978;1979  %add = fadd float %arg0, -0.01980  ret float %add1981}1982 1983define float @fsub_p0(float %arg0) {1984; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1985; CHECK-LABEL: define float @fsub_p01986; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR3]] {1987; CHECK-NEXT:    [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+001988; CHECK-NEXT:    ret float [[SUB]]1989;1990  %sub = fsub float %arg0, 0.01991  ret float %sub1992}1993 1994define float @fsub_n0(float %arg0) {1995; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)1996; CHECK-LABEL: define nofpclass(nzero) float @fsub_n01997; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR3]] {1998; CHECK-NEXT:    [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+001999; CHECK-NEXT:    ret float [[SUB]]2000;2001  %sub = fsub float %arg0, -0.02002  ret float %sub2003}2004 2005define float @fsub_p0_commute(float %arg0) {2006; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2007; CHECK-LABEL: define nofpclass(nzero) float @fsub_p0_commute2008; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR3]] {2009; CHECK-NEXT:    [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]]2010; CHECK-NEXT:    ret float [[SUB]]2011;2012  %sub = fsub float 0.0, %arg02013  ret float %sub2014}2015 2016define float @fsub_n0_commute(float %arg0) {2017; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2018; CHECK-LABEL: define float @fsub_n0_commute2019; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR3]] {2020; CHECK-NEXT:    [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]]2021; CHECK-NEXT:    ret float [[SUB]]2022;2023  %sub = fsub float -0.0, %arg02024  ret float %sub2025}2026 2027define float @fadd_p0_ftz_daz(float %arg0) #3 {2028; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2029; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_ftz_daz2030; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR9:[0-9]+]] {2031; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+002032; CHECK-NEXT:    ret float [[ADD]]2033;2034  %add = fadd float %arg0, 0.02035  ret float %add2036}2037 2038define float @fadd_n0_ftz_daz(float %arg0) #0 {2039; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2040; CHECK-LABEL: define float @fadd_n0_ftz_daz2041; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR10:[0-9]+]] {2042; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+002043; CHECK-NEXT:    ret float [[ADD]]2044;2045  %add = fadd float %arg0, -0.02046  ret float %add2047}2048 2049define float @fsub_p0_ftz_daz(float %arg0) #0 {2050; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2051; CHECK-LABEL: define float @fsub_p0_ftz_daz2052; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR10]] {2053; CHECK-NEXT:    [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+002054; CHECK-NEXT:    ret float [[SUB]]2055;2056  %sub = fsub float %arg0, 0.02057  ret float %sub2058}2059 2060define float @fsub_n0_ftz_daz(float %arg0) #0 {2061; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2062; CHECK-LABEL: define float @fsub_n0_ftz_daz2063; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR10]] {2064; CHECK-NEXT:    [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+002065; CHECK-NEXT:    ret float [[SUB]]2066;2067  %sub = fsub float %arg0, -0.02068  ret float %sub2069}2070 2071define float @fsub_p0_commute_ftz_daz(float %arg0) #0 {2072; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2073; CHECK-LABEL: define float @fsub_p0_commute_ftz_daz2074; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR10]] {2075; CHECK-NEXT:    [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]]2076; CHECK-NEXT:    ret float [[SUB]]2077;2078  %sub = fsub float 0.0, %arg02079  ret float %sub2080}2081 2082define float @fsub_n0_commute_ftz_daz(float %arg0) #0 {2083; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2084; CHECK-LABEL: define float @fsub_n0_commute_ftz_daz2085; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR10]] {2086; CHECK-NEXT:    [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]]2087; CHECK-NEXT:    ret float [[SUB]]2088;2089  %sub = fsub float -0.0, %arg02090  ret float %sub2091}2092 2093define float @fadd_p0_ieee_daz(float %arg0) #2 {2094; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2095; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_ieee_daz2096; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR11:[0-9]+]] {2097; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+002098; CHECK-NEXT:    ret float [[ADD]]2099;2100  %add = fadd float %arg0, 0.02101  ret float %add2102}2103 2104define float @fadd_p0_dapz_ieee(float %arg0) #4 {2105; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2106; CHECK-LABEL: define nofpclass(nzero) float @fadd_p0_dapz_ieee2107; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR12:[0-9]+]] {2108; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], 0.000000e+002109; CHECK-NEXT:    ret float [[ADD]]2110;2111  %add = fadd float %arg0, 0.02112  ret float %add2113}2114 2115define float @fadd_n0_ieee_daz(float %arg0) #2 {2116; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2117; CHECK-LABEL: define float @fadd_n0_ieee_daz2118; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR11]] {2119; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], -0.000000e+002120; CHECK-NEXT:    ret float [[ADD]]2121;2122  %add = fadd float %arg0, -0.02123  ret float %add2124}2125 2126define float @fsub_p0_ieee_daz(float %arg0) #2 {2127; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2128; CHECK-LABEL: define float @fsub_p0_ieee_daz2129; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR11]] {2130; CHECK-NEXT:    [[SUB:%.*]] = fsub float [[ARG0]], 0.000000e+002131; CHECK-NEXT:    ret float [[SUB]]2132;2133  %sub = fsub float %arg0, 0.02134  ret float %sub2135}2136 2137define float @fsub_n0_ieee_daz(float %arg0) #2 {2138; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2139; CHECK-LABEL: define nofpclass(nzero) float @fsub_n0_ieee_daz2140; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR11]] {2141; CHECK-NEXT:    [[SUB:%.*]] = fsub float [[ARG0]], -0.000000e+002142; CHECK-NEXT:    ret float [[SUB]]2143;2144  %sub = fsub float %arg0, -0.02145  ret float %sub2146}2147 2148define float @fsub_p0_commute_ieee_daz(float %arg0) #2 {2149; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2150; CHECK-LABEL: define nofpclass(nzero) float @fsub_p0_commute_ieee_daz2151; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR11]] {2152; CHECK-NEXT:    [[SUB:%.*]] = fsub float 0.000000e+00, [[ARG0]]2153; CHECK-NEXT:    ret float [[SUB]]2154;2155  %sub = fsub float 0.0, %arg02156  ret float %sub2157}2158 2159define float @fsub_n0_commute_ieee_daz(float %arg0) #1 {2160; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2161; CHECK-LABEL: define float @fsub_n0_commute_ieee_daz2162; CHECK-SAME: (float [[ARG0:%.*]]) #[[ATTR13:[0-9]+]] {2163; CHECK-NEXT:    [[SUB:%.*]] = fsub float -0.000000e+00, [[ARG0]]2164; CHECK-NEXT:    ret float [[SUB]]2165;2166  %sub = fsub float -0.0, %arg02167  ret float %sub2168}2169 2170define float @fadd_never_negzero_or_negsub(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) {2171; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2172; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub2173; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR3]] {2174; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]2175; CHECK-NEXT:    ret float [[ADD]]2176;2177  %add = fadd float %a, %b2178  ret float %add2179}2180 2181define float @fadd_never_negzero_or_negsub_daz(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) #2 {2182; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2183; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub_daz2184; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR11]] {2185; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]2186; CHECK-NEXT:    ret float [[ADD]]2187;2188  %add = fadd float %a, %b2189  ret float %add2190}2191 2192define float @fadd_never_negzero_or_negsub_dapz(float nofpclass(nzero nsub) %a, float nofpclass(nzero nsub) %b) #5 {2193; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2194; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_negsub_dapz2195; CHECK-SAME: (float nofpclass(nzero nsub) [[A:%.*]], float nofpclass(nzero nsub) [[B:%.*]]) #[[ATTR14:[0-9]+]] {2196; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]2197; CHECK-NEXT:    ret float [[ADD]]2198;2199  %add = fadd float %a, %b2200  ret float %add2201}2202 2203define float @fadd_never_negzero_or_possub(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) {2204; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2205; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_possub2206; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR3]] {2207; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]2208; CHECK-NEXT:    ret float [[ADD]]2209;2210  %add = fadd float %a, %b2211  ret float %add2212}2213 2214define float @fadd_never_negzero_or_possub_daz(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) #2 {2215; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2216; CHECK-LABEL: define float @fadd_never_negzero_or_possub_daz2217; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR11]] {2218; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]2219; CHECK-NEXT:    ret float [[ADD]]2220;2221  %add = fadd float %a, %b2222  ret float %add2223}2224 2225define float @fadd_never_negzero_or_possub_dapz(float nofpclass(nzero psub) %a, float nofpclass(nzero psub) %b) #5 {2226; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2227; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_possub_dapz2228; CHECK-SAME: (float nofpclass(nzero psub) [[A:%.*]], float nofpclass(nzero psub) [[B:%.*]]) #[[ATTR14]] {2229; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]2230; CHECK-NEXT:    ret float [[ADD]]2231;2232  %add = fadd float %a, %b2233  ret float %add2234}2235 2236define float @fadd_never_negzero_or_sub_daz(float nofpclass(nzero sub) %a, float nofpclass(nzero sub) %b) #2 {2237; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2238; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_sub_daz2239; CHECK-SAME: (float nofpclass(nzero sub) [[A:%.*]], float nofpclass(nzero sub) [[B:%.*]]) #[[ATTR11]] {2240; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]2241; CHECK-NEXT:    ret float [[ADD]]2242;2243  %add = fadd float %a, %b2244  ret float %add2245}2246 2247define float @fadd_never_negzero_or_sub_dapz(float nofpclass(nzero sub) %a, float nofpclass(nzero sub) %b) #5 {2248; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2249; CHECK-LABEL: define nofpclass(nzero) float @fadd_never_negzero_or_sub_dapz2250; CHECK-SAME: (float nofpclass(nzero sub) [[A:%.*]], float nofpclass(nzero sub) [[B:%.*]]) #[[ATTR14]] {2251; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[A]], [[B]]2252; CHECK-NEXT:    ret float [[ADD]]2253;2254  %add = fadd float %a, %b2255  ret float %add2256}2257 2258define float @fadd_known_positive_lhs(float nofpclass(ninf nsub nnorm) %arg0, float %arg1) {2259; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2260; CHECK-LABEL: define float @fadd_known_positive_lhs2261; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float [[ARG1:%.*]]) #[[ATTR3]] {2262; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2263; CHECK-NEXT:    ret float [[ADD]]2264;2265  %add = fadd float %arg0, %arg12266  ret float %add2267}2268 2269define float @fadd_known_positive_rhs(float %arg0, float nofpclass(ninf nsub nnorm) %arg1) {2270; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2271; CHECK-LABEL: define float @fadd_known_positive_rhs2272; CHECK-SAME: (float [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR3]] {2273; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2274; CHECK-NEXT:    ret float [[ADD]]2275;2276  %add = fadd float %arg0, %arg12277  ret float %add2278}2279 2280define float @fadd_known_positive(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm) %arg1) {2281; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2282; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @fadd_known_positive2283; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR3]] {2284; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2285; CHECK-NEXT:    ret float [[ADD]]2286;2287  %add = fadd float %arg0, %arg12288  ret float %add2289}2290 2291define float @fadd_known_positive_daz(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm) %arg1) #0 {2292; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2293; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @fadd_known_positive_daz2294; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR10]] {2295; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2296; CHECK-NEXT:    ret float [[ADD]]2297;2298  %add = fadd float %arg0, %arg12299  ret float %add2300}2301 2302define float @fadd_known_positive_nzero_lhs(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm) %arg1) {2303; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2304; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @fadd_known_positive_nzero_lhs2305; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nsub nnorm) [[ARG1:%.*]]) #[[ATTR3]] {2306; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2307; CHECK-NEXT:    ret float [[ADD]]2308;2309  %add = fadd float %arg0, %arg12310  ret float %add2311}2312 2313define float @fadd_known_positive_nzero_rhs(float nofpclass(ninf nsub nnorm) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) {2314; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2315; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @fadd_known_positive_nzero_rhs2316; CHECK-SAME: (float nofpclass(ninf nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR3]] {2317; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2318; CHECK-NEXT:    ret float [[ADD]]2319;2320  %add = fadd float %arg0, %arg12321  ret float %add2322}2323 2324define float @fadd_known_positive_nzero(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) {2325; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2326; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @fadd_known_positive_nzero2327; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR3]] {2328; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2329; CHECK-NEXT:    ret float [[ADD]]2330;2331  %add = fadd float %arg0, %arg12332  ret float %add2333}2334 2335define float @fadd_known_positive_nzero_ftz_daz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #0 {2336; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2337; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @fadd_known_positive_nzero_ftz_daz2338; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR10]] {2339; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2340; CHECK-NEXT:    ret float [[ADD]]2341;2342  %add = fadd float %arg0, %arg12343  ret float %add2344}2345 2346define float @fadd_known_positive_nzero_ftz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #1 {2347; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2348; CHECK-LABEL: define nofpclass(ninf nsub nnorm) float @fadd_known_positive_nzero_ftz2349; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR13]] {2350; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2351; CHECK-NEXT:    ret float [[ADD]]2352;2353  %add = fadd float %arg0, %arg12354  ret float %add2355}2356 2357define float @fadd_known_positive_nzero_daz(float nofpclass(ninf nsub nnorm nzero) %arg0, float nofpclass(ninf nsub nnorm nzero) %arg1) #2 {2358; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2359; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @fadd_known_positive_nzero_daz2360; CHECK-SAME: (float nofpclass(ninf nzero nsub nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nsub nnorm) [[ARG1:%.*]]) #[[ATTR11]] {2361; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2362; CHECK-NEXT:    ret float [[ADD]]2363;2364  %add = fadd float %arg0, %arg12365  ret float %add2366}2367 2368define float @fadd_known_positive_normal(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) {2369; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2370; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_normal2371; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR3]] {2372; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2373; CHECK-NEXT:    ret float [[ADD]]2374;2375  %add = fadd float %arg0, %arg12376  ret float %add2377}2378 2379define float @fadd_known_positive_normal_daz(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) #0 {2380; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2381; CHECK-LABEL: define float @fadd_known_positive_normal_daz2382; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR10]] {2383; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2384; CHECK-NEXT:    ret float [[ADD]]2385;2386  %add = fadd float %arg0, %arg12387  ret float %add2388}2389 2390define float @fadd_known_positive_normal_except0_daz(float nofpclass(ninf nnorm) %arg0, float nofpclass(ninf nnorm) %arg1) #0 {2391; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2392; CHECK-LABEL: define float @fadd_known_positive_normal_except0_daz2393; CHECK-SAME: (float nofpclass(ninf nnorm) [[ARG0:%.*]], float nofpclass(ninf nnorm) [[ARG1:%.*]]) #[[ATTR10]] {2394; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2395; CHECK-NEXT:    ret float [[ADD]]2396;2397  %add = fadd float %arg0, %arg12398  ret float %add2399}2400 2401define float @fadd_known_positive_normal_dapz(float nofpclass(ninf nnorm nzero) %arg0, float nofpclass(ninf nnorm nzero) %arg1) #3 {2402; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2403; CHECK-LABEL: define nofpclass(nzero) float @fadd_known_positive_normal_dapz2404; CHECK-SAME: (float nofpclass(ninf nzero nnorm) [[ARG0:%.*]], float nofpclass(ninf nzero nnorm) [[ARG1:%.*]]) #[[ATTR9]] {2405; CHECK-NEXT:    [[ADD:%.*]] = fadd float [[ARG0]], [[ARG1]]2406; CHECK-NEXT:    ret float [[ADD]]2407;2408  %add = fadd float %arg0, %arg12409  ret float %add2410}2411 2412define internal float @returns_fence(float %arg) {2413; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2414; TUNIT-LABEL: define internal float @returns_fence2415; TUNIT-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR3]] {2416; TUNIT-NEXT:    [[RET:%.*]] = call float @llvm.arithmetic.fence.f32(float nofpclass(inf) [[ARG]]) #[[ATTR22]]2417; TUNIT-NEXT:    ret float [[RET]]2418;2419; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2420; CGSCC-LABEL: define internal float @returns_fence2421; CGSCC-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR3]] {2422; CGSCC-NEXT:    [[RET:%.*]] = call float @llvm.arithmetic.fence.f32(float nofpclass(nan inf) [[ARG]]) #[[ATTR19]]2423; CGSCC-NEXT:    ret float [[RET]]2424;2425  %ret = call float @llvm.arithmetic.fence.f32(float %arg)2426  ret float %ret2427}2428 2429; Check that the func0 callsite is marked with both no inf and no nan2430define internal float @refine_callsite_attribute(float nofpclass(inf) %arg) {2431; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2432; TUNIT-LABEL: define internal float @refine_callsite_attribute2433; TUNIT-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR3]] {2434; TUNIT-NEXT:    [[FUNC0:%.*]] = call float @returns_fence(float nofpclass(nan inf) [[ARG]]) #[[ATTR19]]2435; TUNIT-NEXT:    [[RET:%.*]] = call float @llvm.arithmetic.fence.f32(float [[FUNC0]]) #[[ATTR22]]2436; TUNIT-NEXT:    ret float [[RET]]2437;2438; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)2439; CGSCC-LABEL: define internal float @refine_callsite_attribute2440; CGSCC-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR4]] {2441; CGSCC-NEXT:    [[FUNC0:%.*]] = call float @returns_fence(float nofpclass(nan inf) [[ARG]]) #[[ATTR19]]2442; CGSCC-NEXT:    [[RET:%.*]] = call float @llvm.arithmetic.fence.f32(float [[FUNC0]]) #[[ATTR19]]2443; CGSCC-NEXT:    ret float [[RET]]2444;2445  %func0 = call float @returns_fence(float nofpclass(nan) %arg)2446  %ret = call float @llvm.arithmetic.fence.f32(float %func0)2447  ret float %ret2448}2449 2450define float @user(float %arg) {2451; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2452; TUNIT-LABEL: define float @user2453; TUNIT-SAME: (float nofpclass(inf) [[ARG:%.*]]) #[[ATTR3]] {2454; TUNIT-NEXT:    [[FUNC1:%.*]] = call float @refine_callsite_attribute(float nofpclass(inf) [[ARG]]) #[[ATTR19]]2455; TUNIT-NEXT:    ret float [[FUNC1]]2456;2457; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)2458; CGSCC-LABEL: define float @user2459; CGSCC-SAME: (float nofpclass(nan inf) [[ARG:%.*]]) #[[ATTR4]] {2460; CGSCC-NEXT:    [[FUNC1:%.*]] = call float @refine_callsite_attribute(float nofpclass(nan inf) [[ARG]]) #[[ATTR19]]2461; CGSCC-NEXT:    ret float [[FUNC1]]2462;2463  %func1 = call float @refine_callsite_attribute(float %arg)2464  ret float %func12465}2466 2467; value is passed through memory2468define internal float @through_memory0(ptr %ptr.arg) {2469; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2470; CGSCC-LABEL: define internal float @through_memory02471; CGSCC-SAME: (float [[TMP0:%.*]]) #[[ATTR3]] {2472; CGSCC-NEXT:    [[PTR_ARG_PRIV:%.*]] = alloca float, align 42473; CGSCC-NEXT:    store float [[TMP0]], ptr [[PTR_ARG_PRIV]], align 42474; CGSCC-NEXT:    [[LOAD:%.*]] = load float, ptr [[PTR_ARG_PRIV]], align 4, !invariant.load [[META0:![0-9]+]]2475; CGSCC-NEXT:    ret float [[LOAD]]2476;2477  %load = load float, ptr %ptr.arg2478  ret float %load2479}2480 2481; value is passed through memory and goes through an inferrable FP user2482define internal float @through_memory1(ptr %ptr.arg) {2483; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2484; TUNIT-LABEL: define internal float @through_memory12485; TUNIT-SAME: (float [[TMP0:%.*]]) #[[ATTR3]] {2486; TUNIT-NEXT:    [[PTR_ARG_PRIV:%.*]] = alloca float, align 42487; TUNIT-NEXT:    store float [[TMP0]], ptr [[PTR_ARG_PRIV]], align 42488; TUNIT-NEXT:    [[LOAD:%.*]] = load float, ptr [[PTR_ARG_PRIV]], align 42489; TUNIT-NEXT:    [[CALL:%.*]] = call float @llvm.arithmetic.fence.f32(float [[LOAD]]) #[[ATTR22]]2490; TUNIT-NEXT:    ret float [[CALL]]2491;2492; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2493; CGSCC-LABEL: define internal float @through_memory12494; CGSCC-SAME: (float [[TMP0:%.*]]) #[[ATTR3]] {2495; CGSCC-NEXT:    [[PTR_ARG_PRIV:%.*]] = alloca float, align 42496; CGSCC-NEXT:    store float [[TMP0]], ptr [[PTR_ARG_PRIV]], align 42497; CGSCC-NEXT:    [[LOAD:%.*]] = load float, ptr [[PTR_ARG_PRIV]], align 4, !invariant.load [[META0]]2498; CGSCC-NEXT:    [[CALL:%.*]] = call float @llvm.arithmetic.fence.f32(float [[LOAD]]) #[[ATTR19]]2499; CGSCC-NEXT:    ret float [[CALL]]2500;2501  %load = load float, ptr %ptr.arg2502  %call = call float @llvm.arithmetic.fence.f32(float %load)2503  ret float %call2504}2505 2506; value is passed through memory and goes through an uninferrable FP user2507define internal float @through_memory2(ptr %ptr.arg) {2508; CHECK: Function Attrs: memory(readwrite, argmem: none)2509; CHECK-LABEL: define internal float @through_memory22510; CHECK-SAME: (float [[TMP0:%.*]]) #[[ATTR15:[0-9]+]] {2511; CHECK-NEXT:    [[PTR_ARG_PRIV:%.*]] = alloca float, align 42512; CHECK-NEXT:    store float [[TMP0]], ptr [[PTR_ARG_PRIV]], align 42513; CHECK-NEXT:    [[LOAD:%.*]] = load float, ptr [[PTR_ARG_PRIV]], align 4, !invariant.load [[META0:![0-9]+]]2514; CHECK-NEXT:    [[CALL:%.*]] = call float @extern.f32(float [[LOAD]])2515; CHECK-NEXT:    ret float [[CALL]]2516;2517  %load = load float, ptr %ptr.arg2518  %call = call float @extern.f32(float %load)2519  ret float %call2520}2521 2522define float @call_through_memory0(float nofpclass(nan) %val) {2523; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2524; TUNIT-LABEL: define nofpclass(nan) float @call_through_memory02525; TUNIT-SAME: (float returned nofpclass(nan) [[VAL:%.*]]) #[[ATTR3]] {2526; TUNIT-NEXT:    [[ALLOCA:%.*]] = alloca float, align 42527; TUNIT-NEXT:    store float [[VAL]], ptr [[ALLOCA]], align 42528; TUNIT-NEXT:    ret float [[VAL]]2529;2530; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)2531; CGSCC-LABEL: define float @call_through_memory02532; CGSCC-SAME: (float nofpclass(nan) [[VAL:%.*]]) #[[ATTR4]] {2533; CGSCC-NEXT:    [[ALLOCA:%.*]] = alloca float, align 42534; CGSCC-NEXT:    store float [[VAL]], ptr [[ALLOCA]], align 42535; CGSCC-NEXT:    [[THROUGH_MEMORY:%.*]] = call float @through_memory0(float nofpclass(nan) [[VAL]]) #[[ATTR19]]2536; CGSCC-NEXT:    ret float [[THROUGH_MEMORY]]2537;2538  %alloca = alloca float2539  store float %val, ptr %alloca2540  %through_memory = call float @through_memory0(ptr %alloca)2541  ret float %through_memory2542}2543 2544define float @call_through_memory1(float nofpclass(nan) %val) {2545; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2546; TUNIT-LABEL: define float @call_through_memory12547; TUNIT-SAME: (float nofpclass(nan) [[VAL:%.*]]) #[[ATTR3]] {2548; TUNIT-NEXT:    [[ALLOCA:%.*]] = alloca float, align 42549; TUNIT-NEXT:    store float [[VAL]], ptr [[ALLOCA]], align 42550; TUNIT-NEXT:    [[TMP1:%.*]] = load float, ptr [[ALLOCA]], align 42551; TUNIT-NEXT:    [[THROUGH_MEMORY:%.*]] = call float @through_memory1(float [[TMP1]]) #[[ATTR21]]2552; TUNIT-NEXT:    ret float [[THROUGH_MEMORY]]2553;2554; CGSCC: Function Attrs: mustprogress nofree nosync nounwind willreturn memory(none)2555; CGSCC-LABEL: define float @call_through_memory12556; CGSCC-SAME: (float nofpclass(nan) [[VAL:%.*]]) #[[ATTR4]] {2557; CGSCC-NEXT:    [[ALLOCA:%.*]] = alloca float, align 42558; CGSCC-NEXT:    store float [[VAL]], ptr [[ALLOCA]], align 42559; CGSCC-NEXT:    [[THROUGH_MEMORY:%.*]] = call float @through_memory1(float nofpclass(nan) [[VAL]]) #[[ATTR19]]2560; CGSCC-NEXT:    ret float [[THROUGH_MEMORY]]2561;2562  %alloca = alloca float2563  store float %val, ptr %alloca2564  %through_memory = call float @through_memory1(ptr %alloca)2565  ret float %through_memory2566}2567 2568define float @call_through_memory2(float nofpclass(nan) %val) {2569; TUNIT-LABEL: define float @call_through_memory22570; TUNIT-SAME: (float nofpclass(nan) [[VAL:%.*]]) {2571; TUNIT-NEXT:    [[ALLOCA:%.*]] = alloca float, align 42572; TUNIT-NEXT:    store float [[VAL]], ptr [[ALLOCA]], align 42573; TUNIT-NEXT:    [[TMP1:%.*]] = load float, ptr [[ALLOCA]], align 42574; TUNIT-NEXT:    [[THROUGH_MEMORY:%.*]] = call float @through_memory2(float [[TMP1]])2575; TUNIT-NEXT:    ret float [[THROUGH_MEMORY]]2576;2577; CGSCC-LABEL: define float @call_through_memory22578; CGSCC-SAME: (float nofpclass(nan) [[VAL:%.*]]) {2579; CGSCC-NEXT:    [[ALLOCA:%.*]] = alloca float, align 42580; CGSCC-NEXT:    store float [[VAL]], ptr [[ALLOCA]], align 42581; CGSCC-NEXT:    [[THROUGH_MEMORY:%.*]] = call float @through_memory2(float nofpclass(nan) [[VAL]])2582; CGSCC-NEXT:    ret float [[THROUGH_MEMORY]]2583;2584  %alloca = alloca float2585  store float %val, ptr %alloca2586  %through_memory = call float @through_memory2(ptr %alloca)2587  ret float %through_memory2588}2589 2590define amdgpu_kernel void @fast_pow_kernel(ptr addrspace(1) nocapture noundef writeonly align 4 %out, ptr addrspace(1) nocapture noundef readonly align 4 %in1, ptr addrspace(1) nocapture noundef readonly align 4 %in2)  {2591; CHECK-LABEL: define amdgpu_kernel void @fast_pow_kernel2592; CHECK-SAME: (ptr addrspace(1) nofree noundef writeonly align 4 captures(none) [[OUT:%.*]], ptr addrspace(1) nofree noundef readonly align 4 captures(none) [[IN1:%.*]], ptr addrspace(1) nofree noundef readonly align 4 captures(none) [[IN2:%.*]]) {2593; CHECK-NEXT:  entry:2594; CHECK-NEXT:    [[CALL:%.*]] = tail call i64 @_Z13get_global_idj(i32 noundef 0)2595; CHECK-NEXT:    [[SEXT:%.*]] = shl i64 [[CALL]], 322596; CHECK-NEXT:    [[IDXPROM:%.*]] = ashr exact i64 [[SEXT]], 322597; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds float, ptr addrspace(1) [[IN1]], i64 [[IDXPROM]]2598; CHECK-NEXT:    [[I:%.*]] = load float, ptr addrspace(1) [[ARRAYIDX]], align 42599; CHECK-NEXT:    [[ARRAYIDX2:%.*]] = getelementptr inbounds float, ptr addrspace(1) [[IN2]], i64 [[IDXPROM]]2600; CHECK-NEXT:    [[I1:%.*]] = load float, ptr addrspace(1) [[ARRAYIDX2]], align 42601; CHECK-NEXT:    [[CALL3:%.*]] = tail call reassoc nnan ninf nsz arcp afn nofpclass(nan inf) float @pow_wrapper(float noundef nofpclass(nan inf) [[I]], float noundef nofpclass(nan inf) [[I1]])2602; CHECK-NEXT:    [[ARRAYIDX5:%.*]] = getelementptr inbounds float, ptr addrspace(1) [[OUT]], i64 [[IDXPROM]]2603; CHECK-NEXT:    store float [[CALL3]], ptr addrspace(1) [[ARRAYIDX5]], align 42604; CHECK-NEXT:    ret void2605;2606entry:2607  %call = tail call i64 @_Z13get_global_idj(i32 noundef 0)2608  %sext = shl i64 %call, 322609  %idxprom = ashr exact i64 %sext, 322610  %arrayidx = getelementptr inbounds float, ptr addrspace(1) %in1, i64 %idxprom2611  %i = load float, ptr addrspace(1) %arrayidx, align 42612  %arrayidx2 = getelementptr inbounds float, ptr addrspace(1) %in2, i64 %idxprom2613  %i1 = load float, ptr addrspace(1) %arrayidx2, align 42614  %call3 = tail call reassoc nnan ninf nsz arcp afn nofpclass(nan inf) float @pow_wrapper(float noundef nofpclass(nan inf) %i, float noundef nofpclass(nan inf) %i1)2615  %arrayidx5 = getelementptr inbounds float, ptr addrspace(1) %out, i64 %idxprom2616  store float %call3, ptr addrspace(1) %arrayidx5, align 42617  ret void2618}2619 2620define internal float @pow_wrapper(float %arg, float %arg1) {2621; TUNIT: Function Attrs: norecurse2622; TUNIT-LABEL: define internal float @pow_wrapper2623; TUNIT-SAME: (float noundef nofpclass(nan inf) [[ARG:%.*]], float noundef nofpclass(nan inf) [[ARG1:%.*]]) #[[ATTR16:[0-9]+]] {2624; TUNIT-NEXT:  bb:2625; TUNIT-NEXT:    [[I:%.*]] = tail call float @pow_impl(float noundef nofpclass(nan inf) [[ARG]], float noundef nofpclass(nan inf) [[ARG1]])2626; TUNIT-NEXT:    ret float [[I]]2627;2628; CGSCC-LABEL: define internal float @pow_wrapper2629; CGSCC-SAME: (float noundef nofpclass(nan inf) [[ARG:%.*]], float noundef nofpclass(nan inf) [[ARG1:%.*]]) {2630; CGSCC-NEXT:  bb:2631; CGSCC-NEXT:    [[I:%.*]] = tail call float @pow_impl(float noundef nofpclass(nan inf) [[ARG]], float noundef nofpclass(nan inf) [[ARG1]])2632; CGSCC-NEXT:    ret float [[I]]2633;2634bb:2635  %i = tail call float @pow_impl(float %arg, float %arg1)2636  ret float %i2637}2638 2639; nofpclass(nan inf) should reach here through pow_wrapper2640define internal float @pow_impl(float %arg, float %arg1) {2641; TUNIT: Function Attrs: norecurse2642; TUNIT-LABEL: define internal float @pow_impl2643; TUNIT-SAME: (float noundef nofpclass(nan inf) [[ARG:%.*]], float noundef nofpclass(nan inf) [[ARG1:%.*]]) #[[ATTR16]] {2644; TUNIT-NEXT:  bb:2645; TUNIT-NEXT:    [[IMPLEMENT_POW:%.*]] = call float asm "2646; TUNIT-NEXT:    ret float [[IMPLEMENT_POW]]2647;2648; CGSCC: Function Attrs: norecurse2649; CGSCC-LABEL: define internal float @pow_impl2650; CGSCC-SAME: (float [[ARG:%.*]], float [[ARG1:%.*]]) #[[ATTR16:[0-9]+]] {2651; CGSCC-NEXT:  bb:2652; CGSCC-NEXT:    [[IMPLEMENT_POW:%.*]] = call float asm "2653; CGSCC-NEXT:    ret float [[IMPLEMENT_POW]]2654;2655bb:2656  %implement.pow = call float asm " ; do pow $0, $1, $2", "=v,v,v"(float %arg, float %arg1)2657  ret float %implement.pow2658}2659 2660define [4 x float] @constant_aggregate_zero() {2661; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2662; CHECK-LABEL: define nofpclass(nan inf nzero sub norm) [4 x float] @constant_aggregate_zero2663; CHECK-SAME: () #[[ATTR3]] {2664; CHECK-NEXT:    ret [4 x float] zeroinitializer2665;2666  ret [4 x float] zeroinitializer2667}2668 2669define <vscale x 4 x float> @scalable_splat_pnorm() {2670; CHECK-CV: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2671; CHECK-CV-LABEL: define noundef <vscale x 4 x float> @scalable_splat_pnorm2672; CHECK-CV-SAME: () #[[ATTR3]] {2673; CHECK-CV-NEXT:    ret <vscale x 4 x float> splat (float 1.000000e+00)2674;2675; CHECK-CI: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2676; CHECK-CI-LABEL: define noundef nofpclass(nan inf zero sub nnorm) <vscale x 4 x float> @scalable_splat_pnorm2677; CHECK-CI-SAME: () #[[ATTR3]] {2678; CHECK-CI-NEXT:    ret <vscale x 4 x float> splat (float 1.000000e+00)2679;2680  ret <vscale x 4 x float> splat (float 1.0)2681}2682 2683define <vscale x 4 x float> @scalable_splat_zero() {2684; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2685; CHECK-LABEL: define noundef nofpclass(nan inf nzero sub norm) <vscale x 4 x float> @scalable_splat_zero2686; CHECK-SAME: () #[[ATTR3]] {2687; CHECK-NEXT:    ret <vscale x 4 x float> zeroinitializer2688;2689  ret <vscale x 4 x float> zeroinitializer2690}2691 2692; Verify we do not derive 'nofpclass(inf zero sub norm)' for the argument __x.2693; See https://github.com/llvm/llvm-project/issues/785072694 2695define double @call_abs(double noundef %__x) {2696; TUNIT: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2697; TUNIT-LABEL: define noundef nofpclass(ninf nzero nsub nnorm) double @call_abs2698; TUNIT-SAME: (double noundef [[__X:%.*]]) #[[ATTR3]] {2699; TUNIT-NEXT:  entry:2700; TUNIT-NEXT:    [[ABS:%.*]] = tail call noundef nofpclass(ninf nzero nsub nnorm) double @llvm.fabs.f64(double noundef [[__X]]) #[[ATTR22]]2701; TUNIT-NEXT:    ret double [[ABS]]2702;2703; CGSCC: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2704; CGSCC-LABEL: define noundef nofpclass(ninf nzero nsub nnorm) double @call_abs2705; CGSCC-SAME: (double noundef [[__X:%.*]]) #[[ATTR3]] {2706; CGSCC-NEXT:  entry:2707; CGSCC-NEXT:    [[ABS:%.*]] = tail call noundef nofpclass(ninf nzero nsub nnorm) double @llvm.fabs.f64(double noundef [[__X]]) #[[ATTR19]]2708; CGSCC-NEXT:    ret double [[ABS]]2709;2710entry:2711  %abs = tail call double @llvm.fabs.f64(double %__x)2712  ret double %abs2713}2714 2715define float @bitcast_to_float_sign_0(i32 %arg) {2716; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2717; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) float @bitcast_to_float_sign_02718; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {2719; CHECK-NEXT:    [[SHR:%.*]] = lshr i32 [[ARG]], 12720; CHECK-NEXT:    [[CAST:%.*]] = bitcast i32 [[SHR]] to float2721; CHECK-NEXT:    ret float [[CAST]]2722;2723  %shr = lshr i32 %arg, 12724  %cast = bitcast i32 %shr to float2725  ret float %cast2726}2727 2728define float @bitcast_to_float_nnan(i32 %arg) {2729; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2730; CHECK-LABEL: define nofpclass(nan inf nzero nsub nnorm) float @bitcast_to_float_nnan2731; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {2732; CHECK-NEXT:    [[SHR:%.*]] = lshr i32 [[ARG]], 22733; CHECK-NEXT:    [[CAST:%.*]] = bitcast i32 [[SHR]] to float2734; CHECK-NEXT:    ret float [[CAST]]2735;2736  %shr = lshr i32 %arg, 22737  %cast = bitcast i32 %shr to float2738  ret float %cast2739}2740 2741define float @bitcast_to_float_sign_1(i32 %arg) {2742; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2743; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) float @bitcast_to_float_sign_12744; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {2745; CHECK-NEXT:    [[OR:%.*]] = or i32 [[ARG]], -21474836482746; CHECK-NEXT:    [[CAST:%.*]] = bitcast i32 [[OR]] to float2747; CHECK-NEXT:    ret float [[CAST]]2748;2749  %or = or i32 %arg, -21474836482750  %cast = bitcast i32 %or to float2751  ret float %cast2752}2753 2754define float @bitcast_to_float_nan(i32 %arg) {2755; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2756; CHECK-LABEL: define nofpclass(inf zero sub norm) float @bitcast_to_float_nan2757; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {2758; CHECK-NEXT:    [[OR:%.*]] = or i32 [[ARG]], 21390950412759; CHECK-NEXT:    [[CAST:%.*]] = bitcast i32 [[OR]] to float2760; CHECK-NEXT:    ret float [[CAST]]2761;2762  %or = or i32 %arg, 21390950412763  %cast = bitcast i32 %or to float2764  ret float %cast2765}2766 2767define float @bitcast_to_float_zero(i32 %arg) {2768; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2769; CHECK-LABEL: define nofpclass(nan inf sub norm) float @bitcast_to_float_zero2770; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {2771; CHECK-NEXT:    [[SHL:%.*]] = shl i32 [[ARG]], 312772; CHECK-NEXT:    [[CAST:%.*]] = bitcast i32 [[SHL]] to float2773; CHECK-NEXT:    ret float [[CAST]]2774;2775  %shl = shl i32 %arg, 312776  %cast = bitcast i32 %shl to float2777  ret float %cast2778}2779 2780define float @bitcast_to_float_nzero(i32 %arg) {2781; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2782; CHECK-LABEL: define nofpclass(zero) float @bitcast_to_float_nzero2783; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {2784; CHECK-NEXT:    [[OR:%.*]] = or i32 [[ARG]], 1342177282785; CHECK-NEXT:    [[CAST:%.*]] = bitcast i32 [[OR]] to float2786; CHECK-NEXT:    ret float [[CAST]]2787;2788  %or = or i32 %arg, 1342177282789  %cast = bitcast i32 %or to float2790  ret float %cast2791}2792 2793define float @bitcast_to_float_inf(i32 %arg) {2794; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2795; CHECK-LABEL: define nofpclass(nan zero sub norm) float @bitcast_to_float_inf2796; CHECK-SAME: (i32 [[ARG:%.*]]) #[[ATTR3]] {2797; CHECK-NEXT:    [[SHR:%.*]] = shl i32 [[ARG]], 312798; CHECK-NEXT:    [[OR:%.*]] = or i32 [[SHR]], 21390950402799; CHECK-NEXT:    [[CAST:%.*]] = bitcast i32 [[OR]] to float2800; CHECK-NEXT:    ret float [[CAST]]2801;2802  %shr = shl i32 %arg, 312803  %or = or i32 %shr, 21390950402804  %cast = bitcast i32 %or to float2805  ret float %cast2806}2807 2808define double @bitcast_to_double_sign_0(i64 %arg) {2809; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2810; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) double @bitcast_to_double_sign_02811; CHECK-SAME: (i64 [[ARG:%.*]]) #[[ATTR3]] {2812; CHECK-NEXT:    [[SHR:%.*]] = lshr i64 [[ARG]], 12813; CHECK-NEXT:    [[CAST:%.*]] = bitcast i64 [[SHR]] to double2814; CHECK-NEXT:    ret double [[CAST]]2815;2816  %shr = lshr i64 %arg, 12817  %cast = bitcast i64 %shr to double2818  ret double %cast2819}2820 2821define double @bitcast_to_double_nnan(i64 %arg) {2822; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2823; CHECK-LABEL: define nofpclass(nan inf nzero nsub nnorm) double @bitcast_to_double_nnan2824; CHECK-SAME: (i64 [[ARG:%.*]]) #[[ATTR3]] {2825; CHECK-NEXT:    [[SHR:%.*]] = lshr i64 [[ARG]], 22826; CHECK-NEXT:    [[CAST:%.*]] = bitcast i64 [[SHR]] to double2827; CHECK-NEXT:    ret double [[CAST]]2828;2829  %shr = lshr i64 %arg, 22830  %cast = bitcast i64 %shr to double2831  ret double %cast2832}2833 2834define double @bitcast_to_double_sign_1(i64 %arg) {2835; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2836; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) double @bitcast_to_double_sign_12837; CHECK-SAME: (i64 [[ARG:%.*]]) #[[ATTR3]] {2838; CHECK-NEXT:    [[OR:%.*]] = or i64 [[ARG]], -92233720368547758082839; CHECK-NEXT:    [[CAST:%.*]] = bitcast i64 [[OR]] to double2840; CHECK-NEXT:    ret double [[CAST]]2841;2842  %or = or i64 %arg, -92233720368547758082843  %cast = bitcast i64 %or to double2844  ret double %cast2845}2846 2847define double @bitcast_to_double_nan(i64 %arg) {2848; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2849; CHECK-LABEL: define nofpclass(inf zero sub norm) double @bitcast_to_double_nan2850; CHECK-SAME: (i64 [[ARG:%.*]]) #[[ATTR3]] {2851; CHECK-NEXT:    [[OR:%.*]] = or i64 [[ARG]], -45035996273704952852; CHECK-NEXT:    [[CAST:%.*]] = bitcast i64 [[OR]] to double2853; CHECK-NEXT:    ret double [[CAST]]2854;2855  %or = or i64 %arg, -45035996273704952856  %cast = bitcast i64 %or to double2857  ret double %cast2858}2859 2860 2861define double @bitcast_to_double_zero(i64 %arg) {2862; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2863; CHECK-LABEL: define nofpclass(nan inf sub norm) double @bitcast_to_double_zero2864; CHECK-SAME: (i64 [[ARG:%.*]]) #[[ATTR3]] {2865; CHECK-NEXT:    [[SHL:%.*]] = shl i64 [[ARG]], 632866; CHECK-NEXT:    [[CAST:%.*]] = bitcast i64 [[SHL]] to double2867; CHECK-NEXT:    ret double [[CAST]]2868;2869  %shl = shl i64 %arg, 632870  %cast = bitcast i64 %shl to double2871  ret double %cast2872}2873 2874define double @bitcast_to_double_nzero(i64 %arg) {2875; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2876; CHECK-LABEL: define nofpclass(zero) double @bitcast_to_double_nzero2877; CHECK-SAME: (i64 [[ARG:%.*]]) #[[ATTR3]] {2878; CHECK-NEXT:    [[OR:%.*]] = or i64 [[ARG]], 11529215046068469762879; CHECK-NEXT:    [[CAST:%.*]] = bitcast i64 [[OR]] to double2880; CHECK-NEXT:    ret double [[CAST]]2881;2882  %or = or i64 %arg, 11529215046068469762883  %cast = bitcast i64 %or to double2884  ret double %cast2885}2886 2887define double @bitcast_to_double_inf(i64 %arg) {2888; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2889; CHECK-LABEL: define nofpclass(nan zero sub norm) double @bitcast_to_double_inf2890; CHECK-SAME: (i64 [[ARG:%.*]]) #[[ATTR3]] {2891; CHECK-NEXT:    [[SHR:%.*]] = shl i64 [[ARG]], 632892; CHECK-NEXT:    [[OR:%.*]] = or i64 [[SHR]], 92188684372274053122893; CHECK-NEXT:    [[CAST:%.*]] = bitcast i64 [[OR]] to double2894; CHECK-NEXT:    ret double [[CAST]]2895;2896  %shr = shl i64 %arg, 632897  %or = or i64 %shr, 92188684372274053122898  %cast = bitcast i64 %or to double2899  ret double %cast2900}2901 2902 2903define <2 x float> @bitcast_to_float_vect_sign_0(<2 x i32> %arg) {2904; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2905; CHECK-LABEL: define nofpclass(ninf nzero nsub nnorm) <2 x float> @bitcast_to_float_vect_sign_02906; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR3]] {2907; CHECK-NEXT:    [[SHR:%.*]] = lshr <2 x i32> [[ARG]], <i32 1, i32 2>2908; CHECK-NEXT:    [[CAST:%.*]] = bitcast <2 x i32> [[SHR]] to <2 x float>2909; CHECK-NEXT:    ret <2 x float> [[CAST]]2910;2911  %shr = lshr <2 x i32> %arg, <i32 1, i32 2>2912  %cast = bitcast <2 x i32> %shr to <2 x float>2913  ret <2 x float> %cast2914}2915 2916define <2 x float> @bitcast_to_float_vect_nnan(<2 x i32> %arg) {2917; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2918; CHECK-LABEL: define nofpclass(nan inf nzero nsub nnorm) <2 x float> @bitcast_to_float_vect_nnan2919; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR3]] {2920; CHECK-NEXT:    [[SHR:%.*]] = lshr <2 x i32> [[ARG]], splat (i32 4)2921; CHECK-NEXT:    [[CAST:%.*]] = bitcast <2 x i32> [[SHR]] to <2 x float>2922; CHECK-NEXT:    ret <2 x float> [[CAST]]2923;2924  %shr = lshr <2 x i32> %arg, <i32 4, i32 4>2925  %cast = bitcast <2 x i32> %shr to <2 x float>2926  ret <2 x float> %cast2927}2928 2929define <2 x float> @bitcast_to_float_vect_sign_1(<2 x i32> %arg) {2930; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2931; CHECK-LABEL: define nofpclass(pinf pzero psub pnorm) <2 x float> @bitcast_to_float_vect_sign_12932; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR3]] {2933; CHECK-NEXT:    [[OR:%.*]] = or <2 x i32> [[ARG]], splat (i32 -2147483648)2934; CHECK-NEXT:    [[CAST:%.*]] = bitcast <2 x i32> [[OR]] to <2 x float>2935; CHECK-NEXT:    ret <2 x float> [[CAST]]2936;2937  %or = or <2 x i32> %arg, <i32 -2147483648, i32 -2147483648>2938  %cast = bitcast <2 x i32> %or to <2 x float>2939  ret <2 x float> %cast2940}2941 2942define <2 x float> @bitcast_to_float_vect_nan(<2 x i32> %arg) {2943; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2944; CHECK-LABEL: define nofpclass(inf zero sub norm) <2 x float> @bitcast_to_float_vect_nan2945; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR3]] {2946; CHECK-NEXT:    [[OR:%.*]] = or <2 x i32> [[ARG]], splat (i32 2139095041)2947; CHECK-NEXT:    [[CAST:%.*]] = bitcast <2 x i32> [[OR]] to <2 x float>2948; CHECK-NEXT:    ret <2 x float> [[CAST]]2949;2950  %or = or <2 x i32> %arg, <i32 2139095041, i32 2139095041>2951  %cast = bitcast <2 x i32> %or to <2 x float>2952  ret <2 x float> %cast2953}2954 2955define <2 x float> @bitcast_to_float_vect_conservative_1(<2 x i32> %arg) {2956; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2957; CHECK-LABEL: define <2 x float> @bitcast_to_float_vect_conservative_12958; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR3]] {2959; CHECK-NEXT:    [[OR:%.*]] = or <2 x i32> [[ARG]], <i32 -2147483648, i32 0>2960; CHECK-NEXT:    [[CAST:%.*]] = bitcast <2 x i32> [[OR]] to <2 x float>2961; CHECK-NEXT:    ret <2 x float> [[CAST]]2962;2963  %or = or <2 x i32> %arg, <i32 -2147483648, i32 0>2964  %cast = bitcast <2 x i32> %or to <2 x float>2965  ret <2 x float> %cast2966}2967 2968define <2 x float> @bitcast_to_float_vect_conservative_2(<2 x i32> %arg) {2969; CHECK: Function Attrs: mustprogress nofree norecurse nosync nounwind willreturn memory(none)2970; CHECK-LABEL: define <2 x float> @bitcast_to_float_vect_conservative_22971; CHECK-SAME: (<2 x i32> [[ARG:%.*]]) #[[ATTR3]] {2972; CHECK-NEXT:    [[OR:%.*]] = or <2 x i32> [[ARG]], <i32 0, i32 2139095041>2973; CHECK-NEXT:    [[CAST:%.*]] = bitcast <2 x i32> [[OR]] to <2 x float>2974; CHECK-NEXT:    ret <2 x float> [[CAST]]2975;2976  %or = or <2 x i32> %arg, <i32 0, i32 2139095041>2977  %cast = bitcast <2 x i32> %or to <2 x float>2978  ret <2 x float> %cast2979}2980 2981declare i64 @_Z13get_global_idj(i32 noundef)2982 2983attributes #0 = { "denormal-fp-math"="preserve-sign,preserve-sign" }2984attributes #1 = { "denormal-fp-math"="preserve-sign,ieee" }2985attributes #2 = { "denormal-fp-math"="ieee,preserve-sign" }2986attributes #3 = { "denormal-fp-math"="positive-zero,positive-zero" }2987attributes #4 = { "denormal-fp-math"="positive-zero,ieee" }2988attributes #5 = { "denormal-fp-math"="ieee,positive-zero" }2989;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:2990; CGSCC-CI: {{.*}}2991; CGSCC-CV: {{.*}}2992; TUNIT-CI: {{.*}}2993; TUNIT-CV: {{.*}}2994