1499 lines · plain
1// RUN: mlir-translate -mlir-to-llvmir %s | FileCheck %s2 3// CHECK-LABEL: @intrinsics4llvm.func @intrinsics(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: !llvm.ptr) {5 // CHECK: call float @llvm.fmuladd.f326 "llvm.intr.fmuladd"(%arg0, %arg1, %arg0) : (f32, f32, f32) -> f327 // CHECK: call <8 x float> @llvm.fmuladd.v8f328 "llvm.intr.fmuladd"(%arg2, %arg2, %arg2) : (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32>9 // CHECK: call float @llvm.fma.f3210 "llvm.intr.fma"(%arg0, %arg1, %arg0) : (f32, f32, f32) -> f3211 // CHECK: call <8 x float> @llvm.fma.v8f3212 "llvm.intr.fma"(%arg2, %arg2, %arg2) : (vector<8xf32>, vector<8xf32>, vector<8xf32>) -> vector<8xf32>13 // CHECK: call void @llvm.prefetch.p0(ptr %3, i32 0, i32 3, i32 1)14 "llvm.intr.prefetch"(%arg3) <{cache = 1 : i32, hint = 3 : i32, rw = 0 : i32}> : (!llvm.ptr) -> ()15 llvm.return16}17 18// CHECK-LABEL: @fpclass_test19llvm.func @fpclass_test(%arg0: f32) -> i1 {20 // CHECK: call i1 @llvm.is.fpclass21 %0 = "llvm.intr.is.fpclass"(%arg0) <{bit = 0 : i32 }>: (f32) -> i122 llvm.return %0 : i123}24 25// CHECK-LABEL: @exp_test26llvm.func @exp_test(%arg0: f32, %arg1: vector<8xf32>) {27 // CHECK: call float @llvm.exp.f3228 "llvm.intr.exp"(%arg0) : (f32) -> f3229 // CHECK: call <8 x float> @llvm.exp.v8f3230 "llvm.intr.exp"(%arg1) : (vector<8xf32>) -> vector<8xf32>31 llvm.return32}33 34// CHECK-LABEL: @exp2_test35llvm.func @exp2_test(%arg0: f32, %arg1: vector<8xf32>) {36 // CHECK: call float @llvm.exp2.f3237 "llvm.intr.exp2"(%arg0) : (f32) -> f3238 // CHECK: call <8 x float> @llvm.exp2.v8f3239 "llvm.intr.exp2"(%arg1) : (vector<8xf32>) -> vector<8xf32>40 llvm.return41}42 43// CHECK-LABEL: @exp10_test44llvm.func @exp10_test(%arg0: f32, %arg1: vector<8xf32>) {45 // CHECK: call float @llvm.exp10.f3246 "llvm.intr.exp10"(%arg0) : (f32) -> f3247 // CHECK: call <8 x float> @llvm.exp10.v8f3248 "llvm.intr.exp10"(%arg1) : (vector<8xf32>) -> vector<8xf32>49 llvm.return50}51 52// CHECK-LABEL: @ldexp_test53llvm.func @ldexp_test(%arg0: f32, %arg1: vector<8xf32>, %arg2: i32) {54 // CHECK: call float @llvm.ldexp.f32.i32(float %{{.*}}, i32 %{{.*}})55 "llvm.intr.ldexp"(%arg0, %arg2) : (f32, i32) -> f3256 // CHECK: call <8 x float> @llvm.ldexp.v8f32.i32(<8 x float> %{{.*}}, i32 %{{.*}})57 "llvm.intr.ldexp"(%arg1, %arg2) : (vector<8xf32>, i32) -> vector<8xf32>58 llvm.return59}60 61// CHECK-LABEL: @frexp_test62llvm.func @frexp_test(%arg0: f32, %arg1: vector<8xf32>) {63 // CHECK: call { float, i32 } @llvm.frexp.f32.i32(float %{{.*}})64 llvm.intr.frexp(%arg0) : (f32) -> !llvm.struct<(f32, i32)>65 // CHECK: call { <8 x float>, i32 } @llvm.frexp.v8f32.i32(<8 x float> %{{.*}})66 llvm.intr.frexp(%arg1) : (vector<8xf32>) -> !llvm.struct<(vector<8xf32>, i32)>67 llvm.return68}69 70// CHECK-LABEL: @log_test71llvm.func @log_test(%arg0: f32, %arg1: vector<8xf32>) {72 // CHECK: call float @llvm.log.f3273 "llvm.intr.log"(%arg0) : (f32) -> f3274 // CHECK: call <8 x float> @llvm.log.v8f3275 "llvm.intr.log"(%arg1) : (vector<8xf32>) -> vector<8xf32>76 llvm.return77}78 79// CHECK-LABEL: @log10_test80llvm.func @log10_test(%arg0: f32, %arg1: vector<8xf32>) {81 // CHECK: call float @llvm.log10.f3282 "llvm.intr.log10"(%arg0) : (f32) -> f3283 // CHECK: call <8 x float> @llvm.log10.v8f3284 "llvm.intr.log10"(%arg1) : (vector<8xf32>) -> vector<8xf32>85 llvm.return86}87 88// CHECK-LABEL: @log2_test89llvm.func @log2_test(%arg0: f32, %arg1: vector<8xf32>) {90 // CHECK: call float @llvm.log2.f3291 "llvm.intr.log2"(%arg0) : (f32) -> f3292 // CHECK: call <8 x float> @llvm.log2.v8f3293 "llvm.intr.log2"(%arg1) : (vector<8xf32>) -> vector<8xf32>94 llvm.return95}96 97// CHECK-LABEL: @fabs_test98llvm.func @fabs_test(%arg0: f32, %arg1: vector<8xf32>) {99 // CHECK: call float @llvm.fabs.f32100 "llvm.intr.fabs"(%arg0) : (f32) -> f32101 // CHECK: call <8 x float> @llvm.fabs.v8f32102 "llvm.intr.fabs"(%arg1) : (vector<8xf32>) -> vector<8xf32>103 llvm.return104}105 106// CHECK-LABEL: @sqrt_test107llvm.func @sqrt_test(%arg0: f32, %arg1: vector<8xf32>) {108 // CHECK: call float @llvm.sqrt.f32109 "llvm.intr.sqrt"(%arg0) : (f32) -> f32110 // CHECK: call <8 x float> @llvm.sqrt.v8f32111 "llvm.intr.sqrt"(%arg1) : (vector<8xf32>) -> vector<8xf32>112 llvm.return113}114 115// CHECK-LABEL: @ceil_test116llvm.func @ceil_test(%arg0: f32, %arg1: vector<8xf32>) {117 // CHECK: call float @llvm.ceil.f32118 "llvm.intr.ceil"(%arg0) : (f32) -> f32119 // CHECK: call <8 x float> @llvm.ceil.v8f32120 "llvm.intr.ceil"(%arg1) : (vector<8xf32>) -> vector<8xf32>121 llvm.return122}123 124// CHECK-LABEL: @floor_test125llvm.func @floor_test(%arg0: f32, %arg1: vector<8xf32>) {126 // CHECK: call float @llvm.floor.f32127 "llvm.intr.floor"(%arg0) : (f32) -> f32128 // CHECK: call <8 x float> @llvm.floor.v8f32129 "llvm.intr.floor"(%arg1) : (vector<8xf32>) -> vector<8xf32>130 llvm.return131}132 133// CHECK-LABEL: @trig_test134llvm.func @trig_test(%arg0: f32, %arg1: vector<8xf32>) {135 // CHECK: call float @llvm.sin.f32136 llvm.intr.sin(%arg0) : (f32) -> f32137 // CHECK: call <8 x float> @llvm.sin.v8f32138 llvm.intr.sin(%arg1) : (vector<8xf32>) -> vector<8xf32>139 140 // CHECK: call float @llvm.cos.f32141 llvm.intr.cos(%arg0) : (f32) -> f32142 // CHECK: call <8 x float> @llvm.cos.v8f32143 llvm.intr.cos(%arg1) : (vector<8xf32>) -> vector<8xf32>144 145 // CHECK: call float @llvm.tan.f32146 llvm.intr.tan(%arg0) : (f32) -> f32147 // CHECK: call <8 x float> @llvm.tan.v8f32148 llvm.intr.tan(%arg1) : (vector<8xf32>) -> vector<8xf32>149 150 // CHECK: call { float, float } @llvm.sincos.f32151 llvm.intr.sincos(%arg0) : (f32) -> !llvm.struct<(f32, f32)>152 // CHECK: call { <8 x float>, <8 x float> } @llvm.sincos.v8f32153 llvm.intr.sincos(%arg1) : (vector<8xf32>) -> !llvm.struct<(vector<8xf32>, vector<8xf32>)>154 llvm.return155}156 157// CHECK-LABEL: @inv_trig_test158llvm.func @inv_trig_test(%arg0: f32, %arg1: vector<8xf32>) {159 // CHECK: call float @llvm.asin.f32160 llvm.intr.asin(%arg0) : (f32) -> f32161 // CHECK: call <8 x float> @llvm.asin.v8f32162 llvm.intr.asin(%arg1) : (vector<8xf32>) -> vector<8xf32>163 164 // CHECK: call float @llvm.acos.f32165 llvm.intr.acos(%arg0) : (f32) -> f32166 // CHECK: call <8 x float> @llvm.acos.v8f32167 llvm.intr.acos(%arg1) : (vector<8xf32>) -> vector<8xf32>168 169 // CHECK: call float @llvm.atan.f32170 llvm.intr.atan(%arg0) : (f32) -> f32171 // CHECK: call <8 x float> @llvm.atan.v8f32172 llvm.intr.atan(%arg1) : (vector<8xf32>) -> vector<8xf32>173 174 llvm.return175}176 177// CHECK-LABEL: @atan2_test178llvm.func @atan2_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {179 // CHECK: call float @llvm.atan2.f32180 "llvm.intr.atan2"(%arg0, %arg1) : (f32, f32) -> f32181 // CHECK: call <8 x float> @llvm.atan2.v8f32182 "llvm.intr.atan2"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>183 llvm.return184}185 186// CHECK-LABEL: @hyperbolic_trig_test187llvm.func @hyperbolic_trig_test(%arg0: f32, %arg1: vector<8xf32>) {188 // CHECK: call float @llvm.sinh.f32189 llvm.intr.sinh(%arg0) : (f32) -> f32190 // CHECK: call <8 x float> @llvm.sinh.v8f32191 llvm.intr.sinh(%arg1) : (vector<8xf32>) -> vector<8xf32>192 193 // CHECK: call float @llvm.cosh.f32194 llvm.intr.cosh(%arg0) : (f32) -> f32195 // CHECK: call <8 x float> @llvm.cosh.v8f32196 llvm.intr.cosh(%arg1) : (vector<8xf32>) -> vector<8xf32>197 198 // CHECK: call float @llvm.tanh.f32199 llvm.intr.tanh(%arg0) : (f32) -> f32200 // CHECK: call <8 x float> @llvm.tanh.v8f32201 llvm.intr.tanh(%arg1) : (vector<8xf32>) -> vector<8xf32>202 llvm.return203}204 205// CHECK-LABEL: @copysign_test206llvm.func @copysign_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {207 // CHECK: call float @llvm.copysign.f32208 "llvm.intr.copysign"(%arg0, %arg1) : (f32, f32) -> f32209 // CHECK: call <8 x float> @llvm.copysign.v8f32210 "llvm.intr.copysign"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>211 llvm.return212}213 214// CHECK-LABEL: @pow_test215llvm.func @pow_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {216 // CHECK: call float @llvm.pow.f32217 "llvm.intr.pow"(%arg0, %arg1) : (f32, f32) -> f32218 // CHECK: call <8 x float> @llvm.pow.v8f32219 "llvm.intr.pow"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>220 llvm.return221}222 223// CHECK-LABEL: @rint_test224llvm.func @rint_test(%arg0 : f32, %arg1 : f64, %arg2 : vector<8xf32>, %arg3 : vector<8xf64>) {225 // CHECK: call float @llvm.rint.f32226 "llvm.intr.rint"(%arg0) : (f32) -> f32227 // CHECK: call double @llvm.rint.f64228 "llvm.intr.rint"(%arg1) : (f64) -> f64229 // CHECK: call <8 x float> @llvm.rint.v8f32230 "llvm.intr.rint"(%arg2) : (vector<8xf32>) -> vector<8xf32>231 // CHECK: call <8 x double> @llvm.rint.v8f64232 "llvm.intr.rint"(%arg3) : (vector<8xf64>) -> vector<8xf64>233 llvm.return234}235 236// CHECK-LABEL: @nearbyint_test237llvm.func @nearbyint_test(%arg0 : f32, %arg1 : f64, %arg2 : vector<8xf32>, %arg3 : vector<8xf64>) {238 // CHECK: call float @llvm.nearbyint.f32239 "llvm.intr.nearbyint"(%arg0) : (f32) -> f32240 // CHECK: call double @llvm.nearbyint.f64241 "llvm.intr.nearbyint"(%arg1) : (f64) -> f64242 // CHECK: call <8 x float> @llvm.nearbyint.v8f32243 "llvm.intr.nearbyint"(%arg2) : (vector<8xf32>) -> vector<8xf32>244 // CHECK: call <8 x double> @llvm.nearbyint.v8f64245 "llvm.intr.nearbyint"(%arg3) : (vector<8xf64>) -> vector<8xf64>246 llvm.return247}248 249// CHECK-LABEL: @lround_test250llvm.func @lround_test(%arg0 : f32, %arg1 : f64,251 %arg2 : vector<2xf32>, %arg3 : vector<2xf64>) {252 // CHECK: call i32 @llvm.lround.i32.f32253 "llvm.intr.lround"(%arg0) : (f32) -> i32254 // CHECK: call i64 @llvm.lround.i64.f32255 "llvm.intr.lround"(%arg0) : (f32) -> i64256 // CHECK: call i32 @llvm.lround.i32.f64257 "llvm.intr.lround"(%arg1) : (f64) -> i32258 // CHECK: call i64 @llvm.lround.i64.f64259 "llvm.intr.lround"(%arg1) : (f64) -> i64260 // CHECK: call <2 x i32> @llvm.lround.v2i32.v2f32261 "llvm.intr.lround"(%arg2) : (vector<2xf32>) -> vector<2xi32>262 // CHECK: call <2 x i32> @llvm.lround.v2i32.v2f64263 "llvm.intr.lround"(%arg3) : (vector<2xf64>) -> vector<2xi32>264 // CHECK: call <2 x i64> @llvm.lround.v2i64.v2f32265 "llvm.intr.lround"(%arg2) : (vector<2xf32>) -> vector<2xi64>266 // CHECK: call <2 x i64> @llvm.lround.v2i64.v2f64267 "llvm.intr.lround"(%arg3) : (vector<2xf64>) -> vector<2xi64>268 llvm.return269}270 271// CHECK-LABEL: @llround_test272llvm.func @llround_test(%arg0 : f32, %arg1 : f64) {273 // CHECK: call i64 @llvm.llround.i64.f32274 "llvm.intr.llround"(%arg0) : (f32) -> i64275 // CHECK: call i64 @llvm.llround.i64.f64276 "llvm.intr.llround"(%arg1) : (f64) -> i64277 llvm.return278}279 280// CHECK-LABEL: @lrint_test281llvm.func @lrint_test(%arg0 : f32, %arg1 : f64,282 %arg2 : vector<2xf32>, %arg3 : vector<2xf64>) {283 // CHECK: call i32 @llvm.lrint.i32.f32284 "llvm.intr.lrint"(%arg0) : (f32) -> i32285 // CHECK: call i64 @llvm.lrint.i64.f32286 "llvm.intr.lrint"(%arg0) : (f32) -> i64287 // CHECK: call i32 @llvm.lrint.i32.f64288 "llvm.intr.lrint"(%arg1) : (f64) -> i32289 // CHECK: call i64 @llvm.lrint.i64.f64290 "llvm.intr.lrint"(%arg1) : (f64) -> i64291 // CHECK: call <2 x i32> @llvm.lrint.v2i32.v2f32292 "llvm.intr.lrint"(%arg2) : (vector<2xf32>) -> vector<2xi32>293 // CHECK: call <2 x i32> @llvm.lrint.v2i32.v2f64294 "llvm.intr.lrint"(%arg3) : (vector<2xf64>) -> vector<2xi32>295 // CHECK: call <2 x i64> @llvm.lrint.v2i64.v2f32296 "llvm.intr.lrint"(%arg2) : (vector<2xf32>) -> vector<2xi64>297 // CHECK: call <2 x i64> @llvm.lrint.v2i64.v2f64298 "llvm.intr.lrint"(%arg3) : (vector<2xf64>) -> vector<2xi64>299 llvm.return300}301 302// CHECK-LABEL: @llrint_test303llvm.func @llrint_test(%arg0 : f32, %arg1 : f64,304 %arg2 : vector<2xf32>, %arg3 : vector<2xf64>) {305 // CHECK: call i64 @llvm.llrint.i64.f32306 "llvm.intr.llrint"(%arg0) : (f32) -> i64307 // CHECK: call i64 @llvm.llrint.i64.f64308 "llvm.intr.llrint"(%arg1) : (f64) -> i64309 // CHECK: call <2 x i64> @llvm.llrint.v2i64.v2f32310 "llvm.intr.llrint"(%arg2) : (vector<2xf32>) -> vector<2xi64>311 // CHECK: call <2 x i64> @llvm.llrint.v2i64.v2f64312 "llvm.intr.llrint"(%arg3) : (vector<2xf64>) -> vector<2xi64>313 llvm.return314}315 316// CHECK-LABEL: @bitreverse_test317llvm.func @bitreverse_test(%arg0: i32, %arg1: vector<8xi32>) {318 // CHECK: call i32 @llvm.bitreverse.i32319 "llvm.intr.bitreverse"(%arg0) : (i32) -> i32320 // CHECK: call <8 x i32> @llvm.bitreverse.v8i32321 "llvm.intr.bitreverse"(%arg1) : (vector<8xi32>) -> vector<8xi32>322 llvm.return323}324 325// CHECK-LABEL: @byteswap_test326llvm.func @byteswap_test(%arg0: i32, %arg1: vector<8xi32>) {327 // CHECK: call i32 @llvm.bswap.i32328 "llvm.intr.bswap"(%arg0) : (i32) -> i32329 // CHECK: call <8 x i32> @llvm.bswap.v8i32330 "llvm.intr.bswap"(%arg1) : (vector<8xi32>) -> vector<8xi32>331 llvm.return332}333 334// CHECK-LABEL: @ctlz_test335llvm.func @ctlz_test(%arg0: i32, %arg1: vector<8xi32>) {336 // CHECK: call i32 @llvm.ctlz.i32337 "llvm.intr.ctlz"(%arg0) <{is_zero_poison = 0 : i1}> : (i32) -> i32338 // CHECK: call <8 x i32> @llvm.ctlz.v8i32339 "llvm.intr.ctlz"(%arg1) <{is_zero_poison = 1 : i1}> : (vector<8xi32>) -> vector<8xi32>340 llvm.return341}342 343// CHECK-LABEL: @cttz_test344llvm.func @cttz_test(%arg0: i32, %arg1: vector<8xi32>) {345 // CHECK: call i32 @llvm.cttz.i32346 "llvm.intr.cttz"(%arg0) <{is_zero_poison = 0 : i1}> : (i32) -> i32347 // CHECK: call <8 x i32> @llvm.cttz.v8i32348 "llvm.intr.cttz"(%arg1) <{is_zero_poison = 1 : i1}> : (vector<8xi32>) -> vector<8xi32>349 llvm.return350}351 352// CHECK-LABEL: @abs_test353llvm.func @abs_test(%arg0: i32, %arg1: vector<8xi32>) {354 // CHECK: call i32 @llvm.abs.i32355 "llvm.intr.abs"(%arg0) <{is_int_min_poison = 0 : i1}> : (i32) -> i32356 // CHECK: call <8 x i32> @llvm.abs.v8i32357 "llvm.intr.abs"(%arg1) <{is_int_min_poison = 1 : i1}> : (vector<8xi32>) -> vector<8xi32>358 llvm.return359}360 361// CHECK-LABEL: @ctpop_test362llvm.func @ctpop_test(%arg0: i32, %arg1: vector<8xi32>) {363 // CHECK: call i32 @llvm.ctpop.i32364 "llvm.intr.ctpop"(%arg0) : (i32) -> i32365 // CHECK: call <8 x i32> @llvm.ctpop.v8i32366 "llvm.intr.ctpop"(%arg1) : (vector<8xi32>) -> vector<8xi32>367 llvm.return368}369 370// CHECK-LABEL: @fshl_test371llvm.func @fshl_test(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: vector<8xi32>, %arg4: vector<8xi32>, %arg5: vector<8xi32>) {372 // CHECK: call i32 @llvm.fshl.i32373 "llvm.intr.fshl"(%arg0, %arg1, %arg2) : (i32, i32, i32) -> i32374 // CHECK: call <8 x i32> @llvm.fshl.v8i32375 "llvm.intr.fshl"(%arg3, %arg4, %arg5) : (vector<8xi32>, vector<8xi32>, vector<8xi32>) -> vector<8xi32>376 llvm.return377}378 379// CHECK-LABEL: @fshr_test380llvm.func @fshr_test(%arg0: i32, %arg1: i32, %arg2: i32, %arg3: vector<8xi32>, %arg4: vector<8xi32>, %arg5: vector<8xi32>) {381 // CHECK: call i32 @llvm.fshr.i32382 "llvm.intr.fshr"(%arg0, %arg1, %arg2) : (i32, i32, i32) -> i32383 // CHECK: call <8 x i32> @llvm.fshr.v8i32384 "llvm.intr.fshr"(%arg3, %arg4, %arg5) : (vector<8xi32>, vector<8xi32>, vector<8xi32>) -> vector<8xi32>385 llvm.return386}387 388// CHECK-LABEL: @maximum_test389llvm.func @maximum_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {390 // CHECK: call float @llvm.maximum.f32391 "llvm.intr.maximum"(%arg0, %arg1) : (f32, f32) -> f32392 // CHECK: call <8 x float> @llvm.maximum.v8f32393 "llvm.intr.maximum"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>394 llvm.return395}396 397// CHECK-LABEL: @minimum_test398llvm.func @minimum_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {399 // CHECK: call float @llvm.minimum.f32400 "llvm.intr.minimum"(%arg0, %arg1) : (f32, f32) -> f32401 // CHECK: call <8 x float> @llvm.minimum.v8f32402 "llvm.intr.minimum"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>403 llvm.return404}405 406// CHECK-LABEL: @maxnum_test407llvm.func @maxnum_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {408 // CHECK: call float @llvm.maxnum.f32409 "llvm.intr.maxnum"(%arg0, %arg1) : (f32, f32) -> f32410 // CHECK: call <8 x float> @llvm.maxnum.v8f32411 "llvm.intr.maxnum"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>412 llvm.return413}414 415// CHECK-LABEL: @minnum_test416llvm.func @minnum_test(%arg0: f32, %arg1: f32, %arg2: vector<8xf32>, %arg3: vector<8xf32>) {417 // CHECK: call float @llvm.minnum.f32418 "llvm.intr.minnum"(%arg0, %arg1) : (f32, f32) -> f32419 // CHECK: call <8 x float> @llvm.minnum.v8f32420 "llvm.intr.minnum"(%arg2, %arg3) : (vector<8xf32>, vector<8xf32>) -> vector<8xf32>421 llvm.return422}423 424// CHECK-LABEL: @smax_test425llvm.func @smax_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {426 // CHECK: call i32 @llvm.smax.i32427 "llvm.intr.smax"(%arg0, %arg1) : (i32, i32) -> i32428 // CHECK: call <8 x i32> @llvm.smax.v8i32429 "llvm.intr.smax"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>430 llvm.return431}432 433// CHECK-LABEL: @smin_test434llvm.func @smin_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {435 // CHECK: call i32 @llvm.smin.i32436 "llvm.intr.smin"(%arg0, %arg1) : (i32, i32) -> i32437 // CHECK: call <8 x i32> @llvm.smin.v8i32438 "llvm.intr.smin"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>439 llvm.return440}441 442// CHECK-LABEL: @umax_test443llvm.func @umax_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {444 // CHECK: call i32 @llvm.umax.i32445 "llvm.intr.umax"(%arg0, %arg1) : (i32, i32) -> i32446 // CHECK: call <8 x i32> @llvm.umax.v8i32447 "llvm.intr.umax"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>448 llvm.return449}450 451// CHECK-LABEL: @umin_test452llvm.func @umin_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {453 // CHECK: call i32 @llvm.umin.i32454 "llvm.intr.umin"(%arg0, %arg1) : (i32, i32) -> i32455 // CHECK: call <8 x i32> @llvm.umin.v8i32456 "llvm.intr.umin"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>457 llvm.return458}459 460// CHECK-LABEL: @assume_without_opbundles461llvm.func @assume_without_opbundles(%cond: i1) {462 // CHECK: call void @llvm.assume(i1 %{{.+}})463 llvm.intr.assume %cond : i1464 llvm.return465}466 467// CHECK-LABEL: @assume_with_opbundles468llvm.func @assume_with_opbundles(%p: !llvm.ptr) {469 %true = llvm.mlir.constant(true) : i1470 %0 = llvm.mlir.constant(8 : i32) : i32471 // CHECK: call void @llvm.assume(i1 true) [ "align"(ptr %{{.+}}, i32 8) ]472 llvm.intr.assume %true ["align"(%p, %0 : !llvm.ptr, i32)] : i1473 llvm.return474}475 476// CHECK-LABEL: @vector_reductions477llvm.func @vector_reductions(%arg0: f32, %arg1: vector<8xf32>, %arg2: vector<8xi32>) {478 // CHECK: call i32 @llvm.vector.reduce.add.v8i32479 "llvm.intr.vector.reduce.add"(%arg2) : (vector<8xi32>) -> i32480 // CHECK: call i32 @llvm.vector.reduce.and.v8i32481 "llvm.intr.vector.reduce.and"(%arg2) : (vector<8xi32>) -> i32482 // CHECK: call float @llvm.vector.reduce.fmax.v8f32483 llvm.intr.vector.reduce.fmax(%arg1) : (vector<8xf32>) -> f32484 // CHECK: call float @llvm.vector.reduce.fmin.v8f32485 llvm.intr.vector.reduce.fmin(%arg1) : (vector<8xf32>) -> f32486 // CHECK: call float @llvm.vector.reduce.fmaximum.v8f32487 llvm.intr.vector.reduce.fmaximum(%arg1) : (vector<8xf32>) -> f32488 // CHECK: call float @llvm.vector.reduce.fminimum.v8f32489 llvm.intr.vector.reduce.fminimum(%arg1) : (vector<8xf32>) -> f32490 // CHECK: call i32 @llvm.vector.reduce.mul.v8i32491 "llvm.intr.vector.reduce.mul"(%arg2) : (vector<8xi32>) -> i32492 // CHECK: call i32 @llvm.vector.reduce.or.v8i32493 "llvm.intr.vector.reduce.or"(%arg2) : (vector<8xi32>) -> i32494 // CHECK: call i32 @llvm.vector.reduce.smax.v8i32495 "llvm.intr.vector.reduce.smax"(%arg2) : (vector<8xi32>) -> i32496 // CHECK: call i32 @llvm.vector.reduce.smin.v8i32497 "llvm.intr.vector.reduce.smin"(%arg2) : (vector<8xi32>) -> i32498 // CHECK: call i32 @llvm.vector.reduce.umax.v8i32499 "llvm.intr.vector.reduce.umax"(%arg2) : (vector<8xi32>) -> i32500 // CHECK: call i32 @llvm.vector.reduce.umin.v8i32501 "llvm.intr.vector.reduce.umin"(%arg2) : (vector<8xi32>) -> i32502 // CHECK: call float @llvm.vector.reduce.fadd.v8f32503 "llvm.intr.vector.reduce.fadd"(%arg0, %arg1) : (f32, vector<8xf32>) -> f32504 // CHECK: call float @llvm.vector.reduce.fmul.v8f32505 "llvm.intr.vector.reduce.fmul"(%arg0, %arg1) : (f32, vector<8xf32>) -> f32506 // CHECK: call reassoc float @llvm.vector.reduce.fadd.v8f32507 "llvm.intr.vector.reduce.fadd"(%arg0, %arg1) <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<8xf32>) -> f32508 // CHECK: call reassoc float @llvm.vector.reduce.fmul.v8f32509 "llvm.intr.vector.reduce.fmul"(%arg0, %arg1) <{fastmathFlags = #llvm.fastmath<reassoc>}> : (f32, vector<8xf32>) -> f32510 // CHECK: call i32 @llvm.vector.reduce.xor.v8i32511 "llvm.intr.vector.reduce.xor"(%arg2) : (vector<8xi32>) -> i32512 llvm.return513}514 515// CHECK-LABEL: @matrix_intrinsics516// 4x16 16x3517llvm.func @matrix_intrinsics(%A: vector<64 x f32>, %B: vector<48 x f32>,518 %ptr: !llvm.ptr, %stride: i64) {519 // CHECK: call <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float> %0, <48 x float> %1, i32 4, i32 16, i32 3)520 %C = llvm.intr.matrix.multiply %A, %B521 { lhs_rows = 4: i32, lhs_columns = 16: i32 , rhs_columns = 3: i32} :522 (vector<64 x f32>, vector<48 x f32>) -> vector<12 x f32>523 // CHECK: call <48 x float> @llvm.matrix.transpose.v48f32(<48 x float> %1, i32 3, i32 16)524 %D = llvm.intr.matrix.transpose %B { rows = 3: i32, columns = 16: i32} :525 vector<48 x f32> into vector<48 x f32>526 // CHECK: call <48 x float> @llvm.matrix.column.major.load.v48f32.i64(ptr align 4 %2, i64 %3, i1 false, i32 3, i32 16)527 %E = llvm.intr.matrix.column.major.load %ptr, <stride=%stride>528 { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :529 vector<48 x f32> from !llvm.ptr stride i64530 // CHECK: call void @llvm.matrix.column.major.store.v48f32.i64(<48 x float> %7, ptr align 4 %2, i64 %3, i1 false, i32 3, i32 16)531 llvm.intr.matrix.column.major.store %E, %ptr, <stride=%stride>532 { isVolatile = 0: i1, rows = 3: i32, columns = 16: i32} :533 vector<48 x f32> to !llvm.ptr stride i64534 llvm.return535}536 537// CHECK-LABEL: @get_active_lane_mask538llvm.func @get_active_lane_mask(%base: i64, %n: i64) -> (vector<7xi1>) {539 // CHECK: call <7 x i1> @llvm.get.active.lane.mask.v7i1.i64(i64 %0, i64 %1)540 %0 = llvm.intr.get.active.lane.mask %base, %n : i64, i64 to vector<7xi1>541 llvm.return %0 : vector<7xi1>542}543 544// CHECK-LABEL: @masked_load_store_intrinsics545llvm.func @masked_load_store_intrinsics(%A: !llvm.ptr, %mask: vector<7xi1>) {546 // CHECK: call <7 x float> @llvm.masked.load.v7f32.p0(ptr align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> poison)547 %a = llvm.intr.masked.load %A, %mask { alignment = 1: i32} :548 (!llvm.ptr, vector<7xi1>) -> vector<7xf32>549 // CHECK: call <7 x float> @llvm.masked.load.v7f32.p0(ptr align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> poison), !nontemporal !1550 %b = llvm.intr.masked.load %A, %mask { alignment = 1: i32, nontemporal} :551 (!llvm.ptr, vector<7xi1>) -> vector<7xf32>552 // CHECK: call <7 x float> @llvm.masked.load.v7f32.p0(ptr align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> %{{.*}})553 %c = llvm.intr.masked.load %A, %mask, %a { alignment = 1: i32} :554 (!llvm.ptr, vector<7xi1>, vector<7xf32>) -> vector<7xf32>555 // CHECK: call void @llvm.masked.store.v7f32.p0(<7 x float> %{{.*}}, ptr align 1 %0, <7 x i1> %{{.*}})556 llvm.intr.masked.store %b, %A, %mask { alignment = 1: i32} :557 vector<7xf32>, vector<7xi1> into !llvm.ptr558 llvm.return559}560 561// CHECK-LABEL: @masked_gather_scatter_intrinsics562llvm.func @masked_gather_scatter_intrinsics(%M: vector<7 x !llvm.ptr>, %mask: vector<7xi1>) {563 // CHECK: call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> poison)564 %a = llvm.intr.masked.gather %M, %mask { alignment = 1: i32} :565 (vector<7 x !llvm.ptr>, vector<7xi1>) -> vector<7xf32>566 // CHECK: call <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr> align 1 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> %{{.*}})567 %b = llvm.intr.masked.gather %M, %mask, %a { alignment = 1: i32} :568 (vector<7 x !llvm.ptr>, vector<7xi1>, vector<7xf32>) -> vector<7xf32>569 // CHECK: call void @llvm.masked.scatter.v7f32.v7p0(<7 x float> %{{.*}}, <7 x ptr> align 1 %{{.*}}, <7 x i1> %{{.*}})570 llvm.intr.masked.scatter %b, %M, %mask { alignment = 1: i32} :571 vector<7xf32>, vector<7xi1> into vector<7 x !llvm.ptr>572 llvm.return573}574 575// CHECK-LABEL: @masked_expand_compress_intrinsics576llvm.func @masked_expand_compress_intrinsics(%ptr: !llvm.ptr, %mask: vector<7xi1>, %passthru: vector<7xf32>) {577 // CHECK: call <7 x float> @llvm.masked.expandload.v7f32(ptr %{{.*}}, <7 x i1> %{{.*}}, <7 x float> %{{.*}})578 %0 = "llvm.intr.masked.expandload"(%ptr, %mask, %passthru)579 : (!llvm.ptr, vector<7xi1>, vector<7xf32>) -> (vector<7xf32>)580 // CHECK: call void @llvm.masked.compressstore.v7f32(<7 x float> %{{.*}}, ptr %{{.*}}, <7 x i1> %{{.*}})581 "llvm.intr.masked.compressstore"(%0, %ptr, %mask)582 : (vector<7xf32>, !llvm.ptr, vector<7xi1>) -> ()583 llvm.return584}585 586// CHECK-LABEL: @masked_expand_compress_intrinsics_with_alignment587llvm.func @masked_expand_compress_intrinsics_with_alignment(%ptr: !llvm.ptr, %mask: vector<7xi1>, %passthru: vector<7xf32>) {588 // CHECK: call <7 x float> @llvm.masked.expandload.v7f32(ptr align 8 %{{.*}}, <7 x i1> %{{.*}}, <7 x float> %{{.*}})589 %0 = "llvm.intr.masked.expandload"(%ptr, %mask, %passthru) {arg_attrs = [{llvm.align = 8 : i32}, {}, {}]}590 : (!llvm.ptr, vector<7xi1>, vector<7xf32>) -> (vector<7xf32>)591 // CHECK: call void @llvm.masked.compressstore.v7f32(<7 x float> %{{.*}}, ptr align 8 %{{.*}}, <7 x i1> %{{.*}})592 "llvm.intr.masked.compressstore"(%0, %ptr, %mask) {arg_attrs = [{}, {llvm.align = 8 : i32}, {}]}593 : (vector<7xf32>, !llvm.ptr, vector<7xi1>) -> ()594 llvm.return595}596 597// CHECK-LABEL: @annotate_intrinsics598llvm.func @annotate_intrinsics(%var: !llvm.ptr, %int: i16, %ptr: !llvm.ptr, %annotation: !llvm.ptr, %fileName: !llvm.ptr, %line: i32, %attr: !llvm.ptr) {599 // CHECK: call void @llvm.var.annotation.p0.p0(ptr %{{.*}}, ptr %{{.*}}, ptr %{{.*}}, i32 %{{.*}}, ptr %{{.*}})600 "llvm.intr.var.annotation"(%var, %annotation, %fileName, %line, %attr) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i32, !llvm.ptr) -> ()601 // CHECK: call ptr @llvm.ptr.annotation.p0.p0(ptr %{{.*}}, ptr %{{.*}}, ptr %{{.*}}, i32 %{{.*}}, ptr %{{.*}})602 %res0 = "llvm.intr.ptr.annotation"(%ptr, %annotation, %fileName, %line, %attr) : (!llvm.ptr, !llvm.ptr, !llvm.ptr, i32, !llvm.ptr) -> (!llvm.ptr)603 // CHECK: call i16 @llvm.annotation.i16.p0(i16 %{{.*}}, ptr %{{.*}}, ptr %{{.*}}, i32 %{{.*}})604 %res1 = "llvm.intr.annotation"(%int, %annotation, %fileName, %line) : (i16, !llvm.ptr, !llvm.ptr, i32) -> (i16)605 llvm.return606}607 608// CHECK-LABEL: @trap_intrinsics609llvm.func @trap_intrinsics() {610 // CHECK: call void @llvm.trap()611 "llvm.intr.trap"() : () -> ()612 // CHECK: call void @llvm.debugtrap()613 "llvm.intr.debugtrap"() : () -> ()614 // CHECK: call void @llvm.ubsantrap(i8 1)615 "llvm.intr.ubsantrap"() {failureKind = 1 : i8} : () -> ()616 617 // CHECK: call void @llvm.trap()618 llvm.intr.trap619 // CHECK: call void @llvm.debugtrap()620 llvm.intr.debugtrap621 // CHECK: call void @llvm.ubsantrap(i8 1)622 llvm.intr.ubsantrap <{failureKind = 1 : i8}>623 llvm.return624}625 626// CHECK-LABEL: @memcpy_test627llvm.func @memcpy_test(%arg0: i32, %arg2: !llvm.ptr, %arg3: !llvm.ptr) {628 // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 4 %{{.*}}, ptr align 8 %{{.*}}, i32 %{{.*}}, i1 false629 "llvm.intr.memcpy"(%arg2, %arg3, %arg0) <{arg_attrs = [{llvm.align = 4 : i64}, {llvm.align = 8 : i64}, {}], isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()630 // CHECK: call void @llvm.memcpy.inline.p0.p0.i32(ptr align 4 %{{.*}}, ptr %{{.*}}, i32 10, i1 true631 "llvm.intr.memcpy.inline"(%arg2, %arg3) <{arg_attrs = [{llvm.align = 4 : i64}, {}], isVolatile = true, len = 10 : i32}> : (!llvm.ptr, !llvm.ptr) -> ()632 // CHECK: call void @llvm.memcpy.inline.p0.p0.i64(ptr %{{.*}}, ptr %{{.*}}, i64 10, i1 true633 "llvm.intr.memcpy.inline"(%arg2, %arg3) <{isVolatile = true, len = 10 : i64}> : (!llvm.ptr, !llvm.ptr) -> ()634 635 // Verify that trailing empty argument attribute dictionaries can be omitted.636 // CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 4 %{{.*}}, ptr align 8 %{{.*}}, i32 %{{.*}}, i1 false637 "llvm.intr.memcpy"(%arg2, %arg3, %arg0) <{arg_attrs = [{llvm.align = 4 : i64}, {llvm.align = 8 : i64}], isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()638 llvm.return639}640 641// CHECK-LABEL: @memmove_test642llvm.func @memmove_test(%arg0: i32, %arg2: !llvm.ptr, %arg3: !llvm.ptr) {643 // CHECK: call void @llvm.memmove.p0.p0.i32(ptr align 4 %{{.*}}, ptr align 8 %{{.*}}, i32 %{{.*}}, i1 false644 "llvm.intr.memmove"(%arg2, %arg3, %arg0) <{arg_attrs = [{llvm.align = 4 : i64}, {llvm.align = 8 : i64}, {}], isVolatile = false}> : (!llvm.ptr, !llvm.ptr, i32) -> ()645 llvm.return646}647 648// CHECK-LABEL: @memset_test649llvm.func @memset_test(%arg0: i32, %arg2: !llvm.ptr, %arg3: i8) {650 %i1 = llvm.mlir.constant(false) : i1651 // CHECK: call void @llvm.memset.p0.i32(ptr align 8 %{{.*}}, i8 %{{.*}}, i32 %{{.*}}, i1 false652 "llvm.intr.memset"(%arg2, %arg3, %arg0) <{arg_attrs = [{llvm.align = 8 : i64}, {}, {}], isVolatile = false}> : (!llvm.ptr, i8, i32) -> ()653 // CHECK: call void @llvm.memset.inline.p0.i32(ptr align 8 %{{.*}}, i8 %{{.*}}, i32 10, i1 true654 "llvm.intr.memset.inline"(%arg2, %arg3) <{arg_attrs = [{llvm.align = 8 : i64}, {}], isVolatile = true, len = 10 : i32}> : (!llvm.ptr, i8) -> ()655 // CHECK: call void @llvm.memset.inline.p0.i64(ptr %{{.*}}, i8 %{{.*}}, i64 10, i1 true656 "llvm.intr.memset.inline"(%arg2, %arg3) <{isVolatile = true, len = 10 : i64}> : (!llvm.ptr, i8) -> ()657 llvm.return658}659 660// CHECK-LABEL: @sadd_with_overflow_test661llvm.func @sadd_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {662 // CHECK: call { i32, i1 } @llvm.sadd.with.overflow.i32663 "llvm.intr.sadd.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>664 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.sadd.with.overflow.v8i32665 "llvm.intr.sadd.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>666 llvm.return667}668 669// CHECK-LABEL: @uadd_with_overflow_test670llvm.func @uadd_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {671 // CHECK: call { i32, i1 } @llvm.uadd.with.overflow.i32672 "llvm.intr.uadd.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>673 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.uadd.with.overflow.v8i32674 "llvm.intr.uadd.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>675 llvm.return676}677 678// CHECK-LABEL: @ssub_with_overflow_test679llvm.func @ssub_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {680 // CHECK: call { i32, i1 } @llvm.ssub.with.overflow.i32681 "llvm.intr.ssub.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>682 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32683 "llvm.intr.ssub.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>684 llvm.return685}686 687// CHECK-LABEL: @usub_with_overflow_test688llvm.func @usub_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {689 // CHECK: call { i32, i1 } @llvm.usub.with.overflow.i32690 "llvm.intr.usub.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>691 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32692 "llvm.intr.usub.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>693 llvm.return694}695 696// CHECK-LABEL: @smul_with_overflow_test697llvm.func @smul_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {698 // CHECK: call { i32, i1 } @llvm.smul.with.overflow.i32699 "llvm.intr.smul.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>700 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.smul.with.overflow.v8i32701 "llvm.intr.smul.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>702 llvm.return703}704 705// CHECK-LABEL: @umul_with_overflow_test706llvm.func @umul_with_overflow_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {707 // CHECK: call { i32, i1 } @llvm.umul.with.overflow.i32708 "llvm.intr.umul.with.overflow"(%arg0, %arg1) : (i32, i32) -> !llvm.struct<(i32, i1)>709 // CHECK: call { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32710 "llvm.intr.umul.with.overflow"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> !llvm.struct<(vector<8xi32>, vector<8xi1>)>711 llvm.return712}713 714// CHECK-LABEL: @is_constant715llvm.func @is_constant(%arg0: i32) {716 // CHECK: call i1 @llvm.is.constant.i32(i32 %{{.*}})717 %0 = "llvm.intr.is.constant"(%arg0) : (i32) -> i1718 llvm.return719}720 721// CHECK-LABEL: @expect722llvm.func @expect(%arg0: i32) {723 %0 = llvm.mlir.constant(42 : i32) : i32724 // CHECK: call i32 @llvm.expect.i32(i32 %{{.*}}, i32 42)725 %1 = llvm.intr.expect %arg0, %0 : i32726 llvm.return727}728 729// CHECK-LABEL: @expect_with_probability730llvm.func @expect_with_probability(%arg0: i16) {731 %0 = llvm.mlir.constant(42 : i16) : i16732 // CHECK: call i16 @llvm.expect.with.probability.i16(i16 %{{.*}}, i16 42, double 5.000000e-01)733 %1 = llvm.intr.expect.with.probability %arg0, %0, 5.000000e-01 : i16734 llvm.return735}736 737llvm.mlir.global external thread_local @tls_var(0 : i32) {addr_space = 0 : i32, alignment = 4 : i64, dso_local} : i32738 739// CHECK-LABEL: @threadlocal_test740llvm.func @threadlocal_test() {741 // CHECK: call ptr @llvm.threadlocal.address.p0(ptr @tls_var)742 %0 = llvm.mlir.addressof @tls_var : !llvm.ptr743 "llvm.intr.threadlocal.address"(%0) : (!llvm.ptr) -> !llvm.ptr744 llvm.return745}746 747// CHECK-LABEL: @sadd_sat_test748llvm.func @sadd_sat_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {749 // CHECK: call i32 @llvm.sadd.sat.i32750 "llvm.intr.sadd.sat"(%arg0, %arg1) : (i32, i32) -> i32751 // CHECK: call <8 x i32> @llvm.sadd.sat.v8i32752 "llvm.intr.sadd.sat"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>753 llvm.return754}755 756// CHECK-LABEL: @uadd_sat_test757llvm.func @uadd_sat_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {758 // CHECK: call i32 @llvm.uadd.sat.i32759 "llvm.intr.uadd.sat"(%arg0, %arg1) : (i32, i32) -> i32760 // CHECK: call <8 x i32> @llvm.uadd.sat.v8i32761 "llvm.intr.uadd.sat"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>762 llvm.return763}764 765// CHECK-LABEL: @ssub_sat_test766llvm.func @ssub_sat_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {767 // CHECK: call i32 @llvm.ssub.sat.i32768 "llvm.intr.ssub.sat"(%arg0, %arg1) : (i32, i32) -> i32769 // CHECK: call <8 x i32> @llvm.ssub.sat.v8i32770 "llvm.intr.ssub.sat"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>771 llvm.return772}773 774// CHECK-LABEL: @usub_sat_test775llvm.func @usub_sat_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {776 // CHECK: call i32 @llvm.usub.sat.i32777 "llvm.intr.usub.sat"(%arg0, %arg1) : (i32, i32) -> i32778 // CHECK: call <8 x i32> @llvm.usub.sat.v8i32779 "llvm.intr.usub.sat"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>780 llvm.return781}782 783// CHECK-LABEL: @sshl_sat_test784llvm.func @sshl_sat_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {785 // CHECK: call i32 @llvm.sshl.sat.i32786 "llvm.intr.sshl.sat"(%arg0, %arg1) : (i32, i32) -> i32787 // CHECK: call <8 x i32> @llvm.sshl.sat.v8i32788 "llvm.intr.sshl.sat"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>789 llvm.return790}791 792// CHECK-LABEL: @ushl_sat_test793llvm.func @ushl_sat_test(%arg0: i32, %arg1: i32, %arg2: vector<8xi32>, %arg3: vector<8xi32>) {794 // CHECK: call i32 @llvm.ushl.sat.i32795 "llvm.intr.ushl.sat"(%arg0, %arg1) : (i32, i32) -> i32796 // CHECK: call <8 x i32> @llvm.ushl.sat.v8i32797 "llvm.intr.ushl.sat"(%arg2, %arg3) : (vector<8xi32>, vector<8xi32>) -> vector<8xi32>798 llvm.return799}800 801// CHECK-LABEL: @coro_id802llvm.func @coro_id(%arg0: i32, %arg1: !llvm.ptr) {803 // CHECK: call token @llvm.coro.id804 %null = llvm.mlir.zero : !llvm.ptr805 llvm.intr.coro.id %arg0, %arg1, %arg1, %null : (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.token806 llvm.return807}808 809// CHECK-LABEL: @coro_begin810llvm.func @coro_begin(%arg0: i32, %arg1: !llvm.ptr) {811 %null = llvm.mlir.zero : !llvm.ptr812 %token = llvm.intr.coro.id %arg0, %arg1, %arg1, %null : (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.token813 // CHECK: call ptr @llvm.coro.begin814 llvm.intr.coro.begin %token, %arg1 : (!llvm.token, !llvm.ptr) -> !llvm.ptr815 llvm.return816}817 818// CHECK-LABEL: @coro_size819llvm.func @coro_size() {820 // CHECK: call i64 @llvm.coro.size.i64821 %0 = llvm.intr.coro.size : i64822 // CHECK: call i32 @llvm.coro.size.i32823 %1 = llvm.intr.coro.size : i32824 llvm.return825}826 827// CHECK-LABEL: @coro_align828llvm.func @coro_align() {829 // CHECK: call i64 @llvm.coro.align.i64830 %0 = llvm.intr.coro.align : i64831 // CHECK: call i32 @llvm.coro.align.i32832 %1 = llvm.intr.coro.align : i32833 llvm.return834}835 836// CHECK-LABEL: @coro_save837llvm.func @coro_save(%arg0: !llvm.ptr) {838 // CHECK: call token @llvm.coro.save839 %0 = llvm.intr.coro.save %arg0 : (!llvm.ptr) -> !llvm.token840 llvm.return841}842 843// CHECK-LABEL: @coro_suspend844llvm.func @coro_suspend(%arg0: i32, %arg1 : i1, %arg2 : !llvm.ptr) {845 %null = llvm.mlir.zero : !llvm.ptr846 %token = llvm.intr.coro.id %arg0, %arg2, %arg2, %null : (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.token847 // CHECK: call i8 @llvm.coro.suspend848 %0 = llvm.intr.coro.suspend %token, %arg1 : i8849 llvm.return850}851 852// CHECK-LABEL: @coro_end853llvm.func @coro_end(%arg0: !llvm.ptr, %arg1 : i1) {854 %none = llvm.mlir.none : !llvm.token855 // CHECK: call void @llvm.coro.end856 llvm.intr.coro.end %arg0, %arg1, %none : (!llvm.ptr, i1, !llvm.token) -> !llvm.void857 llvm.return858}859 860// CHECK-LABEL: @coro_free861llvm.func @coro_free(%arg0: i32, %arg1 : !llvm.ptr) {862 %null = llvm.mlir.zero : !llvm.ptr863 %token = llvm.intr.coro.id %arg0, %arg1, %arg1, %null : (i32, !llvm.ptr, !llvm.ptr, !llvm.ptr) -> !llvm.token864 // CHECK: call ptr @llvm.coro.free865 %0 = llvm.intr.coro.free %token, %arg1 : (!llvm.token, !llvm.ptr) -> !llvm.ptr866 llvm.return867}868 869// CHECK-LABEL: @coro_resume870llvm.func @coro_resume(%arg0: !llvm.ptr) {871 // CHECK: call void @llvm.coro.resume872 llvm.intr.coro.resume %arg0 : !llvm.ptr873 llvm.return874}875 876// CHECK-LABEL: @coro_promise877llvm.func @coro_promise(%arg0: !llvm.ptr, %arg1 : i32, %arg2 : i1) {878 // CHECK: call ptr @llvm.coro.promise879 %0 = llvm.intr.coro.promise %arg0, %arg1, %arg2 : (!llvm.ptr, i32, i1) -> !llvm.ptr880 llvm.return881}882 883// CHECK-LABEL: @eh_typeid_for884llvm.func @eh_typeid_for(%arg0 : !llvm.ptr) {885 // CHECK: call i32 @llvm.eh.typeid.for.p0886 %0 = llvm.intr.eh.typeid.for %arg0 : (!llvm.ptr) -> i32887 llvm.return888}889 890// CHECK-LABEL: @stack_save891llvm.func @stack_save() {892 // CHECK: call ptr @llvm.stacksave.p0893 %0 = llvm.intr.stacksave : !llvm.ptr894 // CHECK: call ptr addrspace(1) @llvm.stacksave.p1895 %1 = llvm.intr.stacksave : !llvm.ptr<1>896 llvm.return897}898 899// CHECK-LABEL: @stack_restore900llvm.func @stack_restore(%arg0: !llvm.ptr, %arg1: !llvm.ptr<1>) {901 // CHECK: call void @llvm.stackrestore.p0(ptr %{{.}})902 llvm.intr.stackrestore %arg0 : !llvm.ptr903 // CHECK: call void @llvm.stackrestore.p1(ptr addrspace(1) %{{.}})904 llvm.intr.stackrestore %arg1 : !llvm.ptr<1>905 llvm.return906}907 908// CHECK-LABEL: @vector_predication_intrinsics909llvm.func @vector_predication_intrinsics(%A: vector<8xi32>, %B: vector<8xi32>,910 %C: vector<8xf32>, %D: vector<8xf32>,911 %E: vector<8xi64>, %F: vector<8xf64>,912 %G: vector<8 x !llvm.ptr>,913 %i: i32, %f: f32,914 %iptr : !llvm.ptr,915 %fptr : !llvm.ptr,916 %mask: vector<8xi1>, %evl: i32) {917 // CHECK: call <8 x i32> @llvm.vp.add.v8i32918 "llvm.intr.vp.add" (%A, %B, %mask, %evl) :919 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>920 // CHECK: call <8 x i32> @llvm.vp.sub.v8i32921 "llvm.intr.vp.sub" (%A, %B, %mask, %evl) :922 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>923 // CHECK: call <8 x i32> @llvm.vp.mul.v8i32924 "llvm.intr.vp.mul" (%A, %B, %mask, %evl) :925 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>926 // CHECK: call <8 x i32> @llvm.vp.sdiv.v8i32927 "llvm.intr.vp.sdiv" (%A, %B, %mask, %evl) :928 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>929 // CHECK: call <8 x i32> @llvm.vp.udiv.v8i32930 "llvm.intr.vp.udiv" (%A, %B, %mask, %evl) :931 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>932 // CHECK: call <8 x i32> @llvm.vp.srem.v8i32933 "llvm.intr.vp.srem" (%A, %B, %mask, %evl) :934 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>935 // CHECK: call <8 x i32> @llvm.vp.urem.v8i32936 "llvm.intr.vp.urem" (%A, %B, %mask, %evl) :937 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>938 // CHECK: call <8 x i32> @llvm.vp.ashr.v8i32939 "llvm.intr.vp.ashr" (%A, %B, %mask, %evl) :940 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>941 // CHECK: call <8 x i32> @llvm.vp.lshr.v8i32942 "llvm.intr.vp.lshr" (%A, %B, %mask, %evl) :943 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>944 // CHECK: call <8 x i32> @llvm.vp.shl.v8i32945 "llvm.intr.vp.shl" (%A, %B, %mask, %evl) :946 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>947 // CHECK: call <8 x i32> @llvm.vp.or.v8i32948 "llvm.intr.vp.or" (%A, %B, %mask, %evl) :949 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>950 // CHECK: call <8 x i32> @llvm.vp.and.v8i32951 "llvm.intr.vp.and" (%A, %B, %mask, %evl) :952 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>953 // CHECK: call <8 x i32> @llvm.vp.xor.v8i32954 "llvm.intr.vp.xor" (%A, %B, %mask, %evl) :955 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>956 // CHECK: call <8 x i32> @llvm.vp.smax.v8i32957 "llvm.intr.vp.smax" (%A, %B, %mask, %evl) :958 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>959 // CHECK: call <8 x i32> @llvm.vp.smin.v8i32960 "llvm.intr.vp.smin" (%A, %B, %mask, %evl) :961 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>962 // CHECK: call <8 x i32> @llvm.vp.umax.v8i32963 "llvm.intr.vp.umax" (%A, %B, %mask, %evl) :964 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>965 // CHECK: call <8 x i32> @llvm.vp.umin.v8i32966 "llvm.intr.vp.umin" (%A, %B, %mask, %evl) :967 (vector<8xi32>, vector<8xi32>, vector<8xi1>, i32) -> vector<8xi32>968 969 // CHECK: call <8 x float> @llvm.vp.fadd.v8f32970 "llvm.intr.vp.fadd" (%C, %D, %mask, %evl) :971 (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>972 // CHECK: call <8 x float> @llvm.vp.fsub.v8f32973 "llvm.intr.vp.fsub" (%C, %D, %mask, %evl) :974 (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>975 // CHECK: call <8 x float> @llvm.vp.fmul.v8f32976 "llvm.intr.vp.fmul" (%C, %D, %mask, %evl) :977 (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>978 // CHECK: call <8 x float> @llvm.vp.fdiv.v8f32979 "llvm.intr.vp.fdiv" (%C, %D, %mask, %evl) :980 (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>981 // CHECK: call <8 x float> @llvm.vp.frem.v8f32982 "llvm.intr.vp.frem" (%C, %D, %mask, %evl) :983 (vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>984 // CHECK: call <8 x float> @llvm.vp.fneg.v8f32985 "llvm.intr.vp.fneg" (%C, %mask, %evl) :986 (vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>987 // CHECK: call <8 x float> @llvm.vp.fma.v8f32988 "llvm.intr.vp.fma" (%C, %D, %D, %mask, %evl) :989 (vector<8xf32>, vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>990 // CHECK: call <8 x float> @llvm.vp.fmuladd.v8f32991 "llvm.intr.vp.fmuladd" (%C, %D, %D, %mask, %evl) :992 (vector<8xf32>, vector<8xf32>, vector<8xf32>, vector<8xi1>, i32) -> vector<8xf32>993 994 // CHECK: call i32 @llvm.vp.reduce.add.v8i32995 "llvm.intr.vp.reduce.add" (%i, %A, %mask, %evl) :996 (i32, vector<8xi32>, vector<8xi1>, i32) -> i32997 // CHECK: call i32 @llvm.vp.reduce.mul.v8i32998 "llvm.intr.vp.reduce.mul" (%i, %A, %mask, %evl) :999 (i32, vector<8xi32>, vector<8xi1>, i32) -> i321000 // CHECK: call i32 @llvm.vp.reduce.and.v8i321001 "llvm.intr.vp.reduce.and" (%i, %A, %mask, %evl) :1002 (i32, vector<8xi32>, vector<8xi1>, i32) -> i321003 // CHECK: call i32 @llvm.vp.reduce.or.v8i321004 "llvm.intr.vp.reduce.or" (%i, %A, %mask, %evl) :1005 (i32, vector<8xi32>, vector<8xi1>, i32) -> i321006 // CHECK: call i32 @llvm.vp.reduce.xor.v8i321007 "llvm.intr.vp.reduce.xor" (%i, %A, %mask, %evl) :1008 (i32, vector<8xi32>, vector<8xi1>, i32) -> i321009 // CHECK: call i32 @llvm.vp.reduce.smax.v8i321010 "llvm.intr.vp.reduce.smax" (%i, %A, %mask, %evl) :1011 (i32, vector<8xi32>, vector<8xi1>, i32) -> i321012 // CHECK: call i32 @llvm.vp.reduce.smin.v8i321013 "llvm.intr.vp.reduce.smin" (%i, %A, %mask, %evl) :1014 (i32, vector<8xi32>, vector<8xi1>, i32) -> i321015 // CHECK: call i32 @llvm.vp.reduce.umax.v8i321016 "llvm.intr.vp.reduce.umax" (%i, %A, %mask, %evl) :1017 (i32, vector<8xi32>, vector<8xi1>, i32) -> i321018 // CHECK: call i32 @llvm.vp.reduce.umin.v8i321019 "llvm.intr.vp.reduce.umin" (%i, %A, %mask, %evl) :1020 (i32, vector<8xi32>, vector<8xi1>, i32) -> i321021 1022 // CHECK: call float @llvm.vp.reduce.fadd.v8f321023 "llvm.intr.vp.reduce.fadd" (%f, %C, %mask, %evl) :1024 (f32, vector<8xf32>, vector<8xi1>, i32) -> f321025 // CHECK: call float @llvm.vp.reduce.fmul.v8f321026 "llvm.intr.vp.reduce.fmul" (%f, %C, %mask, %evl) :1027 (f32, vector<8xf32>, vector<8xi1>, i32) -> f321028 // CHECK: call float @llvm.vp.reduce.fmax.v8f321029 "llvm.intr.vp.reduce.fmax" (%f, %C, %mask, %evl) :1030 (f32, vector<8xf32>, vector<8xi1>, i32) -> f321031 // CHECK: call float @llvm.vp.reduce.fmin.v8f321032 "llvm.intr.vp.reduce.fmin" (%f, %C, %mask, %evl) :1033 (f32, vector<8xf32>, vector<8xi1>, i32) -> f321034 1035 // CHECK: call <8 x i32> @llvm.vp.select.v8i321036 "llvm.intr.vp.select" (%mask, %A, %B, %evl) :1037 (vector<8xi1>, vector<8xi32>, vector<8xi32>, i32) -> vector<8xi32>1038 // CHECK: call <8 x i32> @llvm.vp.merge.v8i321039 "llvm.intr.vp.merge" (%mask, %A, %B, %evl) :1040 (vector<8xi1>, vector<8xi32>, vector<8xi32>, i32) -> vector<8xi32>1041 1042 // CHECK: call void @llvm.vp.store.v8i32.p01043 "llvm.intr.vp.store" (%A, %iptr, %mask, %evl) :1044 (vector<8xi32>, !llvm.ptr, vector<8xi1>, i32) -> ()1045 // CHECK: call <8 x i32> @llvm.vp.load.v8i32.p01046 "llvm.intr.vp.load" (%iptr, %mask, %evl) :1047 (!llvm.ptr, vector<8xi1>, i32) -> vector<8xi32>1048 // CHECK: call void @llvm.experimental.vp.strided.store.v8i32.p0.i321049 "llvm.intr.experimental.vp.strided.store" (%A, %iptr, %i, %mask, %evl) :1050 (vector<8xi32>, !llvm.ptr, i32, vector<8xi1>, i32) -> ()1051 // CHECK: call <8 x i32> @llvm.experimental.vp.strided.load.v8i32.p0.i321052 "llvm.intr.experimental.vp.strided.load" (%iptr, %i, %mask, %evl) :1053 (!llvm.ptr, i32, vector<8xi1>, i32) -> vector<8xi32>1054 1055 // CHECK: call <8 x i32> @llvm.vp.trunc.v8i32.v8i641056 "llvm.intr.vp.trunc" (%E, %mask, %evl) :1057 (vector<8xi64>, vector<8xi1>, i32) -> vector<8xi32>1058 // CHECK: call <8 x i64> @llvm.vp.zext.v8i64.v8i321059 "llvm.intr.vp.zext" (%A, %mask, %evl) :1060 (vector<8xi32>, vector<8xi1>, i32) -> vector<8xi64>1061 // CHECK: call <8 x i64> @llvm.vp.sext.v8i64.v8i321062 "llvm.intr.vp.sext" (%A, %mask, %evl) :1063 (vector<8xi32>, vector<8xi1>, i32) -> vector<8xi64>1064 1065 // CHECK: call <8 x float> @llvm.vp.fptrunc.v8f32.v8f641066 "llvm.intr.vp.fptrunc" (%F, %mask, %evl) :1067 (vector<8xf64>, vector<8xi1>, i32) -> vector<8xf32>1068 // CHECK: call <8 x double> @llvm.vp.fpext.v8f64.v8f321069 "llvm.intr.vp.fpext" (%C, %mask, %evl) :1070 (vector<8xf32>, vector<8xi1>, i32) -> vector<8xf64>1071 1072 // CHECK: call <8 x i64> @llvm.vp.fptoui.v8i64.v8f641073 "llvm.intr.vp.fptoui" (%F, %mask, %evl) :1074 (vector<8xf64>, vector<8xi1>, i32) -> vector<8xi64>1075 // CHECK: call <8 x i64> @llvm.vp.fptosi.v8i64.v8f641076 "llvm.intr.vp.fptosi" (%F, %mask, %evl) :1077 (vector<8xf64>, vector<8xi1>, i32) -> vector<8xi64>1078 1079 // CHECK: call <8 x i64> @llvm.vp.ptrtoint.v8i64.v8p01080 "llvm.intr.vp.ptrtoint" (%G, %mask, %evl) :1081 (vector<8 x !llvm.ptr>, vector<8xi1>, i32) -> vector<8xi64>1082 // CHECK: call <8 x ptr> @llvm.vp.inttoptr.v8p0.v8i641083 "llvm.intr.vp.inttoptr" (%E, %mask, %evl) :1084 (vector<8xi64>, vector<8xi1>, i32) -> vector<8 x !llvm.ptr>1085 llvm.return1086}1087 1088// CHECK-LABEL: @vector_insert_extract1089llvm.func @vector_insert_extract(%f256: vector<8xi32>, %f128: vector<4xi32>,1090 %sv: vector<[4]xi32>) {1091 // CHECK: call <vscale x 4 x i32> @llvm.vector.insert.nxv4i32.v8i321092 %0 = llvm.intr.vector.insert %f256, %sv[0] :1093 vector<8xi32> into vector<[4]xi32>1094 // CHECK: call <vscale x 4 x i32> @llvm.vector.insert.nxv4i32.v4i321095 %1 = llvm.intr.vector.insert %f128, %sv[0] :1096 vector<4xi32> into vector<[4]xi32>1097 // CHECK: call <vscale x 4 x i32> @llvm.vector.insert.nxv4i32.v4i321098 %2 = llvm.intr.vector.insert %f128, %1[4] :1099 vector<4xi32> into vector<[4]xi32>1100 // CHECK: call <8 x i32> @llvm.vector.insert.v8i32.v4i321101 %3 = llvm.intr.vector.insert %f128, %f256[4] :1102 vector<4xi32> into vector<8xi32>1103 // CHECK: call <8 x i32> @llvm.vector.extract.v8i32.nxv4i321104 %4 = llvm.intr.vector.extract %2[0] :1105 vector<8xi32> from vector<[4]xi32>1106 // CHECK: call <4 x i32> @llvm.vector.extract.v4i32.nxv4i321107 %5 = llvm.intr.vector.extract %2[0] :1108 vector<4xi32> from vector<[4]xi32>1109 // CHECK: call <2 x i32> @llvm.vector.extract.v2i32.v8i321110 %6 = llvm.intr.vector.extract %f256[6] :1111 vector<2xi32> from vector<8xi32>1112 llvm.return1113}1114 1115// CHECK-LABEL: @vector_deinterleave21116llvm.func @vector_deinterleave2(%vec1: vector<4xf64>, %vec2: vector<[8]xi32>) {1117 // CHECK: call { <2 x double>, <2 x double> } @llvm.vector.deinterleave2.v4f64(<4 x double> %{{.*}})1118 %0 = "llvm.intr.vector.deinterleave2" (%vec1) :1119 (vector<4xf64>) -> !llvm.struct<(vector<2xf64>, vector<2xf64>)>1120 // CHECK: call { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.vector.deinterleave2.nxv8i32(<vscale x 8 x i32> %{{.*}})1121 %1 = "llvm.intr.vector.deinterleave2" (%vec2) :1122 (vector<[8]xi32>) -> !llvm.struct<(vector<[4]xi32>, vector<[4]xi32>)>1123 llvm.return1124}1125 1126// CHECK-LABEL: @lifetime1127llvm.func @lifetime() {1128 %c = llvm.mlir.constant(16 : i64) : i641129 %a = llvm.alloca %c x i8 : (i64) -> !llvm.ptr1130 // CHECK: call void @llvm.lifetime.start1131 llvm.intr.lifetime.start %a : !llvm.ptr1132 // CHECK: call void @llvm.lifetime.end1133 llvm.intr.lifetime.end %a : !llvm.ptr1134 llvm.return1135}1136 1137// CHECK-LABEL: @invariant1138llvm.func @invariant(%p: !llvm.ptr) {1139 // CHECK: call ptr @llvm.invariant.start1140 %1 = llvm.intr.invariant.start 16, %p : !llvm.ptr1141 // CHECK: call void @llvm.invariant.end1142 llvm.intr.invariant.end %1, 16, %p : !llvm.ptr1143 llvm.return1144}1145 1146// CHECK-LABEL: @invariant_group1147llvm.func @invariant_group(%p: !llvm.ptr) {1148 // CHECK: call ptr @llvm.launder.invariant.group1149 %1 = llvm.intr.launder.invariant.group %p : !llvm.ptr1150 // CHECK: call ptr @llvm.strip.invariant.group1151 %2 = llvm.intr.strip.invariant.group %p : !llvm.ptr1152 llvm.return1153}1154 1155// CHECK-LABEL: @ssa_copy1156llvm.func @ssa_copy(%arg: f32) -> f32 {1157 // CHECK: call float @llvm.ssa.copy1158 %0 = llvm.intr.ssa.copy %arg : f321159 llvm.return %0 : f321160}1161 1162// CHECK-LABEL: @ptrmask1163llvm.func @ptrmask(%p: !llvm.ptr, %mask: i64) -> !llvm.ptr {1164 // CHECK: call ptr @llvm.ptrmask.p0.i641165 %0 = llvm.intr.ptrmask %p, %mask : (!llvm.ptr, i64) -> !llvm.ptr1166 llvm.return %0 : !llvm.ptr1167}1168 1169llvm.func @vector_ptrmask(%p: vector<8 x !llvm.ptr>, %mask: vector<8 x i64>) -> vector<8 x !llvm.ptr> {1170 // CHECK: call <8 x ptr> @llvm.ptrmask.v8p0.v8i641171 %0 = llvm.intr.ptrmask %p, %mask : (vector<8 x !llvm.ptr>, vector<8 x i64>) -> vector<8 x !llvm.ptr>1172 llvm.return %0 : vector<8 x !llvm.ptr>1173}1174 1175// CHECK-LABEL: @experimental_constrained_uitofp1176llvm.func @experimental_constrained_uitofp(%s: i32, %v: vector<4 x i32>) {1177 // CHECK: call float @llvm.experimental.constrained.uitofp.f32.i32(1178 // CHECK: metadata !"round.towardzero"1179 // CHECK: metadata !"fpexcept.ignore"1180 %0 = llvm.intr.experimental.constrained.uitofp %s towardzero ignore : i32 to f321181 // CHECK: call float @llvm.experimental.constrained.uitofp.f32.i32(1182 // CHECK: metadata !"round.tonearest"1183 // CHECK: metadata !"fpexcept.maytrap"1184 %1 = llvm.intr.experimental.constrained.uitofp %s tonearest maytrap : i32 to f321185 // CHECK: call float @llvm.experimental.constrained.uitofp.f32.i32(1186 // CHECK: metadata !"round.upward"1187 // CHECK: metadata !"fpexcept.strict"1188 %2 = llvm.intr.experimental.constrained.uitofp %s upward strict : i32 to f321189 // CHECK: call float @llvm.experimental.constrained.uitofp.f32.i32(1190 // CHECK: metadata !"round.downward"1191 // CHECK: metadata !"fpexcept.ignore"1192 %3 = llvm.intr.experimental.constrained.uitofp %s downward ignore : i32 to f321193 // CHECK: call float @llvm.experimental.constrained.uitofp.f32.i32(1194 // CHECK: metadata !"round.tonearestaway"1195 // CHECK: metadata !"fpexcept.ignore"1196 %4 = llvm.intr.experimental.constrained.uitofp %s tonearestaway ignore : i32 to f321197 // CHECK: call <4 x float> @llvm.experimental.constrained.uitofp.v4f32.v4i32(1198 // CHECK: metadata !"round.upward"1199 // CHECK: metadata !"fpexcept.strict"1200 %5 = llvm.intr.experimental.constrained.uitofp %v upward strict : vector<4 x i32> to vector<4 x f32>1201 llvm.return1202}1203 1204// CHECK-LABEL: @experimental_constrained_sitofp1205llvm.func @experimental_constrained_sitofp(%s: i32, %v: vector<4 x i32>) {1206 // CHECK: call float @llvm.experimental.constrained.sitofp.f32.i32(1207 // CHECK: metadata !"round.towardzero"1208 // CHECK: metadata !"fpexcept.ignore"1209 %0 = llvm.intr.experimental.constrained.sitofp %s towardzero ignore : i32 to f321210 // CHECK: call float @llvm.experimental.constrained.sitofp.f32.i32(1211 // CHECK: metadata !"round.tonearest"1212 // CHECK: metadata !"fpexcept.maytrap"1213 %1 = llvm.intr.experimental.constrained.sitofp %s tonearest maytrap : i32 to f321214 // CHECK: call float @llvm.experimental.constrained.sitofp.f32.i32(1215 // CHECK: metadata !"round.upward"1216 // CHECK: metadata !"fpexcept.strict"1217 %2 = llvm.intr.experimental.constrained.sitofp %s upward strict : i32 to f321218 // CHECK: call float @llvm.experimental.constrained.sitofp.f32.i32(1219 // CHECK: metadata !"round.downward"1220 // CHECK: metadata !"fpexcept.ignore"1221 %3 = llvm.intr.experimental.constrained.sitofp %s downward ignore : i32 to f321222 // CHECK: call float @llvm.experimental.constrained.sitofp.f32.i32(1223 // CHECK: metadata !"round.tonearestaway"1224 // CHECK: metadata !"fpexcept.ignore"1225 %4 = llvm.intr.experimental.constrained.sitofp %s tonearestaway ignore : i32 to f321226 // CHECK: call <4 x float> @llvm.experimental.constrained.sitofp.v4f32.v4i32(1227 // CHECK: metadata !"round.upward"1228 // CHECK: metadata !"fpexcept.strict"1229 %5 = llvm.intr.experimental.constrained.sitofp %v upward strict : vector<4 x i32> to vector<4 x f32>1230 llvm.return1231}1232 1233// CHECK-LABEL: @experimental_constrained_fptrunc1234llvm.func @experimental_constrained_fptrunc(%s: f64, %v: vector<4xf32>) {1235 // CHECK: call float @llvm.experimental.constrained.fptrunc.f32.f64(1236 // CHECK: metadata !"round.towardzero"1237 // CHECK: metadata !"fpexcept.ignore"1238 %0 = llvm.intr.experimental.constrained.fptrunc %s towardzero ignore : f64 to f321239 // CHECK: call float @llvm.experimental.constrained.fptrunc.f32.f64(1240 // CHECK: metadata !"round.tonearest"1241 // CHECK: metadata !"fpexcept.maytrap"1242 %1 = llvm.intr.experimental.constrained.fptrunc %s tonearest maytrap : f64 to f321243 // CHECK: call float @llvm.experimental.constrained.fptrunc.f32.f64(1244 // CHECK: metadata !"round.upward"1245 // CHECK: metadata !"fpexcept.strict"1246 %2 = llvm.intr.experimental.constrained.fptrunc %s upward strict : f64 to f321247 // CHECK: call float @llvm.experimental.constrained.fptrunc.f32.f64(1248 // CHECK: metadata !"round.downward"1249 // CHECK: metadata !"fpexcept.ignore"1250 %3 = llvm.intr.experimental.constrained.fptrunc %s downward ignore : f64 to f321251 // CHECK: call float @llvm.experimental.constrained.fptrunc.f32.f64(1252 // CHECK: metadata !"round.tonearestaway"1253 // CHECK: metadata !"fpexcept.ignore"1254 %4 = llvm.intr.experimental.constrained.fptrunc %s tonearestaway ignore : f64 to f321255 // CHECK: call <4 x half> @llvm.experimental.constrained.fptrunc.v4f16.v4f32(1256 // CHECK: metadata !"round.upward"1257 // CHECK: metadata !"fpexcept.strict"1258 %5 = llvm.intr.experimental.constrained.fptrunc %v upward strict : vector<4xf32> to vector<4xf16>1259 llvm.return1260}1261 1262// CHECK-LABEL: @experimental_constrained_fpext1263llvm.func @experimental_constrained_fpext(%s: f32, %v: vector<4xf32>) {1264 // CHECK: call double @llvm.experimental.constrained.fpext.f64.f32(1265 // CHECK: metadata !"fpexcept.ignore"1266 %0 = llvm.intr.experimental.constrained.fpext %s ignore : f32 to f641267 // CHECK: call double @llvm.experimental.constrained.fpext.f64.f32(1268 // CHECK: metadata !"fpexcept.maytrap"1269 %1 = llvm.intr.experimental.constrained.fpext %s maytrap : f32 to f641270 // CHECK: call double @llvm.experimental.constrained.fpext.f64.f32(1271 // CHECK: metadata !"fpexcept.strict"1272 %2 = llvm.intr.experimental.constrained.fpext %s strict : f32 to f641273 // CHECK: call <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(1274 // CHECK: metadata !"fpexcept.strict"1275 %5 = llvm.intr.experimental.constrained.fpext %v strict : vector<4xf32> to vector<4xf64>1276 llvm.return1277}1278 1279// CHECK-LABEL: @ucmp1280llvm.func @ucmp(%a: i32, %b: i32) -> i2 {1281 // CHECK: call i2 @llvm.ucmp.i2.i321282 %r = llvm.intr.ucmp(%a, %b) : (i32, i32) -> i21283 llvm.return %r : i21284}1285 1286// CHECK-LABEL: @vector_ucmp1287llvm.func @vector_ucmp(%a: vector<4 x i32>, %b: vector<4 x i32>) -> vector<4 x i32> {1288 // CHECK: call <4 x i32> @llvm.ucmp.v4i32.v4i321289 %0 = llvm.intr.ucmp(%a, %b) : (vector<4 x i32>, vector<4 x i32>) -> vector<4 x i32>1290 llvm.return %0 : vector<4 x i32>1291}1292 1293// CHECK-LABEL: @scmp1294llvm.func @scmp(%a: i32, %b: i32) -> i2 {1295 // CHECK: call i2 @llvm.scmp.i2.i321296 %r = llvm.intr.scmp(%a, %b) : (i32, i32) -> i21297 llvm.return %r : i21298}1299 1300// CHECK-LABEL: @vector_scmp1301llvm.func @vector_scmp(%a: vector<4 x i32>, %b: vector<4 x i32>) -> vector<4 x i32> {1302 // CHECK: call <4 x i32> @llvm.scmp.v4i32.v4i321303 %0 = llvm.intr.scmp(%a, %b) : (vector<4 x i32>, vector<4 x i32>) -> vector<4 x i32>1304 llvm.return %0 : vector<4 x i32>1305}1306 1307// Check that intrinsics are declared with appropriate types.1308// CHECK-DAG: declare float @llvm.fma.f32(float, float, float)1309// CHECK-DAG: declare <8 x float> @llvm.fma.v8f32(<8 x float>, <8 x float>, <8 x float>) #01310// CHECK-DAG: declare float @llvm.fmuladd.f32(float, float, float)1311// CHECK-DAG: declare <8 x float> @llvm.fmuladd.v8f32(<8 x float>, <8 x float>, <8 x float>) #01312// CHECK-DAG: declare void @llvm.prefetch.p0(ptr readonly captures(none), i32 immarg, i32 immarg, i32 immarg)1313// CHECK-DAG: declare i1 @llvm.is.fpclass.f32(float, i32 immarg)1314// CHECK-DAG: declare float @llvm.exp.f32(float)1315// CHECK-DAG: declare <8 x float> @llvm.exp.v8f32(<8 x float>) #01316// CHECK-DAG: declare float @llvm.exp2.f32(float)1317// CHECK-DAG: declare <8 x float> @llvm.exp2.v8f32(<8 x float>)1318// CHECK-DAG: declare float @llvm.exp10.f32(float)1319// CHECK-DAG: declare <8 x float> @llvm.exp10.v8f32(<8 x float>)1320// CHECK-DAG: declare float @llvm.ldexp.f32.i32(float, i32)1321// CHECK-DAG: declare <8 x float> @llvm.ldexp.v8f32.i32(<8 x float>, i32)1322// CHECK-DAG: declare { float, i32 } @llvm.frexp.f32.i32(float)1323// CHECK-DAG: declare { <8 x float>, i32 } @llvm.frexp.v8f32.i32(<8 x float>)1324// CHECK-DAG: declare float @llvm.log.f32(float)1325// CHECK-DAG: declare <8 x float> @llvm.log.v8f32(<8 x float>) #01326// CHECK-DAG: declare float @llvm.log10.f32(float)1327// CHECK-DAG: declare <8 x float> @llvm.log10.v8f32(<8 x float>) #01328// CHECK-DAG: declare float @llvm.log2.f32(float)1329// CHECK-DAG: declare <8 x float> @llvm.log2.v8f32(<8 x float>) #01330// CHECK-DAG: declare float @llvm.fabs.f32(float)1331// CHECK-DAG: declare <8 x float> @llvm.fabs.v8f32(<8 x float>) #01332// CHECK-DAG: declare float @llvm.sqrt.f32(float)1333// CHECK-DAG: declare <8 x float> @llvm.sqrt.v8f32(<8 x float>) #01334// CHECK-DAG: declare float @llvm.ceil.f32(float)1335// CHECK-DAG: declare <8 x float> @llvm.ceil.v8f32(<8 x float>) #01336// CHECK-DAG: declare float @llvm.cos.f32(float)1337// CHECK-DAG: declare <8 x float> @llvm.cos.v8f32(<8 x float>) #01338// CHECK-DAG: declare { float, float } @llvm.sincos.f32(float)1339// CHECK-DAG: declare { <8 x float>, <8 x float> } @llvm.sincos.v8f32(<8 x float>)1340// CHECK-DAG: declare float @llvm.copysign.f32(float, float)1341// CHECK-DAG: declare float @llvm.rint.f32(float)1342// CHECK-DAG: declare double @llvm.rint.f64(double)1343// CHECK-DAG: declare <8 x float> @llvm.rint.v8f32(<8 x float>)1344// CHECK-DAG: declare <8 x double> @llvm.rint.v8f64(<8 x double>)1345// CHECK-DAG: declare float @llvm.nearbyint.f32(float)1346// CHECK-DAG: declare double @llvm.nearbyint.f64(double)1347// CHECK-DAG: declare <8 x float> @llvm.nearbyint.v8f32(<8 x float>)1348// CHECK-DAG: declare <8 x double> @llvm.nearbyint.v8f64(<8 x double>)1349// CHECK-DAG: declare i32 @llvm.lround.i32.f32(float)1350// CHECK-DAG: declare i64 @llvm.lround.i64.f32(float)1351// CHECK-DAG: declare i32 @llvm.lround.i32.f64(double)1352// CHECK-DAG: declare i64 @llvm.lround.i64.f64(double)1353// CHECK-DAG: declare i64 @llvm.llround.i64.f32(float)1354// CHECK-DAG: declare i64 @llvm.llround.i64.f64(double)1355// CHECK-DAG: declare i32 @llvm.lrint.i32.f32(float)1356// CHECK-DAG: declare i64 @llvm.lrint.i64.f32(float)1357// CHECK-DAG: declare i32 @llvm.lrint.i32.f64(double)1358// CHECK-DAG: declare i64 @llvm.lrint.i64.f64(double)1359// CHECK-DAG: declare i64 @llvm.llrint.i64.f32(float)1360// CHECK-DAG: declare i64 @llvm.llrint.i64.f64(double)1361// CHECK-DAG: declare <12 x float> @llvm.matrix.multiply.v12f32.v64f32.v48f32(<64 x float>, <48 x float>, i32 immarg, i32 immarg, i32 immarg)1362// CHECK-DAG: declare <48 x float> @llvm.matrix.transpose.v48f32(<48 x float>, i32 immarg, i32 immarg)1363// CHECK-DAG: declare <48 x float> @llvm.matrix.column.major.load.v48f32.i64(ptr captures(none), i64, i1 immarg, i32 immarg, i32 immarg)1364// CHECK-DAG: declare void @llvm.matrix.column.major.store.v48f32.i64(<48 x float>, ptr writeonly captures(none), i64, i1 immarg, i32 immarg, i32 immarg)1365// CHECK-DAG: declare <7 x i1> @llvm.get.active.lane.mask.v7i1.i64(i64, i64)1366// CHECK-DAG: declare <7 x float> @llvm.masked.load.v7f32.p0(ptr captures(none), <7 x i1>, <7 x float>)1367// CHECK-DAG: declare void @llvm.masked.store.v7f32.p0(<7 x float>, ptr captures(none), <7 x i1>)1368// CHECK-DAG: declare <7 x float> @llvm.masked.gather.v7f32.v7p0(<7 x ptr>, <7 x i1>, <7 x float>)1369// CHECK-DAG: declare void @llvm.masked.scatter.v7f32.v7p0(<7 x float>, <7 x ptr>, <7 x i1>)1370// CHECK-DAG: declare <7 x float> @llvm.masked.expandload.v7f32(ptr captures(none), <7 x i1>, <7 x float>)1371// CHECK-DAG: declare void @llvm.masked.compressstore.v7f32(<7 x float>, ptr captures(none), <7 x i1>)1372// CHECK-DAG: declare void @llvm.var.annotation.p0.p0(ptr, ptr, ptr, i32, ptr)1373// CHECK-DAG: declare ptr @llvm.ptr.annotation.p0.p0(ptr, ptr, ptr, i32, ptr)1374// CHECK-DAG: declare i16 @llvm.annotation.i16.p0(i16, ptr, ptr, i32)1375// CHECK-DAG: declare void @llvm.trap()1376// CHECK-DAG: declare void @llvm.debugtrap()1377// CHECK-DAG: declare void @llvm.ubsantrap(i8 immarg)1378// CHECK-DAG: declare void @llvm.memcpy.p0.p0.i32(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i32, i1 immarg)1379// CHECK-DAG: declare void @llvm.memcpy.inline.p0.p0.i32(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i32, i1 immarg)1380// CHECK-DAG: declare void @llvm.memcpy.inline.p0.p0.i64(ptr noalias writeonly captures(none), ptr noalias readonly captures(none), i64, i1 immarg)1381// CHECK-DAG: declare { i32, i1 } @llvm.sadd.with.overflow.i32(i32, i32)1382// CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.sadd.with.overflow.v8i32(<8 x i32>, <8 x i32>)1383// CHECK-DAG: declare { i32, i1 } @llvm.uadd.with.overflow.i32(i32, i32)1384// CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.uadd.with.overflow.v8i32(<8 x i32>, <8 x i32>)1385// CHECK-DAG: declare { i32, i1 } @llvm.ssub.with.overflow.i32(i32, i32)1386// CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.ssub.with.overflow.v8i32(<8 x i32>, <8 x i32>)1387// CHECK-DAG: declare { i32, i1 } @llvm.usub.with.overflow.i32(i32, i32)1388// CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.usub.with.overflow.v8i32(<8 x i32>, <8 x i32>)1389// CHECK-DAG: declare { i32, i1 } @llvm.umul.with.overflow.i32(i32, i32)1390// CHECK-DAG: declare { <8 x i32>, <8 x i1> } @llvm.umul.with.overflow.v8i32(<8 x i32>, <8 x i32>)1391// CHECK-DAG: declare i32 @llvm.sadd.sat.i32(i32, i32)1392// CHECK-DAG: declare <8 x i32> @llvm.sadd.sat.v8i32(<8 x i32>, <8 x i32>)1393// CHECK-DAG: declare i32 @llvm.uadd.sat.i32(i32, i32)1394// CHECK-DAG: declare <8 x i32> @llvm.uadd.sat.v8i32(<8 x i32>, <8 x i32>)1395// CHECK-DAG: declare i32 @llvm.ssub.sat.i32(i32, i32)1396// CHECK-DAG: declare <8 x i32> @llvm.ssub.sat.v8i32(<8 x i32>, <8 x i32>)1397// CHECK-DAG: declare i32 @llvm.usub.sat.i32(i32, i32)1398// CHECK-DAG: declare <8 x i32> @llvm.usub.sat.v8i32(<8 x i32>, <8 x i32>)1399// CHECK-DAG: declare i32 @llvm.sshl.sat.i32(i32, i32)1400// CHECK-DAG: declare <8 x i32> @llvm.sshl.sat.v8i32(<8 x i32>, <8 x i32>)1401// CHECK-DAG: declare i32 @llvm.ushl.sat.i32(i32, i32)1402// CHECK-DAG: declare <8 x i32> @llvm.ushl.sat.v8i32(<8 x i32>, <8 x i32>)1403// CHECK-DAG: declare i1 @llvm.is.constant.i32(i32)1404// CHECK-DAG: declare i32 @llvm.expect.i32(i32, i32)1405// CHECK-DAG: declare i16 @llvm.expect.with.probability.i16(i16, i16, double immarg)1406// CHECK-DAG: declare nonnull ptr @llvm.threadlocal.address.p0(ptr nonnull)1407// CHECK-DAG: declare token @llvm.coro.id(i32, ptr readnone, ptr readonly captures(none), ptr)1408// CHECK-DAG: declare ptr @llvm.coro.begin(token, ptr writeonly)1409// CHECK-DAG: declare i64 @llvm.coro.size.i64()1410// CHECK-DAG: declare i32 @llvm.coro.size.i32()1411// CHECK-DAG: declare token @llvm.coro.save(ptr)1412// CHECK-DAG: declare i8 @llvm.coro.suspend(token, i1)1413// CHECK-DAG: declare void @llvm.coro.end(ptr, i1, token)1414// CHECK-DAG: declare ptr @llvm.coro.free(token, ptr readonly captures(none))1415// CHECK-DAG: declare void @llvm.coro.resume(ptr)1416// CHECK-DAG: declare ptr @llvm.coro.promise(ptr captures(none), i32, i1)1417// CHECK-DAG: declare <8 x i32> @llvm.vp.add.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1418// CHECK-DAG: declare <8 x i32> @llvm.vp.sub.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1419// CHECK-DAG: declare <8 x i32> @llvm.vp.mul.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1420// CHECK-DAG: declare <8 x i32> @llvm.vp.sdiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1421// CHECK-DAG: declare <8 x i32> @llvm.vp.udiv.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1422// CHECK-DAG: declare <8 x i32> @llvm.vp.srem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1423// CHECK-DAG: declare <8 x i32> @llvm.vp.urem.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1424// CHECK-DAG: declare <8 x i32> @llvm.vp.ashr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1425// CHECK-DAG: declare <8 x i32> @llvm.vp.lshr.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1426// CHECK-DAG: declare <8 x i32> @llvm.vp.shl.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1427// CHECK-DAG: declare <8 x i32> @llvm.vp.or.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1428// CHECK-DAG: declare <8 x i32> @llvm.vp.and.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1429// CHECK-DAG: declare <8 x i32> @llvm.vp.xor.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1430// CHECK-DAG: declare <8 x i32> @llvm.vp.smax.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1431// CHECK-DAG: declare <8 x i32> @llvm.vp.smin.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1432// CHECK-DAG: declare <8 x i32> @llvm.vp.umax.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1433// CHECK-DAG: declare <8 x i32> @llvm.vp.umin.v8i32(<8 x i32>, <8 x i32>, <8 x i1>, i32)1434// CHECK-DAG: declare <8 x float> @llvm.vp.fadd.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1435// CHECK-DAG: declare <8 x float> @llvm.vp.fsub.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1436// CHECK-DAG: declare <8 x float> @llvm.vp.fmul.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1437// CHECK-DAG: declare <8 x float> @llvm.vp.fdiv.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1438// CHECK-DAG: declare <8 x float> @llvm.vp.frem.v8f32(<8 x float>, <8 x float>, <8 x i1>, i32)1439// CHECK-DAG: declare <8 x float> @llvm.vp.fneg.v8f32(<8 x float>, <8 x i1>, i32)1440// CHECK-DAG: declare <8 x float> @llvm.vp.fma.v8f32(<8 x float>, <8 x float>, <8 x float>, <8 x i1>, i32)1441// CHECK-DAG: declare i32 @llvm.vp.reduce.add.v8i32(i32, <8 x i32>, <8 x i1>, i32)1442// CHECK-DAG: declare i32 @llvm.vp.reduce.mul.v8i32(i32, <8 x i32>, <8 x i1>, i32)1443// CHECK-DAG: declare i32 @llvm.vp.reduce.and.v8i32(i32, <8 x i32>, <8 x i1>, i32)1444// CHECK-DAG: declare i32 @llvm.vp.reduce.or.v8i32(i32, <8 x i32>, <8 x i1>, i32)1445// CHECK-DAG: declare i32 @llvm.vp.reduce.xor.v8i32(i32, <8 x i32>, <8 x i1>, i32)1446// CHECK-DAG: declare i32 @llvm.vp.reduce.smax.v8i32(i32, <8 x i32>, <8 x i1>, i32)1447// CHECK-DAG: declare i32 @llvm.vp.reduce.smin.v8i32(i32, <8 x i32>, <8 x i1>, i32)1448// CHECK-DAG: declare i32 @llvm.vp.reduce.umax.v8i32(i32, <8 x i32>, <8 x i1>, i32)1449// CHECK-DAG: declare i32 @llvm.vp.reduce.umin.v8i32(i32, <8 x i32>, <8 x i1>, i32)1450// CHECK-DAG: declare float @llvm.vp.reduce.fadd.v8f32(float, <8 x float>, <8 x i1>, i32)1451// CHECK-DAG: declare float @llvm.vp.reduce.fmul.v8f32(float, <8 x float>, <8 x i1>, i32)1452// CHECK-DAG: declare float @llvm.vp.reduce.fmax.v8f32(float, <8 x float>, <8 x i1>, i32)1453// CHECK-DAG: declare float @llvm.vp.reduce.fmin.v8f32(float, <8 x float>, <8 x i1>, i32)1454// CHECK-DAG: declare <8 x i32> @llvm.vp.select.v8i32(<8 x i1>, <8 x i32>, <8 x i32>, i32)1455// CHECK-DAG: declare <8 x i32> @llvm.vp.merge.v8i32(<8 x i1>, <8 x i32>, <8 x i32>, i32)1456// CHECK-DAG: declare void @llvm.experimental.vp.strided.store.v8i32.p0.i32(<8 x i32>, ptr captures(none), i32, <8 x i1>, i32)1457// CHECK-DAG: declare <8 x i32> @llvm.experimental.vp.strided.load.v8i32.p0.i32(ptr captures(none), i32, <8 x i1>, i32)1458// CHECK-DAG: declare <8 x i32> @llvm.vp.trunc.v8i32.v8i64(<8 x i64>, <8 x i1>, i32)1459// CHECK-DAG: declare <8 x i64> @llvm.vp.zext.v8i64.v8i32(<8 x i32>, <8 x i1>, i32)1460// CHECK-DAG: declare <8 x i64> @llvm.vp.sext.v8i64.v8i32(<8 x i32>, <8 x i1>, i32)1461// CHECK-DAG: declare <8 x float> @llvm.vp.fptrunc.v8f32.v8f64(<8 x double>, <8 x i1>, i32)1462// CHECK-DAG: declare <8 x double> @llvm.vp.fpext.v8f64.v8f32(<8 x float>, <8 x i1>, i32)1463// CHECK-DAG: declare <8 x i64> @llvm.vp.fptoui.v8i64.v8f64(<8 x double>, <8 x i1>, i32)1464// CHECK-DAG: declare <8 x i64> @llvm.vp.fptosi.v8i64.v8f64(<8 x double>, <8 x i1>, i32)1465// CHECK-DAG: declare <8 x i64> @llvm.vp.ptrtoint.v8i64.v8p0(<8 x ptr>, <8 x i1>, i32)1466// CHECK-DAG: declare <8 x ptr> @llvm.vp.inttoptr.v8p0.v8i64(<8 x i64>, <8 x i1>, i32)1467// CHECK-DAG: declare <vscale x 4 x i32> @llvm.vector.insert.nxv4i32.v8i32(<vscale x 4 x i32>, <8 x i32>, i64 immarg)1468// CHECK-DAG: declare <vscale x 4 x i32> @llvm.vector.insert.nxv4i32.v4i32(<vscale x 4 x i32>, <4 x i32>, i64 immarg)1469// CHECK-DAG: declare <8 x i32> @llvm.vector.insert.v8i32.v4i32(<8 x i32>, <4 x i32>, i64 immarg)1470// CHECK-DAG: declare <8 x i32> @llvm.vector.extract.v8i32.nxv4i32(<vscale x 4 x i32>, i64 immarg)1471// CHECK-DAG: declare <4 x i32> @llvm.vector.extract.v4i32.nxv4i32(<vscale x 4 x i32>, i64 immarg)1472// CHECK-DAG: declare <2 x i32> @llvm.vector.extract.v2i32.v8i32(<8 x i32>, i64 immarg)1473// CHECK-DAG: declare { <2 x double>, <2 x double> } @llvm.vector.deinterleave2.v4f64(<4 x double>)1474// CHECK-DAG: declare { <vscale x 4 x i32>, <vscale x 4 x i32> } @llvm.vector.deinterleave2.nxv8i32(<vscale x 8 x i32>)1475// CHECK-DAG: declare void @llvm.lifetime.start.p0(ptr captures(none))1476// CHECK-DAG: declare void @llvm.lifetime.end.p0(ptr captures(none))1477// CHECK-DAG: declare ptr @llvm.invariant.start.p0(i64 immarg, ptr captures(none))1478// CHECK-DAG: declare void @llvm.invariant.end.p0(ptr, i64 immarg, ptr captures(none))1479 1480// CHECK-DAG: declare float @llvm.ssa.copy.f32(float returned)1481// CHECK-DAG: declare ptr @llvm.ptrmask.p0.i64(ptr, i64)1482// CHECK-DAG: declare <8 x ptr> @llvm.ptrmask.v8p0.v8i64(<8 x ptr>, <8 x i64>)1483// CHECK-DAG: declare ptr @llvm.stacksave.p0()1484// CHECK-DAG: declare ptr addrspace(1) @llvm.stacksave.p1()1485// CHECK-DAG: declare void @llvm.stackrestore.p0(ptr)1486// CHECK-DAG: declare void @llvm.stackrestore.p1(ptr addrspace(1))1487// CHECK-DAG: declare float @llvm.experimental.constrained.uitofp.f32.i32(i32, metadata, metadata)1488// CHECK-DAG: declare <4 x float> @llvm.experimental.constrained.uitofp.v4f32.v4i32(<4 x i32>, metadata, metadata)1489// CHECK-DAG: declare float @llvm.experimental.constrained.sitofp.f32.i32(i32, metadata, metadata)1490// CHECK-DAG: declare <4 x float> @llvm.experimental.constrained.sitofp.v4f32.v4i32(<4 x i32>, metadata, metadata)1491// CHECK-DAG: declare float @llvm.experimental.constrained.fptrunc.f32.f64(double, metadata, metadata)1492// CHECK-DAG: declare <4 x half> @llvm.experimental.constrained.fptrunc.v4f16.v4f32(<4 x float>, metadata, metadata)1493// CHECK-DAG: declare double @llvm.experimental.constrained.fpext.f64.f32(float, metadata)1494// CHECK-DAG: declare <4 x double> @llvm.experimental.constrained.fpext.v4f64.v4f32(<4 x float>, metadata)1495// CHECK-DAG: declare range(i2 -1, -2) i2 @llvm.ucmp.i2.i32(i32, i32)1496// CHECK-DAG: declare range(i32 -1, 2) <4 x i32> @llvm.ucmp.v4i32.v4i32(<4 x i32>, <4 x i32>)1497// CHECK-DAG: declare range(i2 -1, -2) i2 @llvm.scmp.i2.i32(i32, i32)1498// CHECK-DAG: declare range(i32 -1, 2) <4 x i32> @llvm.scmp.v4i32.v4i32(<4 x i32>, <4 x i32>)1499