1; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+simd128 | FileCheck %s 2; RUN: llc < %s -asm-verbose=false -verify-machineinstrs -disable-wasm-fallthrough-return-opt -wasm-disable-explicit-locals -wasm-keep-registers -mattr=+simd128 -fast-isel | FileCheck %s 3 4; Test that SIMD128 intrinsics lower as expected. These intrinsics are 5; only expected to lower successfully if the simd128 attribute is 6; enabled and legal types are used. 7 8target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128" 9target triple = "wasm32-unknown-unknown" 10 11; ============================================================================== 12; 16 x i8 13; ============================================================================== 14; CHECK-LABEL: swizzle_v16i8: 15; CHECK-NEXT: .functype swizzle_v16i8 (v128, v128) -> (v128){{$}} 16; CHECK-NEXT: i8x16.swizzle $push[[R:[0-9]+]]=, $0, $1{{$}} 17; CHECK-NEXT: return $pop[[R]]{{$}} 18declare <16 x i8> @llvm.wasm.swizzle(<16 x i8>, <16 x i8>) 19define <16 x i8> @swizzle_v16i8(<16 x i8> %x, <16 x i8> %y) { 20 %a = call <16 x i8> @llvm.wasm.swizzle(<16 x i8> %x, <16 x i8> %y) 21 ret <16 x i8> %a 22} 23 24; CHECK-LABEL: add_sat_s_v16i8: 25; CHECK-NEXT: .functype add_sat_s_v16i8 (v128, v128) -> (v128){{$}} 26; CHECK-NEXT: i8x16.add_sat_s $push[[R:[0-9]+]]=, $0, $1{{$}} 27; CHECK-NEXT: return $pop[[R]]{{$}} 28declare <16 x i8> @llvm.sadd.sat.v16i8(<16 x i8>, <16 x i8>) 29define <16 x i8> @add_sat_s_v16i8(<16 x i8> %x, <16 x i8> %y) { 30 %a = call <16 x i8> @llvm.sadd.sat.v16i8(<16 x i8> %x, <16 x i8> %y) 31 ret <16 x i8> %a 32} 33 34; CHECK-LABEL: add_sat_u_v16i8: 35; CHECK-NEXT: .functype add_sat_u_v16i8 (v128, v128) -> (v128){{$}} 36; CHECK-NEXT: i8x16.add_sat_u $push[[R:[0-9]+]]=, $0, $1{{$}} 37; CHECK-NEXT: return $pop[[R]]{{$}} 38declare <16 x i8> @llvm.uadd.sat.v16i8(<16 x i8>, <16 x i8>) 39define <16 x i8> @add_sat_u_v16i8(<16 x i8> %x, <16 x i8> %y) { 40 %a = call <16 x i8> @llvm.uadd.sat.v16i8(<16 x i8> %x, <16 x i8> %y) 41 ret <16 x i8> %a 42} 43 44; CHECK-LABEL: sub_sat_s_v16i8: 45; CHECK-NEXT: .functype sub_sat_s_v16i8 (v128, v128) -> (v128){{$}} 46; CHECK-NEXT: i8x16.sub_sat_s $push[[R:[0-9]+]]=, $0, $1{{$}} 47; CHECK-NEXT: return $pop[[R]]{{$}} 48declare <16 x i8> @llvm.wasm.sub.sat.signed.v16i8(<16 x i8>, <16 x i8>) 49define <16 x i8> @sub_sat_s_v16i8(<16 x i8> %x, <16 x i8> %y) { 50 %a = call <16 x i8> @llvm.wasm.sub.sat.signed.v16i8( 51 <16 x i8> %x, <16 x i8> %y 52 ) 53 ret <16 x i8> %a 54} 55 56; CHECK-LABEL: sub_sat_u_v16i8: 57; CHECK-NEXT: .functype sub_sat_u_v16i8 (v128, v128) -> (v128){{$}} 58; CHECK-NEXT: i8x16.sub_sat_u $push[[R:[0-9]+]]=, $0, $1{{$}} 59; CHECK-NEXT: return $pop[[R]]{{$}} 60declare <16 x i8> @llvm.wasm.sub.sat.unsigned.v16i8(<16 x i8>, <16 x i8>) 61define <16 x i8> @sub_sat_u_v16i8(<16 x i8> %x, <16 x i8> %y) { 62 %a = call <16 x i8> @llvm.wasm.sub.sat.unsigned.v16i8( 63 <16 x i8> %x, <16 x i8> %y 64 ) 65 ret <16 x i8> %a 66} 67 68; CHECK-LABEL: avgr_u_v16i8: 69; CHECK-NEXT: .functype avgr_u_v16i8 (v128, v128) -> (v128){{$}} 70; CHECK-NEXT: i8x16.avgr_u $push[[R:[0-9]+]]=, $0, $1{{$}} 71; CHECK-NEXT: return $pop[[R]]{{$}} 72declare <16 x i8> @llvm.wasm.avgr.unsigned.v16i8(<16 x i8>, <16 x i8>) 73define <16 x i8> @avgr_u_v16i8(<16 x i8> %x, <16 x i8> %y) { 74 %a = call <16 x i8> @llvm.wasm.avgr.unsigned.v16i8(<16 x i8> %x, <16 x i8> %y) 75 ret <16 x i8> %a 76} 77 78; CHECK-LABEL: popcnt_v16i8: 79; CHECK-NEXT: .functype popcnt_v16i8 (v128) -> (v128){{$}} 80; CHECK-NEXT: i8x16.popcnt $push[[R:[0-9]+]]=, $0{{$}} 81; CHECK-NEXT: return $pop[[R]]{{$}} 82declare <16 x i8> @llvm.wasm.popcnt(<16 x i8>) 83define <16 x i8> @popcnt_v16i8(<16 x i8> %x) { 84 %a = call <16 x i8> @llvm.wasm.popcnt(<16 x i8> %x) 85 ret <16 x i8> %a 86} 87 88; CHECK-LABEL: any_v16i8: 89; CHECK-NEXT: .functype any_v16i8 (v128) -> (i32){{$}} 90; CHECK-NEXT: v128.any_true $push[[R:[0-9]+]]=, $0{{$}} 91; CHECK-NEXT: return $pop[[R]]{{$}} 92declare i32 @llvm.wasm.anytrue.v16i8(<16 x i8>) 93define i32 @any_v16i8(<16 x i8> %x) { 94 %a = call i32 @llvm.wasm.anytrue.v16i8(<16 x i8> %x) 95 ret i32 %a 96} 97 98; CHECK-LABEL: all_v16i8: 99; CHECK-NEXT: .functype all_v16i8 (v128) -> (i32){{$}} 100; CHECK-NEXT: i8x16.all_true $push[[R:[0-9]+]]=, $0{{$}} 101; CHECK-NEXT: return $pop[[R]]{{$}} 102declare i32 @llvm.wasm.alltrue.v16i8(<16 x i8>) 103define i32 @all_v16i8(<16 x i8> %x) { 104 %a = call i32 @llvm.wasm.alltrue.v16i8(<16 x i8> %x) 105 ret i32 %a 106} 107 108; CHECK-LABEL: bitmask_v16i8: 109; CHECK-NEXT: .functype bitmask_v16i8 (v128) -> (i32){{$}} 110; CHECK-NEXT: i8x16.bitmask $push[[R:[0-9]+]]=, $0{{$}} 111; CHECK-NEXT: return $pop[[R]]{{$}} 112declare i32 @llvm.wasm.bitmask.v16i8(<16 x i8>) 113define i32 @bitmask_v16i8(<16 x i8> %x) { 114 %a = call i32 @llvm.wasm.bitmask.v16i8(<16 x i8> %x) 115 ret i32 %a 116} 117 118; CHECK-LABEL: bitselect_v16i8: 119; CHECK-NEXT: .functype bitselect_v16i8 (v128, v128, v128) -> (v128){{$}} 120; CHECK-NEXT: v128.bitselect $push[[R:[0-9]+]]=, $0, $1, $2{{$}} 121; CHECK-NEXT: return $pop[[R]]{{$}} 122declare <16 x i8> @llvm.wasm.bitselect.v16i8(<16 x i8>, <16 x i8>, <16 x i8>) 123define <16 x i8> @bitselect_v16i8(<16 x i8> %v1, <16 x i8> %v2, <16 x i8> %c) { 124 %a = call <16 x i8> @llvm.wasm.bitselect.v16i8( 125 <16 x i8> %v1, <16 x i8> %v2, <16 x i8> %c 126 ) 127 ret <16 x i8> %a 128} 129 130; CHECK-LABEL: narrow_signed_v16i8: 131; CHECK-NEXT: .functype narrow_signed_v16i8 (v128, v128) -> (v128){{$}} 132; CHECK-NEXT: i8x16.narrow_i16x8_s $push[[R:[0-9]+]]=, $0, $1{{$}} 133; CHECK-NEXT: return $pop[[R]]{{$}} 134declare <16 x i8> @llvm.wasm.narrow.signed.v16i8.v8i16(<8 x i16>, <8 x i16>) 135define <16 x i8> @narrow_signed_v16i8(<8 x i16> %low, <8 x i16> %high) { 136 %a = call <16 x i8> @llvm.wasm.narrow.signed.v16i8.v8i16( 137 <8 x i16> %low, <8 x i16> %high 138 ) 139 ret <16 x i8> %a 140} 141 142; CHECK-LABEL: narrow_unsigned_v16i8: 143; CHECK-NEXT: .functype narrow_unsigned_v16i8 (v128, v128) -> (v128){{$}} 144; CHECK-NEXT: i8x16.narrow_i16x8_u $push[[R:[0-9]+]]=, $0, $1{{$}} 145; CHECK-NEXT: return $pop[[R]]{{$}} 146declare <16 x i8> @llvm.wasm.narrow.unsigned.v16i8.v8i16(<8 x i16>, <8 x i16>) 147define <16 x i8> @narrow_unsigned_v16i8(<8 x i16> %low, <8 x i16> %high) { 148 %a = call <16 x i8> @llvm.wasm.narrow.unsigned.v16i8.v8i16( 149 <8 x i16> %low, <8 x i16> %high 150 ) 151 ret <16 x i8> %a 152} 153 154; CHECK-LABEL: shuffle_v16i8: 155; NO-CHECK-NOT: i8x16 156; CHECK-NEXT: .functype shuffle_v16i8 (v128, v128) -> (v128){{$}} 157; CHECK-NEXT: i8x16.shuffle $push[[R:[0-9]+]]=, $0, $1, 158; CHECK-SAME: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0{{$}} 159; CHECK-NEXT: return $pop[[R]]{{$}} 160declare <16 x i8> @llvm.wasm.shuffle( 161 <16 x i8>, <16 x i8>, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, i32, 162 i32, i32, i32, i32, i32) 163define <16 x i8> @shuffle_v16i8(<16 x i8> %x, <16 x i8> %y) { 164 %res = call <16 x i8> @llvm.wasm.shuffle(<16 x i8> %x, <16 x i8> %y, 165 i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, 166 i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14, i32 35) 167 ret <16 x i8> %res 168} 169 170; CHECK-LABEL: shuffle_undef_v16i8: 171; NO-CHECK-NOT: i8x16 172; CHECK-NEXT: .functype shuffle_undef_v16i8 (v128, v128) -> (v128){{$}} 173; CHECK-NEXT: i8x16.shuffle $push[[R:[0-9]+]]=, $0, $1, 174; CHECK-SAME: 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2{{$}} 175; CHECK-NEXT: return $pop[[R]]{{$}} 176define <16 x i8> @shuffle_undef_v16i8(<16 x i8> %x, <16 x i8> %y) { 177 %res = call <16 x i8> @llvm.wasm.shuffle(<16 x i8> %x, <16 x i8> %y, 178 i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, 179 i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, 180 i32 undef, i32 undef, i32 undef, i32 2) 181 ret <16 x i8> %res 182} 183 184; ============================================================================== 185; 8 x i16 186; ============================================================================== 187; CHECK-LABEL: add_sat_s_v8i16: 188; CHECK-NEXT: .functype add_sat_s_v8i16 (v128, v128) -> (v128){{$}} 189; CHECK-NEXT: i16x8.add_sat_s $push[[R:[0-9]+]]=, $0, $1{{$}} 190; CHECK-NEXT: return $pop[[R]]{{$}} 191declare <8 x i16> @llvm.sadd.sat.v8i16(<8 x i16>, <8 x i16>) 192define <8 x i16> @add_sat_s_v8i16(<8 x i16> %x, <8 x i16> %y) { 193 %a = call <8 x i16> @llvm.sadd.sat.v8i16(<8 x i16> %x, <8 x i16> %y) 194 ret <8 x i16> %a 195} 196 197; CHECK-LABEL: add_sat_u_v8i16: 198; CHECK-NEXT: .functype add_sat_u_v8i16 (v128, v128) -> (v128){{$}} 199; CHECK-NEXT: i16x8.add_sat_u $push[[R:[0-9]+]]=, $0, $1{{$}} 200; CHECK-NEXT: return $pop[[R]]{{$}} 201declare <8 x i16> @llvm.uadd.sat.v8i16(<8 x i16>, <8 x i16>) 202define <8 x i16> @add_sat_u_v8i16(<8 x i16> %x, <8 x i16> %y) { 203 %a = call <8 x i16> @llvm.uadd.sat.v8i16(<8 x i16> %x, <8 x i16> %y) 204 ret <8 x i16> %a 205} 206 207; CHECK-LABEL: sub_sat_s_v8i16: 208; CHECK-NEXT: .functype sub_sat_s_v8i16 (v128, v128) -> (v128){{$}} 209; CHECK-NEXT: i16x8.sub_sat_s $push[[R:[0-9]+]]=, $0, $1{{$}} 210; CHECK-NEXT: return $pop[[R]]{{$}} 211declare <8 x i16> @llvm.wasm.sub.sat.signed.v8i16(<8 x i16>, <8 x i16>) 212define <8 x i16> @sub_sat_s_v8i16(<8 x i16> %x, <8 x i16> %y) { 213 %a = call <8 x i16> @llvm.wasm.sub.sat.signed.v8i16( 214 <8 x i16> %x, <8 x i16> %y 215 ) 216 ret <8 x i16> %a 217} 218 219; CHECK-LABEL: sub_sat_u_v8i16: 220; CHECK-NEXT: .functype sub_sat_u_v8i16 (v128, v128) -> (v128){{$}} 221; CHECK-NEXT: i16x8.sub_sat_u $push[[R:[0-9]+]]=, $0, $1{{$}} 222; CHECK-NEXT: return $pop[[R]]{{$}} 223declare <8 x i16> @llvm.wasm.sub.sat.unsigned.v8i16(<8 x i16>, <8 x i16>) 224define <8 x i16> @sub_sat_u_v8i16(<8 x i16> %x, <8 x i16> %y) { 225 %a = call <8 x i16> @llvm.wasm.sub.sat.unsigned.v8i16( 226 <8 x i16> %x, <8 x i16> %y 227 ) 228 ret <8 x i16> %a 229} 230 231; CHECK-LABEL: avgr_u_v8i16: 232; CHECK-NEXT: .functype avgr_u_v8i16 (v128, v128) -> (v128){{$}} 233; CHECK-NEXT: i16x8.avgr_u $push[[R:[0-9]+]]=, $0, $1{{$}} 234; CHECK-NEXT: return $pop[[R]]{{$}} 235declare <8 x i16> @llvm.wasm.avgr.unsigned.v8i16(<8 x i16>, <8 x i16>) 236define <8 x i16> @avgr_u_v8i16(<8 x i16> %x, <8 x i16> %y) { 237 %a = call <8 x i16> @llvm.wasm.avgr.unsigned.v8i16(<8 x i16> %x, <8 x i16> %y) 238 ret <8 x i16> %a 239} 240 241; CHECK-LABEL: q15mulr_sat_s_v8i16: 242; CHECK-NEXT: .functype q15mulr_sat_s_v8i16 (v128, v128) -> (v128){{$}} 243; CHECK-NEXT: i16x8.q15mulr_sat_s $push[[R:[0-9]+]]=, $0, $1{{$}} 244; CHECK-NEXT: return $pop[[R]]{{$}} 245declare <8 x i16> @llvm.wasm.q15mulr.sat.signed(<8 x i16>, <8 x i16>) 246define <8 x i16> @q15mulr_sat_s_v8i16(<8 x i16> %x, <8 x i16> %y) { 247 %a = call <8 x i16> @llvm.wasm.q15mulr.sat.signed(<8 x i16> %x, 248 <8 x i16> %y) 249 ret <8 x i16> %a 250} 251 252; CHECK-LABEL: extmul_low_s_v8i16: 253; CHECK-NEXT: .functype extmul_low_s_v8i16 (v128, v128) -> (v128){{$}} 254; CHECK-NEXT: i16x8.extmul_low_i8x16_s $push[[R:[0-9]+]]=, $0, $1{{$}} 255; CHECK-NEXT: return $pop[[R]]{{$}} 256declare <8 x i16> @llvm.wasm.extmul.low.signed.v8i16(<16 x i8>, <16 x i8>) 257define <8 x i16> @extmul_low_s_v8i16(<16 x i8> %x, <16 x i8> %y) { 258 %a = call <8 x i16> @llvm.wasm.extmul.low.signed.v8i16( 259 <16 x i8> %x, <16 x i8> %y 260 ) 261 ret <8 x i16> %a 262} 263 264; CHECK-LABEL: extmul_high_s_v8i16: 265; CHECK-NEXT: .functype extmul_high_s_v8i16 (v128, v128) -> (v128){{$}} 266; CHECK-NEXT: i16x8.extmul_high_i8x16_s $push[[R:[0-9]+]]=, $0, $1{{$}} 267; CHECK-NEXT: return $pop[[R]]{{$}} 268declare <8 x i16> @llvm.wasm.extmul.high.signed.v8i16(<16 x i8>, <16 x i8>) 269define <8 x i16> @extmul_high_s_v8i16(<16 x i8> %x, <16 x i8> %y) { 270 %a = call <8 x i16> @llvm.wasm.extmul.high.signed.v8i16( 271 <16 x i8> %x, <16 x i8> %y 272 ) 273 ret <8 x i16> %a 274} 275 276; CHECK-LABEL: extmul_low_u_v8i16: 277; CHECK-NEXT: .functype extmul_low_u_v8i16 (v128, v128) -> (v128){{$}} 278; CHECK-NEXT: i16x8.extmul_low_i8x16_u $push[[R:[0-9]+]]=, $0, $1{{$}} 279; CHECK-NEXT: return $pop[[R]]{{$}} 280declare <8 x i16> @llvm.wasm.extmul.low.unsigned.v8i16(<16 x i8>, <16 x i8>) 281define <8 x i16> @extmul_low_u_v8i16(<16 x i8> %x, <16 x i8> %y) { 282 %a = call <8 x i16> @llvm.wasm.extmul.low.unsigned.v8i16( 283 <16 x i8> %x, <16 x i8> %y 284 ) 285 ret <8 x i16> %a 286} 287 288; CHECK-LABEL: extmul_high_u_v8i16: 289; CHECK-NEXT: .functype extmul_high_u_v8i16 (v128, v128) -> (v128){{$}} 290; CHECK-NEXT: i16x8.extmul_high_i8x16_u $push[[R:[0-9]+]]=, $0, $1{{$}} 291; CHECK-NEXT: return $pop[[R]]{{$}} 292declare <8 x i16> @llvm.wasm.extmul.high.unsigned.v8i16(<16 x i8>, <16 x i8>) 293define <8 x i16> @extmul_high_u_v8i16(<16 x i8> %x, <16 x i8> %y) { 294 %a = call <8 x i16> @llvm.wasm.extmul.high.unsigned.v8i16( 295 <16 x i8> %x, <16 x i8> %y 296 ) 297 ret <8 x i16> %a 298} 299 300; CHECK-LABEL: extadd_pairwise_s_v8i16: 301; CHECK-NEXT: .functype extadd_pairwise_s_v8i16 (v128) -> (v128){{$}} 302; CHECK-NEXT: i16x8.extadd_pairwise_i8x16_s $push[[R:[0-9]+]]=, $0{{$}} 303; CHECK-NEXT: return $pop[[R]]{{$}} 304declare <8 x i16> @llvm.wasm.extadd.pairwise.signed.v8i16(<16 x i8>) 305define <8 x i16> @extadd_pairwise_s_v8i16(<16 x i8> %x) { 306 %a = call <8 x i16> @llvm.wasm.extadd.pairwise.signed.v8i16(<16 x i8> %x) 307 ret <8 x i16> %a 308} 309 310; CHECK-LABEL: extadd_pairwise_u_v8i16: 311; CHECK-NEXT: .functype extadd_pairwise_u_v8i16 (v128) -> (v128){{$}} 312; CHECK-NEXT: i16x8.extadd_pairwise_i8x16_u $push[[R:[0-9]+]]=, $0{{$}} 313; CHECK-NEXT: return $pop[[R]]{{$}} 314declare <8 x i16> @llvm.wasm.extadd.pairwise.unsigned.v8i16(<16 x i8>) 315define <8 x i16> @extadd_pairwise_u_v8i16(<16 x i8> %x) { 316 %a = call <8 x i16> @llvm.wasm.extadd.pairwise.unsigned.v8i16(<16 x i8> %x) 317 ret <8 x i16> %a 318} 319 320; CHECK-LABEL: any_v8i16: 321; CHECK-NEXT: .functype any_v8i16 (v128) -> (i32){{$}} 322; CHECK-NEXT: v128.any_true $push[[R:[0-9]+]]=, $0{{$}} 323; CHECK-NEXT: return $pop[[R]]{{$}} 324declare i32 @llvm.wasm.anytrue.v8i16(<8 x i16>) 325define i32 @any_v8i16(<8 x i16> %x) { 326 %a = call i32 @llvm.wasm.anytrue.v8i16(<8 x i16> %x) 327 ret i32 %a 328} 329 330; CHECK-LABEL: all_v8i16: 331; CHECK-NEXT: .functype all_v8i16 (v128) -> (i32){{$}} 332; CHECK-NEXT: i16x8.all_true $push[[R:[0-9]+]]=, $0{{$}} 333; CHECK-NEXT: return $pop[[R]]{{$}} 334declare i32 @llvm.wasm.alltrue.v8i16(<8 x i16>) 335define i32 @all_v8i16(<8 x i16> %x) { 336 %a = call i32 @llvm.wasm.alltrue.v8i16(<8 x i16> %x) 337 ret i32 %a 338} 339 340; CHECK-LABEL: bitmask_v8i16: 341; CHECK-NEXT: .functype bitmask_v8i16 (v128) -> (i32){{$}} 342; CHECK-NEXT: i16x8.bitmask $push[[R:[0-9]+]]=, $0{{$}} 343; CHECK-NEXT: return $pop[[R]]{{$}} 344declare i32 @llvm.wasm.bitmask.v8i16(<8 x i16>) 345define i32 @bitmask_v8i16(<8 x i16> %x) { 346 %a = call i32 @llvm.wasm.bitmask.v8i16(<8 x i16> %x) 347 ret i32 %a 348} 349 350; CHECK-LABEL: bitselect_v8i16: 351; CHECK-NEXT: .functype bitselect_v8i16 (v128, v128, v128) -> (v128){{$}} 352; CHECK-NEXT: v128.bitselect $push[[R:[0-9]+]]=, $0, $1, $2{{$}} 353; CHECK-NEXT: return $pop[[R]]{{$}} 354declare <8 x i16> @llvm.wasm.bitselect.v8i16(<8 x i16>, <8 x i16>, <8 x i16>) 355define <8 x i16> @bitselect_v8i16(<8 x i16> %v1, <8 x i16> %v2, <8 x i16> %c) { 356 %a = call <8 x i16> @llvm.wasm.bitselect.v8i16( 357 <8 x i16> %v1, <8 x i16> %v2, <8 x i16> %c 358 ) 359 ret <8 x i16> %a 360} 361 362; CHECK-LABEL: narrow_signed_v8i16: 363; CHECK-NEXT: .functype narrow_signed_v8i16 (v128, v128) -> (v128){{$}} 364; CHECK-NEXT: i16x8.narrow_i32x4_s $push[[R:[0-9]+]]=, $0, $1{{$}} 365; CHECK-NEXT: return $pop[[R]]{{$}} 366declare <8 x i16> @llvm.wasm.narrow.signed.v8i16.v4i32(<4 x i32>, <4 x i32>) 367define <8 x i16> @narrow_signed_v8i16(<4 x i32> %low, <4 x i32> %high) { 368 %a = call <8 x i16> @llvm.wasm.narrow.signed.v8i16.v4i32( 369 <4 x i32> %low, <4 x i32> %high 370 ) 371 ret <8 x i16> %a 372} 373 374; CHECK-LABEL: narrow_unsigned_v8i16: 375; CHECK-NEXT: .functype narrow_unsigned_v8i16 (v128, v128) -> (v128){{$}} 376; CHECK-NEXT: i16x8.narrow_i32x4_u $push[[R:[0-9]+]]=, $0, $1{{$}} 377; CHECK-NEXT: return $pop[[R]]{{$}} 378declare <8 x i16> @llvm.wasm.narrow.unsigned.v8i16.v4i32(<4 x i32>, <4 x i32>) 379define <8 x i16> @narrow_unsigned_v8i16(<4 x i32> %low, <4 x i32> %high) { 380 %a = call <8 x i16> @llvm.wasm.narrow.unsigned.v8i16.v4i32( 381 <4 x i32> %low, <4 x i32> %high 382 ) 383 ret <8 x i16> %a 384} 385 386; ============================================================================== 387; 4 x i32 388; ============================================================================== 389; CHECK-LABEL: dot: 390; CHECK-NEXT: .functype dot (v128, v128) -> (v128){{$}} 391; CHECK-NEXT: i32x4.dot_i16x8_s $push[[R:[0-9]+]]=, $0, $1{{$}} 392; CHECK-NEXT: return $pop[[R]]{{$}} 393declare <4 x i32> @llvm.wasm.dot(<8 x i16>, <8 x i16>) 394define <4 x i32> @dot(<8 x i16> %x, <8 x i16> %y) { 395 %a = call <4 x i32> @llvm.wasm.dot(<8 x i16> %x, <8 x i16> %y) 396 ret <4 x i32> %a 397} 398 399 400; CHECK-LABEL: extmul_low_s_v4i32: 401; CHECK-NEXT: .functype extmul_low_s_v4i32 (v128, v128) -> (v128){{$}} 402; CHECK-NEXT: i32x4.extmul_low_i16x8_s $push[[R:[0-9]+]]=, $0, $1{{$}} 403; CHECK-NEXT: return $pop[[R]]{{$}} 404declare <4 x i32> @llvm.wasm.extmul.low.signed.v4i32(<8 x i16>, <8 x i16>) 405define <4 x i32> @extmul_low_s_v4i32(<8 x i16> %x, <8 x i16> %y) { 406 %a = call <4 x i32> @llvm.wasm.extmul.low.signed.v4i32( 407 <8 x i16> %x, <8 x i16> %y 408 ) 409 ret <4 x i32> %a 410} 411 412; CHECK-LABEL: extmul_high_s_v4i32: 413; CHECK-NEXT: .functype extmul_high_s_v4i32 (v128, v128) -> (v128){{$}} 414; CHECK-NEXT: i32x4.extmul_high_i16x8_s $push[[R:[0-9]+]]=, $0, $1{{$}} 415; CHECK-NEXT: return $pop[[R]]{{$}} 416declare <4 x i32> @llvm.wasm.extmul.high.signed.v4i32(<8 x i16>, <8 x i16>) 417define <4 x i32> @extmul_high_s_v4i32(<8 x i16> %x, <8 x i16> %y) { 418 %a = call <4 x i32> @llvm.wasm.extmul.high.signed.v4i32( 419 <8 x i16> %x, <8 x i16> %y 420 ) 421 ret <4 x i32> %a 422} 423 424; CHECK-LABEL: extmul_low_u_v4i32: 425; CHECK-NEXT: .functype extmul_low_u_v4i32 (v128, v128) -> (v128){{$}} 426; CHECK-NEXT: i32x4.extmul_low_i16x8_u $push[[R:[0-9]+]]=, $0, $1{{$}} 427; CHECK-NEXT: return $pop[[R]]{{$}} 428declare <4 x i32> @llvm.wasm.extmul.low.unsigned.v4i32(<8 x i16>, <8 x i16>) 429define <4 x i32> @extmul_low_u_v4i32(<8 x i16> %x, <8 x i16> %y) { 430 %a = call <4 x i32> @llvm.wasm.extmul.low.unsigned.v4i32( 431 <8 x i16> %x, <8 x i16> %y 432 ) 433 ret <4 x i32> %a 434} 435 436; CHECK-LABEL: extmul_high_u_v4i32: 437; CHECK-NEXT: .functype extmul_high_u_v4i32 (v128, v128) -> (v128){{$}} 438; CHECK-NEXT: i32x4.extmul_high_i16x8_u $push[[R:[0-9]+]]=, $0, $1{{$}} 439; CHECK-NEXT: return $pop[[R]]{{$}} 440declare <4 x i32> @llvm.wasm.extmul.high.unsigned.v4i32(<8 x i16>, <8 x i16>) 441define <4 x i32> @extmul_high_u_v4i32(<8 x i16> %x, <8 x i16> %y) { 442 %a = call <4 x i32> @llvm.wasm.extmul.high.unsigned.v4i32( 443 <8 x i16> %x, <8 x i16> %y 444 ) 445 ret <4 x i32> %a 446} 447 448; CHECK-LABEL: extadd_pairwise_s_v4i32: 449; CHECK-NEXT: .functype extadd_pairwise_s_v4i32 (v128) -> (v128){{$}} 450; CHECK-NEXT: i32x4.extadd_pairwise_i16x8_s $push[[R:[0-9]+]]=, $0{{$}} 451; CHECK-NEXT: return $pop[[R]]{{$}} 452declare <4 x i32> @llvm.wasm.extadd.pairwise.signed.v4i32(<8 x i16>) 453define <4 x i32> @extadd_pairwise_s_v4i32(<8 x i16> %x) { 454 %a = call <4 x i32> @llvm.wasm.extadd.pairwise.signed.v4i32(<8 x i16> %x) 455 ret <4 x i32> %a 456} 457 458; CHECK-LABEL: extadd_pairwise_u_v4i32: 459; CHECK-NEXT: .functype extadd_pairwise_u_v4i32 (v128) -> (v128){{$}} 460; CHECK-NEXT: i32x4.extadd_pairwise_i16x8_u $push[[R:[0-9]+]]=, $0{{$}} 461; CHECK-NEXT: return $pop[[R]]{{$}} 462declare <4 x i32> @llvm.wasm.extadd.pairwise.unsigned.v4i32(<8 x i16>) 463define <4 x i32> @extadd_pairwise_u_v4i32(<8 x i16> %x) { 464 %a = call <4 x i32> @llvm.wasm.extadd.pairwise.unsigned.v4i32(<8 x i16> %x) 465 ret <4 x i32> %a 466} 467 468 469; CHECK-LABEL: any_v4i32: 470; CHECK-NEXT: .functype any_v4i32 (v128) -> (i32){{$}} 471; CHECK-NEXT: v128.any_true $push[[R:[0-9]+]]=, $0{{$}} 472; CHECK-NEXT: return $pop[[R]]{{$}} 473declare i32 @llvm.wasm.anytrue.v4i32(<4 x i32>) 474define i32 @any_v4i32(<4 x i32> %x) { 475 %a = call i32 @llvm.wasm.anytrue.v4i32(<4 x i32> %x) 476 ret i32 %a 477} 478 479; CHECK-LABEL: all_v4i32: 480; CHECK-NEXT: .functype all_v4i32 (v128) -> (i32){{$}} 481; CHECK-NEXT: i32x4.all_true $push[[R:[0-9]+]]=, $0{{$}} 482; CHECK-NEXT: return $pop[[R]]{{$}} 483declare i32 @llvm.wasm.alltrue.v4i32(<4 x i32>) 484define i32 @all_v4i32(<4 x i32> %x) { 485 %a = call i32 @llvm.wasm.alltrue.v4i32(<4 x i32> %x) 486 ret i32 %a 487} 488 489; CHECK-LABEL: bitmask_v4i32: 490; CHECK-NEXT: .functype bitmask_v4i32 (v128) -> (i32){{$}} 491; CHECK-NEXT: i32x4.bitmask $push[[R:[0-9]+]]=, $0{{$}} 492; CHECK-NEXT: return $pop[[R]]{{$}} 493declare i32 @llvm.wasm.bitmask.v4i32(<4 x i32>) 494define i32 @bitmask_v4i32(<4 x i32> %x) { 495 %a = call i32 @llvm.wasm.bitmask.v4i32(<4 x i32> %x) 496 ret i32 %a 497} 498 499; CHECK-LABEL: bitselect_v4i32: 500; CHECK-NEXT: .functype bitselect_v4i32 (v128, v128, v128) -> (v128){{$}} 501; CHECK-NEXT: v128.bitselect $push[[R:[0-9]+]]=, $0, $1, $2{{$}} 502; CHECK-NEXT: return $pop[[R]]{{$}} 503declare <4 x i32> @llvm.wasm.bitselect.v4i32(<4 x i32>, <4 x i32>, <4 x i32>) 504define <4 x i32> @bitselect_v4i32(<4 x i32> %v1, <4 x i32> %v2, <4 x i32> %c) { 505 %a = call <4 x i32> @llvm.wasm.bitselect.v4i32( 506 <4 x i32> %v1, <4 x i32> %v2, <4 x i32> %c 507 ) 508 ret <4 x i32> %a 509} 510 511; CHECK-LABEL: trunc_sat_s_v4i32: 512; NO-CHECK-NOT: f32x4 513; CHECK-NEXT: .functype trunc_sat_s_v4i32 (v128) -> (v128){{$}} 514; CHECK-NEXT: i32x4.trunc_sat_f32x4_s $push[[R:[0-9]+]]=, $0 515; CHECK-NEXT: return $pop[[R]] 516declare <4 x i32> @llvm.fptosi.sat.v4i32.v4f32(<4 x float>) 517define <4 x i32> @trunc_sat_s_v4i32(<4 x float> %x) { 518 %a = call <4 x i32> @llvm.fptosi.sat.v4i32.v4f32(<4 x float> %x) 519 ret <4 x i32> %a 520} 521 522; CHECK-LABEL: trunc_sat_u_v4i32: 523; NO-CHECK-NOT: f32x4 524; CHECK-NEXT: .functype trunc_sat_u_v4i32 (v128) -> (v128){{$}} 525; CHECK-NEXT: i32x4.trunc_sat_f32x4_u $push[[R:[0-9]+]]=, $0 526; CHECK-NEXT: return $pop[[R]] 527declare <4 x i32> @llvm.fptoui.sat.v4i32.v4f32(<4 x float>) 528define <4 x i32> @trunc_sat_u_v4i32(<4 x float> %x) { 529 %a = call <4 x i32> @llvm.fptoui.sat.v4i32.v4f32(<4 x float> %x) 530 ret <4 x i32> %a 531} 532 533; CHECK-LABEL: trunc_sat_zero_s_v4i32: 534; CHECK-NEXT: .functype trunc_sat_zero_s_v4i32 (v128) -> (v128){{$}} 535; CHECK-NEXT: i32x4.trunc_sat_zero_f64x2_s $push[[R:[0-9]+]]=, $0{{$}} 536; CHECK-NEXT: return $pop[[R]]{{$}} 537declare <2 x i32> @llvm.fptosi.sat.v2i32.v2f64(<2 x double>) 538define <4 x i32> @trunc_sat_zero_s_v4i32(<2 x double> %x) { 539 %v = call <2 x i32> @llvm.fptosi.sat.v2i32.v2f64(<2 x double> %x) 540 %a = shufflevector <2 x i32> %v, <2 x i32> <i32 0, i32 0>, 541 <4 x i32> <i32 0, i32 1, i32 2, i32 3> 542 ret <4 x i32> %a 543} 544 545; CHECK-LABEL: trunc_sat_zero_u_v4i32: 546; CHECK-NEXT: .functype trunc_sat_zero_u_v4i32 (v128) -> (v128){{$}} 547; CHECK-NEXT: i32x4.trunc_sat_zero_f64x2_u $push[[R:[0-9]+]]=, $0{{$}} 548; CHECK-NEXT: return $pop[[R]]{{$}} 549declare <2 x i32> @llvm.fptoui.sat.v2i32.v2f64(<2 x double>) 550define <4 x i32> @trunc_sat_zero_u_v4i32(<2 x double> %x) { 551 %v = call <2 x i32> @llvm.fptoui.sat.v2i32.v2f64(<2 x double> %x) 552 %a = shufflevector <2 x i32> %v, <2 x i32> <i32 0, i32 0>, 553 <4 x i32> <i32 0, i32 1, i32 2, i32 3> 554 ret <4 x i32> %a 555} 556 557; ============================================================================== 558; 2 x i64 559; ============================================================================== 560; CHECK-LABEL: extmul_low_s_v2i64: 561; CHECK-NEXT: .functype extmul_low_s_v2i64 (v128, v128) -> (v128){{$}} 562; CHECK-NEXT: i64x2.extmul_low_i32x4_s $push[[R:[0-9]+]]=, $0, $1{{$}} 563; CHECK-NEXT: return $pop[[R]]{{$}} 564declare <2 x i64> @llvm.wasm.extmul.low.signed.v2i64(<4 x i32>, <4 x i32>) 565define <2 x i64> @extmul_low_s_v2i64(<4 x i32> %x, <4 x i32> %y) { 566 %a = call <2 x i64> @llvm.wasm.extmul.low.signed.v2i64( 567 <4 x i32> %x, <4 x i32> %y 568 ) 569 ret <2 x i64> %a 570} 571 572; CHECK-LABEL: extmul_high_s_v2i64: 573; CHECK-NEXT: .functype extmul_high_s_v2i64 (v128, v128) -> (v128){{$}} 574; CHECK-NEXT: i64x2.extmul_high_i32x4_s $push[[R:[0-9]+]]=, $0, $1{{$}} 575; CHECK-NEXT: return $pop[[R]]{{$}} 576declare <2 x i64> @llvm.wasm.extmul.high.signed.v2i64(<4 x i32>, <4 x i32>) 577define <2 x i64> @extmul_high_s_v2i64(<4 x i32> %x, <4 x i32> %y) { 578 %a = call <2 x i64> @llvm.wasm.extmul.high.signed.v2i64( 579 <4 x i32> %x, <4 x i32> %y 580 ) 581 ret <2 x i64> %a 582} 583 584; CHECK-LABEL: extmul_low_u_v2i64: 585; CHECK-NEXT: .functype extmul_low_u_v2i64 (v128, v128) -> (v128){{$}} 586; CHECK-NEXT: i64x2.extmul_low_i32x4_u $push[[R:[0-9]+]]=, $0, $1{{$}} 587; CHECK-NEXT: return $pop[[R]]{{$}} 588declare <2 x i64> @llvm.wasm.extmul.low.unsigned.v2i64(<4 x i32>, <4 x i32>) 589define <2 x i64> @extmul_low_u_v2i64(<4 x i32> %x, <4 x i32> %y) { 590 %a = call <2 x i64> @llvm.wasm.extmul.low.unsigned.v2i64( 591 <4 x i32> %x, <4 x i32> %y 592 ) 593 ret <2 x i64> %a 594} 595 596; CHECK-LABEL: extmul_high_u_v2i64: 597; CHECK-NEXT: .functype extmul_high_u_v2i64 (v128, v128) -> (v128){{$}} 598; CHECK-NEXT: i64x2.extmul_high_i32x4_u $push[[R:[0-9]+]]=, $0, $1{{$}} 599; CHECK-NEXT: return $pop[[R]]{{$}} 600declare <2 x i64> @llvm.wasm.extmul.high.unsigned.v2i64(<4 x i32>, <4 x i32>) 601define <2 x i64> @extmul_high_u_v2i64(<4 x i32> %x, <4 x i32> %y) { 602 %a = call <2 x i64> @llvm.wasm.extmul.high.unsigned.v2i64( 603 <4 x i32> %x, <4 x i32> %y 604 ) 605 ret <2 x i64> %a 606} 607 608; CHECK-LABEL: any_v2i64: 609; CHECK-NEXT: .functype any_v2i64 (v128) -> (i32){{$}} 610; CHECK-NEXT: v128.any_true $push[[R:[0-9]+]]=, $0{{$}} 611; CHECK-NEXT: return $pop[[R]]{{$}} 612declare i32 @llvm.wasm.anytrue.v2i64(<2 x i64>) 613define i32 @any_v2i64(<2 x i64> %x) { 614 %a = call i32 @llvm.wasm.anytrue.v2i64(<2 x i64> %x) 615 ret i32 %a 616} 617 618; CHECK-LABEL: all_v2i64: 619; CHECK-NEXT: .functype all_v2i64 (v128) -> (i32){{$}} 620; CHECK-NEXT: i64x2.all_true $push[[R:[0-9]+]]=, $0{{$}} 621; CHECK-NEXT: return $pop[[R]]{{$}} 622declare i32 @llvm.wasm.alltrue.v2i64(<2 x i64>) 623define i32 @all_v2i64(<2 x i64> %x) { 624 %a = call i32 @llvm.wasm.alltrue.v2i64(<2 x i64> %x) 625 ret i32 %a 626} 627 628; CHECK-LABEL: bitmask_v2i64: 629; CHECK-NEXT: .functype bitmask_v2i64 (v128) -> (i32){{$}} 630; CHECK-NEXT: i64x2.bitmask $push[[R:[0-9]+]]=, $0{{$}} 631; CHECK-NEXT: return $pop[[R]]{{$}} 632declare i32 @llvm.wasm.bitmask.v2i64(<2 x i64>) 633define i32 @bitmask_v2i64(<2 x i64> %x) { 634 %a = call i32 @llvm.wasm.bitmask.v2i64(<2 x i64> %x) 635 ret i32 %a 636} 637 638; CHECK-LABEL: bitselect_v2i64: 639; CHECK-NEXT: .functype bitselect_v2i64 (v128, v128, v128) -> (v128){{$}} 640; CHECK-NEXT: v128.bitselect $push[[R:[0-9]+]]=, $0, $1, $2{{$}} 641; CHECK-NEXT: return $pop[[R]]{{$}} 642declare <2 x i64> @llvm.wasm.bitselect.v2i64(<2 x i64>, <2 x i64>, <2 x i64>) 643define <2 x i64> @bitselect_v2i64(<2 x i64> %v1, <2 x i64> %v2, <2 x i64> %c) { 644 %a = call <2 x i64> @llvm.wasm.bitselect.v2i64( 645 <2 x i64> %v1, <2 x i64> %v2, <2 x i64> %c 646 ) 647 ret <2 x i64> %a 648} 649 650; ============================================================================== 651; 4 x f32 652; ============================================================================== 653; CHECK-LABEL: bitselect_v4f32: 654; CHECK-NEXT: .functype bitselect_v4f32 (v128, v128, v128) -> (v128){{$}} 655; CHECK-NEXT: v128.bitselect $push[[R:[0-9]+]]=, $0, $1, $2{{$}} 656; CHECK-NEXT: return $pop[[R]]{{$}} 657declare <4 x float> @llvm.wasm.bitselect.v4f32(<4 x float>, <4 x float>, <4 x float>) 658define <4 x float> @bitselect_v4f32(<4 x float> %v1, <4 x float> %v2, <4 x float> %c) { 659 %a = call <4 x float> @llvm.wasm.bitselect.v4f32( 660 <4 x float> %v1, <4 x float> %v2, <4 x float> %c 661 ) 662 ret <4 x float> %a 663} 664 665; CHECK-LABEL: pmin_v4f32: 666; CHECK-NEXT: .functype pmin_v4f32 (v128, v128) -> (v128){{$}} 667; CHECK-NEXT: f32x4.pmin $push[[R:[0-9]+]]=, $0, $1{{$}} 668; CHECK-NEXT: return $pop[[R]]{{$}} 669declare <4 x float> @llvm.wasm.pmin.v4f32(<4 x float>, <4 x float>) 670define <4 x float> @pmin_v4f32(<4 x float> %a, <4 x float> %b) { 671 %v = call <4 x float> @llvm.wasm.pmin.v4f32(<4 x float> %a, <4 x float> %b) 672 ret <4 x float> %v 673} 674 675; CHECK-LABEL: pmax_v4f32: 676; CHECK-NEXT: .functype pmax_v4f32 (v128, v128) -> (v128){{$}} 677; CHECK-NEXT: f32x4.pmax $push[[R:[0-9]+]]=, $0, $1{{$}} 678; CHECK-NEXT: return $pop[[R]]{{$}} 679declare <4 x float> @llvm.wasm.pmax.v4f32(<4 x float>, <4 x float>) 680define <4 x float> @pmax_v4f32(<4 x float> %a, <4 x float> %b) { 681 %v = call <4 x float> @llvm.wasm.pmax.v4f32(<4 x float> %a, <4 x float> %b) 682 ret <4 x float> %v 683} 684 685; CHECK-LABEL: ceil_v4f32: 686; CHECK-NEXT: .functype ceil_v4f32 (v128) -> (v128){{$}} 687; CHECK-NEXT: f32x4.ceil $push[[R:[0-9]+]]=, $0{{$}} 688; CHECK-NEXT: return $pop[[R]]{{$}} 689declare <4 x float> @llvm.ceil.v4f32(<4 x float>) 690define <4 x float> @ceil_v4f32(<4 x float> %a) { 691 %v = call <4 x float> @llvm.ceil.v4f32(<4 x float> %a) 692 ret <4 x float> %v 693} 694 695; CHECK-LABEL: floor_v4f32: 696; CHECK-NEXT: .functype floor_v4f32 (v128) -> (v128){{$}} 697; CHECK-NEXT: f32x4.floor $push[[R:[0-9]+]]=, $0{{$}} 698; CHECK-NEXT: return $pop[[R]]{{$}} 699declare <4 x float> @llvm.floor.v4f32(<4 x float>) 700define <4 x float> @floor_v4f32(<4 x float> %a) { 701 %v = call <4 x float> @llvm.floor.v4f32(<4 x float> %a) 702 ret <4 x float> %v 703} 704 705; CHECK-LABEL: trunc_v4f32: 706; CHECK-NEXT: .functype trunc_v4f32 (v128) -> (v128){{$}} 707; CHECK-NEXT: f32x4.trunc $push[[R:[0-9]+]]=, $0{{$}} 708; CHECK-NEXT: return $pop[[R]]{{$}} 709declare <4 x float> @llvm.trunc.v4f32(<4 x float>) 710define <4 x float> @trunc_v4f32(<4 x float> %a) { 711 %v = call <4 x float> @llvm.trunc.v4f32(<4 x float> %a) 712 ret <4 x float> %v 713} 714 715; CHECK-LABEL: nearest_v4f32: 716; CHECK-NEXT: .functype nearest_v4f32 (v128) -> (v128){{$}} 717; CHECK-NEXT: f32x4.nearest $push[[R:[0-9]+]]=, $0{{$}} 718; CHECK-NEXT: return $pop[[R]]{{$}} 719declare <4 x float> @llvm.nearbyint.v4f32(<4 x float>) 720define <4 x float> @nearest_v4f32(<4 x float> %a) { 721 %v = call <4 x float> @llvm.nearbyint.v4f32(<4 x float> %a) 722 ret <4 x float> %v 723} 724 725; CHECK-LABEL: demote_zero_v4f32: 726; CHECK-NEXT: .functype demote_zero_v4f32 (v128) -> (v128){{$}} 727; CHECK-NEXT: f32x4.demote_zero_f64x2 $push[[R:[0-9]+]]=, $0{{$}} 728; CHECK-NEXT: return $pop[[R]]{{$}} 729declare <4 x float> @llvm.wasm.demote.zero(<2 x double>) 730define <4 x float> @demote_zero_v4f32(<2 x double> %a) { 731 %v = call <4 x float> @llvm.wasm.demote.zero(<2 x double> %a) 732 ret <4 x float> %v 733} 734 735; ============================================================================== 736; 2 x f64 737; ============================================================================== 738; CHECK-LABEL: bitselect_v2f64: 739; CHECK-NEXT: .functype bitselect_v2f64 (v128, v128, v128) -> (v128){{$}} 740; CHECK-NEXT: v128.bitselect $push[[R:[0-9]+]]=, $0, $1, $2{{$}} 741; CHECK-NEXT: return $pop[[R]]{{$}} 742declare <2 x double> @llvm.wasm.bitselect.v2f64(<2 x double>, <2 x double>, <2 x double>) 743define <2 x double> @bitselect_v2f64(<2 x double> %v1, <2 x double> %v2, <2 x double> %c) { 744 %a = call <2 x double> @llvm.wasm.bitselect.v2f64( 745 <2 x double> %v1, <2 x double> %v2, <2 x double> %c 746 ) 747 ret <2 x double> %a 748} 749 750; CHECK-LABEL: pmin_v2f64: 751; CHECK-NEXT: .functype pmin_v2f64 (v128, v128) -> (v128){{$}} 752; CHECK-NEXT: f64x2.pmin $push[[R:[0-9]+]]=, $0, $1{{$}} 753; CHECK-NEXT: return $pop[[R]]{{$}} 754declare <2 x double> @llvm.wasm.pmin.v2f64(<2 x double>, <2 x double>) 755define <2 x double> @pmin_v2f64(<2 x double> %a, <2 x double> %b) { 756 %v = call <2 x double> @llvm.wasm.pmin.v2f64(<2 x double> %a, <2 x double> %b) 757 ret <2 x double> %v 758} 759 760; CHECK-LABEL: pmax_v2f64: 761; CHECK-NEXT: .functype pmax_v2f64 (v128, v128) -> (v128){{$}} 762; CHECK-NEXT: f64x2.pmax $push[[R:[0-9]+]]=, $0, $1{{$}} 763; CHECK-NEXT: return $pop[[R]]{{$}} 764declare <2 x double> @llvm.wasm.pmax.v2f64(<2 x double>, <2 x double>) 765define <2 x double> @pmax_v2f64(<2 x double> %a, <2 x double> %b) { 766 %v = call <2 x double> @llvm.wasm.pmax.v2f64(<2 x double> %a, <2 x double> %b) 767 ret <2 x double> %v 768} 769 770; CHECK-LABEL: ceil_v2f64: 771; CHECK-NEXT: .functype ceil_v2f64 (v128) -> (v128){{$}} 772; CHECK-NEXT: f64x2.ceil $push[[R:[0-9]+]]=, $0{{$}} 773; CHECK-NEXT: return $pop[[R]]{{$}} 774declare <2 x double> @llvm.ceil.v2f64(<2 x double>) 775define <2 x double> @ceil_v2f64(<2 x double> %a) { 776 %v = call <2 x double> @llvm.ceil.v2f64(<2 x double> %a) 777 ret <2 x double> %v 778} 779 780; CHECK-LABEL: floor_v2f64: 781; CHECK-NEXT: .functype floor_v2f64 (v128) -> (v128){{$}} 782; CHECK-NEXT: f64x2.floor $push[[R:[0-9]+]]=, $0{{$}} 783; CHECK-NEXT: return $pop[[R]]{{$}} 784declare <2 x double> @llvm.floor.v2f64(<2 x double>) 785define <2 x double> @floor_v2f64(<2 x double> %a) { 786 %v = call <2 x double> @llvm.floor.v2f64(<2 x double> %a) 787 ret <2 x double> %v 788} 789 790; CHECK-LABEL: trunc_v2f64: 791; CHECK-NEXT: .functype trunc_v2f64 (v128) -> (v128){{$}} 792; CHECK-NEXT: f64x2.trunc $push[[R:[0-9]+]]=, $0{{$}} 793; CHECK-NEXT: return $pop[[R]]{{$}} 794declare <2 x double> @llvm.trunc.v2f64(<2 x double>) 795define <2 x double> @trunc_v2f64(<2 x double> %a) { 796 %v = call <2 x double> @llvm.trunc.v2f64(<2 x double> %a) 797 ret <2 x double> %v 798} 799 800; CHECK-LABEL: nearest_v2f64: 801; CHECK-NEXT: .functype nearest_v2f64 (v128) -> (v128){{$}} 802; CHECK-NEXT: f64x2.nearest $push[[R:[0-9]+]]=, $0{{$}} 803; CHECK-NEXT: return $pop[[R]]{{$}} 804declare <2 x double> @llvm.nearbyint.v2f64(<2 x double>) 805define <2 x double> @nearest_v2f64(<2 x double> %a) { 806 %v = call <2 x double> @llvm.nearbyint.v2f64(<2 x double> %a) 807 ret <2 x double> %v 808} 809 810; CHECK-LABEL: promote_low_v2f64: 811; CHECK-NEXT: .functype promote_low_v2f64 (v128) -> (v128){{$}} 812; CHECK-NEXT: f64x2.promote_low_f32x4 $push[[R:[0-9]+]]=, $0{{$}} 813; CHECK-NEXT: return $pop[[R]]{{$}} 814declare <2 x double> @llvm.wasm.promote.low(<4 x float>) 815define <2 x double> @promote_low_v2f64(<4 x float> %a) { 816 %v = call <2 x double> @llvm.wasm.promote.low(<4 x float> %a) 817 ret <2 x double> %v 818} 819