brintos / llvm-project-archived public Read only

1; RUN: mlir-translate -import-llvm %s | FileCheck %s2 3; CHECK-LABEL:  llvm.func @fmuladd_test4define void @fmuladd_test(float %0, float %1, <8 x float> %2, ptr %3) {5  ; CHECK: llvm.intr.fmuladd(%{{.*}}, %{{.*}}, %{{.*}}) : (f32, f32, f32) -> f326  %5 = call float @llvm.fmuladd.f32(float %0, float %1, float %0)7  ; CHECK: llvm.intr.fmuladd(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32>8  %6 = call <8 x float> @llvm.fmuladd.v8f32(<8 x float> %2, <8 x float> %2, <8 x float> %2)9  ; CHECK: llvm.intr.fma(%{{.*}}, %{{.*}}, %{{.*}}) : (f32, f32, f32) -> f3210  %7 = call float @llvm.fma.f32(float %0, float %1, float %0)11  ; CHECK: llvm.intr.fma(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32>12  %8 = call <8 x float> @llvm.fma.v8f32(<8 x float> %2, <8 x float> %2, <8 x float> %2)13  ; CHECK: "llvm.intr.prefetch"(%{{.*}}) <{cache = 1 : i32, hint = 3 : i32, rw = 0 : i32}> : (!llvm.ptr) -> ()14  call void @llvm.prefetch.p0(ptr %3, i32 0, i32 3, i32 1)15  ret void16}17 18; CHECK-LABEL:  llvm.func @fpclass_test19define void @fpclass_test(float %0, <8 x float> %1) {20  ; CHECK: "llvm.intr.is.fpclass"(%{{.*}}) <{bit = 0 : i32}> : (f32) -> i121  %3 = call i1 @llvm.is.fpclass.f32(float %0, i32 0)22  ; CHECK: "llvm.intr.is.fpclass"(%{{.*}}) <{bit = 1 : i32}> : (vector<8xf32>) -> vector<8xi1>23  %4 = call <8 x i1> @llvm.is.fpclass.v8f32(<8 x float> %1, i32 1)24  ret void25}26 27; CHECK-LABEL:  llvm.func @exp_test28define void @exp_test(float %0, <8 x float> %1) {29  ; CHECK: llvm.intr.exp(%{{.*}}) : (f32) -> f3230  %3 = call float @llvm.exp.f32(float %0)31  ; CHECK: llvm.intr.exp(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>32  %4 = call <8 x float> @llvm.exp.v8f32(<8 x float> %1)33  ret void34}35 36; CHECK-LABEL:  llvm.func @exp2_test37define void @exp2_test(float %0, <8 x float> %1) {38  ; CHECK:  llvm.intr.exp2(%{{.*}}) : (f32) -> f3239  %3 = call float @llvm.exp2.f32(float %0)40  ; CHECK:  llvm.intr.exp2(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>41  %4 = call <8 x float> @llvm.exp2.v8f32(<8 x float> %1)42  ret void43}44 45; CHECK-LABEL:  llvm.func @exp10_test46define void @exp10_test(float %0, <8 x float> %1) {47  ; CHECK:  llvm.intr.exp10(%{{.*}}) : (f32) -> f3248  %3 = call float @llvm.exp10.f32(float %0)49  ; CHECK:  llvm.intr.exp10(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>50  %4 = call <8 x float> @llvm.exp10.v8f32(<8 x float> %1)51  ret void52}53 54; CHECK-LABEL:  llvm.func @ldexp_test55define void @ldexp_test(float %0, <8 x float> %1, i32 %2) {56  ; CHECK:  llvm.intr.ldexp(%{{.*}}, %{{.*}}) : (f32, i32) -> f3257  %4 = call float @llvm.ldexp.f32.i32(float %0, i32 %2)58  ; CHECK:  llvm.intr.ldexp(%{{.*}}, %{{.*}}) : (vector<8xf32>, i32) -> vector<8xf32>59  %5 = call <8 x float> @llvm.ldexp.v8f32.i32(<8 x float> %1, i32 %2)60  ret void61}62 63; CHECK-LABEL:  llvm.func @frexp_test64define void @frexp_test(float %0, <8 x float> %1) {65  ; CHECK:  llvm.intr.frexp(%{{.*}}) : (f32) -> !llvm.struct<(f32, i32)>66  %4 = call { float, i32 } @llvm.frexp.f32.i32(float %0)67  ; CHECK:  llvm.intr.frexp(%{{.*}}) : (vector<8xf32>) -> !llvm.struct<(vector<8xf32>, i32)>68  %5 = call { <8 x float>, i32 } @llvm.frexp.v8f32.i32(<8 x float> %1)69  ret void70}71 72; CHECK-LABEL:  llvm.func @log_test73define void @log_test(float %0, <8 x float> %1) {74  ; CHECK:  llvm.intr.log(%{{.*}}) : (f32) -> f3275  %3 = call float @llvm.log.f32(float %0)76  ; CHECK:  llvm.intr.log(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>77  %4 = call <8 x float> @llvm.log.v8f32(<8 x float> %1)78  ret void79}80 81; CHECK-LABEL:  llvm.func @log10_test82define void @log10_test(float %0, <8 x float> %1) {83  ; CHECK:  llvm.intr.log10(%{{.*}}) : (f32) -> f3284  %3 = call float @llvm.log10.f32(float %0)85  ; CHECK:  llvm.intr.log10(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>86  %4 = call <8 x float> @llvm.log10.v8f32(<8 x float> %1)87  ret void88}89 90; CHECK-LABEL:  llvm.func @log2_test91define void @log2_test(float %0, <8 x float> %1)  {92  ; CHECK:  llvm.intr.log2(%{{.*}}) : (f32) -> f3293  %3 = call float @llvm.log2.f32(float %0)94  ; CHECK: llvm.intr.log2(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>95  %4 = call <8 x float> @llvm.log2.v8f32(<8 x float> %1)96  ret void97}98 99; CHECK-LABEL:  llvm.func @fabs_test100define void @fabs_test(float %0, <8 x float> %1) {101  ; CHECK: llvm.intr.fabs(%{{.*}}) : (f32) -> f32102  %3 = call float @llvm.fabs.f32(float %0)103  ; CHECK: llvm.intr.fabs(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>104  %4 = call <8 x float> @llvm.fabs.v8f32(<8 x float> %1)105  ret void106}107; CHECK-LABEL:  llvm.func @sqrt_test108define void @sqrt_test(float %0, <8 x float> %1) {109  ; CHECK: llvm.intr.sqrt(%{{.*}}) : (f32) -> f32110  %3 = call float @llvm.sqrt.f32(float %0)111  ; CHECK: llvm.intr.sqrt(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>112  %4 = call <8 x float> @llvm.sqrt.v8f32(<8 x float> %1)113  ret void114}115; CHECK-LABEL:  llvm.func @ceil_test116define void @ceil_test(float %0, <8 x float> %1) {117  ; CHECK: llvm.intr.ceil(%{{.*}}) : (f32) -> f32118  %3 = call float @llvm.ceil.f32(float %0)119  ; CHECK: llvm.intr.ceil(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>120  %4 = call <8 x float> @llvm.ceil.v8f32(<8 x float> %1)121  ret void122}123; CHECK-LABEL:  llvm.func @floor_test124define void @floor_test(float %0, <8 x float> %1) {125  ; CHECK: llvm.intr.floor(%{{.*}}) : (f32) -> f32126  %3 = call float @llvm.floor.f32(float %0)127  ; CHECK: llvm.intr.floor(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>128  %4 = call <8 x float> @llvm.floor.v8f32(<8 x float> %1)129  ret void130}131; CHECK-LABEL:  llvm.func @trig_test132define void @trig_test(float %0, <8 x float> %1) {133  ; CHECK: llvm.intr.sin(%{{.*}}) : (f32) -> f32134  %3 = call float @llvm.sin.f32(float %0)135  ; CHECK: llvm.intr.sin(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>136  %4 = call <8 x float> @llvm.sin.v8f32(<8 x float> %1)137 138  ; CHECK: llvm.intr.cos(%{{.*}}) : (f32) -> f32139  %5 = call float @llvm.cos.f32(float %0)140  ; CHECK: llvm.intr.cos(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>141  %6 = call <8 x float> @llvm.cos.v8f32(<8 x float> %1)142 143  ; CHECK: llvm.intr.tan(%{{.*}}) : (f32) -> f32144  %7 = call float @llvm.tan.f32(float %0)145  ; CHECK: llvm.intr.tan(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>146  %8 = call <8 x float> @llvm.tan.v8f32(<8 x float> %1)147 148  ret void149}150; CHECK-LABEL:  llvm.func @inv_trig_test151define void @inv_trig_test(float %0, <8 x float> %1) {152  ; CHECK: llvm.intr.asin(%{{.*}}) : (f32) -> f32153  %3 = call float @llvm.asin.f32(float %0)154  ; CHECK: llvm.intr.asin(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>155  %4 = call <8 x float> @llvm.asin.v8f32(<8 x float> %1)156 157  ; CHECK: llvm.intr.acos(%{{.*}}) : (f32) -> f32158  %5 = call float @llvm.acos.f32(float %0)159  ; CHECK: llvm.intr.acos(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>160  %6 = call <8 x float> @llvm.acos.v8f32(<8 x float> %1)161 162  ; CHECK: llvm.intr.atan(%{{.*}}) : (f32) -> f32163  %7 = call float @llvm.atan.f32(float %0)164  ; CHECK: llvm.intr.atan(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>165  %8 = call <8 x float> @llvm.atan.v8f32(<8 x float> %1)166 167  ret void168}169; CHECK-LABEL:  llvm.func @atan2_test170define void @atan2_test(float %0, float %1, <8 x float> %2, <8 x float> %3) {171  ; CHECK:  llvm.intr.atan2(%{{.*}}, %{{.*}}) : (f32, f32) -> f32172  %5 = call float @llvm.atan2.f32(float %0, float %1)173  ; CHECK:  llvm.intr.atan2(%{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>174  %6 = call <8 x float> @llvm.atan2.v8f32(<8 x float> %2, <8 x float> %3)175  ret void176}177; CHECK-LABEL:  llvm.func @hyperbolic_trig_test178define void @hyperbolic_trig_test(float %0, <8 x float> %1) {179  ; CHECK: llvm.intr.sinh(%{{.*}}) : (f32) -> f32180  %3 = call float @llvm.sinh.f32(float %0)181  ; CHECK: llvm.intr.sinh(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>182  %4 = call <8 x float> @llvm.sinh.v8f32(<8 x float> %1)183 184  ; CHECK: llvm.intr.cosh(%{{.*}}) : (f32) -> f32185  %5 = call float @llvm.cosh.f32(float %0)186  ; CHECK: llvm.intr.cosh(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>187  %6 = call <8 x float> @llvm.cosh.v8f32(<8 x float> %1)188 189  ; CHECK: llvm.intr.tanh(%{{.*}}) : (f32) -> f32190  %7 = call float @llvm.tanh.f32(float %0)191  ; CHECK: llvm.intr.tanh(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>192  %8 = call <8 x float> @llvm.tanh.v8f32(<8 x float> %1)193  ret void194}195 196; CHECK-LABEL:  llvm.func @copysign_test197define void @copysign_test(float %0, float %1, <8 x float> %2, <8 x float> %3) {198  ; CHECK:  llvm.intr.copysign(%{{.*}}, %{{.*}}) : (f32, f32) -> f32199  %5 = call float @llvm.copysign.f32(float %0, float %1)200  ; CHECK:  llvm.intr.copysign(%{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>201  %6 = call <8 x float> @llvm.copysign.v8f32(<8 x float> %2, <8 x float> %3)202  ret void203}204; CHECK-LABEL:  llvm.func @pow_test205define void @pow_test(float %0, float %1, <8 x float> %2, <8 x float> %3) {206  ; CHECK:  llvm.intr.pow(%{{.*}}, %{{.*}}) : (f32, f32) -> f32207  %5 = call float @llvm.pow.f32(float %0, float %1)208  ; CHECK:  llvm.intr.pow(%{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>209  %6 = call <8 x float> @llvm.pow.v8f32(<8 x float> %2, <8 x float> %3)210  ret void211}212 213; CHECK-LABEL: llvm.func @rint_test214define void @rint_test(float %0, double %1, <8 x float> %2, <8 x double> %3) {215  ; CHECK: llvm.intr.rint(%{{.*}}) : (f32) -> f32216  %5 = call float @llvm.rint.f32(float %0)217  ; CHECK: llvm.intr.rint(%{{.*}}) : (f64) -> f64218  %6 = call double @llvm.rint.f64(double %1)219  ; CHECK: llvm.intr.rint(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>220  %7 = call <8 x float> @llvm.rint.v8f32(<8 x float> %2)221  ; CHECK: llvm.intr.rint(%{{.*}}) : (vector<8xf64>) -> vector<8xf64>222  %8 = call <8 x double> @llvm.rint.v8f64(<8 x double> %3)223  ret void224}225; CHECK-LABEL: llvm.func @nearbyint_test226define void @nearbyint_test(float %0, double %1, <8 x float> %2, <8 x double> %3) {227  ; CHECK: llvm.intr.nearbyint(%{{.*}}) : (f32) -> f32228  %5 = call float @llvm.nearbyint.f32(float %0)229  ; CHECK: llvm.intr.nearbyint(%{{.*}}) : (f64) -> f64230  %6 = call double @llvm.nearbyint.f64(double %1)231  ; CHECK: llvm.intr.nearbyint(%{{.*}}) : (vector<8xf32>) -> vector<8xf32>232  %7 = call <8 x float> @llvm.nearbyint.v8f32(<8 x float> %2)233  ; CHECK: llvm.intr.nearbyint(%{{.*}}) : (vector<8xf64>) -> vector<8xf64>234  %8 = call <8 x double> @llvm.nearbyint.v8f64(<8 x double> %3)235  ret void236}237; CHECK-LABEL: llvm.func @lround_test238define void @lround_test(float %0, double %1, <2 x float> %2, <2 x double> %3) {239  ; CHECK: llvm.intr.lround(%{{.*}}) : (f32) -> i32240  %5 = call i32 @llvm.lround.i32.f32(float %0)241  ; CHECK: llvm.intr.lround(%{{.*}}) : (f32) -> i64242  %6 = call i64 @llvm.lround.i64.f32(float %0)243  ; CHECK: llvm.intr.lround(%{{.*}}) : (f64) -> i32244  %7 = call i32 @llvm.lround.i32.f64(double %1)245  ; CHECK: llvm.intr.lround(%{{.*}}) : (f64) -> i64246  %8 = call i64 @llvm.lround.i64.f64(double %1)247  ; CHECK: llvm.intr.lround(%{{.*}}) : (vector<2xf32>) -> vector<2xi32>248  %9 = call <2 x i32> @llvm.lround.v2i32.v2f32(<2 x float> %2)249  ; CHECK: llvm.intr.lround(%{{.*}}) : (vector<2xf64>) -> vector<2xi32>250  %10 = call <2 x i32> @llvm.lround.v2i32.v2f64(<2 x double> %3)251  ; CHECK: llvm.intr.lround(%{{.*}}) : (vector<2xf32>) -> vector<2xi64>252  %11 = call <2 x i64> @llvm.lround.v2i64.v2f32(<2 x float> %2)253  ; CHECK: llvm.intr.lround(%{{.*}}) : (vector<2xf64>) -> vector<2xi64>254  %12 = call <2 x i64> @llvm.lround.v2i64.v2f64(<2 x double> %3)255  ret void256}257; CHECK-LABEL: llvm.func @llround_test258define void @llround_test(float %0, double %1) {259  ; CHECK: llvm.intr.llround(%{{.*}}) : (f32) -> i64260  %3 = call i64 @llvm.llround.i64.f32(float %0)261  ; CHECK: llvm.intr.llround(%{{.*}}) : (f64) -> i64262  %4 = call i64 @llvm.llround.i64.f64(double %1)263  ret void264}265; CHECK-LABEL: llvm.func @lrint_test266define void @lrint_test(float %0, double %1, <2 x float> %2, <2 x double> %3) {267  ; CHECK: llvm.intr.lrint(%{{.*}}) : (f32) -> i32268  %5 = call i32 @llvm.lrint.i32.f32(float %0)269  ; CHECK: llvm.intr.lrint(%{{.*}}) : (f32) -> i64270  %6 = call i64 @llvm.lrint.i64.f32(float %0)271  ; CHECK: llvm.intr.lrint(%{{.*}}) : (f64) -> i32272  %7 = call i32 @llvm.lrint.i32.f64(double %1)273  ; CHECK: llvm.intr.lrint(%{{.*}}) : (f64) -> i64274  %8 = call i64 @llvm.lrint.i64.f64(double %1)275  ; CHECK: llvm.intr.lrint(%{{.*}}) : (vector<2xf32>) -> vector<2xi32>276  %9 = call <2 x i32> @llvm.lrint.v2i32.v2f32(<2 x float> %2)277  ; CHECK: llvm.intr.lrint(%{{.*}}) : (vector<2xf64>) -> vector<2xi32>278  %10 = call <2 x i32> @llvm.lrint.v2i32.v2f64(<2 x double> %3)279  ; CHECK: llvm.intr.lrint(%{{.*}}) : (vector<2xf32>) -> vector<2xi64>280  %11 = call <2 x i64> @llvm.lrint.v2i64.v2f32(<2 x float> %2)281  ; CHECK: llvm.intr.lrint(%{{.*}}) : (vector<2xf64>) -> vector<2xi64>282  %12 = call <2 x i64> @llvm.lrint.v2i64.v2f64(<2 x double> %3)283  ret void284}285; CHECK-LABEL: llvm.func @llrint_test286define void @llrint_test(float %0, double %1, <2 x float> %2, <2 x double> %3) {287  ; CHECK: llvm.intr.llrint(%{{.*}}) : (f32) -> i64288  %5 = call i64 @llvm.llrint.i64.f32(float %0)289  ; CHECK: llvm.intr.llrint(%{{.*}}) : (f64) -> i64290  %6 = call i64 @llvm.llrint.i64.f64(double %1)291  ; CHECK: llvm.intr.llrint(%{{.*}}) : (vector<2xf32>) -> vector<2xi64>292  %7 = call <2 x i64> @llvm.llrint.v2i64.v2f32(<2 x float> %2)293  ; CHECK: llvm.intr.llrint(%{{.*}}) : (vector<2xf64>) -> vector<2xi64>294  %8 = call <2 x i64> @llvm.llrint.v2i64.v2f64(<2 x double> %3)295  ret void296}297 298; CHECK-LABEL:  llvm.func @bitreverse_test299define void @bitreverse_test(i32 %0, <8 x i32> %1) {300  ; CHECK:   llvm.intr.bitreverse(%{{.*}}) : (i32) -> i32301  %3 = call i32 @llvm.bitreverse.i32(i32 %0)302  ; CHECK:   llvm.intr.bitreverse(%{{.*}}) : (vector<8xi32>) -> vector<8xi32>303  %4 = call <8 x i32> @llvm.bitreverse.v8i32(<8 x i32> %1)304  ret void305}306; CHECK-LABEL:  llvm.func @byteswap_test307define void @byteswap_test(i32 %0, <8 x i32> %1) {308  ; CHECK:   llvm.intr.bswap(%{{.*}}) : (i32) -> i32309  %3 = call i32 @llvm.bswap.i32(i32 %0)310  ; CHECK:   llvm.intr.bswap(%{{.*}}) : (vector<8xi32>) -> vector<8xi32>311  %4 = call <8 x i32> @llvm.bswap.v8i32(<8 x i32> %1)312  ret void313}314; CHECK-LABEL:  llvm.func @ctlz_test315define void @ctlz_test(i32 %0, <8 x i32> %1) {316  ; CHECK:   "llvm.intr.ctlz"(%{{.*}}) <{is_zero_poison = false}> : (i32) -> i32317  %3 = call i32 @llvm.ctlz.i32(i32 %0, i1 false)318  ; CHECK:   "llvm.intr.ctlz"(%{{.*}}) <{is_zero_poison = false}> : (vector<8xi32>) -> vector<8xi32>319  %4 = call <8 x i32> @llvm.ctlz.v8i32(<8 x i32> %1, i1 false)320  ret void321}322; CHECK-LABEL:  llvm.func @cttz_test323define void @cttz_test(i32 %0, <8 x i32> %1) {324  ; CHECK:   "llvm.intr.cttz"(%{{.*}}) <{is_zero_poison = false}> : (i32) -> i32325  %3 = call i32 @llvm.cttz.i32(i32 %0, i1 false)326  ; CHECK:   "llvm.intr.cttz"(%{{.*}}) <{is_zero_poison = false}> : (vector<8xi32>) -> vector<8xi32>327  %4 = call <8 x i32> @llvm.cttz.v8i32(<8 x i32> %1, i1 false)328  ret void329}330; CHECK-LABEL:  llvm.func @abs_test331define void @abs_test(i32 %0, <8 x i32> %1) {332  ; CHECK:   "llvm.intr.abs"(%{{.*}}) <{is_int_min_poison = false}> : (i32) -> i32333  %3 = call i32 @llvm.abs.i32(i32 %0, i1 false)334  ; CHECK:   "llvm.intr.abs"(%{{.*}}) <{is_int_min_poison = true}> : (vector<8xi32>) -> vector<8xi32>335  %4 = call <8 x i32> @llvm.abs.v8i32(<8 x i32> %1, i1 true)336  ret void337}338 339; CHECK-LABEL:  llvm.func @ctpop_test340define void @ctpop_test(i32 %0, <8 x i32> %1) {341  ; CHECK:   llvm.intr.ctpop(%{{.*}}) : (i32) -> i32342  %3 = call i32 @llvm.ctpop.i32(i32 %0)343  ; CHECK:   llvm.intr.ctpop(%{{.*}}) : (vector<8xi32>) -> vector<8xi32>344  %4 = call <8 x i32> @llvm.ctpop.v8i32(<8 x i32> %1)345  ret void346}347 348; CHECK-LABEL:  llvm.func @fshl_test349define void @fshl_test(i32 %0, i32 %1, i32 %2, <8 x i32> %3, <8 x i32> %4, <8 x i32> %5) {350  ; CHECK:   llvm.intr.fshl(%{{.*}}, %{{.*}}, %{{.*}}) : (i32, i32, i32) -> i32351  %7 = call i32 @llvm.fshl.i32(i32 %0, i32 %1, i32 %2)352  ; CHECK:   llvm.intr.fshl(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi32>) -> vector<8xi32>353  %8 = call <8 x i32> @llvm.fshl.v8i32(<8 x i32> %3, <8 x i32> %4, <8 x i32> %5)354  ret void355}356 357; CHECK-LABEL:  llvm.func @fshr_test358define void @fshr_test(i32 %0, i32 %1, i32 %2, <8 x i32> %3, <8 x i32> %4, <8 x i32> %5) {359  ; CHECK:   llvm.intr.fshr(%{{.*}}, %{{.*}}, %{{.*}}) : (i32, i32, i32) -> i32360  %7 = call i32 @llvm.fshr.i32(i32 %0, i32 %1, i32 %2)361  ; CHECK:   llvm.intr.fshr(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi32>) -> vector<8xi32>362  %8 = call <8 x i32> @llvm.fshr.v8i32(<8 x i32> %3, <8 x i32> %4, <8 x i32> %5)363  ret void364}365 366; CHECK-LABEL:  llvm.func @maximum_test367define void @maximum_test(float %0, float %1, <8 x float> %2, <8 x float> %3) {368  ; CHECK:   llvm.intr.maximum(%{{.*}}, %{{.*}}) : (f32, f32) -> f32369  %5 = call float @llvm.maximum.f32(float %0, float %1)370  ; CHECK:   llvm.intr.maximum(%{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>371  %6 = call <8 x float> @llvm.maximum.v8f32(<8 x float> %2, <8 x float> %3)372  ret void373}374 375; CHECK-LABEL:    llvm.func @minimum_test376define void @minimum_test(float %0, float %1, <8 x float> %2, <8 x float> %3) {377  ; CHECK:   llvm.intr.minimum(%{{.*}}, %{{.*}}) : (f32, f32) -> f32378  %5 = call float @llvm.minimum.f32(float %0, float %1)379  ; CHECK:   llvm.intr.minimum(%{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>380  %6 = call <8 x float> @llvm.minimum.v8f32(<8 x float> %2, <8 x float> %3)381  ret void382}383 384; CHECK-LABEL:  llvm.func @maxnum_test385define void @maxnum_test(float %0, float %1, <8 x float> %2, <8 x float> %3) {386  ; CHECK:   llvm.intr.maxnum(%{{.*}}, %{{.*}}) : (f32, f32) -> f32387  %5 = call float @llvm.maxnum.f32(float %0, float %1)388  ; CHECK:   llvm.intr.maxnum(%{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>389  %6 = call <8 x float> @llvm.maxnum.v8f32(<8 x float> %2, <8 x float> %3)390  ret void391}392 393; CHECK-LABEL:  llvm.func @minnum_test394define void @minnum_test(float %0, float %1, <8 x float> %2, <8 x float> %3) {395  ; CHECK:   llvm.intr.minnum(%{{.*}}, %{{.*}}) : (f32, f32) -> f32396  %5 = call float @llvm.minnum.f32(float %0, float %1)397  ; CHECK:   llvm.intr.minnum(%{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>398  %6 = call <8 x float> @llvm.minnum.v8f32(<8 x float> %2, <8 x float> %3)399  ret void400}401 402; CHECK-LABEL:  llvm.func @smax_test403define void @smax_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {404  ; CHECK:  llvm.intr.smax(%{{.*}}, %{{.*}}) : (i32, i32) -> i32405  %5 = call i32 @llvm.smax.i32(i32 %0, i32 %1)406  ; CHECK:  llvm.intr.smax(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>407  %6 = call <8 x i32> @llvm.smax.v8i32(<8 x i32> %2, <8 x i32> %3)408  ret void409}410 411; CHECK-LABEL:  llvm.func @smin_test412define void @smin_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {413  ; CHECK:   llvm.intr.smin(%{{.*}}, %{{.*}}) : (i32, i32) -> i32414  %5 = call i32 @llvm.smin.i32(i32 %0, i32 %1)415  ; CHECK:   llvm.intr.smin(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>416  %6 = call <8 x i32> @llvm.smin.v8i32(<8 x i32> %2, <8 x i32> %3)417  ret void418}419 420; CHECK-LABEL:  llvm.func @umax_test421define void @umax_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {422  ; CHECK:   llvm.intr.umax(%{{.*}}, %{{.*}}) : (i32, i32) -> i32423  %5 = call i32 @llvm.umax.i32(i32 %0, i32 %1)424  ; CHECK:   llvm.intr.umax(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>425  %6 = call <8 x i32> @llvm.umax.v8i32(<8 x i32> %2, <8 x i32> %3)426  ret void427}428 429; CHECK-LABEL:  llvm.func @umin_test430define void @umin_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {431  ; CHECK:   llvm.intr.umin(%{{.*}}, %{{.*}}) : (i32, i32) -> i32432  %5 = call i32 @llvm.umin.i32(i32 %0, i32 %1)433  ; CHECK:   llvm.intr.umin(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>434  %6 = call <8 x i32> @llvm.umin.v8i32(<8 x i32> %2, <8 x i32> %3)435  ret void436}437 438; CHECK-LABEL:  llvm.func @vector_reductions439define void @vector_reductions(float %0, <8 x float> %1, <8 x i32> %2) {440  ; CHECK: "llvm.intr.vector.reduce.add"(%{{.*}}) : (vector<8xi32>) -> i32441  %4 = call i32 @llvm.vector.reduce.add.v8i32(<8 x i32> %2)442  ; CHECK: "llvm.intr.vector.reduce.and"(%{{.*}}) : (vector<8xi32>) -> i32443  %5 = call i32 @llvm.vector.reduce.and.v8i32(<8 x i32> %2)444  ; CHECK: llvm.intr.vector.reduce.fmax(%{{.*}}) : (vector<8xf32>) -> f32445  %6 = call float @llvm.vector.reduce.fmax.v8f32(<8 x float> %1)446  ; CHECK: llvm.intr.vector.reduce.fmin(%{{.*}}) : (vector<8xf32>) -> f32447  %7 = call float @llvm.vector.reduce.fmin.v8f32(<8 x float> %1)448  ; CHECK: "llvm.intr.vector.reduce.mul"(%{{.*}}) : (vector<8xi32>) -> i32449  %8 = call i32 @llvm.vector.reduce.mul.v8i32(<8 x i32> %2)450  ; CHECK: "llvm.intr.vector.reduce.or"(%{{.*}}) : (vector<8xi32>) -> i32451  %9 = call i32 @llvm.vector.reduce.or.v8i32(<8 x i32> %2)452  ; CHECK: "llvm.intr.vector.reduce.smax"(%{{.*}}) : (vector<8xi32>) -> i32453  %10 = call i32 @llvm.vector.reduce.smax.v8i32(<8 x i32> %2)454  ; CHECK: "llvm.intr.vector.reduce.smin"(%{{.*}}) : (vector<8xi32>) -> i32455  %11 = call i32 @llvm.vector.reduce.smin.v8i32(<8 x i32> %2)456  ; CHECK: "llvm.intr.vector.reduce.umax"(%{{.*}}) : (vector<8xi32>) -> i32457  %12 = call i32 @llvm.vector.reduce.umax.v8i32(<8 x i32> %2)458  ; CHECK: "llvm.intr.vector.reduce.umin"(%{{.*}}) : (vector<8xi32>) -> i32459  %13 = call i32 @llvm.vector.reduce.umin.v8i32(<8 x i32> %2)460  ; CHECK: "llvm.intr.vector.reduce.fadd"(%{{.*}}, %{{.*}}) <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<8xf32>) -> f32461  %14 = call float @llvm.vector.reduce.fadd.v8f32(float %0, <8 x float> %1)462  ; CHECK: "llvm.intr.vector.reduce.fmul"(%{{.*}}, %{{.*}}) <{fastmathFlags = #llvm.fastmath<none>}> : (f32, vector<8xf32>) -> f32463  %15 = call float @llvm.vector.reduce.fmul.v8f32(float %0, <8 x float> %1)464  ; CHECK: "llvm.intr.vector.reduce.fadd"(%{{.*}}, %{{.*}}) <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<8xf32>) -> f32465  %16 = call reassoc float @llvm.vector.reduce.fadd.v8f32(float %0, <8 x float> %1)466  ; CHECK: "llvm.intr.vector.reduce.fmul"(%{{.*}}, %{{.*}}) <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<8xf32>) -> f32467  %17 = call reassoc float @llvm.vector.reduce.fmul.v8f32(float %0, <8 x float> %1)468  ; CHECK:  "llvm.intr.vector.reduce.xor"(%{{.*}}) : (vector<8xi32>) -> i32469  %18 = call i32 @llvm.vector.reduce.xor.v8i32(<8 x i32> %2)470  ; CHECK: llvm.intr.vector.reduce.fmaximum(%{{.*}}) : (vector<8xf32>) -> f32471  %19 = call float @llvm.vector.reduce.fmaximum.v8f32(<8 x float> %1)472  ; CHECK: llvm.intr.vector.reduce.fminimum(%{{.*}}) : (vector<8xf32>) -> f32473  %20 = call float @llvm.vector.reduce.fminimum.v8f32(<8 x float> %1)474  ret void475}476 477; CHECK-LABEL: @matrix_intrinsics478; CHECK-SAME:  %[[VEC1:[a-zA-Z0-9]+]]479; CHECK-SAME:  %[[VEC2:[a-zA-Z0-9]+]]480; CHECK-SAME:  %[[PTR:[a-zA-Z0-9]+]]481; CHECK-SAME:  %[[STRIDE:[a-zA-Z0-9]+]]482define void @matrix_intrinsics(<64 x float> %vec1, <48 x float> %vec2, ptr %ptr, i64 %stride) {483  ; CHECK:  llvm.intr.matrix.multiply %[[VEC1]], %[[VEC2]]484  ; CHECK-SAME:  {lhs_columns = 16 : i32, lhs_rows = 4 : i32, rhs_columns = 3 : i32}485  %1 = call <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float> %vec1, <48 x float> %vec2, i32 4, i32 16, i32 3)486  ; CHECK:  llvm.intr.matrix.transpose %[[VEC2]]487  ; CHECK-SAME:  {columns = 16 : i32, rows = 3 : i32}488  %2 = call <48 x float> @llvm.matrix.transpose.v48f32(<48 x float> %vec2, i32 3, i32 16)489  ; CHECK:  %[[VAL1:.+]] = llvm.intr.matrix.column.major.load %[[PTR]], <stride = %[[STRIDE]]>490  ; CHECK-SAME:  {columns = 16 : i32, isVolatile = false, rows = 3 : i32}491  %3 = call <48 x float> @llvm.matrix.column.major.load.v48f32.i64(ptr align 4 %ptr, i64 %stride, i1 false, i32 3, i32 16)492  ; CHECK:  llvm.intr.matrix.column.major.store %[[VAL1]], %[[PTR]], <stride = %[[STRIDE]]>493  ; CHECK-SAME:  {columns = 16 : i32, isVolatile = true, rows = 3 : i32}494  call void @llvm.matrix.column.major.store.v48f32.i64(<48 x float> %3, ptr align 4 %ptr, i64 %stride, i1 true, i32 3, i32 16)495  ret void496}497 498; CHECK-LABEL: llvm.func @get_active_lane_mask499define <7 x i1> @get_active_lane_mask(i64 %0, i64 %1) {500  ; CHECK: llvm.intr.get.active.lane.mask %{{.*}}, %{{.*}} : i64, i64 to vector<7xi1>501  %3 = call <7 x i1> @llvm.get.active.lane.mask.v7i1.i64(i64 %0, i64 %1)502  ret <7 x i1> %3503}504 505; CHECK-LABEL: @masked_load_store_intrinsics506; CHECK-SAME:  %[[VEC:[a-zA-Z0-9]+]]507; CHECK-SAME:  %[[MASK:[a-zA-Z0-9]+]]508define void @masked_load_store_intrinsics(ptr %vec, <7 x i1> %mask) {509  ; CHECK:  %[[UNDEF:.+]] = llvm.mlir.undef510  ; CHECK:  %[[VAL1:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[UNDEF]] {alignment = 1 : i32}511  ; CHECK-SAME:  (!llvm.ptr, vector<7xi1>, vector<7xf32>) -> vector<7xf32>512  %1 = call <7 x float> @llvm.masked.load.v7f32.p0(ptr %vec, i32 1, <7 x i1> %mask, <7 x float> undef)513  ; CHECK:  %[[VAL2:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[VAL1]] {alignment = 4 : i32}514  %2 = call <7 x float> @llvm.masked.load.v7f32.p0(ptr %vec, i32 4, <7 x i1> %mask, <7 x float> %1)515  ; CHECK:  %[[VAL3:.+]] = llvm.intr.masked.load %[[VEC]], %[[MASK]], %[[VAL1]] {alignment = 4 : i32, nontemporal}516  %3 = call <7 x float> @llvm.masked.load.v7f32.p0(ptr %vec, i32 4, <7 x i1> %mask, <7 x float> %1), !nontemporal !{i32 1}517  ; CHECK:  llvm.intr.masked.store %[[VAL2]], %[[VEC]], %[[MASK]] {alignment = 8 : i32}518  ; CHECK-SAME:  vector<7xf32>, vector<7xi1> into !llvm.ptr519  call void @llvm.masked.store.v7f32.p0(<7 x float> %2, ptr %vec, i32 8, <7 x i1> %mask)520  ret void521}522 523; CHECK-LABEL: @masked_gather_scatter_intrinsics524; CHECK-SAME:  %[[VEC:[a-zA-Z0-9]+]]525; CHECK-SAME:  %[[MASK:[a-zA-Z0-9]+]]526define void @masked_gather_scatter_intrinsics(<7 x ptr> %vec, <7 x i1> %mask) {527  ; CHECK:  %[[UNDEF:.+]] = llvm.mlir.undef528  ; CHECK:  %[[VAL1:.+]] = llvm.intr.masked.gather %[[VEC]], %[[MASK]], %[[UNDEF]] {alignment = 1 : i32}529  ; CHECK-SAME:  (vector<7x!llvm.ptr>, vector<7xi1>, vector<7xf32>) -> vector<7xf32>530  %1 = call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> %vec, i32 1, <7 x i1> %mask, <7 x float> undef)531  ; CHECK:  %[[VAL2:.+]] = llvm.intr.masked.gather %[[VEC]], %[[MASK]], %[[VAL1]] {alignment = 4 : i32}532  %2 = call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> %vec, i32 4, <7 x i1> %mask, <7 x float> %1)533  ; CHECK:  llvm.intr.masked.scatter %[[VAL2]], %[[VEC]], %[[MASK]] {alignment = 8 : i32}534  ; CHECK-SAME:  vector<7xf32>, vector<7xi1> into vector<7x!llvm.ptr>535  call void @llvm.masked.scatter.v7f32.v7p0(<7 x float> %2, <7 x ptr> %vec, i32 8, <7 x i1> %mask)536  ret void537}538 539; CHECK-LABEL:  llvm.func @masked_expand_compress_intrinsics540define void @masked_expand_compress_intrinsics(ptr %0, <7 x i1> %1, <7 x float> %2) {541  ; CHECK: %[[val1:.+]] = "llvm.intr.masked.expandload"(%{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, vector<7xi1>, vector<7xf32>) -> vector<7xf32>542  %4 = call <7 x float> @llvm.masked.expandload.v7f32(ptr %0, <7 x i1> %1, <7 x float> %2)543  ; CHECK: "llvm.intr.masked.compressstore"(%[[val1]], %{{.*}}, %{{.*}}) : (vector<7xf32>, !llvm.ptr, vector<7xi1>) -> ()544  call void @llvm.masked.compressstore.v7f32(<7 x float> %4, ptr %0, <7 x i1> %1)545  ret void546}547 548; CHECK-LABEL:  llvm.func @masked_expand_compress_intrinsics_with_alignment549define void @masked_expand_compress_intrinsics_with_alignment(ptr %0, <7 x i1> %1, <7 x float> %2) {550  ; CHECK: %[[val1:.+]] = "llvm.intr.masked.expandload"(%{{.*}}, %{{.*}}, %{{.*}}) <{arg_attrs = [{llvm.align = 8 : i64}, {}, {}]}> : (!llvm.ptr, vector<7xi1>, vector<7xf32>) -> vector<7xf32>551  %4 = call <7 x float> @llvm.masked.expandload.v7f32(ptr align 8 %0, <7 x i1> %1, <7 x float> %2)552  ; CHECK: "llvm.intr.masked.compressstore"(%[[val1]], %{{.*}}, %{{.*}}) <{arg_attrs = [{}, {llvm.align = 8 : i64}, {}]}> : (vector<7xf32>, !llvm.ptr, vector<7xi1>) -> ()553  call void @llvm.masked.compressstore.v7f32(<7 x float> %4, ptr align 8 %0, <7 x i1> %1)554  ret void555}556 557; CHECK-LABEL:  llvm.func @annotate_intrinsics558define void @annotate_intrinsics(ptr %var, ptr %ptr, i16 %int, ptr %annotation, ptr %fileName, i32 %line, ptr %args) {559  ; CHECK: "llvm.intr.var.annotation"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i32, !llvm.ptr) -> ()560  call void @llvm.var.annotation.p0.p0(ptr %var, ptr %annotation, ptr %fileName, i32 %line, ptr %args)561  ; CHECK: %{{.*}} = "llvm.intr.ptr.annotation"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i32, !llvm.ptr) -> !llvm.ptr562  %1 = call ptr @llvm.ptr.annotation.p0.p0(ptr %ptr, ptr %annotation, ptr %fileName, i32 %line, ptr %args)563  ; CHECK: %{{.*}} = "llvm.intr.annotation"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i16, !llvm.ptr, !llvm.ptr, i32) -> i16564  %2 = call i16 @llvm.annotation.i16.p0(i16 %int, ptr %annotation, ptr %fileName, i32 %line)565  ret void566}567 568; CHECK-LABEL:  llvm.func @trap_intrinsics569define void @trap_intrinsics() {570  ; CHECK: llvm.intr.trap571  call void @llvm.trap()572  ; CHECK: llvm.intr.debugtrap573  call void @llvm.debugtrap()574  ; CHECK: llvm.intr.ubsantrap <{failureKind = 1 : i8}>575  call void @llvm.ubsantrap(i8 1)576  ret void577}578 579; CHECK-LABEL:  llvm.func @memcpy_test580define void @memcpy_test(i32 %0, ptr %1, ptr %2) {581  ; CHECK: "llvm.intr.memcpy"(%{{.*}}, %{{.*}}, %{{.*}}) <{arg_attrs = [{llvm.align = 4 : i64}, {llvm.align = 8 : i64}, {}], isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()582  call void @llvm.memcpy.p0.p0.i32(ptr align 4 %1, ptr align 8 %2, i32 %0, i1 false)583  ; CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}) <{arg_attrs = [{}, {llvm.align = 4 : i64}], isVolatile = false, len = 10 : i64}> : (!llvm.ptr, !llvm.ptr) -> ()584  call void @llvm.memcpy.inline.p0.p0.i64(ptr %1, ptr align 4 %2, i64 10, i1 false)585  ; CHECK: "llvm.intr.memcpy.inline"(%{{.*}}, %{{.*}}) <{isVolatile = false, len = 10 : i32}> : (!llvm.ptr, !llvm.ptr) -> ()586  call void @llvm.memcpy.inline.p0.p0.i32(ptr %1, ptr %2, i32 10, i1 false)587  ret void588}589 590; CHECK-LABEL:  llvm.func @memmove_test591define void @memmove_test(i32 %0, ptr %1, ptr %2) {592  ; CHECK: "llvm.intr.memmove"(%{{.*}}, %{{.*}}, %{{.*}}) <{arg_attrs = [{llvm.align = 16 : i64}, {}, {}], isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()593  call void @llvm.memmove.p0.p0.i32(ptr align 16 %1, ptr %2, i32 %0, i1 false)594  ret void595}596 597; CHECK-LABEL:  llvm.func @memset_test598define void @memset_test(i32 %0, ptr %1, i8 %2) {599  ; CHECK: "llvm.intr.memset"(%{{.*}}, %{{.*}}, %{{.*}}) <{arg_attrs = [{llvm.align = 2 : i64}, {}, {}], isVolatile = false}> : (!llvm.ptr, i8, i32) -> ()600  call void @llvm.memset.p0.i32(ptr align 2 %1, i8 %2, i32 %0, i1 false)601  ; CHECK: "llvm.intr.memset.inline"(%{{.*}}, %{{.*}}) <{arg_attrs = [{llvm.align = 4 : i64}, {}], isVolatile = false, len = 10 : i64}> : (!llvm.ptr, i8) -> ()602  call void @llvm.memset.inline.p0.i64(ptr align 4 %1, i8 %2, i64 10, i1 false)603  ; CHECK: "llvm.intr.memset.inline"(%{{.*}}, %{{.*}}) <{isVolatile = false, len = 10 : i32}> : (!llvm.ptr, i8) -> ()604  call void @llvm.memset.inline.p0.i32(ptr %1, i8 %2, i32 10, i1 false)605  ret void606}607 608; CHECK-LABEL:  llvm.func @sadd_with_overflow_test609define void @sadd_with_overflow_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {610  ; CHECK: "llvm.intr.sadd.with.overflow"(%{{.*}}, %{{.*}}) : (i32, i32) -> !llvm.struct<(i32, i1)>611  %5 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %0, i32 %1)612  ; CHECK: "llvm.intr.sadd.with.overflow"(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>613  %6 = call { <8 x i32>, <8 x i1> } @llvm.sadd.with.overflow.v8i32(<8 x i32> %2, <8 x i32> %3)614  ret void615}616 617; CHECK-LABEL:  llvm.func @uadd_with_overflow_test618define void @uadd_with_overflow_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {619  ; CHECK: "llvm.intr.uadd.with.overflow"(%{{.*}}, %{{.*}}) : (i32, i32) -> !llvm.struct<(i32, i1)>620  %5 = call { i32, i1 } @llvm.uadd.with.overflow.i32(i32 %0, i32 %1)621  ; CHECK: "llvm.intr.uadd.with.overflow"(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>622  %6 = call { <8 x i32>, <8 x i1> } @llvm.uadd.with.overflow.v8i32(<8 x i32> %2, <8 x i32> %3)623  ret void624}625 626; CHECK-LABEL:  llvm.func @ssub_with_overflow_test627define void @ssub_with_overflow_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {628  ; CHECK: "llvm.intr.ssub.with.overflow"(%{{.*}}, %{{.*}}) : (i32, i32) -> !llvm.struct<(i32, i1)>629  %5 = call { i32, i1 } @llvm.ssub.with.overflow.i32(i32 %0, i32 %1)630  ; CHECK: "llvm.intr.ssub.with.overflow"(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>631  %6 = call { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32(<8 x i32> %2, <8 x i32> %3)632  ret void633}634 635; CHECK-LABEL:  llvm.func @usub_with_overflow_test636define void @usub_with_overflow_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {637  ; CHECK: "llvm.intr.usub.with.overflow"(%{{.*}}, %{{.*}}) : (i32, i32) -> !llvm.struct<(i32, i1)>638  %5 = call { i32, i1 } @llvm.usub.with.overflow.i32(i32 %0, i32 %1)639  ; CHECK: "llvm.intr.usub.with.overflow"(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>640  %6 = call { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32(<8 x i32> %2, <8 x i32> %3)641  ret void642}643 644; CHECK-LABEL:  llvm.func @smul_with_overflow_test645define void @smul_with_overflow_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {646  ; CHECK: "llvm.intr.smul.with.overflow"(%{{.*}}, %{{.*}}) : (i32, i32) -> !llvm.struct<(i32, i1)>647  %5 = call { i32, i1 } @llvm.smul.with.overflow.i32(i32 %0, i32 %1)648  ; CHECK: "llvm.intr.smul.with.overflow"(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>649  %6 = call { <8 x i32>, <8 x i1> } @llvm.smul.with.overflow.v8i32(<8 x i32> %2, <8 x i32> %3)650  ret void651}652 653; CHECK-LABEL:  llvm.func @umul_with_overflow_test654define void @umul_with_overflow_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {655  ; CHECK: "llvm.intr.umul.with.overflow"(%{{.*}}, %{{.*}}) : (i32, i32) -> !llvm.struct<(i32, i1)>656  %5 = call { i32, i1 } @llvm.umul.with.overflow.i32(i32 %0, i32 %1)657  ; CHECK: "llvm.intr.umul.with.overflow"(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>658  %6 = call { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32(<8 x i32> %2, <8 x i32> %3)659  ret void660}661 662; CHECK-LABEL:  llvm.func @sadd_sat_test663define void @sadd_sat_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {664  ; CHECK: llvm.intr.sadd.sat(%{{.*}}, %{{.*}}) : (i32, i32) -> i32665  %5 = call i32 @llvm.sadd.sat.i32(i32 %0, i32 %1)666  ; CHECK: llvm.intr.sadd.sat(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>667  %6 = call <8 x i32> @llvm.sadd.sat.v8i32(<8 x i32> %2, <8 x i32> %3)668  ret void669}670 671; CHECK-LABEL:  llvm.func @uadd_sat_test672define void @uadd_sat_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {673  ; CHECK: llvm.intr.uadd.sat(%{{.*}}, %{{.*}}) : (i32, i32) -> i32674  %5 = call i32 @llvm.uadd.sat.i32(i32 %0, i32 %1)675  ; CHECK: llvm.intr.uadd.sat(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>676  %6 = call <8 x i32> @llvm.uadd.sat.v8i32(<8 x i32> %2, <8 x i32> %3)677  ret void678}679 680; CHECK-LABEL:  llvm.func @ssub_sat_test681define void @ssub_sat_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {682  ; CHECK: llvm.intr.ssub.sat(%{{.*}}, %{{.*}}) : (i32, i32) -> i32683  %5 = call i32 @llvm.ssub.sat.i32(i32 %0, i32 %1)684  ; CHECK: llvm.intr.ssub.sat(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>685  %6 = call <8 x i32> @llvm.ssub.sat.v8i32(<8 x i32> %2, <8 x i32> %3)686  ret void687}688 689; CHECK-LABEL:  llvm.func @usub_sat_test690define void @usub_sat_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {691  ; CHECK: llvm.intr.usub.sat(%{{.*}}, %{{.*}}) : (i32, i32) -> i32692  %5 = call i32 @llvm.usub.sat.i32(i32 %0, i32 %1)693  ; CHECK: llvm.intr.usub.sat(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>694  %6 = call <8 x i32> @llvm.usub.sat.v8i32(<8 x i32> %2, <8 x i32> %3)695  ret void696}697 698; CHECK-LABEL:  llvm.func @sshl_sat_test699define void @sshl_sat_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {700  ; CHECK: llvm.intr.sshl.sat(%{{.*}}, %{{.*}}) : (i32, i32) -> i32701  %5 = call i32 @llvm.sshl.sat.i32(i32 %0, i32 %1)702  ; CHECK: llvm.intr.sshl.sat(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>703  %6 = call <8 x i32> @llvm.sshl.sat.v8i32(<8 x i32> %2, <8 x i32> %3)704  ret void705}706 707; CHECK-LABEL:  llvm.func @ushl_sat_test708define void @ushl_sat_test(i32 %0, i32 %1, <8 x i32> %2, <8 x i32> %3) {709  ; CHECK: llvm.intr.ushl.sat(%{{.*}}, %{{.*}}) : (i32, i32) -> i32710  %5 = call i32 @llvm.ushl.sat.i32(i32 %0, i32 %1)711  ; CHECK: llvm.intr.ushl.sat(%{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>712  %6 = call <8 x i32> @llvm.ushl.sat.v8i32(<8 x i32> %2, <8 x i32> %3)713  ret void714}715 716; CHECK-LABEL: llvm.func @va_intrinsics_test717define void @va_intrinsics_test(ptr %0, ptr %1, ...) {718; CHECK: llvm.intr.vastart %{{.*}}719  call void @llvm.va_start.p0(ptr %0)720; CHECK: llvm.intr.vacopy %{{.*}} to %{{.*}}721  call void @llvm.va_copy.p0(ptr %1, ptr %0)722; CHECK: llvm.intr.vaend %{{.*}}723  call void @llvm.va_end.p0(ptr %0)724  ret void725}726 727; CHECK-LABEL: @assume728; CHECK-SAME:  %[[TRUE:[a-zA-Z0-9]+]]729define void @assume(i1 %true) {730  ; CHECK:  llvm.intr.assume %[[TRUE]] : i1731  call void @llvm.assume(i1 %true)732  ret void733}734 735; CHECK-LABEL: @assume_with_opbundles736; CHECK-SAME:  %[[PTR:[a-zA-Z0-9]+]]737define void @assume_with_opbundles(ptr %p) {738  ; CHECK: %[[TRUE:.+]] = llvm.mlir.constant(true) : i1739  ; CHECK: %[[ALIGN:.+]] = llvm.mlir.constant(8 : i32) : i32740  ; CHECK:  llvm.intr.assume %[[TRUE]] ["align"(%[[PTR]], %[[ALIGN]] : !llvm.ptr, i32)] : i1741  call void @llvm.assume(i1 true) ["align"(ptr %p, i32 8)]742  ret void743}744 745; CHECK-LABEL: @is_constant746; CHECK-SAME:  %[[VAL:[a-zA-Z0-9]+]]747define void @is_constant(i32 %0) {748  ; CHECK:  "llvm.intr.is.constant"(%[[VAL]]) : (i32) -> i1749  %2 = call i1 @llvm.is.constant.i32(i32 %0)750  ret void751}752 753; CHECK-LABEL: @expect754; CHECK-SAME:  %[[VAL:[a-zA-Z0-9]+]]755define void @expect(i32 %0) {756  ; CHECK:  %[[EXP:.+]] = llvm.mlir.constant(42 : i32) : i32757  ; CHECK:  llvm.intr.expect %[[VAL]], %[[EXP]] : i32758  %2 = call i32 @llvm.expect.i32(i32 %0, i32 42)759  ret void760}761 762; CHECK-LABEL: @expect_with_probability763; CHECK-SAME:  %[[VAL:[a-zA-Z0-9]+]]764define void @expect_with_probability(i16 %0) {765  ; CHECK:  %[[EXP:.+]] = llvm.mlir.constant(42 : i16) : i16766  ; CHECK:  llvm.intr.expect.with.probability %[[VAL]], %[[EXP]], 5.000000e-01 : i16767  %2 = call i16 @llvm.expect.with.probability.i16(i16 %0, i16 42, double 0.5)768  ret void769}770 771@tls_var = dso_local thread_local global i32 0, align 4772 773; CHECK-LABEL: llvm.func @threadlocal_test774define void @threadlocal_test() {775  ; CHECK: "llvm.intr.threadlocal.address"(%{{.*}}) : (!llvm.ptr) -> !llvm.ptr776  %local = call ptr @llvm.threadlocal.address.p0(ptr @tls_var)777  ret void778}779 780; CHECK-LABEL:  llvm.func @coro_id781define void @coro_id(i32 %0, ptr %1) {782  ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.token783  %3 = call token @llvm.coro.id(i32 %0, ptr %1, ptr %1, ptr null)784  ret void785}786 787; CHECK-LABEL:  llvm.func @coro_begin788define void @coro_begin(i32 %0, ptr %1) {789  ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.token790  %3 = call token @llvm.coro.id(i32 %0, ptr %1, ptr %1, ptr null)791  ; CHECK: llvm.intr.coro.begin %{{.*}}, %{{.*}} : (!llvm.token, !llvm.ptr) -> !llvm.ptr792  %4 = call ptr @llvm.coro.begin(token %3, ptr %1)793  ret void794}795 796; CHECK-LABEL:  llvm.func @coro_size()797define void @coro_size() {798  ; CHECK: llvm.intr.coro.size : i64799  %1 = call i64 @llvm.coro.size.i64()800  ; CHECK: llvm.intr.coro.size : i32801  %2 = call i32 @llvm.coro.size.i32()802  ret void803}804; CHECK-LABEL:  llvm.func @coro_align()805define void @coro_align() {806  ; CHECK: llvm.intr.coro.align : i64807  %1 = call i64 @llvm.coro.align.i64()808  ; CHECK: llvm.intr.coro.align : i32809  %2 = call i32 @llvm.coro.align.i32()810  ret void811}812 813; CHECK-LABEL:  llvm.func @coro_save814define void @coro_save(ptr %0) {815  ; CHECK: llvm.intr.coro.save %{{.*}} : (!llvm.ptr) -> !llvm.token816  %2 = call token @llvm.coro.save(ptr %0)817  ret void818}819 820; CHECK-LABEL:  llvm.func @coro_suspend821define void @coro_suspend(i32 %0, i1 %1, ptr %2) {822  ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.token823  %4 = call token @llvm.coro.id(i32 %0, ptr %2, ptr %2, ptr null)824  ; CHECK: llvm.intr.coro.suspend %{{.*}}, %{{.*}} : i8825  %5 = call i8 @llvm.coro.suspend(token %4, i1 %1)826  ret void827}828 829; CHECK-LABEL:  llvm.func @coro_end830define void @coro_end(ptr %0, i1 %1) {831  ; CHECK:  llvm.intr.coro.end832  call void @llvm.coro.end(ptr %0, i1 %1, token none)833  ret void834}835 836; CHECK-LABEL:  llvm.func @coro_free837define void @coro_free(i32 %0, ptr %1) {838  ; CHECK: llvm.intr.coro.id %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}} : (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.token839  %3 = call token @llvm.coro.id(i32 %0, ptr %1, ptr %1, ptr null)840  ; CHECK: llvm.intr.coro.free %{{.*}}, %{{.*}} : (!llvm.token, !llvm.ptr) -> !llvm.ptr841  %4 = call ptr @llvm.coro.free(token %3, ptr %1)842  ret void843}844 845; CHECK-LABEL:  llvm.func @coro_resume846define void @coro_resume(ptr %0) {847  ; CHECK: llvm.intr.coro.resume %{{.*}}848  call void @llvm.coro.resume(ptr %0)849  ret void850}851 852; CHECK-LABEL:  llvm.func @coro_promise853define void @coro_promise(ptr %0, i32 %1, i1 %2) {854  ; CHECK: llvm.intr.coro.promise %{{.*}}, %{{.*}}, %{{.*}} : (!llvm.ptr, i32, i1) -> !llvm.ptr855  %4 = call ptr @llvm.coro.promise(ptr %0, i32 %1, i1 %2)856  ret void857}858 859; CHECK-LABEL:  llvm.func @eh_typeid_for860define void @eh_typeid_for(ptr %0) {861  ; CHECK: llvm.intr.eh.typeid.for %{{.*}} : (!llvm.ptr) -> i32862  %2 = call i32 @llvm.eh.typeid.for.p0(ptr %0)863  ret void864}865 866; CHECK-LABEL:  llvm.func @stack_save() {867define void @stack_save() {868  ; CHECK: llvm.intr.stacksave : !llvm.ptr869  %1 = call ptr @llvm.stacksave.p0()870  ; CHECK: llvm.intr.stacksave : !llvm.ptr<1>871  %2 = call ptr addrspace(1) @llvm.stacksave.p1()872  ret void873}874 875; CHECK-LABEL:  llvm.func @stack_restore876define void @stack_restore(ptr %0, ptr addrspace(1) %1) {877  ; CHECK: llvm.intr.stackrestore %{{.*}} : !llvm.ptr878  call void @llvm.stackrestore.p0(ptr %0)879  ; CHECK: llvm.intr.stackrestore %{{.*}} : !llvm.ptr<1>880  call void @llvm.stackrestore.p1(ptr addrspace(1) %1)881  ret void882}883 884; CHECK-LABEL: llvm.func @lifetime885define void @lifetime() {886  %a = alloca [16 x i8]887  ; CHECK: llvm.intr.lifetime.start %{{.*}} : !llvm.ptr888  call void @llvm.lifetime.start.p0(ptr %a)889  ; CHECK: llvm.intr.lifetime.end %{{.*}} : !llvm.ptr890  call void @llvm.lifetime.end.p0(ptr %a)891  ret void892}893 894; CHECK-LABEL: llvm.func @invariant895define void @invariant(ptr %0) {896  ; CHECK: %[[START:.*]] = llvm.intr.invariant.start 16, %{{.*}} : !llvm.ptr897  %2 = call ptr @llvm.invariant.start.p0(i64 16, ptr %0)898  ; CHECK: llvm.intr.invariant.end %[[START]], 32, %{{.*}} : !llvm.ptr899  call void @llvm.invariant.end.p0(ptr %2, i64 32, ptr %0)900  ret void901}902 903; CHECK-LABEL: llvm.func @invariant_group904define void @invariant_group(ptr %0) {905  ; CHECK: %{{.+}} = llvm.intr.launder.invariant.group %{{.*}} : !llvm.ptr906  %2 = call ptr @llvm.launder.invariant.group.p0(ptr %0)907  ; CHECK: %{{.+}} = llvm.intr.strip.invariant.group %{{.*}} : !llvm.ptr908  %3 = call ptr @llvm.strip.invariant.group.p0(ptr %0)909  ret void910}911 912; CHECK-LABEL: llvm.func @vector_insert913define void @vector_insert(<vscale x 4 x float> %0, <4 x float> %1) {914  ; CHECK: llvm.intr.vector.insert %{{.*}}, %{{.*}}[4] : vector<4xf32> into vector<[4]xf32>915  %3 = call <vscale x 4 x float>  @llvm.vector.insert.nxv4f32.v4f32(<vscale x 4 x float> %0, <4 x float> %1, i64 4);916  ret void917}918 919; CHECK-LABEL: llvm.func @vector_extract920define void @vector_extract(<vscale x 4 x float> %0) {921  ; llvm.intr.vector.extract %{{.*}}[0] : vector<4xf32> from !llvm.vec<? x 4 x  f32>922  %2 = call <4 x float> @llvm.vector.extract.v4f32.nxv4f32(<vscale x 4 x float> %0, i64 0);923  ret void924}925 926; CHECK-LABEL: llvm.func @vector_deinterleave2927define void @vector_deinterleave2(<4 x double> %0, <vscale x 8 x i32> %1) {928  ; CHECK: "llvm.intr.vector.deinterleave2"(%{{.*}}) : (vector<4xf64>) -> !llvm.struct<(vector<2xf64>, vector<2xf64>)>929  %3 = call { <2 x double>, <2 x double> } @llvm.vector.deinterleave2.v4f64(<4 x double> %0);930  ; CHECK: "llvm.intr.vector.deinterleave2"(%{{.*}}) : (vector<[8]xi32>) -> !llvm.struct<(vector<[4]xi32>, vector<[4]xi32>)>931  %4 = call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.vector.deinterleave2.nxv8i32(<vscale x 8 x i32> %1);932  ret void933}934 935; CHECK-LABEL:  llvm.func @vector_predication_intrinsics936define void @vector_predication_intrinsics(<8 x i32> %0, <8 x i32> %1, <8 x float> %2, <8 x float> %3, <8 x i64> %4, <8 x double> %5, <8 x ptr> %6, i32 %7, float %8, ptr %9, ptr %10, <8 x i1> %11, i32 %12) {937  ; CHECK: "llvm.intr.vp.add"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>938  %14 = call <8 x i32> @llvm.vp.add.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)939  ; CHECK: "llvm.intr.vp.sub"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>940  %15 = call <8 x i32> @llvm.vp.sub.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)941  ; CHECK: "llvm.intr.vp.mul"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>942  %16 = call <8 x i32> @llvm.vp.mul.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)943  ; CHECK: "llvm.intr.vp.sdiv"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>944  %17 = call <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)945  ; CHECK: "llvm.intr.vp.udiv"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>946  %18 = call <8 x i32> @llvm.vp.udiv.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)947  ; CHECK: "llvm.intr.vp.srem"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>948  %19 = call <8 x i32> @llvm.vp.srem.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)949  ; CHECK: "llvm.intr.vp.urem"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>950  %20 = call <8 x i32> @llvm.vp.urem.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)951  ; CHECK: "llvm.intr.vp.ashr"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>952  %21 = call <8 x i32> @llvm.vp.ashr.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)953  ; CHECK: "llvm.intr.vp.lshr"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>954  %22 = call <8 x i32> @llvm.vp.lshr.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)955  ; CHECK: "llvm.intr.vp.shl"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>956  %23 = call <8 x i32> @llvm.vp.shl.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)957  ; CHECK: "llvm.intr.vp.or"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>958  %24 = call <8 x i32> @llvm.vp.or.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)959  ; CHECK: "llvm.intr.vp.and"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>960  %25 = call <8 x i32> @llvm.vp.and.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)961  ; CHECK: "llvm.intr.vp.xor"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>962  %26 = call <8 x i32> @llvm.vp.xor.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)963  ; CHECK: "llvm.intr.vp.fadd"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>964  %27 = call <8 x float> @llvm.vp.fadd.v8f32(<8 x float> %2, <8 x float> %3, <8 x i1> %11, i32 %12)965  ; CHECK: "llvm.intr.vp.fsub"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>966  %28 = call <8 x float> @llvm.vp.fsub.v8f32(<8 x float> %2, <8 x float> %3, <8 x i1> %11, i32 %12)967  ; CHECK: "llvm.intr.vp.fmul"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>968  %29 = call <8 x float> @llvm.vp.fmul.v8f32(<8 x float> %2, <8 x float> %3, <8 x i1> %11, i32 %12)969  ; CHECK: "llvm.intr.vp.fdiv"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>970  %30 = call <8 x float> @llvm.vp.fdiv.v8f32(<8 x float> %2, <8 x float> %3, <8 x i1> %11, i32 %12)971  ; CHECK: "llvm.intr.vp.frem"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>972  %31 = call <8 x float> @llvm.vp.frem.v8f32(<8 x float> %2, <8 x float> %3, <8 x i1> %11, i32 %12)973  ; CHECK: "llvm.intr.vp.fneg"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>974  %32 = call <8 x float> @llvm.vp.fneg.v8f32(<8 x float> %2, <8 x i1> %11, i32 %12)975  ; CHECK: "llvm.intr.vp.fma"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>976  %33 = call <8 x float> @llvm.vp.fma.v8f32(<8 x float> %2, <8 x float> %3, <8 x float> %3, <8 x i1> %11, i32 %12)977  ; CHECK: "llvm.intr.vp.reduce.add"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32978  %34 = call i32 @llvm.vp.reduce.add.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)979  ; CHECK: "llvm.intr.vp.reduce.mul"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32980  %35 = call i32 @llvm.vp.reduce.mul.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)981  ; CHECK: "llvm.intr.vp.reduce.and"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32982  %36 = call i32 @llvm.vp.reduce.and.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)983  ; CHECK: "llvm.intr.vp.reduce.or"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32984  %37 = call i32 @llvm.vp.reduce.or.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)985  ; CHECK: "llvm.intr.vp.reduce.xor"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32986  %38 = call i32 @llvm.vp.reduce.xor.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)987  ; CHECK: "llvm.intr.vp.reduce.smax"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32988  %39 = call i32 @llvm.vp.reduce.smax.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)989  ; CHECK: "llvm.intr.vp.reduce.smin"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32990  %40 = call i32 @llvm.vp.reduce.smin.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)991  ; CHECK: "llvm.intr.vp.reduce.umax"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32992  %41 = call i32 @llvm.vp.reduce.umax.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)993  ; CHECK: "llvm.intr.vp.reduce.umin"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (i32, vector<8xi32>, vector<8xi1>, i32) -> i32994  %42 = call i32 @llvm.vp.reduce.umin.v8i32(i32 %7, <8 x i32> %0, <8 x i1> %11, i32 %12)995  ; CHECK: "llvm.intr.vp.reduce.fadd"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (f32, vector<8xf32>, vector<8xi1>, i32) -> f32996  %43 = call float @llvm.vp.reduce.fadd.v8f32(float %8, <8 x float> %2, <8 x i1> %11, i32 %12)997  ; CHECK: "llvm.intr.vp.reduce.fmul"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (f32, vector<8xf32>, vector<8xi1>, i32) -> f32998  %44 = call float @llvm.vp.reduce.fmul.v8f32(float %8, <8 x float> %2, <8 x i1> %11, i32 %12)999  ; CHECK: "llvm.intr.vp.reduce.fmax"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (f32, vector<8xf32>, vector<8xi1>, i32) -> f321000  %45 = call float @llvm.vp.reduce.fmax.v8f32(float %8, <8 x float> %2, <8 x i1> %11, i32 %12)1001  ; CHECK: "llvm.intr.vp.reduce.fmin"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (f32, vector<8xf32>, vector<8xi1>, i32) -> f321002  %46 = call float @llvm.vp.reduce.fmin.v8f32(float %8, <8 x float> %2, <8 x i1> %11, i32 %12)1003  ; CHECK: "llvm.intr.vp.select"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi1>, vector<8xi32>, vector<8xi32>, i32) -> vector<8xi32>1004  %47 = call <8 x i32> @llvm.vp.select.v8i32(<8 x i1> %11, <8 x i32> %0, <8 x i32> %1, i32 %12)1005  ; CHECK: "llvm.intr.vp.merge"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi1>, vector<8xi32>, vector<8xi32>, i32) -> vector<8xi32>1006  %48 = call <8 x i32> @llvm.vp.merge.v8i32(<8 x i1> %11, <8 x i32> %0, <8 x i32> %1, i32 %12)1007  ; CHECK: "llvm.intr.vp.store"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, !llvm.ptr, vector<8xi1>, i32) -> ()1008  call void @llvm.vp.store.v8i32.p0(<8 x i32> %0, ptr %9, <8 x i1> %11, i32 %12)1009  ; CHECK: "llvm.intr.vp.load"(%{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, vector<8xi1>, i32) -> vector<8xi32>1010  %49 = call <8 x i32> @llvm.vp.load.v8i32.p0(ptr %9, <8 x i1> %11, i32 %12)1011  ; CHECK: "llvm.intr.experimental.vp.strided.store"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, !llvm.ptr, i32, vector<8xi1>, i32) -> ()1012  call void @llvm.experimental.vp.strided.store.v8i32.p0.i32(<8 x i32> %0, ptr %9, i32 %7, <8 x i1> %11, i32 %12)1013  ; CHECK: "llvm.intr.experimental.vp.strided.load"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (!llvm.ptr, i32, vector<8xi1>, i32) -> vector<8xi32>1014  %50 = call <8 x i32> @llvm.experimental.vp.strided.load.v8i32.p0.i32(ptr %9, i32 %7, <8 x i1> %11, i32 %12)1015  ; CHECK: "llvm.intr.vp.trunc"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi64>, vector<8xi1>, i32) -> vector<8xi32>1016  %51 = call <8 x i32> @llvm.vp.trunc.v8i32.v8i64(<8 x i64> %4, <8 x i1> %11, i32 %12)1017  ; CHECK: "llvm.intr.vp.zext"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi1>, i32) -> vector<8xi64>1018  %52 = call <8 x i64> @llvm.vp.zext.v8i64.v8i32(<8 x i32> %0, <8 x i1> %11, i32 %12)1019  ; CHECK: "llvm.intr.vp.sext"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi1>, i32) -> vector<8xi64>1020  %53 = call <8 x i64> @llvm.vp.sext.v8i64.v8i32(<8 x i32> %0, <8 x i1> %11, i32 %12)1021  ; CHECK: "llvm.intr.vp.fptrunc"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf64>, vector<8xi1>, i32) -> vector<8xf32>1022  %54 = call <8 x float> @llvm.vp.fptrunc.v8f32.v8f64(<8 x double> %5, <8 x i1> %11, i32 %12)1023  ; CHECK: "llvm.intr.vp.fpext"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xi1>, i32) -> vector<8xf64>1024  %55 = call <8 x double> @llvm.vp.fpext.v8f64.v8f32(<8 x float> %2, <8 x i1> %11, i32 %12)1025  ; CHECK: "llvm.intr.vp.fptoui"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf64>, vector<8xi1>, i32) -> vector<8xi64>1026  %56 = call <8 x i64> @llvm.vp.fptoui.v8i64.v8f64(<8 x double> %5, <8 x i1> %11, i32 %12)1027  ; CHECK: "llvm.intr.vp.fptosi"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf64>, vector<8xi1>, i32) -> vector<8xi64>1028  %57 = call <8 x i64> @llvm.vp.fptosi.v8i64.v8f64(<8 x double> %5, <8 x i1> %11, i32 %12)1029  ; CHECK: "llvm.intr.vp.ptrtoint"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8x!llvm.ptr>, vector<8xi1>, i32) -> vector<8xi64>1030  %58 = call <8 x i64> @llvm.vp.ptrtoint.v8i64.v8p0(<8 x ptr> %6, <8 x i1> %11, i32 %12)1031  ; CHECK: "llvm.intr.vp.inttoptr"(%{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi64>, vector<8xi1>, i32) -> vector<8x!llvm.ptr>1032  %59 = call <8 x ptr> @llvm.vp.inttoptr.v8p0.v8i64(<8 x i64> %4, <8 x i1> %11, i32 %12)1033  ; CHECK: "llvm.intr.vp.fmuladd"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xf32>, vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>1034  %60 = call <8 x float> @llvm.vp.fmuladd.v8f32(<8 x float> %2, <8 x float> %3, <8 x float> %3, <8 x i1> %11, i32 %12)1035  ; CHECK: "llvm.intr.vp.smax"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>1036  %61 = call <8 x i32> @llvm.vp.smax.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)1037  ; CHECK: "llvm.intr.vp.smin"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>1038  %62 = call <8 x i32> @llvm.vp.smin.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)1039  ; CHECK: "llvm.intr.vp.umax"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>1040  %63 = call <8 x i32> @llvm.vp.umax.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)1041  ; CHECK: "llvm.intr.vp.umin"(%{{.*}}, %{{.*}}, %{{.*}}, %{{.*}}) : (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>1042  %64 = call <8 x i32> @llvm.vp.umin.v8i32(<8 x i32> %0, <8 x i32> %1, <8 x i1> %11, i32 %12)1043  ret void1044}1045 1046; CHECK-LABEL:  llvm.func @ssa_copy1047define float @ssa_copy(float %0) {1048  ; CHECK: %{{.*}} = llvm.intr.ssa.copy %{{.*}} : f321049  %2 = call float @llvm.ssa.copy.f32(float %0)1050  ret float %21051}1052 1053; CHECK-LABEL:  llvm.func @ptrmask1054define ptr @ptrmask(ptr %0, i64 %1) {1055  ; CHECK: %{{.*}} = llvm.intr.ptrmask %{{.*}} : (!llvm.ptr, i64) -> !llvm.ptr1056  %3 = call ptr @llvm.ptrmask.p0.i64(ptr %0, i64 %1)1057  ret ptr %31058}1059 1060; CHECK-LABEL:  llvm.func @vector_ptrmask1061define <8 x ptr> @vector_ptrmask(<8 x ptr> %0, <8 x i64> %1) {1062  ; CHECK: %{{.*}} = llvm.intr.ptrmask %{{.*}} : (vector<8x!llvm.ptr>, vector<8xi64>) -> vector<8x!llvm.ptr>1063  %3 = call <8 x ptr> @llvm.ptrmask.v8p0.v8i64(<8 x ptr> %0, <8 x i64> %1)1064  ret <8 x ptr> %31065}1066 1067; CHECK-LABEL: experimental_constrained_fptrunc1068define void @experimental_constrained_fptrunc(double %s, <4 x double> %v) {1069  ; CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} towardzero ignore : f64 to f321070  %1 = call float @llvm.experimental.constrained.fptrunc.f32.f64(double %s, metadata !"round.towardzero", metadata !"fpexcept.ignore")1071  ; CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} tonearest maytrap : f64 to f321072  %2 = call float @llvm.experimental.constrained.fptrunc.f32.f64(double %s, metadata !"round.tonearest", metadata !"fpexcept.maytrap")1073  ; CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} upward strict : f64 to f321074  %3 = call float @llvm.experimental.constrained.fptrunc.f32.f64(double %s, metadata !"round.upward", metadata !"fpexcept.strict")1075  ; CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} downward ignore : f64 to f321076  %4 = call float @llvm.experimental.constrained.fptrunc.f32.f64(double %s, metadata !"round.downward", metadata !"fpexcept.ignore")1077  ; CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} tonearestaway ignore : f64 to f321078  %5 = call float @llvm.experimental.constrained.fptrunc.f32.f64(double %s, metadata !"round.tonearestaway", metadata !"fpexcept.ignore")1079  ; CHECK: llvm.intr.experimental.constrained.fptrunc %{{.*}} tonearestaway ignore : vector<4xf64> to vector<4xf16>1080  %6 = call <4 x half> @llvm.experimental.constrained.fptrunc.v4f16.v4f64(<4 x double> %v, metadata !"round.tonearestaway", metadata !"fpexcept.ignore")1081  ret void1082}1083 1084; CHECK-LABEL: experimental_constrained_uitofp1085define void @experimental_constrained_uitofp(i32 %s, <4 x i32> %v) {1086  ; CHECK: llvm.intr.experimental.constrained.uitofp %{{.*}} towardzero ignore : i32 to f321087  %1 = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %s, metadata !"round.towardzero", metadata !"fpexcept.ignore")1088  ; CHECK: llvm.intr.experimental.constrained.uitofp %{{.*}} tonearest maytrap : i32 to f321089  %2 = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %s, metadata !"round.tonearest", metadata !"fpexcept.maytrap")1090  ; CHECK: llvm.intr.experimental.constrained.uitofp %{{.*}} upward strict : i32 to f321091  %3 = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %s, metadata !"round.upward", metadata !"fpexcept.strict")1092  ; CHECK: llvm.intr.experimental.constrained.uitofp %{{.*}} downward ignore : i32 to f321093  %4 = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %s, metadata !"round.downward", metadata !"fpexcept.ignore")1094  ; CHECK: llvm.intr.experimental.constrained.uitofp %{{.*}} tonearestaway ignore : i32 to f321095  %5 = call float @llvm.experimental.constrained.uitofp.f32.i32(i32 %s, metadata !"round.tonearestaway", metadata !"fpexcept.ignore")1096  ; CHECK: llvm.intr.experimental.constrained.uitofp %{{.*}} tonearestaway ignore : vector<4xi32> to vector<4xf32>1097  %6 = call <4 x float> @llvm.experimental.constrained.uitofp.v4f32.v4i32(<4 x i32> %v, metadata !"round.tonearestaway", metadata !"fpexcept.ignore")1098  ret void1099}1100 1101; CHECK-LABEL: experimental_constrained_sitofp1102define void @experimental_constrained_sitofp(i32 %s, <4 x i32> %v) {1103  ; CHECK: llvm.intr.experimental.constrained.sitofp %{{.*}} towardzero ignore : i32 to f321104  %1 = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %s, metadata !"round.towardzero", metadata !"fpexcept.ignore")1105  ; CHECK: llvm.intr.experimental.constrained.sitofp %{{.*}} tonearest maytrap : i32 to f321106  %2 = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %s, metadata !"round.tonearest", metadata !"fpexcept.maytrap")1107  ; CHECK: llvm.intr.experimental.constrained.sitofp %{{.*}} upward strict : i32 to f321108  %3 = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %s, metadata !"round.upward", metadata !"fpexcept.strict")1109  ; CHECK: llvm.intr.experimental.constrained.sitofp %{{.*}} downward ignore : i32 to f321110  %4 = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %s, metadata !"round.downward", metadata !"fpexcept.ignore")1111  ; CHECK: llvm.intr.experimental.constrained.sitofp %{{.*}} tonearestaway ignore : i32 to f321112  %5 = call float @llvm.experimental.constrained.sitofp.f32.i32(i32 %s, metadata !"round.tonearestaway", metadata !"fpexcept.ignore")1113  ; CHECK: llvm.intr.experimental.constrained.sitofp %{{.*}} tonearestaway ignore : vector<4xi32> to vector<4xf32>1114  %6 = call <4 x float> @llvm.experimental.constrained.sitofp.v4f32.v4i32(<4 x i32> %v, metadata !"round.tonearestaway", metadata !"fpexcept.ignore")1115  ret void1116}1117 1118; CHECK-LABEL: experimental_constrained_fpext1119define void @experimental_constrained_fpext(float %s, <4 x float> %v) {1120  ; CHECK: llvm.intr.experimental.constrained.fpext %{{.*}} ignore : f32 to f641121  %1 = call double @llvm.experimental.constrained.fpext.f64.f32(float %s, metadata !"fpexcept.ignore")1122  ; CHECK: llvm.intr.experimental.constrained.fpext %{{.*}} maytrap : f32 to f641123  %2 = call double @llvm.experimental.constrained.fpext.f64.f32(float %s, metadata !"fpexcept.maytrap")1124  ; CHECK: llvm.intr.experimental.constrained.fpext %{{.*}} strict : f32 to f641125  %3 = call double @llvm.experimental.constrained.fpext.f64.f32(float %s, metadata !"fpexcept.strict")1126  ; CHECK: llvm.intr.experimental.constrained.fpext %{{.*}} ignore : vector<4xf32> to vector<4xf64>1127  %6 = call <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float> %v, metadata !"fpexcept.ignore")1128  ret void1129}1130 1131; CHECK-LABEL:  llvm.func @ucmp1132define i2 @ucmp(i32 %a, i32 %b) {1133  ; CHECK: %{{.*}} = llvm.intr.ucmp(%{{.*}}, %{{.*}}) : (i32, i32) -> i21134  %r = call i2 @llvm.ucmp.i2.i32(i32 %a, i32 %b)1135  ret i2 %r1136}1137 1138; CHECK-LABEL:  llvm.func @vector_ucmp1139define <4 x i32> @vector_ucmp(<4 x i32> %a, <4 x i32> %b) {1140  ; CHECK: %{{.*}} = llvm.intr.ucmp(%{{.*}}, %{{.*}}) : (vector<4xi32>, vector<4xi32>) -> vector<4xi32>1141  %r = call <4 x i32> @llvm.ucmp.v4i32.v4i32(<4 x i32> %a, <4 x i32> %b)1142  ret <4 x i32> %r1143}1144 1145; CHECK-LABEL:  llvm.func @scmp1146define i2 @scmp(i32 %a, i32 %b) {1147  ; CHECK: %{{.*}} = llvm.intr.scmp(%{{.*}}, %{{.*}}) : (i32, i32) -> i21148  %r = call i2 @llvm.scmp.i2.i32(i32 %a, i32 %b)1149  ret i2 %r1150}1151 1152; CHECK-LABEL:  llvm.func @vector_scmp1153define <4 x i32> @vector_scmp(<4 x i32> %a, <4 x i32> %b) {1154  ; CHECK: %{{.*}} = llvm.intr.scmp(%{{.*}}, %{{.*}}) : (vector<4xi32>, vector<4xi32>) -> vector<4xi32>1155  %r = call <4 x i32> @llvm.scmp.v4i32.v4i32(<4 x i32> %a, <4 x i32> %b)1156  ret <4 x i32> %r1157}1158 1159declare float @llvm.fmuladd.f32(float, float, float)1160declare <8 x float> @llvm.fmuladd.v8f32(<8 x float>, <8 x float>, <8 x float>)1161declare float @llvm.fma.f32(float, float, float)1162declare <8 x float> @llvm.fma.v8f32(<8 x float>, <8 x float>, <8 x float>)1163declare void @llvm.prefetch.p0(ptr nocapture readonly, i32 immarg, i32 immarg, i32)1164declare i1 @llvm.is.fpclass.f32(float, i32 immarg)1165declare <8 x i1> @llvm.is.fpclass.v8f32(<8 x float>, i32 immarg)1166declare float @llvm.exp.f32(float)1167declare <8 x float> @llvm.exp.v8f32(<8 x float>)1168declare float @llvm.exp2.f32(float)1169declare <8 x float> @llvm.exp2.v8f32(<8 x float>)1170declare float @llvm.exp10.f32(float)1171declare <8 x float> @llvm.exp10.v8f32(<8 x float>)1172declare float @llvm.ldexp.f32.i32(float, i32)1173declare <8 x float> @llvm.ldexp.v8f32.i32(<8 x float>, i32)1174declare { float, i32 } @llvm.frexp.f32.i32(float)1175declare { <8 x float>, i32 } @llvm.frexp.v8f32.i32(<8 x float>)1176declare float @llvm.log.f32(float)1177declare <8 x float> @llvm.log.v8f32(<8 x float>)1178declare float @llvm.log10.f32(float)1179declare <8 x float> @llvm.log10.v8f32(<8 x float>)1180declare float @llvm.log2.f32(float)1181declare <8 x float> @llvm.log2.v8f32(<8 x float>)1182declare float @llvm.fabs.f32(float)1183declare <8 x float> @llvm.fabs.v8f32(<8 x float>)1184declare float @llvm.sqrt.f32(float)1185declare <8 x float> @llvm.sqrt.v8f32(<8 x float>)1186declare float @llvm.ceil.f32(float)1187declare <8 x float> @llvm.ceil.v8f32(<8 x float>)1188declare float @llvm.floor.f32(float)1189declare <8 x float> @llvm.floor.v8f32(<8 x float>)1190declare float @llvm.cos.f32(float)1191declare <8 x float> @llvm.cos.v8f32(<8 x float>)1192declare float @llvm.sinh.f32(float)1193declare <8 x float> @llvm.sinh.v8f32(<8 x float>)1194declare float @llvm.cosh.f32(float)1195declare <8 x float> @llvm.cosh.v8f32(<8 x float>)1196declare float @llvm.tanh.f32(float)1197declare <8 x float> @llvm.tanh.v8f32(<8 x float>)1198declare float @llvm.copysign.f32(float, float)1199declare <8 x float> @llvm.copysign.v8f32(<8 x float>, <8 x float>)1200declare float @llvm.pow.f32(float, float)1201declare <8 x float> @llvm.pow.v8f32(<8 x float>, <8 x float>)1202declare float @llvm.rint.f32(float)1203declare double @llvm.rint.f64(double)1204declare <8 x float> @llvm.rint.v8f32(<8 x float>)1205declare <8 x double> @llvm.rint.v8f64(<8 x double>)1206declare float @llvm.nearbyint.f32(float)1207declare double @llvm.nearbyint.f64(double)1208declare <8 x float> @llvm.nearbyint.v8f32(<8 x float>)1209declare <8 x double> @llvm.nearbyint.v8f64(<8 x double>)1210declare i32 @llvm.lround.i32.f32(float)1211declare i64 @llvm.lround.i64.f32(float)1212declare i32 @llvm.lround.i32.f64(double)1213declare i64 @llvm.lround.i64.f64(double)1214declare i64 @llvm.llround.i64.f32(float)1215declare i64 @llvm.llround.i64.f64(double)1216declare i32 @llvm.lrint.i32.f32(float)1217declare i64 @llvm.lrint.i64.f32(float)1218declare i32 @llvm.lrint.i32.f64(double)1219declare i64 @llvm.lrint.i64.f64(double)1220declare i64 @llvm.llrint.i64.f32(float)1221declare i64 @llvm.llrint.i64.f64(double)1222declare i32 @llvm.bitreverse.i32(i32)1223declare <8 x i32> @llvm.bitreverse.v8i32(<8 x i32>)1224declare i32 @llvm.bswap.i32(i32)1225declare <8 x i32> @llvm.bswap.v8i32(<8 x i32>)1226declare i32 @llvm.ctlz.i32(i32, i1 immarg)1227declare <8 x i32> @llvm.ctlz.v8i32(<8 x i32>, i1 immarg)1228declare i32 @llvm.cttz.i32(i32, i1 immarg)1229declare <8 x i32> @llvm.cttz.v8i32(<8 x i32>, i1 immarg)1230declare i32 @llvm.abs.i32(i32, i1 immarg)1231declare <8 x i32> @llvm.abs.v8i32(<8 x i32>, i1 immarg)1232declare i32 @llvm.ctpop.i32(i32)1233declare <8 x i32> @llvm.ctpop.v8i32(<8 x i32>)1234declare i32 @llvm.fshl.i32(i32, i32, i32)1235declare <8 x i32> @llvm.fshl.v8i32(<8 x i32>, <8 x i32>, <8 x i32>)1236declare i32 @llvm.fshr.i32(i32, i32, i32)1237declare <8 x i32> @llvm.fshr.v8i32(<8 x i32>, <8 x i32>, <8 x i32>)1238declare float @llvm.maximum.f32(float, float)1239declare <8 x float> @llvm.maximum.v8f32(<8 x float>, <8 x float>)1240declare float @llvm.minimum.f32(float, float)1241declare <8 x float> @llvm.minimum.v8f32(<8 x float>, <8 x float>)1242declare float @llvm.maxnum.f32(float, float)1243declare <8 x float> @llvm.maxnum.v8f32(<8 x float>, <8 x float>)1244declare float @llvm.minnum.f32(float, float)1245declare <8 x float> @llvm.minnum.v8f32(<8 x float>, <8 x float>)1246declare i32 @llvm.smax.i32(i32, i32)1247declare <8 x i32> @llvm.smax.v8i32(<8 x i32>, <8 x i32>)1248declare i32 @llvm.smin.i32(i32, i32)1249declare <8 x i32> @llvm.smin.v8i32(<8 x i32>, <8 x i32>)1250declare i32 @llvm.umax.i32(i32, i32)1251declare <8 x i32> @llvm.umax.v8i32(<8 x i32>, <8 x i32>)1252declare i32 @llvm.umin.i32(i32, i32)1253declare <8 x i32> @llvm.umin.v8i32(<8 x i32>, <8 x i32>)1254declare i32 @llvm.vector.reduce.add.v8i32(<8 x i32>)1255declare i32 @llvm.vector.reduce.and.v8i32(<8 x i32>)1256declare float @llvm.vector.reduce.fmax.v8f32(<8 x float>)1257declare float @llvm.vector.reduce.fmin.v8f32(<8 x float>)1258declare float @llvm.vector.reduce.fmaximum.v8f32(<8 x float>)1259declare float @llvm.vector.reduce.fminimum.v8f32(<8 x float>)1260declare i32 @llvm.vector.reduce.mul.v8i32(<8 x i32>)1261declare i32 @llvm.vector.reduce.or.v8i32(<8 x i32>)1262declare i32 @llvm.vector.reduce.smax.v8i32(<8 x i32>)1263declare i32 @llvm.vector.reduce.smin.v8i32(<8 x i32>)1264declare i32 @llvm.vector.reduce.umax.v8i32(<8 x i32>)1265declare i32 @llvm.vector.reduce.umin.v8i32(<8 x i32>)1266declare float @llvm.vector.reduce.fadd.v8f32(float, <8 x float>)1267declare float @llvm.vector.reduce.fmul.v8f32(float, <8 x float>)1268declare i32 @llvm.vector.reduce.xor.v8i32(<8 x i32>)1269declare <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float>, <48 x float>, i32 immarg, i32 immarg, i32 immarg)1270declare <48 x float> @llvm.matrix.transpose.v48f32(<48 x float>, i32 immarg, i32 immarg)1271declare <48 x float> @llvm.matrix.column.major.load.v48f32.i64(ptr nocapture, i64, i1 immarg, i32 immarg, i32 immarg)1272declare void @llvm.matrix.column.major.store.v48f32.i64(<48 x float>, ptr nocapture writeonly, i64, i1 immarg, i32 immarg, i32 immarg)1273declare <7 x i1> @llvm.get.active.lane.mask.v7i1.i64(i64, i64)1274declare <7 x float> @llvm.masked.load.v7f32.p0(ptr, i32 immarg, <7 x i1>, <7 x float>)1275declare void @llvm.masked.store.v7f32.p0(<7 x float>, ptr, i32 immarg, <7 x i1>)1276declare <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr>, i32 immarg, <7 x i1>, <7 x float>)1277declare void @llvm.masked.scatter.v7f32.v7p0(<7 x float>, <7 x ptr>, i32 immarg, <7 x i1>)1278declare <7 x float> @llvm.masked.expandload.v7f32(ptr, <7 x i1>, <7 x float>)1279declare void @llvm.masked.compressstore.v7f32(<7 x float>, ptr, <7 x i1>)1280declare void @llvm.var.annotation.p0.p0(ptr, ptr, ptr, i32, ptr)1281declare ptr @llvm.ptr.annotation.p0.p0(ptr, ptr, ptr, i32, ptr)1282declare i16 @llvm.annotation.i16.p0(i16, ptr, ptr, i32)1283declare void @llvm.trap()1284declare void @llvm.debugtrap()1285declare void @llvm.ubsantrap(i8 immarg)1286declare void @llvm.memcpy.p0.p0.i32(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i32, i1 immarg)1287declare void @llvm.memcpy.inline.p0.p0.i64(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i64 immarg, i1 immarg)1288declare void @llvm.memcpy.inline.p0.p0.i32(ptr noalias nocapture writeonly, ptr noalias nocapture readonly, i32 immarg, i1 immarg)1289declare void @llvm.memmove.p0.p0.i32(ptr nocapture writeonly, ptr nocapture readonly, i32, i1 immarg)1290declare void @llvm.memset.p0.i32(ptr nocapture writeonly, i8, i32, i1 immarg)1291declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32)1292declare { <8 x i32>, <8 x i1> } @llvm.sadd.with.overflow.v8i32(<8 x i32>, <8 x i32>)1293declare { i32, i1 } @llvm.uadd.with.overflow.i32(i32, i32)1294declare { <8 x i32>, <8 x i1> } @llvm.uadd.with.overflow.v8i32(<8 x i32>, <8 x i32>)1295declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32)1296declare { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32(<8 x i32>, <8 x i32>)1297declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32)1298declare { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32(<8 x i32>, <8 x i32>)1299declare { i32, i1 } @llvm.smul.with.overflow.i32(i32, i32)1300declare { <8 x i32>, <8 x i1> } @llvm.smul.with.overflow.v8i32(<8 x i32>, <8 x i32>)1301declare { i32, i1 } @llvm.umul.with.overflow.i32(i32, i32)1302declare { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32(<8 x i32>, <8 x i32>)1303declare i32 @llvm.sadd.sat.i32(i32, i32)1304declare <8 x i32> @llvm.sadd.sat.v8i32(<8 x i32>, <8 x i32>)1305declare i32 @llvm.uadd.sat.i32(i32, i32)1306declare <8 x i32> @llvm.uadd.sat.v8i32(<8 x i32>, <8 x i32>)1307declare i32 @llvm.ssub.sat.i32(i32, i32)1308declare <8 x i32> @llvm.ssub.sat.v8i32(<8 x i32>, <8 x i32>)1309declare i32 @llvm.usub.sat.i32(i32, i32)1310declare <8 x i32> @llvm.usub.sat.v8i32(<8 x i32>, <8 x i32>)1311declare i32 @llvm.sshl.sat.i32(i32, i32)1312declare <8 x i32> @llvm.sshl.sat.v8i32(<8 x i32>, <8 x i32>)1313declare i32 @llvm.ushl.sat.i32(i32, i32)1314declare <8 x i32> @llvm.ushl.sat.v8i32(<8 x i32>, <8 x i32>)1315declare i1 @llvm.is.constant.i32(i32)1316declare i32 @llvm.expect.i32(i32, i32)1317declare i16 @llvm.expect.with.probability.i16(i16, i16, double immarg)1318declare nonnull ptr @llvm.threadlocal.address.p0(ptr nonnull)1319declare token @llvm.coro.id(i32, ptr readnone, ptr nocapture readonly, ptr)1320declare ptr @llvm.coro.begin(token, ptr writeonly)1321declare i64 @llvm.coro.size.i64()1322declare i32 @llvm.coro.size.i32()1323declare i64 @llvm.coro.align.i64()1324declare i32 @llvm.coro.align.i32()1325declare token @llvm.coro.save(ptr)1326declare i8 @llvm.coro.suspend(token, i1)1327declare void @llvm.coro.end(ptr, i1, token)1328declare ptr @llvm.coro.free(token, ptr nocapture readonly)1329declare void @llvm.coro.resume(ptr)1330declare ptr @llvm.coro.promise(ptr nocapture, i32, i1)1331declare i32 @llvm.eh.typeid.for.p0(ptr)1332declare ptr @llvm.stacksave.p0()1333declare ptr addrspace(1) @llvm.stacksave.p1()1334declare void @llvm.stackrestore.p0(ptr)1335declare void @llvm.stackrestore.p1(ptr addrspace(1))1336declare void @llvm.va_start.p0(ptr)1337declare void @llvm.va_copy.p0(ptr, ptr)1338declare void @llvm.va_end.p0(ptr)1339declare <8 x i32> @llvm.vp.add.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1340declare <8 x i32> @llvm.vp.sub.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1341declare <8 x i32> @llvm.vp.mul.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1342declare <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1343declare <8 x i32> @llvm.vp.udiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1344declare <8 x i32> @llvm.vp.srem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1345declare <8 x i32> @llvm.vp.urem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1346declare <8 x i32> @llvm.vp.ashr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1347declare <8 x i32> @llvm.vp.lshr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1348declare <8 x i32> @llvm.vp.shl.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1349declare <8 x i32> @llvm.vp.or.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1350declare <8 x i32> @llvm.vp.and.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1351declare <8 x i32> @llvm.vp.xor.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1352declare <8 x float> @llvm.vp.fadd.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1353declare <8 x float> @llvm.vp.fsub.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1354declare <8 x float> @llvm.vp.fmul.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1355declare <8 x float> @llvm.vp.fdiv.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1356declare <8 x float> @llvm.vp.frem.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1357declare <8 x float> @llvm.vp.fneg.v8f32(<8 x float>, <8 x i1>, i32)1358declare <8 x float> @llvm.vp.fma.v8f32(<8 x float>, <8 x float>, <8 x float>, <8 x i1>, i32)1359declare <8 x float> @llvm.vp.fmuladd.v8f32(<8 x float>, <8 x float>, <8 x float>, <8 x i1>, i32)1360declare <8 x i32> @llvm.vp.smax.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1361declare <8 x i32> @llvm.vp.smin.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1362declare <8 x i32> @llvm.vp.umax.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1363declare <8 x i32> @llvm.vp.umin.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1364declare i32 @llvm.vp.reduce.add.v8i32(i32, <8 x i32>, <8 x i1>, i32)1365declare i32 @llvm.vp.reduce.mul.v8i32(i32, <8 x i32>, <8 x i1>, i32)1366declare i32 @llvm.vp.reduce.and.v8i32(i32, <8 x i32>, <8 x i1>, i32)1367declare i32 @llvm.vp.reduce.or.v8i32(i32, <8 x i32>, <8 x i1>, i32)1368declare i32 @llvm.vp.reduce.xor.v8i32(i32, <8 x i32>, <8 x i1>, i32)1369declare i32 @llvm.vp.reduce.smax.v8i32(i32, <8 x i32>, <8 x i1>, i32)1370declare i32 @llvm.vp.reduce.smin.v8i32(i32, <8 x i32>, <8 x i1>, i32)1371declare i32 @llvm.vp.reduce.umax.v8i32(i32, <8 x i32>, <8 x i1>, i32)1372declare i32 @llvm.vp.reduce.umin.v8i32(i32, <8 x i32>, <8 x i1>, i32)1373declare float @llvm.vp.reduce.fadd.v8f32(float, <8 x float>, <8 x i1>, i32)1374declare float @llvm.vp.reduce.fmul.v8f32(float, <8 x float>, <8 x i1>, i32)1375declare float @llvm.vp.reduce.fmax.v8f32(float, <8 x float>, <8 x i1>, i32)1376declare float @llvm.vp.reduce.fmin.v8f32(float, <8 x float>, <8 x i1>, i32)1377declare <8 x i32> @llvm.vp.select.v8i32(<8 x i1>, <8 x i32>, <8 x i32>, i32)1378declare <8 x i32> @llvm.vp.merge.v8i32(<8 x i1>, <8 x i32>, <8 x i32>, i32)1379declare void @llvm.vp.store.v8i32.p0(<8 x i32>, ptr nocapture, <8 x i1>, i32)1380declare <8 x i32> @llvm.vp.load.v8i32.p0(ptr nocapture, <8 x i1>, i32)1381declare void @llvm.experimental.vp.strided.store.v8i32.p0.i32(<8 x i32>, ptr nocapture, i32, <8 x i1>, i32)1382declare <8 x i32> @llvm.experimental.vp.strided.load.v8i32.p0.i32(ptr nocapture, i32, <8 x i1>, i32)1383declare <8 x i32> @llvm.vp.trunc.v8i32.v8i64(<8 x i64>, <8 x i1>, i32)1384declare <8 x i64> @llvm.vp.zext.v8i64.v8i32(<8 x i32>, <8 x i1>, i32)1385declare <8 x i64> @llvm.vp.sext.v8i64.v8i32(<8 x i32>, <8 x i1>, i32)1386declare <8 x float> @llvm.vp.fptrunc.v8f32.v8f64(<8 x double>, <8 x i1>, i32)1387declare <8 x double> @llvm.vp.fpext.v8f64.v8f32(<8 x float>, <8 x i1>, i32)1388declare <8 x i64> @llvm.vp.fptoui.v8i64.v8f64(<8 x double>, <8 x i1>, i32)1389declare <8 x i64> @llvm.vp.fptosi.v8i64.v8f64(<8 x double>, <8 x i1>, i32)1390declare <8 x i64> @llvm.vp.ptrtoint.v8i64.v8p0(<8 x ptr>, <8 x i1>, i32)1391declare <8 x ptr> @llvm.vp.inttoptr.v8p0.v8i64(<8 x i64>, <8 x i1>, i32)1392declare void @llvm.lifetime.start.p0(ptr nocapture)1393declare void @llvm.lifetime.end.p0(ptr nocapture)1394declare ptr @llvm.invariant.start.p0(i64 immarg, ptr nocapture)1395declare void @llvm.invariant.end.p0(ptr, i64 immarg, ptr nocapture)1396declare ptr @llvm.launder.invariant.group.p0(ptr nocapture)1397declare ptr @llvm.strip.invariant.group.p0(ptr nocapture)1398 1399declare void @llvm.assume(i1)1400declare float @llvm.ssa.copy.f32(float returned)1401declare ptr @llvm.ptrmask.p0.i64(ptr, i64)1402declare <8 x ptr> @llvm.ptrmask.v8p0.v8i64(<8 x ptr>, <8 x i64>)1403declare <vscale x 4 x float> @llvm.vector.insert.nxv4f32.v4f32(<vscale x 4 x float>, <4 x float>, i64)1404declare <4 x float> @llvm.vector.extract.v4f32.nxv4f32(<vscale x 4 x float>, i64)1405declare <4 x float> @llvm.experimental.constrained.uitofp.v4f32.v4i32(<4 x i32>, metadata, metadata)1406declare float @llvm.experimental.constrained.uitofp.f32.i32(i32, metadata, metadata)1407declare <4 x float> @llvm.experimental.constrained.sitofp.v4f32.v4i32(<4 x i32>, metadata, metadata)1408declare float @llvm.experimental.constrained.sitofp.f32.i32(i32, metadata, metadata)1409declare <4 x half> @llvm.experimental.constrained.fptrunc.v4f16.v4f64(<4 x double>, metadata, metadata)1410declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)1411declare <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float>, metadata)1412declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)1413declare i2 @llvm.ucmp.i2.i32(i32, i32)1414declare <4 x i32> @llvm.ucmp.v4i32.v4i32(<4 x i32>, <4 x i32>)1415declare i2 @llvm.scmp.i2.i32(i32, i32)1416declare <4 x i32> @llvm.scmp.v4i32.v4i32(<4 x i32>, <4 x i32>)1417